minsky.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2012
  @author Russell Standish
  This file is part of Minsky.

  Minsky is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  Minsky is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef MINSKY_H
#define MINSKY_H

#include "stringKeyMap.h"
#include "intrusiveMap.h"
#include "bookmark.h"
#include "cairoItems.h"
#include "canvas.h"
#include "clipboard.h"
#include "dimension.h"
#include "evalOp.h"
#include "equationDisplay.h"
#include "equations.h"
#include "fontDisplay.h"
#include "godleyIcon.h"
#include "intrusiveMap.h"
#include "latexMarkup.h"
#include "variableValues.h"
#include "canvas.h"
#include "lock.h"
#include "operation.h"
#include "pannableTab.h"
#include "phillipsDiagram.h"
#include "plotWidget.h"
#include "progress.h"
#include "pubTab.h"
#include "ravelWrap.h"
#include "rungeKutta.h"
#include "saver.h"
#include "stringKeyMap.h"
#include "variablePane.h"
#include "version.h"

#include <vector>
#include <string>
#include <set>
#include <deque>
#include <cstdio>

#include <ecolab.h>
#include <xml_pack_base.h>
#include <xml_unpack_base.h>

namespace minsky
{
  using namespace std;
  using classdesc::shared_ptr;
  using namespace civita;
  using namespace boost::posix_time;
  
  struct CallableFunction;
  class VariableInstanceList;
  
  class SaveThread;
  
  // a place to put working variables of the Minsky class that needn't
  // be serialised.
  struct MinskyExclude
  {
    shared_ptr<ofstream> outputDataFile;
    unique_ptr<BackgroundSaver> autoSaver;

    enum StateFlags {is_edited=1, reset_needed=2, fullEqnDisplay_needed=4};
    int flags=reset_needed;

    static constexpr std::chrono::milliseconds resetNowThreshold{500};
    static constexpr std::chrono::milliseconds resetPostponedThreshold{1500};
    std::chrono::time_point<std::chrono::system_clock> resetAt=std::chrono::time_point<std::chrono::system_clock>::max();
    std::chrono::milliseconds resetDuration;

    Progress progressState;
    int busyCursorStack=0;
    
    std::vector<int> flagStack;

    Clipboard clipboard; 
    
    // make copy operations just dummies, as assignment of Minsky's
    // doesn't need to change this
    MinskyExclude(): historyPtr(0) {}
    MinskyExclude(const MinskyExclude&): historyPtr(0) {}
    MinskyExclude& operator=(const MinskyExclude&) {return *this;}

    std::set<RenderNativeWindow*> nativeWindowsToRedraw;
    
  protected:
    /* 
       TODO: it should be sufficient to add move semantics to pack_t,
       but for some reason copy semantics are required, requiring the
       use of shared_ptr
     */
    std::deque<classdesc::pack_t> history;
    std::size_t historyPtr;
    bool undone=false; //< flag indicating undo() was previous command 
  };

  enum ItemType {wire, op, var, group, godley, plot};

  struct Minsky_multipleEquities: public ecolab::TCLAccessor<Minsky,bool>
  {
    Minsky_multipleEquities(const std::string& name, ecolab::TCLAccessor<Minsky,bool>::Getter g,
                            ecolab::TCLAccessor<Minsky,bool>::Setter s):
      ecolab::TCLAccessor<Minsky,bool>(name,g,s) {}  
  };

  
  class Minsky: public Exclude<MinskyExclude>, public RungeKutta, public Minsky_multipleEquities
  {
    CLASSDESC_ACCESS(Minsky);

    std::string diagnoseNonFinite() const;

    void logVariables() const;

    Exclude<ptime> lastRedraw;

    bool m_multipleEquities=false;    
    
    void balanceColumns(const GodleyIcon& srcGodley, int srcCol, GodleyIcon& destGodley, int destCol) const;

    void removeItems(Wire& wire);

