minsky::Minsky Class Reference

#include <minsky.h>

Inheritance diagram for minsky::Minsky:

Collaboration diagram for minsky::Minsky:

Public Types
enum	CmdData { no_command, is_const, is_setterGetter, generic }
enum	MemCheckResult { OK, proceed, abort }
	check whether to proceed or abort, given a request to allocate bytes of memory. Implemented in MinskyTCL More...
using	AvailableOperationsMapping = classdesc::StringKeyMap< std::vector< OperationType::Type > >

Public Member Functions
void	addNewPublicationTab (const std::string &name)
void	addCanvasItemToPublicationTab (size_t i)
bool	multipleEquities () const
bool	multipleEquities (const bool &m)
bool	edited () const
	reflects whether the model has been changed since last save More...
bool	reset_flag () const
	true if reset needs to be called prior to numerical integration More...
void	markEdited ()
	indicate model has been changed since last saved More...
void	requestReset ()
void	requestRedraw ()
	requests a redraw of the curren active tab More...
bool	resetIfFlagged () override
	checks whether a reset is required, and resets the simulation if so More...
void	populateMissingDimensions ()
	fills in dimensions table with all loaded ravel axes More...
void	populateMissingDimensionsFromVariable (const VariableValue &, bool &incompatibleMessageDisplayed)
	populate missing dimensions from a variableValue More...
void	populateMissingDimensionsFromVariable (const VariableValue &v)
void	renameDimension (const std::string &oldName, const std::string &newName)
void	setGodleyIconResource (const string &s)
void	setGroupIconResource (const string &s)
void	setLockIconResource (const string &locked, const string &unlocked)
void	setRavelIconResource (const string &s)
std::set< string >	matchingTableColumns (const GodleyIcon &currTable, GodleyAssetClass::AssetClass ac)
void	importDuplicateColumn (GodleyTable &srcTable, int srcCol)
	find any duplicate column, and use it as a source column for balanceDuplicateColumns More...
void	balanceDuplicateColumns (const GodleyIcon &srcTable, int srcCol)
	makes all duplicated columns consistent with srcTable, srcCol More...
std::vector< std::string >	allGodleyFlowVars () const
	Minsky ()
	~Minsky ()
void	clearAllMaps (bool clearHistory)
void	clearAllMaps ()
void	clearAllMapsTCL ()
VariablePtr	definingVar (const std::string &valueId) const
	returns reference to variable defining (ie input wired) for valueId More...
void	saveCanvasItemAsFile (const string &fileName) const
void	initGodleys ()
void	cut ()
	erase items in current selection, put copy into clipboard More...
void	copy () const
	copy items in current selection into clipboard More...
void	paste ()
	paste clipboard as a new group or ungrouped items on the canvas. canvas.itemFocus is set to refer to the new group or items. More...
bool	clipboardEmpty () const
	return true if nothing available in clipboard More...
void	saveSelectionAsFile (const string &fileName) const
void	insertGroupFromFile (const string &file)
void	makeVariablesConsistent ()
void	imposeDimensions ()
void	garbageCollect ()
bool	cycleCheck () const
	checks for presence of illegal cycles in network. Returns true if there are some More...
void	openLogFile (const string &)
	opens the log file, and writes out a header line describing names of all variables More...
void	closeLogFile ()
	closes log file More...
bool	loggingEnabled () const
	returns true if logging is in operation More...
void	constructEquations ()
	construct the equations based on input data More...
void	dimensionalAnalysis () const
	performs dimension analysis, throws if there is a problem More...
void	deleteAllUnits ()
	removes units markup from all variables in model More...
bool	checkEquationOrder () const
	consistency check of the equation order. Should return true. Outputs the operation number of the invalidly ordered operation. More...
double	deltaT () const
void	reset ()
	resets the variables back to their initial values More...
std::vector< double >	step ()
	step the equations (by n steps, default 1) More...
void	save (const std::string &filename)
void	load (const std::string &filename)
	load from a file More...
void	displayErrorItem (const Item &op) const
	indicate operation item has error, if visible, otherwise contining group More...
std::string	autoSaveFile () const
	name of an auto save file More...
void	setAutoSaveFile (const std::string &file)
	initialises auto saving empty file to turn off autosave More...
void	clearHistory ()
	clear history More...
void	checkPushHistory ()
	called periodically to ensure history up to date More...
bool	pushHistory ()
	push current model state onto history if it differs from previous More...
bool	commandHook (const std::string &command, unsigned nargs)
	Executed after each interpreter command to maintain undo/redo stack, edited flag, autosaving etc. More...
virtual CmdData	getCommandData (const std::string &command) const
	return meta information on a given command More...
long	undo (int changes=1)
	restore model to state changes ago More...
void	convertVarType (const std::string &name, VariableType::Type type)
	Converts variable(s) named by name into a variable of type type. More...