  public:
    PannableTab<EquationDisplay> equationDisplay;
    FontDisplay fontSampler;
    PhillipsDiagram phillipsDiagram;
    std::vector<PubTab> publicationTabs;

    void addNewPublicationTab(const std::string& name) {publicationTabs.emplace_back(name);}
    void addCanvasItemToPublicationTab(size_t i) {
      if (canvas.item && i<publicationTabs.size())
        publicationTabs[i].items.emplace_back(canvas.item);
    }
    
    // Allow multiple equity columns.
    bool multipleEquities() const {return m_multipleEquities;}
    bool multipleEquities(const bool& m);
    
    bool edited() const {return flags & is_edited;}
    bool reset_flag() const {return flags & reset_needed;}
    void markEdited() {
      flags |= is_edited | fullEqnDisplay_needed;
      if (!running) flags|=reset_needed; // don't reset when running
      variablePane.update();
      canvas.requestRedraw();
      canvas.model.updateTimestamp();
    }
    void requestReset();
    void requestRedraw();
    
    void pushFlags() {flagStack.push_back(flags);}
    void popFlags() {
      if (!flagStack.empty()) {
        flags=flagStack.back();
        flagStack.pop_back();
      }
    }

    bool resetIfFlagged() override {
      if (reset_flag())
        reset();
      return reset_flag();
    }
    
    VariableValues variableValues;
    Dimensions dimensions;
    Conversions conversions;
    std::map<Units, double> maxValue;
    std::map<Units, double> maxFlowValue; // max flow values along wires
    void populateMissingDimensions();
    void populateMissingDimensionsFromVariable(const VariableValue&, bool& incompatibleMessageDisplayed);
    void populateMissingDimensionsFromVariable(const VariableValue& v)
    {bool dummy; populateMissingDimensionsFromVariable(v,dummy);}
    void renameDimension(const std::string& oldName, const std::string& newName);
    
    void setGodleyIconResource(const string& s)
    {GodleyIcon::svgRenderer.setResource(s);}
    void setGroupIconResource(const string& s)
    {Group::svgRenderer.setResource(s);}
    void setLockIconResource(const string& locked, const string& unlocked) {
      Lock::lockedIcon.setResource(locked);
      Lock::unlockedIcon.setResource(unlocked);
    }
    void setRavelIconResource(const string& s)
    {Ravel::svgRenderer.setResource(s);}
    SVGRenderer histogramResource;
    
    //  @param ac type of column we wish matches for
    std::set<string> matchingTableColumns(const GodleyIcon& currTable, GodleyAssetClass::AssetClass ac);

    void importDuplicateColumn(GodleyTable& srcTable, int srcCol);

    void balanceDuplicateColumns(const GodleyIcon& srcTable, int srcCol);

    std::vector<std::string> allGodleyFlowVars() const;
    
    // reset m_edited as the GodleyIcon constructor calls markEdited
    Minsky():
      ECOLAB_ACESSOR_INIT(Minsky, multipleEquities),
      equationDisplay(*this) {
      lastRedraw=boost::posix_time::microsec_clock::local_time();
      model->iHeight(std::numeric_limits<float>::max());
      model->iWidth(std::numeric_limits<float>::max());
      model->self=model;
      publicationTabs.emplace_back("Publication");
    }
    ~Minsky();

    // needs to be declared after variableValues
    Exclude<std::map<std::string, std::shared_ptr<CallableFunction>>> userFunctions;

    GroupPtr model{new Group};
    Canvas canvas{model};

    void clearAllMaps(bool clearHistory);
    void clearAllMaps() {clearAllMaps(true);}
    // for TCL use
    void clearAllMapsTCL() {clearAllMaps(true);}
    
    VariablePtr definingVar(const std::string& valueId) const;

    static void saveGroupAsFile(const Group&, const string& fileName);
    void saveCanvasItemAsFile(const string& fileName) const
    {if (auto g=dynamic_cast<Group*>(canvas.item.get())) saveGroupAsFile(*g,fileName);}