void	addIntegral ()
	add integral to current canvas item (which must be variable convertible to an integral variable More...
bool	inputWired (const std::string &name) const
	returns true if any variable of name name has a wired input More...
void	renderCanvasToPS (const std::string &filename)
	render canvas to a postscript file More...
void	renderCanvasToPDF (const std::string &filename)
	render canvas to a PDF file More...
void	renderCanvasToSVG (const std::string &filename)
	render canvas to an SVG file More...
void	renderCanvasToPNG (const std::string &filename)
	render canvas to a PNG image file More...
void	renderCanvasToPNG (const std::string &filename, const Canvas::ZoomCrop &z)
	Render canvas to a PNG file filename, scaling the canvas temporarily by zoom, shifts it to left, top, and crops to width, height (in ZoomCrop struct). More...
void	renderCanvasToEMF (const std::string &filename)
	render canvas to a EMF image file (Windows only) More...
void	renderAllPlotsAsSVG (const string &prefix) const
	render all plots More...
void	exportAllPlotsAsCSV (const string &prefix) const
	export all plots More...
void	setAllDEmode (bool)
	set DE mode on all godley tables More...
void	srand (int seed)
	set std library RNG seed More...
void	setGodleyDisplayValue (bool displayValues, GodleyTable::DisplayStyle displayStyle)
	set display value mode on all godley table editor modes More...
void	importVensim (const std::string &)
	import a Vensim file More...
void	redrawAllGodleyTables ()
	request all Godley table windows to redraw More...
virtual void	setBusyCursor ()
	set/clear busy cursor in GUI More...
virtual void	clearBusyCursor ()
virtual void	progress (const std::string &title, int)
	set progress bar, out of 100, labelling the progress bar with title More...
virtual void	bookmarkRefresh ()
	refresh the bookmark menu after changes More...
virtual void	resetScroll ()
	reset main window scroll bars after model has been panned More...
virtual void	message (const std::string &)
	display a message in a popup box on the GUI More...
virtual void	runItemDeletedCallback (const Item &)
	run callback attached to item More...
virtual MemCheckResult	checkMemAllocation (size_t bytes) const
vector< string >	listFonts () const
void	latex (const std::string &filename, bool wrapLaTeXLines)
void	matlab (const std::string &filename)
string	latex2pango (const std::string &x)
void	autoLayout ()
	auto layout current open group and recentre More...
void	randomLayout ()
	randomly layout current open group and recentre reinitialises canvas to the group located in item More...
void	openGroupInCanvas ()
void	openModelInCanvas ()
	reinitialises canvas to the toplevel group More...
void	listAllInstances ()
void	nameCurrentItem (const std::string &name)
void	itemFromNamedItem (const std::string &name)
bool	triggerCheckMemAllocationCallback () const
	trigger checkMem callback for testing purposes More...
char	getc () const
	Used to implement a pause until return pressed for attaching debugger purposes. More...
void	setDefinition (const std::string &valueId, const std::string &definition)
	add/replace a definition for a flow variable given by valueId More...
void	reloadAllCSVParameters ()
	reload all CSV parameters from latest values in files. More...
void	pushFlags ()
	push and pop state of the flags More...
void	popFlags ()
	push and pop state of the flags More...
Public Member Functions inherited from minsky::RungeKutta
virtual	~RungeKutta ()=default
void	rkreset ()
	reset the simulation More...
void	rkstep ()
	step the equations (by n steps, default 1) evaluate the flow equations without stepping. More...
void	evalEquations ()

Static Public Member Functions
static void	saveGroupAsFile (const Group &, const string &fileName)
static void	exportSchema (const std::string &filename, int schemaLevel=1)
static std::string	ecolabVersion ()
static std::string	ravelVersion ()
static bool	ravelAvailable ()
static bool	ravelExpired ()
static int	daysUntilRavelExpires ()
static std::size_t	physicalMem ()
	returns amount of memory installed on system More...
static int	numOpArgs (OperationType::Type o)
static OperationType::Group	classifyOp (OperationType::Type o)
static std::vector< std::string >	availableOperations ()
	list of available operations More...
static Minsky::AvailableOperationsMapping	availableOperationsMapping ()
static std::vector< std::string >	variableTypes ()
	list of available variable types More...
static std::vector< std::string >	assetClasses ()
	return list of available asset classes More...
static std::string	defaultFont ()
	the default used by Pango More...
static std::string	defaultFont (const std::string &x)
	the default used by Pango More...
static double	fontScale ()
	an extra scaling factor of Pango fonts More...
static double	fontScale (double)
	an extra scaling factor of Pango fonts More...

Public Attributes
PannableTab< EquationDisplay >	equationDisplay
FontDisplay	fontSampler
PhillipsDiagram	phillipsDiagram
std::vector< PubTab >	publicationTabs
VariableValues	variableValues
Dimensions	dimensions
Conversions	conversions
std::map< Units, double >	maxValue
	stash the maximum absolute value obtained by a dimensioned quantity More...
std::map< Units, double >	maxFlowValue
SVGRenderer	histogramResource
Exclude< std::map< std::string, std::shared_ptr< CallableFunction > > >	userFunctions
GroupPtr	model {new Group}
Canvas	canvas {model}
std::set< string >	logVarList
	set of variables (valueIds) to log More...
double	lastT {0}
	previous timestep More...
int	numBackups =1
	number of previous versions of saved files to keep save to a file More...
std::string	fileVersion
	Minsky version file was saved under. More...
unsigned	maxHistory {100}
	maximum no. of history states to save More...
int	maxWaitMS =100
	maximum wait in millisecond between redrawing canvas during simulation More...
bool	doPushHistory =true
	flag to indicate whether a TCL should be pushed onto the history stack, or logged in a recording. This is used to avoid movements being added to recordings and undo history More...
bool	displayValues =false
GodleyTable::DisplayStyle	displayStyle =GodleyTable::sign
std::shared_ptr< VariableInstanceList >	variableInstanceList
	supports navigation to all instances of current variable More...
std::map< std::string, std::weak_ptr< Item > >	namedItems
VariablePane	variablePane
Public Attributes inherited from minsky::RungeKutta
double	t {0}
	time More...
bool	running =false
	controls whether simulation is running More...
bool	reverse =false
	reverse direction of simulation More...
EvalGodley	evalGodley
Public Attributes inherited from minsky::Simulation
double	stepMin {0}
double	stepMax {0.01}
int	nSteps {1}
double	epsRel {1e-2}
double	epsAbs {1e-3}
int	order {4}
bool	implicit {false}
int	simulationDelay {0}
std::string	timeUnit
double	tmax {INFINITY}
double	t0 {0}

Static Public Attributes
static const std::string	minskyVersion =MINSKY_VERSION
Static Public Attributes inherited from minsky::ValueVector
static std::vector< double, CIVITA_ALLOCATOR< double > >	stockVars
	vector of variables that are integrated via Runge-Kutta. These variables label the columns of the Godley table More...
static std::vector< double, CIVITA_ALLOCATOR< double > >	flowVars
	variables defined as a simple function of the stock variables, also known as lhs variables. These variables appear in the body of the Godley table More...

Private Member Functions
	CLASSDESC_ACCESS (Minsky)
std::string	diagnoseNonFinite () const
	returns a diagnostic about an item that is infinite or NaN. Either a variable name, or and operator type. More...
void	logVariables () const
	write current state of all variables to the log file More...
void	balanceColumns (const GodleyIcon &srcGodley, int srcCol, GodleyIcon &destGodley, int destCol) const
	balance two Godley columns More...
void	removeItems (Wire &wire)
	remove the definition network from wire, up to, but not including attached variables. More...

Private Attributes
Exclude< ptime >	lastRedraw
bool	m_multipleEquities =false

Additional Inherited Members
Protected Member Functions inherited from minsky::RungeKutta
void	evalEquations (double result[], double, const double vars[])
void	evalJacobian (Matrix &, double, const double vars[])
Static Protected Member Functions inherited from minsky::RungeKutta
static int	RKfunction (double, const double y[], double f[], void *)
	function to be integrated (internal use) More...
static int	jacobian (double, const double y[], double *, double dfdt[], void *)
	compute jacobian (internal use) More...

Detailed Description

Definition at line 119 of file minsky.h.

Member Typedef Documentation

AvailableOperationsMapping

using minsky::Minsky::AvailableOperationsMapping = classdesc::StringKeyMap<std::vector<OperationType::Type> >

Definition at line 496 of file minsky.h.

Member Enumeration Documentation

CmdData

enum minsky::Minsky::CmdData

Enumerator
no_command
is_const
is_setterGetter
generic

Definition at line 362 of file minsky.h.

{no_command, is_const, is_setterGetter, generic};

MemCheckResult

enum minsky::Minsky::MemCheckResult

check whether to proceed or abort, given a request to allocate bytes of memory. Implemented in MinskyTCL

Enumerator
OK
proceed
abort

Definition at line 449 of file minsky.h.

{OK, proceed, abort};

Constructor & Destructor Documentation

Minsky()

minsky::Minsky::Minsky ( )

inline

Definition at line 229 of file minsky.h.

            :
      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()

minsky::Minsky::~Minsky

(

)

Definition at line 119 of file minsky.cc.

References minsky::remove().

  {
    if (edited() && autoSaver)
      // if we're at this point, then the user has already been asked to save, and chosen no.
      boost::filesystem::remove(autoSaver->fileName);
  }

Here is the call graph for this function:

Member Function Documentation

addCanvasItemToPublicationTab()

void minsky::Minsky::addCanvasItemToPublicationTab ( size_t  i )

inline

Definition at line 147 of file minsky.h.

                                                 {
      if (canvas.item && i<publicationTabs.size())
        publicationTabs[i].items.emplace_back(canvas.item);
    }

addIntegral()

void minsky::Minsky::addIntegral

(

)

add integral to current canvas item (which must be variable convertible to an integral variable

Definition at line 1526 of file minsky.cc.

References minsky::Item::moveTo().

  {
    if (auto v=canvas.item->variableCast())
      if (auto g=v->group.lock())
        {
          // nb throws if conversion cannot be performed
          convertVarType(v->valueId(),VariableType::integral);
          auto integ=new IntOp;
          g->addItem(integ);
          integ->moveTo(canvas.item->x(), canvas.item->y());
          // remove intVar from its group
          if (auto g=integ->intVar->group.lock())
            g->removeItem(*integ->intVar);
          integ->intVar=dynamic_pointer_cast<VariableBase>(canvas.item);
          integ->toggleCoupled();
          
          canvas.requestRedraw();
        }
  }

Here is the call graph for this function:

addNewPublicationTab()

void minsky::Minsky::addNewPublicationTab ( const std::string &  name )

inline

Definition at line 146 of file minsky.h.

{publicationTabs.emplace_back(name);}

allGodleyFlowVars()

vector< string > minsky::Minsky::allGodleyFlowVars

(

)

const

Definition at line 819 of file minsky.cc.

  {
    set<string> r;
    model->recursiveDo(&GroupItems::items, [&](const Items&, Items::const_iterator i) {
      if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
        {
          auto flowVars=g->table.getVariables();
          r.insert(flowVars.begin(),flowVars.end());
        }
      return false;
    });
    return {r.begin(),r.end()};
  }

assetClasses()

vector< string > minsky::Minsky::assetClasses ( )

static

return list of available asset classes

Definition at line 1609 of file minsky.cc.

  {return enumVals<GodleyTable::AssetClass>();}

autoLayout()

void minsky::Minsky::autoLayout

(

)

auto layout current open group and recentre

Definition at line 1624 of file minsky.cc.

  {
    canvas.model->autoLayout();
    canvas.recentre();
  }

autoSaveFile()

std::string minsky::Minsky::autoSaveFile ( ) const

inline

name of an auto save file

Definition at line 343 of file minsky.h.

{return autoSaver? autoSaver->fileName: std::string();}

availableOperations()

vector< string > minsky::Minsky::availableOperations ( )

static

list of available operations

Definition at line 1605 of file minsky.cc.

  {return enumVals<OperationType::Type>();}

availableOperationsMapping()

Minsky::AvailableOperationsMapping minsky::Minsky::availableOperationsMapping ( )

static

Definition at line 1612 of file minsky.cc.

References minsky::op.

  {
    AvailableOperationsMapping r;
    for (OperationType::Type op{}; op != OperationType::numOps; op=OperationType::Type(int(op)+1))
      {
        if (classifyOp(op)==OperationType::general) continue;
        if (op==OperationType::copy) continue;
        r[classdesc::to_string(classifyOp(op))].push_back(op);
      }
    return r;
  }

balanceColumns()

void minsky::Minsky::balanceColumns ( const GodleyIcon &  srcGodley, int  srcCol, GodleyIcon &  destGodley, int  destCol  ) const

private

balance two Godley columns

Definition at line 644 of file minsky.cc.

References minsky::FlowCoef::coef, minsky::GodleyIcon::flowSignature(), minsky::FlowCoef::name, minsky::scope(), minsky::FlowCoef::str(), minsky::GodleyIcon::table, minsky::trimWS(), minsky::uqName(), and minsky::GodleyIcon::valueId().

  {
    auto& srcTable=srcGodley.table;
    auto& destTable=destGodley.table;
    // reverse lookup tables for mapping flow variable to destination row numbers via row labels
    map<string,string> srcRowLabels;
    map<string, int> destRowLabels;
    set<string> uniqueSrcRowLabels; // check for uniqueness of source row labels
    for (size_t row=1; row!=srcTable.rows(); ++row)
      if (!srcTable.initialConditionRow(row) && !srcTable.cell(row,0).empty() &&
          !srcTable.cell(row,srcCol).empty())
        {
          if (!uniqueSrcRowLabels.insert(srcTable.cell(row,0)).second)
            throw runtime_error("Duplicate source row label: "+srcTable.cell(row,0));
          const FlowCoef fc(srcTable.cell(row,srcCol));
          if (!fc.name.empty())
            srcRowLabels[srcGodley.valueId(fc.name)]=
              trimWS(srcTable.cell(row,0));
        }
      else if (srcTable.initialConditionRow(row))
        // copy directly into destination initial condition,
        for (size_t r=1; r<destTable.rows(); ++r)
          if (destTable.initialConditionRow(r))
            destTable.cell(r,destCol)=srcTable.cell(row,srcCol);
    for (size_t row=1; row!=destTable.rows(); ++row)
      if (!destTable.initialConditionRow(row) && !destTable.cell(row,0).empty())
        destRowLabels[trimWS(destTable.cell(row,0))]=row;


    // compute column signature for both src and destination columns
    map<string,double> srcFlows=srcGodley.flowSignature(srcCol), 
      destFlows=destGodley.flowSignature(destCol);
    // items to add
    for (map<string,double>::iterator i=srcFlows.begin(); i!=srcFlows.end(); ++i)
      if (i->second != destFlows[i->first])
        {
          const int scope=-1;
          if (i->first.find(':')!=string::npos)
            minsky::scope(i->first);
          FlowCoef df;
          if (scope==-1 || !variableValues.count(i->first))
            df.name=uqName(i->first);
          else
            df.name=variableValues[i->first]->name;
          df.coef=i->second-destFlows[i->first];
          if (df.coef==0) continue;
          const string flowEntry=df.str();
          const string rowLabel=srcRowLabels[srcGodley.valueId(i->first)];
          const map<string,int>::iterator dr=destRowLabels.find(rowLabel);
          if (dr!=destRowLabels.end())
            if (FlowCoef(destTable.cell(dr->second, destCol)).coef==0)
              destTable.cell(dr->second, destCol) = flowEntry;
            else
              // add a new blank labelled flow line
              {
                destTable.resize(destTable.rows()+1,destTable.cols());
                destTable.cell(destTable.rows()-1, destCol) = flowEntry;
              }
          else
            // labels don't match, so add a new labelled line
            {
              destTable.resize(destTable.rows()+1,destTable.cols());
              destTable.cell(destTable.rows()-1, 0) = rowLabel;
              destRowLabels[rowLabel] = destTable.rows()-1;
              destTable.cell(destTable.rows()-1, destCol) = flowEntry;
            }
        }
    // items to delete
    set<size_t> rowsToDelete;
    for (map<string,double>::iterator i=destFlows.begin(); i!=destFlows.end(); ++i)
      if (i->second!=0 && srcFlows[i->first]==0)
        for (size_t row=1; row<destTable.rows(); ++row)
          {
            FlowCoef fc(destTable.cell(row, destCol));
            if (!fc.name.empty())
              fc.name=destGodley.valueId(fc.name);
            if (fc.name==destGodley.valueId(i->first))
              {
                destTable.cell(row, destCol).clear();
                // if this leaves an empty row, delete entire row
                for (size_t c=0; c<destTable.cols(); ++c)
                  if (!destTable.cell(row, c).empty())
                    goto rowNotEmpty;
                rowsToDelete.insert(row);
              rowNotEmpty:;
              }
          }
    // amalgamate unlabelled rows with singular value
    map<string,double> unlabelledSigs;
    for (size_t row=1; row<destTable.rows(); ++row)
      {
        if (!destTable.singularRow(row, destCol)) continue;
        const FlowCoef fc(destTable.cell(row, destCol));
        unlabelledSigs[fc.name]+=fc.coef;
        rowsToDelete.insert(row);
      }
    // append amalgamated rows
    for (auto& i: unlabelledSigs)
      if (i.second!=0)
        {
          destTable.insertRow(destTable.rows());
          destTable.cell(destTable.rows()-1,destCol)=FlowCoef(i.second,i.first).str();
        }
                   
    for (auto row=rowsToDelete.rbegin(); row!=rowsToDelete.rend(); ++row)
      destTable.deleteRow(*row);
  }

Here is the call graph for this function:

balanceDuplicateColumns()

void minsky::Minsky::balanceDuplicateColumns	(	const GodleyIcon &	srcTable,
		int	srcCol
	)

makes all duplicated columns consistent with srcTable, srcCol

Definition at line 752 of file minsky.cc.

References minsky::GodleyTable::assetClass(), minsky::GodleyTable::cell(), minsky::GodleyTable::cols(), minsky::GodleyIcon::table, minsky::trimWS(), and minsky::GodleyIcon::valueId().

Referenced by minsky::GodleyIcon::deleteRow(), minsky::GodleyTableEditor::mouseUp(), minsky::GodleyIcon::setCell(), and minsky::GodleyTableEditor::update().

  {
    const GodleyTable& srcTable=srcGodley.table;
    if (srcCol<0 || size_t(srcCol)>=srcTable.cols()) return;
    // find if there is a matching column
    const string& colName=srcGodley.valueId(trimWS(srcTable.cell(0,srcCol)));
    if (colName.empty() || colName==":_") return; //ignore blank columns

    bool matchFound=false;
    model->recursiveDo
      (&Group::items,
       [&](Items& m, Items::iterator i)
       {
         if (auto gi=dynamic_cast<GodleyIcon*>(i->get()))
           {
             if (&gi->table==&srcTable) // if source table, then check for duplicated asset/equity columns
               {
                 for (size_t col=1; col<gi->table.cols(); col++)
                   if (col==size_t(srcCol)) continue; // skip over source column
                   else if (srcGodley.valueId(trimWS(srcTable.cell(0,col)))==colName)
                     {
                       switch (srcGodley.table.assetClass(srcCol))
                         {
                         case GodleyAssetClass::asset:
                           if (srcTable.assetClass(col)!=GodleyAssetClass::equity)
                             throw error("asset column %s matches a non-liability column",colName.c_str());
                           break;
                         case GodleyAssetClass::equity:
                           if (srcTable.assetClass(col)!=GodleyAssetClass::asset)
                             throw error("equity column %s matches a non-asset column",colName.c_str());
                           break;
                         default:
                           throw error("invalid asset class for duplicate column %s",colName.c_str());
                         }
                       balanceColumns(srcGodley, srcCol, *gi, col);
                     }
               }
             else  // match asset/liability columns on different Godley tables
               for (size_t col=1; col<gi->table.cols(); col++)
                 if (gi->valueId(trimWS(gi->table.cell(0,col)))==colName) // we have a match
                   {
                     // checks asset class rules
                     switch (srcGodley.table.assetClass(srcCol))
                       {
                       case GodleyAssetClass::asset:
                         if (gi->table.assetClass(col)!=GodleyAssetClass::liability)
                           throw error("asset column %s matches a non-liability column",colName.c_str());
                         break;
                       case GodleyAssetClass::liability:
                         if (gi->table.assetClass(col)!=GodleyAssetClass::asset)
                           throw error("liability column %s matches a non-asset column",colName.c_str());
                         break;
                       default:
                         throw error("invalid asset class for duplicate column %s",colName.c_str());
                       }

                     // checks that nom more than two duplicated columns exist
                     if (matchFound)
                       throw error("more than one duplicated column detected for %s",colName.c_str());
                     matchFound=true;
                     balanceColumns(srcGodley, srcCol, *gi, col);
                   }
           }
         return false;
       });  // TODO - this lambda is FAR too long!
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bookmarkRefresh()

virtual void minsky::Minsky::bookmarkRefresh ( )

inlinevirtual

refresh the bookmark menu after changes

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 436 of file minsky.h.

Referenced by minsky::GroupItems::addItem(), minsky::Item::adjustBookmark(), minsky::Group::deleteItem(), and minsky::Canvas::openGroupInCanvas().

{}

Here is the caller graph for this function:

checkEquationOrder()

bool minsky::Minsky::checkEquationOrder

(

)

const

consistency check of the equation order. Should return true. Outputs the operation number of the invalidly ordered operation.

Definition at line 1176 of file minsky.cc.

References minsky::op.

  {
    ecolab::array<bool> fvInit(flowVars.size(), false);
    // firstly, find all flowVars that are constants
    for (auto& v: variableValues)
      if (!inputWired(v.first) && v.second->idx()>=0)
        fvInit[v.second->idx()]=true;

    for (auto& e: equations)
      if (auto eo=dynamic_cast<const ScalarEvalOp*>(e.get()))
        {
          if (eo->out < 0|| (eo->numArgs()>0 && eo->in1.empty()) ||
              (eo->numArgs() > 1 && eo->in2.empty()))
            {
              return false;
            }
          switch  (eo->numArgs())
            {
            case 0:
              fvInit[eo->out]=true;
              break;
            case 1:
              fvInit[eo->out]=!eo->flow1 || fvInit[eo->in1[0]];
              break;
            case 2:
              // we need to check if an associated binary operator has
              // an unwired input, and if so, treat its input as
              // initialised, since it has already been initialised in
              // getInputFromVar()
              if (auto op=eo->state)
                switch (op->type())
                  {
                  case OperationType::add: case OperationType::subtract:
                  case OperationType::multiply: case OperationType::divide:
                    fvInit[eo->in1[0]] |= op->ports(1).lock()->wires().empty();
                    fvInit[eo->in2[0][0].idx] |= op->ports(3).lock()->wires().empty();
                    break;
                  default: break;
                  }
            
              fvInit[eo->out]=
                (!eo->flow1 ||  fvInit[eo->in1[0]]) && (!eo->flow2 ||  fvInit[eo->in2[0][0].idx]);
              break;
            default: break;
            }
          //        if (!fvInit[eo.out])
          //          cerr << "Operation "<<opIdOfEvalOp(eo)<<" out of order"<<endl;
        }
    
    return all(fvInit);
  }

checkMemAllocation()

virtual MemCheckResult minsky::Minsky::checkMemAllocation ( size_t  bytes ) const

inlinevirtual

Definition at line 450 of file minsky.h.

{return OK;}

checkPushHistory()

void minsky::Minsky::checkPushHistory ( )

inline

called periodically to ensure history up to date

Definition at line 351 of file minsky.h.

{if (historyPtr==history.size()) pushHistory();}

CLASSDESC_ACCESS()

minsky::Minsky::CLASSDESC_ACCESS ( Minsky  )

private

classifyOp()

static OperationType::Group minsky::Minsky::classifyOp ( OperationType::Type  o )

inlinestatic

Definition at line 481 of file minsky.h.

References minsky::OperationType::classify().

{return OperationType::classify(o);}

Here is the call graph for this function:

clearAllMaps() [1/2]

void minsky::Minsky::clearAllMaps

(

bool

clearHistory

)

Definition at line 126 of file minsky.cc.

  {
    model->clear();
    canvas.openGroupInCanvas(model);
    equations.clear();
    integrals.clear();
    variableValues.clear();
    variablePane.update();
    maxValue.clear();
    PhillipsFlow::maxFlow.clear();
    PhillipsStock::maxStock.clear();
    phillipsDiagram.clear();
    publicationTabs.clear();
    publicationTabs.emplace_back("Publication");
    userFunctions.clear();
    UserFunction::nextId=0;
    
    flowVars.clear();
    stockVars.clear();

    dimensions.clear();
    namedItems.clear();
    flags=reset_needed|fullEqnDisplay_needed;
    fileVersion=minskyVersion;
    if (doClearHistory) clearHistory();
  }

clearAllMaps() [2/2]

void minsky::Minsky::clearAllMaps ( )

inline

Definition at line 246 of file minsky.h.

References clearAllMaps().

Referenced by clearAllMaps().

{clearAllMaps(true);}

Here is the call graph for this function:

Here is the caller graph for this function:

clearAllMapsTCL()

void minsky::Minsky::clearAllMapsTCL ( )

inline

Definition at line 248 of file minsky.h.

{clearAllMaps(true);}

clearBusyCursor()

virtual void minsky::Minsky::clearBusyCursor ( )

inlinevirtual

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 431 of file minsky.h.

{}

clearHistory()

void minsky::Minsky::clearHistory ( )

inline

clear history

Definition at line 349 of file minsky.h.

{history.clear(); historyPtr=0;}

clipboardEmpty()

bool minsky::Minsky::clipboardEmpty ( ) const

inline

return true if nothing available in clipboard

Definition at line 267 of file minsky.h.

{return clipboard.getClipboard().empty();}

closeLogFile()

void minsky::Minsky::closeLogFile ( )

inline

closes log file

Definition at line 287 of file minsky.h.

{outputDataFile.reset();}

commandHook()

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

Executed after each interpreter command to maintain undo/redo stack, edited flag, autosaving etc.

Parameters

command	'.' separated command
nargs	number of arguments

Returns

whether to save the command when recording events

Definition at line 1325 of file minsky.cc.

Referenced by minsky::RESTMinsky::commandHook().

  {
    static const set<string> constableCommands={ // commands that should not trigger the edit flag
      "minsky.availableOperations",
      "minsky.canvas.displayDelayedTooltip",
      "minsky.canvas.findVariableDefinition",
      "minsky.canvas.focusFollowsMouse",
      "minsky.canvas.moveTo",
      "minsky.canvas.model.moveTo",
      "minsky.canvas.model.zoom",
      /* we record mouse movements, but filter from history */
      "minsky.canvas.mouseDown",
      "minsky.canvas.mouseMove",
      "minsky.canvas.position",
      "minsky.canvas.recentre",
      "minsky.canvas.select",
      "minsky.canvas.selectVar",
      "minsky.canvas.scaleFactor",
      "minsky.canvas.zoom",
      "minsky.canvas.zoomToFit",
      "minsky.histogramResource.setResource",
      "minsky.model.moveTo",
      "minsky.clearAllMaps",
      "minsky.doPushHistory",
      "minsky.fontScale",
      "minsky.load",
      "minsky.model.zoom",
      "minsky.multipleEquities",
      "minsky.openGroupInCanvas",
      "minsky.openModelInCanvas",
      "minsky.popFlags",
      "minsky.pushFlags",
      "minsky.pushHistory",
      "minsky.redrawAllGodleyTables",
      "minsky.reverse",
      "minsky.running",
      "minsky.save",
      "minsky.select",
      "minsky.selectVar",
      "minsky.setGodleyDisplayValue",
      "minsky.setGodleyIconResource",
      "minsky.setGroupIconResource",
      "minsky.setLockIconResource",
      "minsky.setRavelIconResource",
      "minsky.setAutoSaveFile",
      "minsky.step",
      "minsky.undo"
    };
    if (doPushHistory && !constableCommands.contains(command) &&
        command.find("minsky.phillipsDiagram")==string::npos &&
        command.find("minsky.equationDisplay")==string::npos && 
        command.find("minsky.publicationTabs")==string::npos && 
        command.find(".renderFrame")==string::npos && 
        command.find(".requestRedraw")==string::npos && 
        command.find(".backgroundColour")==string::npos && 
        command.find(".get")==string::npos && 
        command.find(".@elem")==string::npos && 
        command.find(".mouseFocus")==string::npos
        )
      {
        auto t=getCommandData(command);
        if (t==generic || (t==is_setterGetter && nargs>0))
          {
            const bool modelChanged=pushHistory();
            if (modelChanged && command.find(".keyPress")==string::npos)
              {
                markEdited();
              }
            return modelChanged;
          }
      }
    return command=="minsky.canvas.requestRedraw" || command=="minsky.canvas.mouseDown" || command=="minsky.canvas.mouseMove" || command.find(".get")!=string::npos;
  }

Here is the caller graph for this function:

constructEquations()

void minsky::Minsky::constructEquations

(

)

construct the equations based on input data

Exceptions

ecolab::error

if the data is inconsistent

Definition at line 392 of file minsky.cc.

References minsky::canonicalName(), f, MathDAG::SystemOfEquations::populateEvalOpVector(), minsky::timeUnit, MathDAG::SystemOfEquations::updatePortVariableValue(), and minsky::valueIdFromScope().

  {
    if (cycleCheck()) throw error("cyclic network detected");

    const ProgressUpdater pu(progressState,"Construct equations",8);
    garbageCollect();
    equations.clear();
    integrals.clear();
    ++progressState;
    
    // add all user defined functions to the global symbol tables
    userFunctions.clear();
    model->recursiveDo
      (&Group::items,
       [this](const Items&, Items::const_iterator it){
         if (auto f=dynamic_pointer_cast<CallableFunction>(*it))
           userFunctions[valueIdFromScope((*it)->group.lock(), canonicalName(f->name()))]=f;
         return false;
       });
    ++progressState;
    model->recursiveDo
      (&Group::groups,
       [this](const Groups&, Groups::const_iterator it){
         userFunctions[valueIdFromScope((*it)->group.lock(), canonicalName((*it)->name()))]=*it;
         return false;
       });
    ++progressState;

    EvalOpBase::timeUnit=timeUnit;

    MathDAG::SystemOfEquations system(*this);
    ++progressState;
    assert(variableValues.validEntries());
    system.populateEvalOpVector(equations, integrals);
    ++progressState;
    assert(variableValues.validEntries());
    system.updatePortVariableValue(equations);
  }

Here is the call graph for this function:

convertVarType()

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

Converts variable(s) named by name into a variable of type type.

Exceptions

if	conversion is disallowed

Definition at line 1456 of file minsky.cc.

References minsky::isValueId(), and minsky::var.

Referenced by minsky::IntOp::description(), minsky::VariableBase::retype(), and minsky::GodleyIcon::updateVars().

  {
    assert(isValueId(name));
    const VariableValues::iterator i=variableValues.find(name);
    if (i==variableValues.end())
      throw error("variable %s doesn't exist",name.c_str());
    if (i->second->type()==type) return; // nothing to do!

    string newName=name; // useful for checking flows and stocks with same name and renaming them as the case may be. for ticket 1272  
    model->recursiveDo
      (&GroupItems::items,
       [&](const Items&,Items::const_iterator i)
       {
         if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
           {
             if (type!=VariableType::flow)
               for (auto& v: g->flowVars())
                 if (v->valueId()==name)
                   {
                     newName=v->name()+"^{Flow}";
                     const VariableValues::iterator iv=variableValues.find(newName);
                     if (iv==variableValues.end()) {g->table.renameFlows(v->name(),newName); v->retype(VariableType::flow);}
                     else throw error("flow variables in Godley tables cannot be converted to a different type");
                   }    
             if (type!=VariableType::stock)
               for (auto& v: g->stockVars())
                 if (v->valueId()==name)
                   {
                     newName=v->name()+"^{Stock}";
                     const VariableValues::iterator iv=variableValues.find(newName);
                     if (iv==variableValues.end()) {g->table.renameStock(v->name(),newName); v->retype(VariableType::stock);}
                     else throw error("stock variables in Godley tables cannot be converted to a different type");
                   }
           }
         return false;
       });   
                         
    if (auto var=definingVar(name))
      // we want to be able to convert stock vars to flow vars when their input is wired. condition is only met when newName has not been changed above. for ticket 1272
      if (name==newName && var->type() != type && (!var->isStock() || var->controller.lock()))
        throw error("cannot convert a variable to a type other than its defined type");

    // filter out invalid targets
    switch (type)
      {
      case VariableType::undefined: case VariableType::numVarTypes: 
      case VariableType::tempFlow:
        throw error("convertVarType not supported for type=%s",
                    VariableType::typeName(type).c_str());
      default: break;
      }

    // convert all references
    model->recursiveDo(&Group::items,
                       [&](Items&, Items::iterator i) {
                         if (auto v=VariablePtr(*i))
                           if (v->valueId()==name)
                             {
                               v.retype(type);
                               if (*i==canvas.item)
                                 canvas.item=v;
                               *i=v;
                             }
                         return false;
                       });
    auto init=i->second->init();
    i->second=VariableValuePtr(type,i->second->name);
    i->second->init(init);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

copy()

void minsky::Minsky::copy

(

)

const

copy items in current selection into clipboard

Definition at line 190 of file minsky.cc.

References minsky::schemaURL, and classdesc::xml_pack().

Referenced by minsky::Canvas::select().

  {
    if (canvas.selection.empty())
      clipboard.putClipboard(""); // clear clipboard
    else
      {
        schema3::Minsky m(canvas.selection);
        ostringstream os;
        xml_pack_t packer(os, schemaURL);
        xml_pack(packer, "Minsky", m);
        clipboard.putClipboard(os.str());
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

cut()

void minsky::Minsky::cut

(

)

erase items in current selection, put copy into clipboard

Definition at line 156 of file minsky.cc.

  {
    copy();
    for (auto& i: canvas.selection.items)
      {
        if (auto v=i->variableCast())
          if (v->controller.lock())
            continue; // do not delete a variable controlled by another item
        model->deleteItem(*i);
      }
    for (auto& i: canvas.selection.groups)
      model->removeGroup(*i);
    for (auto& i: canvas.selection.wires)
      model->removeWire(*i);
    canvas.item.reset();
    canvas.itemFocus.reset();
#ifndef NDEBUG
    garbageCollect();
    for (auto& i: canvas.selection.items)
      {
        if (auto v=i->variableCast())
          if (v->controller.lock())
            continue; // variable controlled by another item is not being destroyed
        assert(i.use_count()==1);
      }
    for (auto& i: canvas.selection.groups)
      assert(i.use_count()==1);
    for (auto& i: canvas.selection.wires)
      assert(i.use_count()==1);
#endif
    canvas.selection.clear();
    canvas.requestRedraw();
  }

cycleCheck()

bool minsky::Minsky::cycleCheck

(

)

const

checks for presence of illegal cycles in network. Returns true if there are some

Definition at line 1158 of file minsky.cc.

  {
    // construct the network schematic
    Network net;
    for (auto& w: model->findWires([](const WirePtr&){return true;}))
      net.emplace(w->from().get(), w->to().get());
    for (auto& i: model->findItems([](const ItemPtr&){return true;}))
      if (!dynamic_cast<IntOp*>(i.get()) && !dynamic_cast<GodleyIcon*>(i.get()))
        for (unsigned j=1; j<i->portsSize(); ++j)
          net.emplace(i->ports(j).lock().get(), i->ports(0).lock().get());
    
    for (auto& i: net)
      if (!i.first->input() && !net.portsVisited.contains(i.first))
        if (net.followWire(i.first))
          return true;
    return false;
  }

daysUntilRavelExpires()

static int minsky::Minsky::daysUntilRavelExpires ( )

inlinestatic

Definition at line 335 of file minsky.h.

{return  ravelCAPI::daysUntilExpired();}

defaultFont() [1/2]

string minsky::Minsky::defaultFont ( )

static

the default used by Pango

Definition at line 1750 of file minsky.cc.

References minsky::_defaultFont.

  {return _defaultFont? _defaultFont.get(): "";}

defaultFont() [2/2]

string minsky::Minsky::defaultFont ( const std::string &  x )

static

the default used by Pango

Definition at line 1753 of file minsky.cc.

References minsky::_defaultFont.

  {
    _defaultFont.reset(new char[x.length()+1]);
    strncpy(_defaultFont.get(),x.c_str(),x.length()+1);
    ecolab::Pango::defaultFamily=_defaultFont.get();
    return x;
  }

definingVar()

VariablePtr minsky::Minsky::definingVar

(

const std::string &

valueId

)

const

returns reference to variable defining (ie input wired) for valueId

Definition at line 204 of file minsky.cc.

References minsky::valueId().

Referenced by minsky::VariableValue::hypercube(), minsky::VariableValue::init(), minsky::Canvas::renameItem(), minsky::VariableValues::resetValue(), minsky::VariableBase::sliderVisible(), and minsky::GodleyIcon::update().

  {
    return dynamic_pointer_cast<VariableBase>
      (model->findAny(&Group::items, [&](const ItemPtr& x) {
        auto v=x->variableCast();
        return v && v->valueId()==valueId && v->defined();
      }));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

deleteAllUnits()

void minsky::Minsky::deleteAllUnits

(

)

removes units markup from all variables in model

Definition at line 459 of file minsky.cc.

References minsky::timeUnit.

  {
    for (auto& i: variableValues)
      i.second->units.clear();
    timeUnit.clear();
  }

deltaT()

double minsky::Minsky::deltaT ( ) const

inline

Definition at line 308 of file minsky.h.

{return t-lastT;}

diagnoseNonFinite()

string minsky::Minsky::diagnoseNonFinite ( ) const

private

returns a diagnostic about an item that is infinite or NaN. Either a variable name, or and operator type.

Definition at line 998 of file minsky.cc.

References minsky::anonymous_namespace{userFunction.cc}::isfinite().

  {
    // firstly check if any variables are not finite
    for (VariableValues::const_iterator v=variableValues.begin();
         v!=variableValues.end(); ++v)
      if (!isfinite(v->second->value()))
        return v->first;

    // now check operator equations
    for (EvalOpVector::const_iterator e=equations.begin(); e!=equations.end(); ++e)
      if (!isfinite(flowVars[(*e)->out]))
        return OperationType::typeName((*e)->type());
    return "";
  }

Here is the call graph for this function:

dimensionalAnalysis()

void minsky::Minsky::dimensionalAnalysis

(

)

const

performs dimension analysis, throws if there is a problem

Definition at line 431 of file minsky.cc.

  {
    const_cast<Minsky*>(this)->variableValues.resetUnitsCache();
    // increment varsPassed by one to prevent resettting the cache on each check
    const IncrDecrCounter vpIdc(VariableBase::varsPassed);
    model->recursiveDo
      (&Group::items,
       [&](Items& m, Items::iterator i)
       {
         if (auto v=(*i)->variableCast())
           {
             // check only the defining variables
             if (v->isStock() && (v->inputWired() || v->controller.lock().get()))
               v->checkUnits();
           }
         else if ((*i)->portsSize()>0 && !(*i)->ports(0).lock()->input() &&
                  (*i)->ports(0).lock()->wires().empty())
           (*i)->checkUnits(); // check anything with an unwired output port
         else if (auto p=(*i)->plotWidgetCast())
           for (size_t j=0; j<p->portsSize(); ++j)
             p->ports(j).lock()->checkUnits();
         else if (auto p=dynamic_cast<Sheet*>(i->get()))
           for (size_t j=0; j<p->portsSize(); ++j)
             p->ports(j).lock()->checkUnits();
         return false;
       });
  }

displayErrorItem()

void minsky::Minsky::displayErrorItem

(

const Item &

op

)

const

indicate operation item has error, if visible, otherwise contining group

Definition at line 1229 of file minsky.cc.

References minsky::Canvas::itemIndicator, pyminsky::minsky, minsky::op, and resetScroll().

Referenced by MathDAG::OperationDAGBase::addEvalOps(), minsky::TensorOpFactory::create(), minsky::RungeKutta::evalEquations(), minsky::anonymous_namespace{minsky.cc}::Network::followWire(), MathDAG::SystemOfEquations::makeDAG(), MathDAG::anonymous_namespace{equations.cc}::NoArgument::NoArgument(), and minsky::Item::throw_error().

  {
    // this method is logically const, but because of the way
    // canvas rendering is done, canvas state needs updating
    auto& canvas=const_cast<Canvas&>(this->canvas);
    if (op.visible())
      canvas.itemIndicator=canvas.model->findItem(op);
    else if (auto v=op.variableCast())
      if (auto c=v->controller.lock())
        displayErrorItem(*c);

    if (!canvas.itemIndicator)
      if (auto g=op.group.lock())
        {
          while (g && !g->visible()) g=g->group.lock();
          if (g && g->visible())
            canvas.itemIndicator=g;
        }
    
    if (canvas.itemIndicator)
      {
        auto physX=canvas.itemIndicator->x();
        auto physY=canvas.itemIndicator->y();
        if (physX<100 || physX>canvas.frameArgs().childWidth-100 ||
            physY<100 || physY>canvas.frameArgs().childHeight-100)
          {
            canvas.model->moveTo(0.5*canvas.frameArgs().childWidth-physX+canvas.model->x(),
                                 0.5*canvas.frameArgs().childHeight-physY+canvas.model->y());
            minsky().resetScroll();
          }
      }
    //requestRedraw calls back into TCL, so don't call it from the simulation thread. See ticket #973
    if (!RKThreadRunning) canvas.requestRedraw();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ecolabVersion()

static std::string minsky::Minsky::ecolabVersion ( )

inlinestatic

Definition at line 324 of file minsky.h.

{return VERSION;}

edited()

bool minsky::Minsky::edited ( ) const

inline

reflects whether the model has been changed since last save

Definition at line 157 of file minsky.h.

{return flags & is_edited;}

exportAllPlotsAsCSV()

void minsky::Minsky::exportAllPlotsAsCSV

(

const string &

prefix

)

const

export all plots

Definition at line 1562 of file minsky.cc.

References minsky::str().

  {
    unsigned plotNum=0;
    model->recursiveDo(&Group::items,
                       [&](Items&, Items::iterator i) {
                         if (auto p=(*i)->plotWidgetCast())
                           {
                             if (!p->title.empty())
                               p->exportAsCSV((prefix+"-"+p->title+".csv"));
                             else
                               p->exportAsCSV((prefix+"-"+str(plotNum++)+".csv"));
                           }
                         return false;
                       });
  }

Here is the call graph for this function:

exportSchema()

void minsky::Minsky::exportSchema ( const std::string &  filename, int  schemaLevel = 1  )

static

Definition at line 1105 of file minsky.cc.

References f, minsky::schemaURL, and classdesc::xsd_generate().

  {
    xsd_generate_t x;
    switch (schemaLevel)
      {
      case 0:
        xsd_generate(x,"Minsky",schema0::Minsky());
        break;
      case 1:
        xsd_generate(x,"Minsky",schema1::Minsky());
        break;
      case 2:
        xsd_generate(x,"Minsky",schema2::Minsky());
        break;
      case 3:
        xsd_generate(x,"Minsky",schema3::Minsky());
        break;
      }
    ofstream f(filename);
    x.output(f,schemaURL);
  }

Here is the call graph for this function:

fontScale() [1/2]

double minsky::Minsky::fontScale ( )

static

an extra scaling factor of Pango fonts

Definition at line 1761 of file minsky.cc.

  {return ecolab::Pango::scaleFactor;}

fontScale() [2/2]

double minsky::Minsky::fontScale ( double  s )

static

an extra scaling factor of Pango fonts

Definition at line 1764 of file minsky.cc.

  {return ecolab::Pango::scaleFactor=s;}

garbageCollect()

void minsky::Minsky::garbageCollect

(

)

Definition at line 374 of file minsky.cc.

  {
    makeVariablesConsistent();
    stockVars.clear();
    flowVars.clear();
    equations.clear();
    integrals.clear();

    // remove all temporaries
    for (auto v=variableValues.begin(); v!=variableValues.end();)
      if (v->second->temp())
        variableValues.erase(v++);
      else
        ++v;

    variableValues.reset();
  }

getc()

char minsky::Minsky::getc ( ) const

inline

Used to implement a pause until return pressed for attaching debugger purposes.

Definition at line 526 of file minsky.h.

{return std::getc(stdin);}

getCommandData()

virtual CmdData minsky::Minsky::getCommandData ( const std::string &  command ) const

inlinevirtual

return meta information on a given command

Reimplemented in minsky::RESTMinsky.

Definition at line 365 of file minsky.h.

{return generic;}

importDuplicateColumn()

void minsky::Minsky::importDuplicateColumn	(	GodleyTable &	srcTable,
		int	srcCol
	)

find any duplicate column, and use it as a source column for balanceDuplicateColumns

Definition at line 617 of file minsky.cc.

References minsky::GodleyTable::cell(), minsky::GodleyTable::cols(), and minsky::trimWS().

Referenced by minsky::GodleyTableEditor::importStockVarByCol(), minsky::GodleyIcon::setCell(), and minsky::GodleyTableEditor::update().

  {
    if (srcCol<0 || size_t(srcCol)>=srcTable.cols()) return;
    // find any duplicate column, and use it to do balanceDuplicateColumns
    const string& colName=trimWS(srcTable.cell(0,srcCol));
    if (colName.empty()) return; //ignore blank columns

    try
      {
        model->recursiveDo
          (&Group::items,
           [&](Items& m, Items::iterator i)
           {
             if (auto gi=dynamic_cast<GodleyIcon*>(i->get()))
               for (size_t col=1; col<gi->table.cols(); col++)
                 if ((&gi->table!=&srcTable || int(col)!=srcCol) && trimWS(gi->table.cell(0,col))==colName) // we have a match
                   balanceDuplicateColumns(*gi, col);
             return false;
           });
      }
    catch (...) // in the event of business rules being violated, delete column name
      {
        srcTable.cell(0,srcCol).clear();
        throw;
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

importVensim()

void minsky::Minsky::importVensim

(

const std::string &

filename

)

import a Vensim file

Definition at line 1598 of file minsky.cc.

References f, and minsky::readMdl().

  {
    ifstream f(filename);
    readMdl(*model,*this,f);
    canvas.requestRedraw();
  }

Here is the call graph for this function:

imposeDimensions()

void minsky::Minsky::imposeDimensions

(

)

Definition at line 364 of file minsky.cc.

Referenced by minsky::Ravel::setDimension().

  {
    for (auto& v: variableValues)
      {
        v.second->imposeDimensions(dimensions);
        v.second->tensorInit.imposeDimensions(dimensions);
      }
  }

Here is the caller graph for this function:

initGodleys()

void minsky::Minsky::initGodleys

(

)

Definition at line 856 of file minsky.cc.

  {
    auto toGodleyIcon=[](const ItemPtr& i) {return dynamic_cast<GodleyIcon*>(i.get());};
    auto godleyItems=model->findAll<GodleyIcon*>
      (toGodleyIcon, &GroupItems::items, toGodleyIcon);
    evalGodley.initialiseGodleys(GodleyIt(godleyItems.begin()), 
                                 GodleyIt(godleyItems.end()), variableValues);
  }

inputWired()

bool minsky::Minsky::inputWired ( const std::string &  name ) const

inline

returns true if any variable of name name has a wired input

Definition at line 385 of file minsky.h.

Referenced by minsky::GroupItems::addWire().

{return definingVar(name).get();}

Here is the caller graph for this function:

insertGroupFromFile()

void minsky::Minsky::insertGroupFromFile

(

const string &

file

)

Definition at line 322 of file minsky.cc.

References schema3::Minsky::populateGroup(), and minsky::stripByteOrderingMarker().

  {
    ifstream inf(file);
    if (!inf)
      throw runtime_error(string("failed to open ")+file);
    stripByteOrderingMarker(inf);
    xml_unpack_t saveFile(inf);
    const schema3::Minsky currentSchema(saveFile);

    const GroupPtr g(new Group);
    currentSchema.populateGroup(*model->addGroup(g));
    g->resizeOnContents();
    canvas.itemFocus=g;
  }

Here is the call graph for this function:

itemFromNamedItem()

void minsky::Minsky::itemFromNamedItem ( const std::string &  name )

inline

Definition at line 517 of file minsky.h.

{canvas.item=namedItems[name].lock();}

latex()

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

Definition at line 1767 of file minsky.cc.

References f, MathDAG::SystemOfEquations::latex(), and MathDAG::SystemOfEquations::latexWrapped().

  {
    if (cycleCheck()) throw error("cyclic network detected");
    ofstream f(filename);

    f<<"\\documentclass{article}\n";
    if (wrapLaTeXLines)
      {
        f<<"\\usepackage{breqn}\n\\begin{document}\n";
        MathDAG::SystemOfEquations(*this).latexWrapped(f);
      }
    else
      {
        f<<"\\begin{document}\n";
        MathDAG::SystemOfEquations(*this).latex(f);
      }
    f<<"\\end{document}\n";
  }

Here is the call graph for this function:

latex2pango()

string minsky::Minsky::latex2pango ( const std::string &  x )

inline

Definition at line 492 of file minsky.h.

References minsky::latexToPango().

{return latexToPango(x.c_str());}

Here is the call graph for this function:

listAllInstances()

void minsky::Minsky::listAllInstances

(

)

Definition at line 1636 of file minsky.cc.

  {
    if (canvas.item)
      if (auto v=canvas.item->variableCast())
        {
          variableInstanceList=std::make_shared<VariableInstanceList>(*canvas.model, v->valueId());
          return;
        }
    variableInstanceList.reset();
  }

listFonts()

vector<string> minsky::Minsky::listFonts ( ) const

inline

Definition at line 455 of file minsky.h.

                                     {
      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;
    }

load()

void minsky::Minsky::load

(

const std::string &

filename

)

load from a file

Definition at line 1047 of file minsky.cc.

References schema3::Minsky::populateMinsky(), schema3::Minsky::schemaVersion, minsky::stripByteOrderingMarker(), and schema3::Minsky::version.

  {
    running=false;
    clearAllMaps(true);

    ifstream inf(filename);
    if (!inf)
      throw runtime_error("failed to open "+filename);
    stripByteOrderingMarker(inf);
    
    {
      const BusyCursor busy(*this);
      xml_unpack_t saveFile(inf);
      const schema3::Minsky currentSchema(saveFile);
      currentSchema.populateMinsky(*this);
      if (currentSchema.schemaVersion<currentSchema.version)
        message("You are converting the model from an older version of Minsky. "
                "Once you save this file, you may not be able to open this file"
                " in older versions of Minsky.");
    }

    const LocalMinsky lm(*this); // populateMinsky resets the local minsky pointer, so restore it here
    flags=fullEqnDisplay_needed;
    
    // try balancing all Godley tables
    try
      {
        model->recursiveDo(&Group::items, 
                           [this](Items&,Items::iterator i) {
                             try
                               {
                                 if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
                                   {
                                     for (unsigned j=1; j<g->table.cols(); ++j)
                                       balanceDuplicateColumns(*g,j);
                                   }
                                 (*i)->adjustBookmark();
                               }
                             catch (...) {}
                             return false;
                           });

        // try resetting the system, but ignore any errors
        reset();
        populateMissingDimensions();
      }
    catch (...) {flags|=reset_needed;}
    canvas.requestRedraw();
    canvas.moveTo(0,0); // force placement of ports
    // sometimes we need to recalculate the bounding boxes
    model->recursiveDo(&Group::items,
                       [](Items&,Items::iterator i) {
                         (*i)->updateBoundingBox();
                         return false;
                       });
    pushHistory();
  }

Here is the call graph for this function:

loggingEnabled()

bool minsky::Minsky::loggingEnabled ( ) const

inline

returns true if logging is in operation

Definition at line 291 of file minsky.h.

{return outputDataFile.get();}

logVariables()

void minsky::Minsky::logVariables ( ) const

private

write current state of all variables to the log file

Definition at line 107 of file minsky.cc.

  {
    if (outputDataFile)
      {
        *outputDataFile<<t;
        for (auto& v: variableValues)
          if (logVarList.contains(v.first))
            *outputDataFile<<" "<<v.second->value();
        *outputDataFile<<endl;
      }
  }        

makeVariablesConsistent()

void minsky::Minsky::makeVariablesConsistent

(

)

Definition at line 337 of file minsky.cc.

  {
    // remove variableValues not in variables
    set<string> existingNames;
    existingNames.insert("constant:zero");
    existingNames.insert("constant:one");
    vector<GodleyIcon*> godleysToUpdate;
    model->recursiveDo(&Group::items, 
                       [&](Items&,Items::iterator i) {
                         if (auto v=(*i)->variableCast())
                           existingNames.insert(v->valueId());
                         // ensure Godley table variables are the correct types
                         if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
                           godleysToUpdate.push_back(g);
                         return false;
                       }
                       );

    for (auto g: godleysToUpdate) g->update();
    for (auto i=variableValues.begin(); i!=variableValues.end(); )
      if (existingNames.contains(i->first))
        ++i;
      else
        variableValues.erase(i++);
    
  }

markEdited()

void minsky::Minsky::markEdited ( )

inline

indicate model has been changed since last saved

Definition at line 161 of file minsky.h.

Referenced by minsky::Canvas::keyPress(), and minsky::GodleyTable::markEdited().

                      {
      flags |= is_edited | fullEqnDisplay_needed;
      if (!running) flags|=reset_needed; // don't reset when running
      variablePane.update();
      canvas.requestRedraw();
      canvas.model.updateTimestamp();
    }

Here is the caller graph for this function:

matchingTableColumns()

std::set< string > minsky::Minsky::matchingTableColumns	(	const GodleyIcon &	currTable,
		GodleyAssetClass::AssetClass	ac
	)

Returns

available matching columns from other Godley tables

Parameters

currTable

- this table, not included in the matching process

Definition at line 566 of file minsky.cc.

References minsky::godley, and minsky::scope().

Referenced by minsky::GodleyTableEditor::matchingTableColumnsByCol().

  {
    std::set<string> r;
    GodleyAssetClass::AssetClass target_ac;
    // matching liability with assets and vice-versa
    switch (ac)
      {
      case GodleyAssetClass::liability:
      case GodleyAssetClass::equity:
        target_ac=GodleyAssetClass::asset;
        break;
      case GodleyAssetClass::asset:
        target_ac=GodleyAssetClass::liability;
        break;
      default:
        return r; // other types do not match anything
      }

    std::set<string> duplicatedColumns;
    model->recursiveDo
      (&Group::items,
       [&](Items& m, Items::iterator it)
       {
         if (auto gi=dynamic_cast<GodleyIcon*>(it->get()))
           {
             for (size_t i=1; i<gi->table.cols(); ++i)
               if (!gi->table.cell(0,i).empty())
                 {
                   auto v=gi->table.cell(0,i);
                   auto scope=minsky::scope(gi->group.lock(),v);
                   if (scope->higher(*godley.group.lock()))
                     v=':'+v; //NOLINT
                   else if (scope!=godley.group.lock())
                     continue; // variable is inaccessible
                   if (r.contains(v) || gi->table.assetClass(i)!=target_ac) 
                     {
                       r.erase(v); // column already duplicated, or in current, nothing to match
                       duplicatedColumns.insert(v);
                     }
                   else if (!duplicatedColumns.contains(v) && gi->table.assetClass(i)==target_ac &&
                            // insert unmatched asset columns from this table only for equity (feature #174)
                            // otherwise matches are between separate tables
                            ((ac!=GodleyAssetClass::equity && gi!=&godley) || (ac==GodleyAssetClass::equity && gi==&godley) ))
                     r.insert(v);
                 }
           }
         return false;
       });
    return r;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

matlab()

void minsky::Minsky::matlab ( const std::string &  filename )

inline

Definition at line 485 of file minsky.h.

References f, and MathDAG::SystemOfEquations::matlab().

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

Here is the call graph for this function:

message()

virtual void minsky::Minsky::message ( const std::string &  )

inlinevirtual

display a message in a popup box on the GUI

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 442 of file minsky.h.

{}

multipleEquities() [1/2]

bool minsky::Minsky::multipleEquities ( ) const

inline

Definition at line 153 of file minsky.h.

{return m_multipleEquities;}

multipleEquities() [2/2]

bool minsky::Minsky::multipleEquities

(

const bool &

m

)

Definition at line 89 of file minsky.cc.

                                             {
    m_multipleEquities=m;
    canvas.requestRedraw();
    redrawAllGodleyTables();
    return m_multipleEquities;
  }

nameCurrentItem()

void minsky::Minsky::nameCurrentItem ( const std::string &  name )

inline

Definition at line 516 of file minsky.h.

{namedItems[name]=canvas.item;}

numOpArgs()

int minsky::Minsky::numOpArgs ( OperationType::Type  o )

static

Definition at line 1786 of file minsky.cc.

References minsky::op.

  {
    const OperationPtr op(o);
    return op->numPorts()-1;
  }

openGroupInCanvas()

void minsky::Minsky::openGroupInCanvas ( )

inline

Definition at line 507 of file minsky.h.

{canvas.openGroupInCanvas(canvas.item);}

openLogFile()

void minsky::Minsky::openLogFile

(

const string &

name

)

opens the log file, and writes out a header line describing names of all variables

Definition at line 96 of file minsky.cc.

References minsky::CSVQuote().

  {
    outputDataFile.reset(new ofstream(name));
    *outputDataFile<< "#time";
    for (auto& v: variableValues)
      if (logVarList.contains(v.first))
        *outputDataFile<<" "<<CSVQuote(v.second->name,' ');
    *outputDataFile<<endl;
  }

Here is the call graph for this function:

openModelInCanvas()

void minsky::Minsky::openModelInCanvas ( )

inline

reinitialises canvas to the toplevel group

Definition at line 509 of file minsky.h.

{canvas.openGroupInCanvas(model);}

paste()

void minsky::Minsky::paste

(

)

paste clipboard as a new group or ungrouped items on the canvas. canvas.itemFocus is set to refer to the new group or items.

Definition at line 219 of file minsky.cc.

References schema3::Minsky::populateGroup(), and minsky::valueId().

      {
        // don't paste if previous created item hasn't been placed yet.
        if (canvas.itemFocus) return; 
        map<string,string> existingParms; 
        // preserve initial conditions.
        for (auto& [valueId,vv]: variableValues)
          existingParms.emplace(valueId,vv->init());

        istringstream is(clipboard.getClipboard());
        xml_unpack_t unpacker(is); 
        schema3::Minsky m(unpacker);
        GroupPtr g(new Group);
        g->self=g;
        m.populateGroup(*g);
        
        // stash values of parameters in the copied group, for ticket 1258
        for (auto& i: g->items) 
          if (auto v=i->variableCast(); v && v->type()==VariableType::parameter)
            existingParms.emplace(v->valueId(),v->init());
        
        // Default pasting no longer occurs as grouped items or as a group within a group. Fix for tickets 1080/1098    
        canvas.selection.clear();
        // The following is only necessary if one pastes into an existing model. For ticket 1258   
        if (!history.empty() || !canvas.model.get()->empty()) {     
          bool alreadyDefinedMessageDisplayed=false;
      
          // convert stock variables that aren't defined to flow variables, and other fix up multiply defined vars
          g->recursiveDo(&GroupItems::items,
                         [&](Items&, Items::iterator i) {
                           if (auto v=(*i)->variableCast())
                             if (v->defined() || v->isStock())
                               {
                                 // if defined, check no other defining variable exists
                                 auto alreadyDefined = canvas.model->findAny
                                   (&GroupItems::items,
                                    [&v](const ItemPtr& j)
                                    {return j.get()!=v && j->variableCast() &&  j->variableCast()->defined();});
                                 if (v->isStock())
                                   {
                                     if (v->defined() && alreadyDefined && !alreadyDefinedMessageDisplayed)
                                       {
                                         message("Integral/Stock variable "+v->name()+" already defined.");
                                         alreadyDefinedMessageDisplayed=true;
                                       }
                                     else if (!v->defined() && !alreadyDefined)
                                       {
                                         // need to do this var explicitly, as not currently part of model structure
                                         if (auto vp=VariablePtr(*i))
                                           {
                                             vp.retype(VariableType::flow);
                                             *i=vp;
                                             convertVarType(vp->valueId(), VariableType::flow);
                                           }
                                       }
                                   }
                                 else if (alreadyDefined)
                                   {
                                     // delete defining wire from this
                                     assert(v->portsSize()>1 && !v->ports(1).lock()->wires().empty());
                                     g->removeWire(*v->ports(1).lock()->wires()[0]);
                                   }
                               }
                           return false;
                         });
        }                              

        canvas.model->addGroup(g); // needed to ensure wires are correctly handled
        auto copyOfItems=g->items;
        auto copyOfGroups=g->groups;
    
        // ungroup g, putting all its contents on the canvas
        canvas.model->moveContents(*g); 

        // leave newly ungrouped items in selection
        for (auto& i: copyOfItems) 
          canvas.selection.ensureItemInserted(i);

        // ensure that initial values of pasted parameters are correct. for ticket 1258
        for (auto& p: existingParms)
          if (auto vv=variableValues.find(p.first); vv!=variableValues.end())
            vv->second->init(p.second);
        existingParms.clear();
        
        // Attach mouse focus only to first visible item in selection. For ticket 1098.      
        for (auto& i: canvas.selection.items)
          if (i->visible())
            {
              canvas.setItemFocus(i);
              break;
            }
                        
        if (!copyOfGroups.empty()) canvas.setItemFocus(copyOfGroups[0]);   

        canvas.model->removeGroup(*g);  
        canvas.requestRedraw();
      }  
    catch (...)
      {
        throw runtime_error("clipboard data invalid");
      }

Here is the call graph for this function:

physicalMem()

size_t minsky::Minsky::physicalMem ( )

static

returns amount of memory installed on system

Definition at line 1725 of file minsky.cc.

  {
#if defined(__linux__)
    struct sysinfo s;
    sysinfo(&s);
    return s.totalram;
#elif defined(WIN32)
    MEMORYSTATUSEX s{sizeof(MEMORYSTATUSEX)};
    GlobalMemoryStatusEx(&s);
    return s.ullTotalPhys;
#elif defined(__APPLE__)
    int mib[]={CTL_HW,HW_MEMSIZE};
    uint64_t physical_memory;
    size_t length = sizeof(uint64_t);
    if (sysctl(mib, sizeof(mib)/sizeof(int), &physical_memory, &length, NULL, 0))
      perror("physicalMem:");
    return physical_memory;
#else
    // all else fails, return max value
    return ~0UL;
#endif  
  }

popFlags()

void minsky::Minsky::popFlags ( )

inline

push and pop state of the flags

Definition at line 174 of file minsky.h.

                    {
      if (!flagStack.empty()) {
        flags=flagStack.back();
        flagStack.pop_back();
      }
    }

populateMissingDimensions()

void minsky::Minsky::populateMissingDimensions

(

)

fills in dimensions table with all loaded ravel axes

Definition at line 496 of file minsky.cc.

                                         {
    // populate from variable value table first, then override by ravels
    bool incompatibleMessageDisplayed=false;
    for (auto& v: variableValues)
      populateMissingDimensionsFromVariable(*v.second, incompatibleMessageDisplayed);
    model->recursiveDo
      (&Group::items,[&](Items& m, Items::iterator it)
      {
        if (auto ri=dynamic_cast<Ravel*>(it->get()))
          {
            auto state=ri->getState();
            for (auto& j: state.handleStates)
              dimensions.emplace(j.description,Dimension());
          }
        return false;
      });
    requestReset();
  }

populateMissingDimensionsFromVariable() [1/2]

void minsky::Minsky::populateMissingDimensionsFromVariable	(	const VariableValue &	v,
		bool &	incompatibleMessageDisplayed
	)

populate missing dimensions from a variableValue

Parameters

incompatibleMessageDisplayed

boolean flag to make message display single shot

Definition at line 515 of file minsky.cc.

References minsky::VariableValue::hypercube().

Referenced by minsky::VariableBase::importFromCSV().

  {
    set<string> varDimensions;
    for (auto& xv: v.hypercube().xvectors)
      {
        auto d=dimensions.find(xv.name);
        if (d==dimensions.end())
          {
            dimensions.emplace(xv.name, xv.dimension);
            varDimensions.insert(xv.name);
          }
        else if (d->second.type!=xv.dimension.type && !incompatibleMessageDisplayed)
          {
            message("Incompatible dimension type for dimension "+d->first+". Please adjust the global dimension in the dimensions dialog, which can be found under the Edit menu.");
            incompatibleMessageDisplayed=true;
          }
      }
    // set all newly populated dimensions on Ravels to forward sort order
    model->recursiveDo
      (&Group::items,[&](Items& m, Items::iterator it)
      {
        if (auto ri=dynamic_cast<Ravel*>(it->get()))
          for (size_t i=0; i<ri->numHandles(); ++i)
            if (varDimensions.contains(ri->handleDescription(i)))
              ri->setHandleSortOrder(ravel::HandleSort::forward, i);
        return false;
      });
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateMissingDimensionsFromVariable() [2/2]

void minsky::Minsky::populateMissingDimensionsFromVariable ( const VariableValue &  v )

inline

Definition at line 199 of file minsky.h.

    {bool dummy; populateMissingDimensionsFromVariable(v,dummy);}

progress()

virtual void minsky::Minsky::progress ( const std::string &  title, int    )

inlinevirtual

set progress bar, out of 100, labelling the progress bar with title

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 433 of file minsky.h.

Referenced by minsky::Progress::displayProgress().

{}

Here is the caller graph for this function:

pushFlags()

void minsky::Minsky::pushFlags ( )

inline

push and pop state of the flags

Definition at line 173 of file minsky.h.

{flagStack.push_back(flags);}

pushHistory()

bool minsky::Minsky::pushHistory

(

)

push current model state onto history if it differs from previous

Definition at line 1264 of file minsky.cc.

References classdesc::xml_pack().

Referenced by minsky::PubTab::addNote(), minsky::Canvas::copyItem(), minsky::PhillipsDiagram::init(), minsky::PubTab::mouseUp(), minsky::PhillipsDiagram::mouseUp(), minsky::VariableBase::onMouseMotion(), minsky::PubTab::removeItemAt(), and minsky::PubTab::removeSelf().

  {
    // do not pushHistory after undo or redo
    if (undone)
      return undone=false;

    // go via a schema object, as serialising minsky::Minsky has
    // problems due to port management
    schema3::Minsky m(*this, false /* don't pack tensor data */);
    pack_t buf;
    buf<<m;
    if (history.empty())
      {
        history.emplace_back();
        buf.swap(history.back());
        historyPtr=history.size();
        return true;
      }
    while (history.size()>maxHistory)
      history.pop_front();
    if (history.empty() || history.back().size()!=buf.size() || memcmp(buf.data(), history.back().data(), buf.size())!=0)
      {
        // check XML versions differ (slower)
        ostringstream prev, curr;
        xml_pack_t prevXbuf(prev), currXbuf(curr);
        xml_pack(currXbuf,"Minsky",m);
        schema3::Minsky previousMinsky;
        history.back().reseto()>>previousMinsky;
        xml_pack(prevXbuf,"Minsky",previousMinsky);

        if (curr.str()!=prev.str())
          {
            // This bit of code outputs an XML representation that can be
            //        used for debugging issues related to unnecessary
            //        history pushes.
            //buf.reseto()>>m;
            //xml_pack_t tb(cout);
            //tb.prettyPrint=true;
            //xml_pack(tb,"Minsky",m); 
            //cout<<"------"<<endl;
            history.emplace_back();
            buf.swap(history.back());
            historyPtr=history.size();
            if (autoSaver && doPushHistory)
              try
                {
                  //autoSaver->packer.prettyPrint=true;
                  autoSaver->save(m);
                }
              catch (...)
                {
                  autoSaver.reset();
                  throw;
                }
            return true;
          }
      }
    historyPtr=history.size();
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

randomLayout()

void minsky::Minsky::randomLayout

(

)

randomly layout current open group and recentre reinitialises canvas to the group located in item

Definition at line 1630 of file minsky.cc.

  {
    canvas.model->randomLayout();
    canvas.recentre();
  }

ravelAvailable()

static bool minsky::Minsky::ravelAvailable ( )

inlinestatic

Definition at line 333 of file minsky.h.

{return  ravelCAPI::available();}

ravelExpired()

static bool minsky::Minsky::ravelExpired ( )

inlinestatic

Definition at line 334 of file minsky.h.

{return  ravelCAPI::available() && ravelCAPI::daysUntilExpired()<0;}

ravelVersion()

static std::string minsky::Minsky::ravelVersion ( )

inlinestatic

Definition at line 325 of file minsky.h.

                                    {
      if (ravelCAPI::Ravel::available())
        {
          int d=ravelCAPI::Ravel::daysUntilExpired();
          return ravelCAPI::Ravel::version() + ": "+((d>=0)?("Expires in "+std::to_string(d)+" day"+(d!=1?"s":"")): "Expired");
        }
      else return "unavailable";
    }

redrawAllGodleyTables()

void minsky::Minsky::redrawAllGodleyTables

(

)

request all Godley table windows to redraw

Definition at line 1715 of file minsky.cc.

Referenced by minsky::GodleyTableEditor::update().

  {
    model->recursiveDo(&Group::items, 
                       [&](Items&,Items::iterator i) {
                         if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
                           g->popup.requestRedraw();
                         return false;
                       });
  }

Here is the caller graph for this function:

reloadAllCSVParameters()

void minsky::Minsky::reloadAllCSVParameters

(

)

reload all CSV parameters from latest values in files.

Definition at line 1701 of file minsky.cc.

  {
    model->recursiveDo(&GroupItems::items,
                         [&](Items&, Items::iterator i) {
                           if (auto v=(*i)->variableCast())
                             {
                               v->reloadCSV();
                               requestReset();
                             }
                           return false;
                         });
  }

removeItems()

void minsky::Minsky::removeItems ( Wire &  wire )

private

remove the definition network from wire, up to, but not including attached variables.

Definition at line 1647 of file minsky.cc.

References minsky::wire.

  {
    if (wire.from()->wires().size()==1)
      { // only remove higher up the network if this item is the only item feeding from it
        auto& item=wire.from()->item();
        if (!item.variableCast())
          {
            for (size_t i=1; i<item.portsSize(); ++i)
              if (auto p=item.ports(i).lock())
                for (auto w: p->wires())
                  removeItems(*w);
            model->removeItem(item);
          }
        else if (auto p=item.ports(1).lock())
          if (p->wires().empty())
            model->removeItem(item); // remove non-definition variables as well
      }
    model->removeWire(wire);
  }

renameDimension()

void minsky::Minsky::renameDimension	(	const std::string &	oldName,
		const std::string &	newName
	)

Definition at line 544 of file minsky.cc.

  {
    auto i=dimensions.find(oldName);
    if (i!=dimensions.end())
      {
        dimensions[newName]=i->second;
        dimensions.erase(i);
      }

    for (auto& v: variableValues)
      {
        auto hc=v.second->tensorInit.hypercube();
        for (auto& x: hc.xvectors)
          if (x.name==oldName)
            {
              x.name=newName;
            }
        v.second->tensorInit.hypercube(hc);
      }
  }

renderAllPlotsAsSVG()

void minsky::Minsky::renderAllPlotsAsSVG

(

const string &

prefix

)

const

render all plots

Definition at line 1547 of file minsky.cc.

References minsky::str().

  {
    unsigned plotNum=0;
    model->recursiveDo(&Group::items,
                       [&](Items&, Items::iterator i) {
                         if (auto p=(*i)->plotWidgetCast())
                           {
                             if (!p->title.empty())
                               p->RenderNativeWindow::renderToSVG(prefix+"-"+p->title+".svg");
                             else
                               p->RenderNativeWindow::renderToSVG(prefix+"-"+str(plotNum++)+".svg");
                           }
                         return false;
                       });
  }

Here is the call graph for this function:

renderCanvasToEMF()

void minsky::Minsky::renderCanvasToEMF ( const std::string &  filename )

inline

render canvas to a EMF image file (Windows only)

Definition at line 404 of file minsky.h.

{canvas.renderToEMF(filename);}

renderCanvasToPDF()

void minsky::Minsky::renderCanvasToPDF ( const std::string &  filename )

inline

render canvas to a PDF file

Definition at line 390 of file minsky.h.

{canvas.renderToPDF(filename);}

renderCanvasToPNG() [1/2]

void minsky::Minsky::renderCanvasToPNG ( const std::string &  filename )

inline

render canvas to a PNG image file

Definition at line 394 of file minsky.h.

{canvas.renderToPNG(filename);}

renderCanvasToPNG() [2/2]

void minsky::Minsky::renderCanvasToPNG ( const std::string &  filename, const Canvas::ZoomCrop &  z  )

inline

Render canvas to a PNG file filename, scaling the canvas temporarily by zoom, shifts it to left, top, and crops to width, height (in ZoomCrop struct).

Definition at line 400 of file minsky.h.

    {canvas.renderToPNGCropped(filename,z);}

renderCanvasToPS()

void minsky::Minsky::renderCanvasToPS ( const std::string &  filename )

inline

render canvas to a postscript file

Definition at line 388 of file minsky.h.

{canvas.renderToPS(filename);}

renderCanvasToSVG()

void minsky::Minsky::renderCanvasToSVG ( const std::string &  filename )

inline

render canvas to an SVG file

Definition at line 392 of file minsky.h.

{canvas.renderToSVG(filename);}

requestRedraw()

void minsky::Minsky::requestRedraw

(

)

requests a redraw of the curren active tab

Definition at line 486 of file minsky.cc.

  {
    // requestRedraw on all tabs - only the active one will actually do anything
    canvas.requestRedraw();
    equationDisplay.requestRedraw();
    phillipsDiagram.requestRedraw();
    for (auto& pub: publicationTabs)
      pub.requestRedraw();
  }

requestReset()

void minsky::Minsky::requestReset

(

)

Definition at line 466 of file minsky.cc.

Referenced by minsky::Ravel::collapseAllHandles(), minsky::Canvas::deleteItem(), minsky::Canvas::deleteWire(), minsky::Sheet::draw(), minsky::RavelPopup::mouseOver(), minsky::PubTab::mouseUp(), minsky::Canvas::mouseUp(), minsky::Ravel::onKeyPress(), minsky::VariableBase::onKeyPress(), minsky::VariableBase::onMouseMotion(), minsky::Ravel::pickSliceLabels(), minsky::Group::renameAllInstances(), and minsky::Ravel::sortByValue().

  {
    if (resetDuration<resetNowThreshold)
      {
        try
          {
            reset();
          }
        catch (...)
          {}
        return;
      }
    flags|=reset_needed;
    // schedule reset for some time in the future
    if (resetDuration<resetPostponedThreshold)
      resetAt=std::chrono::system_clock::now()+resetPostponedThreshold;
    else // postpone "indefinitely"
      resetAt=std::chrono::time_point<std::chrono::system_clock>::max();
  }

Here is the caller graph for this function:

reset()

void minsky::Minsky::reset

(

)

resets the variables back to their initial values

Definition at line 865 of file minsky.cc.

References minsky::onStackExit(), and minsky::wire.

Referenced by minsky::Lock::toggleLocked().

      {
        // do not reset while simulation is running
        if (RKThreadRunning)
          {
            flags |= reset_needed;
            if (RKThreadRunning) return;
          }

        auto start=chrono::high_resolution_clock::now();
        auto updateResetDuration=onStackExit([&]{resetDuration=chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()-start);});
        canvas.itemIndicator.reset();
        const BusyCursor busy(*this);
        EvalOpBase::t=t=t0;
        lastT=t0;
        const ProgressUpdater pu(progressState,"Resetting",5);
        constructEquations();
        constructEquations();
        ++progressState;
        // if no stock variables in system, add a dummy stock variable to
        // make the simulation proceed
        if (stockVars.empty()) stockVars.resize(1,0);

        initGodleys();
        ++progressState;

        if (!stockVars.empty())
          rkreset();
    
        // update flow variable
        evalEquations();
        ++progressState;

        // populate ravel hypercubes first, before reattaching plots.
        model->recursiveDo
          (&Group::items,
           [&](Items& m, Items::iterator i)
           {
             if (auto r=dynamic_cast<Ravel*>(i->get()))
               {
                 if (r->ports(1).lock()->numWires()>0)
                   if (auto vv=r->ports(1).lock()->getVariableValue())
                     r->populateHypercube(vv->hypercube());
               }
             else if (auto v=(*i)->variableCast())
               v->resetMiniPlot();
             return false;
           });

        // attach the plots
        model->recursiveDo
          (&Group::items,
           [&](Items& m, Items::iterator it)
           {
             if (auto p=(*it)->plotWidgetCast())
               {
                 p->disconnectAllVars();// clear any old associations
                 p->clearPenAttributes();
                 p->autoScale();
                 for (size_t i=0; i<p->portsSize(); ++i)
                   {
                     auto pp=p->ports(i).lock();
                     for (auto wire: pp->wires())
                       if (auto fromPort=wire->from())
                         if (auto vv=wire->from()->getVariableValue())
                           if (vv->idx()>=0)
                             p->connectVar(vv, i);
                   }
                 p->clear();
                 if (running)
                   p->updateIcon(t);
                 else
                   p->addConstantCurves();
                 p->requestRedraw();
               }
             return false;
           });
        ++progressState;

        //    if (running)
        flags &= ~reset_needed; // clear reset flag
        resetAt=std::chrono::time_point<std::chrono::system_clock>::max();
        // else
        //  flags |= reset_needed; // enforce another reset at simulation start
        running=false;

        requestRedraw();
    
        // update maxValues
        PhillipsFlow::maxFlow.clear();
        PhillipsStock::maxStock.clear();
        for (auto& v: variableValues)
          {
            if (v.second->type()==VariableType::stock)
              {
                PhillipsStock::maxStock[v.second->units]+=v.second->value();
              }
          }
        for (auto& i: PhillipsStock::maxStock) i.second=abs(i.second);
     }
    catch (...)
      {
        // in the event of an exception, clear reset flag
        flags &= ~reset_needed; // clear reset flag
        resetAt=std::chrono::time_point<std::chrono::system_clock>::max();
        resetDuration=chrono::milliseconds::max();
        throw;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

reset_flag()

bool minsky::Minsky::reset_flag ( ) const

inline

true if reset needs to be called prior to numerical integration

Definition at line 159 of file minsky.h.

Referenced by minsky::Canvas::mouseMove().

{return flags & reset_needed;}

Here is the caller graph for this function:

resetIfFlagged()

bool minsky::Minsky::resetIfFlagged ( )

inlineoverridevirtual

checks whether a reset is required, and resets the simulation if so

Returns

whether simulation was reset

Reimplemented from minsky::RungeKutta.

Definition at line 182 of file minsky.h.

                                   {
      if (reset_flag())
        reset();
      return reset_flag();
    }

resetScroll()

virtual void minsky::Minsky::resetScroll ( )

inlinevirtual

reset main window scroll bars after model has been panned

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 439 of file minsky.h.

Referenced by displayErrorItem(), minsky::VariableInstanceList::gotoInstance(), and minsky::Canvas::zoomToDisplay().

{}

Here is the caller graph for this function:

runItemDeletedCallback()

virtual void minsky::Minsky::runItemDeletedCallback ( const Item &  )

inlinevirtual

run callback attached to item

Definition at line 445 of file minsky.h.

Referenced by minsky::Group::deleteItem().

{}

Here is the caller graph for this function:

save()

void minsky::Minsky::save

(

const std::string &

filename

)

Definition at line 1013 of file minsky.cc.

References minsky::Saver::os, minsky::Saver::packer, minsky::remove(), and minsky::Saver::save().

  {
    // back up to temporary file name
    rename(filename.c_str(), (filename+"~").c_str());
    
    const schema3::Minsky m(*this);
    Saver saver(filename);
    saver.packer.prettyPrint=true;
    try
      {
        saver.save(m);
      }
    catch (...) {
      // rename backup in place
      rename((filename+"~").c_str(), filename.c_str());
      // if exception is due to file error, provide a more useful message
      if (!saver.os)
          throw runtime_error("cannot save to "+filename);
      throw;
    }
    pushHistory(); // ensure history is up to date to prevent trivial setting of dirty flag
    flags &= ~is_edited;
    fileVersion=minskyVersion;
    if (autoSaver)
      boost::filesystem::remove(autoSaver->fileName);
    // rotate saved versions
    for (int i=numBackups; i>1; --i)
      rename((filename+";"+to_string(i-1)).c_str(), (filename+";"+to_string(i)).c_str());
    if (numBackups>0)
      rename((filename+"~").c_str(), (filename+";1").c_str());
    else
      ::remove((filename+"~").c_str());
  }

Here is the call graph for this function:

saveCanvasItemAsFile()

void minsky::Minsky::saveCanvasItemAsFile ( const string &  fileName ) const

inline

Definition at line 254 of file minsky.h.

    {if (auto g=dynamic_cast<Group*>(canvas.item.get())) saveGroupAsFile(*g,fileName);}

saveGroupAsFile()

void minsky::Minsky::saveGroupAsFile ( const Group &  g, const string &  fileName  )

static

Definition at line 213 of file minsky.cc.

References minsky::Saver::save().

  {
    const schema3::Minsky m(g);
    Saver(fileName).save(m);
  }

Here is the call graph for this function:

saveSelectionAsFile()

void minsky::Minsky::saveSelectionAsFile ( const string &  fileName ) const

inline

Definition at line 268 of file minsky.h.

{saveGroupAsFile(canvas.selection,fileName);}

setAllDEmode()

void minsky::Minsky::setAllDEmode

(

bool

mode

)

set DE mode on all godley tables

Definition at line 1578 of file minsky.cc.

                                     {
    model->recursiveDo(&GroupItems::items, [mode](Items&,Items::iterator i) {
      if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
        g->table.setDEmode(mode);
      return false;
    });
  }

setAutoSaveFile()

void minsky::Minsky::setAutoSaveFile

(

const std::string &

file

)

initialises auto saving empty file to turn off autosave

Definition at line 1792 of file minsky.cc.

                                                    {
    if (file.empty())
      autoSaver.reset();
    else
      autoSaver.reset(new BackgroundSaver(file));
  }

setBusyCursor()

virtual void minsky::Minsky::setBusyCursor ( )

inlinevirtual

set/clear busy cursor in GUI

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky.

Definition at line 430 of file minsky.h.

{}

setDefinition()

void minsky::Minsky::setDefinition	(	const std::string &	valueId,
		const std::string &	definition
	)

add/replace a definition for a flow variable given by valueId

Definition at line 1667 of file minsky.cc.

References minsky::UserFunction::expression, minsky::flipped(), minsky::group, minsky::Item::moveTo(), minsky::Item::ports(), minsky::valueId(), minsky::var, and minsky::Item::width().

  {
    auto var=definingVar(valueId);
    if (!var) // find
      var=dynamic_pointer_cast<VariableBase>(model->findAny(&GroupItems::items, [&](const ItemPtr& it) {
        if (auto v=it->variableCast())
          return v->valueId()==valueId;
        return false;
      }));
    if (var)
      if (auto p=var->ports(1).lock())
        {
          auto group=var->group.lock();
          if (!group) group=model;
          UserFunction* udf=p->wires().empty()? nullptr: dynamic_cast<UserFunction*>(&p->wires().front()->from()->item());
          if (!udf)
            {
              // remove previous definition network
              for (auto w: p->wires())
                {
                  assert(w);
                  removeItems(*w);
                }

              udf=new UserFunction(var->name()+"()");
              group->addItem(udf); // ownership passed
              const bool notFlipped=!flipped(var->rotation());
              udf->moveTo(var->x()+(notFlipped? -1:1)*0.6*(var->width()+udf->width()), var->y());
              group->addWire(udf->ports(0), var->ports(1));
            }
          udf->expression=definition;
        }
  }

Here is the call graph for this function:

setGodleyDisplayValue()

void minsky::Minsky::setGodleyDisplayValue	(	bool	displayValues,
		GodleyTable::DisplayStyle	displayStyle
	)

set display value mode on all godley table editor modes

Definition at line 1586 of file minsky.cc.

  {
    this->displayValues=displayValues;
    this->displayStyle=displayStyle;
    canvas.requestRedraw();
    model->recursiveDo(&GroupItems::items, [](Items&,Items::iterator i) {
      if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
        g->popup.requestRedraw();
      return false;
    });
  }

setGodleyIconResource()

void minsky::Minsky::setGodleyIconResource ( const string &  s )

inline

Definition at line 203 of file minsky.h.

References minsky::SVGRenderer::setResource(), and minsky::GodleyIcon::svgRenderer.

    {GodleyIcon::svgRenderer.setResource(s);}

Here is the call graph for this function:

setGroupIconResource()

void minsky::Minsky::setGroupIconResource ( const string &  s )

inline

Definition at line 205 of file minsky.h.

References minsky::SVGRenderer::setResource(), and minsky::Group::svgRenderer.

    {Group::svgRenderer.setResource(s);}

Here is the call graph for this function:

setLockIconResource()

void minsky::Minsky::setLockIconResource ( const string &  locked, const string &  unlocked  )

inline

Definition at line 207 of file minsky.h.

References minsky::Lock::lockedIcon, minsky::SVGRenderer::setResource(), and minsky::Lock::unlockedIcon.

                                                                           {
      Lock::lockedIcon.setResource(locked);
      Lock::unlockedIcon.setResource(unlocked);
    }

Here is the call graph for this function:

setRavelIconResource()

void minsky::Minsky::setRavelIconResource ( const string &  s )

inline

Definition at line 211 of file minsky.h.

References minsky::SVGRenderer::setResource(), and minsky::Ravel::svgRenderer.

    {Ravel::svgRenderer.setResource(s);}

Here is the call graph for this function:

srand()

void minsky::Minsky::srand ( int  seed )

inline

set std library RNG seed

Definition at line 414 of file minsky.h.

{::srand(seed);}

step()

vector< double > minsky::Minsky::step

(

)

step the equations (by n steps, default 1)

Definition at line 975 of file minsky.cc.

  {
    lastT=t;
    rkstep();

    logVariables();

    model->recursiveDo
      (&Group::items, 
       [&](Items&, Items::iterator i) 
       {(*i)->updateIcon(t); return false;});

    // throttle redraws
    const time_duration maxWait=milliseconds(maxWaitMS);
    if ((microsec_clock::local_time()-(ptime&)lastRedraw) > maxWait)
      {
        requestRedraw();
        lastRedraw=microsec_clock::local_time();
      }

    return {t, deltaT()};
  }

triggerCheckMemAllocationCallback()

bool minsky::Minsky::triggerCheckMemAllocationCallback ( ) const

inline

trigger checkMem callback for testing purposes

Definition at line 520 of file minsky.h.

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

undo()

long minsky::Minsky::undo

(

int

changes = 1

)

restore model to state changes ago

Returns

index of current state in history

Definition at line 1400 of file minsky.cc.

References schema3::Minsky::phillipsDiagram, schema3::Minsky::populateGroup(), schema3::PhillipsDiagram::populatePhillipsDiagram(), schema3::Minsky::populatePublicationTabs(), and schema3::Minsky::zoomFactor.

Referenced by minsky::Canvas::copyItem().

  {
    // save current state for later restoration if needed
    if (historyPtr==history.size())
      pushHistory();
    historyPtr-=changes;
    if (historyPtr > 0 && historyPtr <= history.size())
      {
        schema3::Minsky m;
        history[historyPtr-1].reseto()>>m;
        // stash tensorInit data for later restoration
        auto stashedValues=std::move(variableValues);
        // preserve bookmarks. For now, we can only preserve model and canvas.model bookmarks
        // count the total number of bookmarks
        unsigned numBookmarks=0;
        model->recursiveDo(&GroupItems::groups, [&](const Groups&,const Groups::const_iterator i) {
          numBookmarks+=(*i)->bookmarks.size();
          return false;
        });
        auto stashedGlobalBookmarks=model->bookmarks;
        auto stashedCanvasBookmarks=canvas.model->bookmarks;
        clearAllMaps(false);
        model->clear();
        m.populateGroup(*model);
        model->setZoom(m.zoomFactor);
        m.phillipsDiagram.populatePhillipsDiagram(phillipsDiagram);
        m.populatePublicationTabs(publicationTabs);
        requestRedraw();
        
        // restore tensorInit data
        for (auto& v: variableValues)
          {
            auto stashedValue=stashedValues.find(v.first);
            if (stashedValue!=stashedValues.end())
              v.second->tensorInit=std::move(stashedValue->second->tensorInit);
          }
        // restore bookmarks
        model->bookmarks=std::move(stashedGlobalBookmarks);
        canvas.model->bookmarks=std::move(stashedCanvasBookmarks);
        unsigned numBookmarksAfterwards=0;
        model->recursiveDo(&GroupItems::groups, [&](const Groups&,const Groups::const_iterator i) {
          numBookmarksAfterwards+=(*i)->bookmarks.size();
          return false;
        });
        if (numBookmarksAfterwards!=numBookmarks)
          message("This undo/redo operation potentially deletes some bookmarks");
        try {requestReset();}
        catch (...) {}
          
      }
    else
      historyPtr+=changes; // revert
    undone=true; //ensure next pushHistory is ignored 
    return historyPtr;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

variableTypes()

vector< string > minsky::Minsky::variableTypes ( )

static

list of available variable types

Definition at line 1607 of file minsky.cc.

  {return enumVals<VariableType::Type>();}

Member Data Documentation

canvas

Canvas minsky::Minsky::canvas {model}

Definition at line 243 of file minsky.h.

Referenced by minsky::Canvas::copyItem(), minsky::VariablePaneCell::emplace(), minsky::Group::gotoBookmark_b(), minsky::VariableInstanceList::gotoInstance(), minsky::VariableBase::local(), schema3::Minsky::populateMinsky(), MathDAG::SystemOfEquations::SystemOfEquations(), and minsky::GodleyTableEditor::update().

conversions

Conversions minsky::Minsky::conversions

Definition at line 190 of file minsky.h.

Referenced by schema3::Minsky::Minsky(), and schema3::Minsky::populateMinsky().

dimensions

Dimensions minsky::Minsky::dimensions

Definition at line 189 of file minsky.h.

Referenced by minsky::Ravel::dimension(), minsky::Ravel::dimensionType(), minsky::Ravel::dimensionUnitsFormat(), minsky::Ravel::hypercube(), schema3::Minsky::Minsky(), schema3::Minsky::populateMinsky(), minsky::VariableValues::resetValue(), and minsky::Ravel::setDimension().

displayStyle

GodleyTable::DisplayStyle minsky::Minsky::displayStyle =GodleyTable::sign

Definition at line 418 of file minsky.h.

displayValues

bool minsky::Minsky::displayValues =false

Definition at line 417 of file minsky.h.

Referenced by minsky::GodleyTableEditor::draw().

doPushHistory

bool minsky::Minsky::doPushHistory =true

flag to indicate whether a TCL should be pushed onto the history stack, or logged in a recording. This is used to avoid movements being added to recordings and undo history

Definition at line 370 of file minsky.h.

equationDisplay

PannableTab<EquationDisplay> minsky::Minsky::equationDisplay

Definition at line 141 of file minsky.h.

fileVersion

std::string minsky::Minsky::fileVersion

Minsky version file was saved under.

Definition at line 337 of file minsky.h.

Referenced by schema3::Minsky::populateMinsky().

fontSampler

FontDisplay minsky::Minsky::fontSampler

Definition at line 142 of file minsky.h.

histogramResource

SVGRenderer minsky::Minsky::histogramResource

Definition at line 213 of file minsky.h.

Referenced by minsky::Operation< minsky::OperationType::integrate >::iconDraw().

lastRedraw

Exclude<ptime> minsky::Minsky::lastRedraw

private

Definition at line 130 of file minsky.h.

lastT

double minsky::Minsky::lastT {0}

previous timestep

Definition at line 307 of file minsky.h.

logVarList

std::set<string> minsky::Minsky::logVarList

set of variables (valueIds) to log

Definition at line 289 of file minsky.h.

m_multipleEquities

bool minsky::Minsky::m_multipleEquities =false

private

Definition at line 132 of file minsky.h.

maxFlowValue

std::map<Units, double> minsky::Minsky::maxFlowValue

Definition at line 193 of file minsky.h.

maxHistory

unsigned minsky::Minsky::maxHistory {100}

maximum no. of history states to save

Definition at line 339 of file minsky.h.

maxValue

std::map<Units, double> minsky::Minsky::maxValue

stash the maximum absolute value obtained by a dimensioned quantity

Definition at line 192 of file minsky.h.

maxWaitMS

int minsky::Minsky::maxWaitMS =100

maximum wait in millisecond between redrawing canvas during simulation

Definition at line 340 of file minsky.h.

Referenced by minsky::Canvas::reportDrawTime().

minskyVersion

const std::string minsky::Minsky::minskyVersion =MINSKY_VERSION

static

Definition at line 323 of file minsky.h.

Referenced by schema3::Minsky::Minsky().

model

GroupPtr minsky::Minsky::model {new Group}

Definition at line 242 of file minsky.h.

Referenced by minsky::IntOp::description(), minsky::Group::gotoBookmark_b(), minsky::PhillipsDiagram::init(), minsky::anonymous_namespace{group.cc}::isGlobal(), minsky::Ravel::joinLockGroup(), minsky::Ravel::lockGroupColours(), schema3::Minsky::Minsky(), schema3::Minsky::populateMinsky(), minsky::Ravel::Ravel(), minsky::Group::renameAllInstances(), minsky::VariableValue::summary(), MathDAG::SystemOfEquations::SystemOfEquations(), minsky::IntOp::toggleCoupled(), minsky::VariableBase::units(), and minsky::GodleyTableEditor::update().

namedItems

std::map<std::string,std::weak_ptr<Item> > minsky::Minsky::namedItems

Definition at line 515 of file minsky.h.

numBackups

int minsky::Minsky::numBackups =1

number of previous versions of saved files to keep save to a file

Definition at line 312 of file minsky.h.

phillipsDiagram

PhillipsDiagram minsky::Minsky::phillipsDiagram

Definition at line 143 of file minsky.h.

Referenced by schema3::Minsky::Minsky(), and schema3::Minsky::populateMinsky().

publicationTabs

std::vector<PubTab> minsky::Minsky::publicationTabs

Definition at line 144 of file minsky.h.

Referenced by schema3::Minsky::Minsky(), schema3::Minsky::populateMinsky(), and minsky::PubTab::removeSelf().

userFunctions

Exclude<std::map<std::string, std::shared_ptr<CallableFunction> > > minsky::Minsky::userFunctions

Definition at line 240 of file minsky.h.

Referenced by minsky::UserFunction::compile(), and minsky::UserFunction::units().

variableInstanceList

std::shared_ptr<VariableInstanceList> minsky::Minsky::variableInstanceList

supports navigation to all instances of current variable

Definition at line 512 of file minsky.h.

variablePane

VariablePane minsky::Minsky::variablePane

Definition at line 523 of file minsky.h.

variableValues

VariableValues minsky::Minsky::variableValues

Definition at line 188 of file minsky.h.

Referenced by MathDAG::ConstantDAG::addEvalOps(), MathDAG::VariableDAG::addEvalOps(), minsky::UserFunction::compile(), minsky::IntOp::description(), minsky::GodleyTableEditor::draw(), minsky::VariableBase::ensureValueExists(), minsky::VariableBase::exportAsCSV(), minsky::VariableBase::init(), minsky::VariableValue::init(), MathDAG::latexInit(), MathDAG::matlabInit(), minsky::VariableBase::setUnits(), minsky::GodleyIcon::stockVarUnits(), MathDAG::SystemOfEquations::SystemOfEquations(), MathDAG::VariableDAG::tensorEval(), minsky::UserFunction::units(), minsky::VariableBase::units(), minsky::GodleyIcon::update(), minsky::VariableBase::value(), and minsky::VariableBase::vValue().

---

The documentation for this class was generated from the following files:

• model/minsky.h
• model/minsky.cc