    void initGodleys();

    void cut();
    void copy() const;
    void paste();
    bool clipboardEmpty() const {return clipboard.getClipboard().empty();}
    void saveSelectionAsFile(const string& fileName) const {saveGroupAsFile(canvas.selection,fileName);}
    
    void insertGroupFromFile(const string& file);

    void makeVariablesConsistent();

    void imposeDimensions();

    // runs over all ports and variables removing those not in use
    void garbageCollect();

    bool cycleCheck() const;

    void openLogFile(const string&);
    void closeLogFile() {outputDataFile.reset();}
    std::set<string> logVarList;
    bool loggingEnabled() const {return outputDataFile.get();}
    
    void constructEquations();
    void dimensionalAnalysis() const;
    void deleteAllUnits();
    
    bool checkEquationOrder() const;

    
    double lastT{0}; 
    double deltaT() const {return t-lastT;}
    void reset(); 
    std::vector<double> step();  

    int numBackups=1; 
    void save(const std::string& filename);
    void load(const std::string& filename);

    /*static*/ void exportSchema(const std::string& filename, int schemaLevel=1);

    void displayErrorItem(const Item& op) const;

    static const std::string minskyVersion;
    /*static*/ std::string ecolabVersion() const {return VERSION;}
    /*static*/ std::string ravelVersion() const {
      if (ravel::Ravel::available())
        {
          int d=ravel::Ravel::daysUntilExpired();
          return ravel::Ravel::version() + ": "+((d>=0)?("Expires in "+std::to_string(d)+" day"+(d!=1?"s":"")): "Expired");
        }
      else return "unavailable";
    }
    static bool ravelAvailable() {return  ravel::Ravel::available();}
    static bool ravelExpired() {return  ravel::Ravel::available() && ravel::Ravel::daysUntilExpired()<0;}
    static int daysUntilRavelExpires() {return  ravel::Ravel::daysUntilExpired();}
    
    std::string fileVersion; 
    
    unsigned maxHistory{100}; 
    int maxWaitMS=100; 

    std::string autoSaveFile() const {return autoSaver? autoSaver->fileName: std::string();}
    void setAutoSaveFile(const std::string& file);
    
    void clearHistory() {history.clear(); historyPtr=0;}
    void checkPushHistory() {if (historyPtr==history.size()) pushHistory();}

    bool pushHistory();

    bool commandHook(const std::string& command, unsigned nargs);

    enum CmdData {no_command, is_const, is_setterGetter, generic};

    virtual CmdData getCommandData(const std::string& command) const {return generic;}
    
    bool doPushHistory=true;

    long undo(int changes=1);

    void convertVarType(const std::string& name, VariableType::Type type);

    void addIntegral();
    
    bool inputWired(const std::string& name) const {return definingVar(name).get();}

    void renderCanvasToPS(const std::string& filename) {canvas.renderToPS(filename);}
    void renderCanvasToPDF(const std::string& filename) {canvas.renderToPDF(filename);}
    void renderCanvasToSVG(const std::string& filename) {canvas.renderToSVG(filename);}
    void renderCanvasToPNG(const std::string& filename) {canvas.renderToPNG(filename);}

    
    void renderCanvasToPNG(const std::string& filename, const Canvas::ZoomCrop& z)
    {canvas.renderToPNGCropped(filename,z);}
      
    void renderCanvasToEMF(const std::string& filename) {canvas.renderToEMF(filename);}
    
    void renderAllPlotsAsSVG(const string& prefix) const;
    void exportAllPlotsAsCSV(const string& prefix) const;

    void setAllDEmode(bool);
    void srand(int seed) {::srand(seed);}

    // godley table display values preferences
    bool displayValues=false;
    GodleyTable::DisplayStyle displayStyle=GodleyTable::sign;

    void setGodleyDisplayValue(bool displayValues, GodleyTable::DisplayStyle displayStyle);

    void importVensim(const std::string&);
    
    void redrawAllGodleyTables();

    virtual void setBusyCursor() {}
    virtual void clearBusyCursor() {}
    virtual void progress(const std::string& title,int) {}

    virtual void bookmarkRefresh() {}
    
    virtual void resetScroll() {}
    
    virtual void message(const std::string&) {}

    virtual void runItemDeletedCallback(const Item&) {}
    
    enum MemCheckResult {OK, proceed, abort};
    virtual MemCheckResult checkMemAllocation(size_t bytes) const {return OK;}

    /*static*/ std::size_t physicalMem() const;
    
    vector<string> listFonts() const {
      vector<string> r;
#ifdef PANGO
      PangoFontFamily **families;
      int num;
      pango_font_map_list_families(pango_cairo_font_map_get_default(),
                                   &families,&num);
      for (int i=0; i<num; ++i)
        r.push_back(pango_font_family_get_name(families[i]));
      g_free(families);
      std::sort(r.begin(),r.end());
#endif
      return r;
    }

    /*static*/ std::string defaultFont();
    /*static*/ std::string defaultFont(const std::string& x);

    /*static*/ double fontScale();
    /*static*/ double fontScale(double);
    
    /*static*/ int numOpArgs(OperationType::Type o);
    OperationType::Group classifyOp(OperationType::Type o) const {return OperationType::classify(o);}

    void latex(const std::string& filename, bool wrapLaTeXLines);

    void matlab(const std::string& filename) {
      if (cycleCheck()) throw error("cyclic network detected");
      ofstream f(filename);
      MathDAG::SystemOfEquations(*this).matlab(f);
    }

    // for testing purposes
    string latex2pango(const std::string& x) {return latexToPango(x.c_str());}

    /*static*/ std::vector<std::string> availableOperations();
    using AvailableOperationsMapping=classdesc::StringKeyMap<std::vector<OperationType::Type>>;
    /*static*/ Minsky::AvailableOperationsMapping availableOperationsMapping() const;
    
    /*static*/ std::vector<std::string> variableTypes();
    /*static*/ std::vector<std::string> assetClasses();

    void autoLayout(); 
    void randomLayout(); 
    void openGroupInCanvas() {canvas.openGroupInCanvas(canvas.item);}
    void openModelInCanvas() {canvas.openGroupInCanvas(model);}

    std::shared_ptr<VariableInstanceList> variableInstanceList;
    void listAllInstances();

    std::map<std::string,std::weak_ptr<Item>> namedItems;
    void nameCurrentItem(const std::string& name) {namedItems[name]=canvas.item;}
    void itemFromNamedItem(const std::string& name) {canvas.item=namedItems[name].lock();}

    bool triggerCheckMemAllocationCallback() const
    {return checkMemAllocation(std::numeric_limits<size_t>::max());}

    VariablePane variablePane;

    char getc() const {return std::getc(stdin);}

    void setDefinition(const std::string& valueId, const std::string& definition);
  };

  Minsky& minsky();
  inline const Minsky& cminsky() {return minsky();}
  struct LocalMinsky
  {
    LocalMinsky(Minsky& m);
    ~LocalMinsky();
  };



}

#ifdef _CLASSDESC
#pragma omit pack minsky::MinskyExclude
#pragma omit unpack minsky::MinskyExclude
#pragma omit TCL_obj minsky::MinskyExclude
#pragma omit xml_pack minsky::MinskyExclude
#pragma omit xml_unpack minsky::MinskyExclude
#pragma omit xsd_generate minsky::MinskyExclude

#pragma omit xml_pack minsky::Integral
#pragma omit xml_unpack minsky::Integral

#pragma omit pack minsky::MinskyMatrix
#pragma omit unpack minsky::MinskyMatrix
#pragma omit xml_pack minsky::MinskyMatrix
#pragma omit xml_unpack minsky::MinskyMatrix
#pragma omit xsd_generate minsky::MinskyMatrix
#endif

#include "minsky.cd"
#endif