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	exportSchema (const std::string &filename, int schemaLevel=1)
void	displayErrorItem (const Item &op) const
	indicate operation item has error, if visible, otherwise contining group More...
std::string	ecolabVersion () const
std::string	ravelVersion () const
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
std::size_t	physicalMem () const
	returns amount of memory installed on system More...
vector< string >	listFonts () const
int	numOpArgs (OperationType::Type o)
OperationType::Group	classifyOp (OperationType::Type o) const
void	latex (const std::string &filename, bool wrapLaTeXLines)
void	matlab (const std::string &filename)
string	latex2pango (const std::string &x)
std::vector< std::string >	availableOperations ()
	list of available operations More...
Minsky::AvailableOperationsMapping	availableOperationsMapping () const
std::vector< std::string >	variableTypes ()
	list of available variable types More...
std::vector< std::string >	assetClasses ()
	return list of available asset classes More...
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	pushFlags ()
	push and pop state of the flags More...
void	popFlags ()
	push and pop state of the flags More...
std::string	defaultFont ()
	the default used by Pango More...
std::string	defaultFont (const std::string &x)
	the default used by Pango More...
double	fontScale ()
	an extra scaling factor of Pango fonts More...
double	fontScale (double)
	an extra scaling factor of Pango fonts 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 ()
Public Member Functions inherited from minsky::Minsky_multipleEquities
	Minsky_multipleEquities (const std::string &name, ecolab::TCLAccessor< Minsky, bool >::Getter g, ecolab::TCLAccessor< Minsky, bool >::Setter s)

Static Public Member Functions
static void	saveGroupAsFile (const Group &, const string &fileName)
static bool	ravelAvailable ()
static bool	ravelExpired ()
static int	daysUntilRavelExpires ()

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
	return the AEGIS assigned version number More...
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 131 of file minsky.h.

Member Typedef Documentation

AvailableOperationsMapping

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

Definition at line 510 of file minsky.h.

Member Enumeration Documentation

CmdData

enum minsky::Minsky::CmdData

Enumerator
no_command
is_const
is_setterGetter
generic

Definition at line 376 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 463 of file minsky.h.

{OK, proceed, abort};

Constructor & Destructor Documentation

Minsky()

minsky::Minsky::Minsky ( )

inline

Definition at line 241 of file minsky.h.

            :
      ECOLAB_ACESSOR_INIT(Minsky, multipleEquities),
      equationDisplay(*this) {
      lastRedraw=boost::posix_time::microsec_clock::local_time();
      model->iHeight(std::numeric_limits<float>::max());
      model->iWidth(std::numeric_limits<float>::max());
      model->self=model;
      publicationTabs.emplace_back("Publication");
    }

~Minsky()

minsky::Minsky::~Minsky

(

)

Definition at line 120 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 159 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 1527 of file minsky.cc.

References minsky::Item::moveTo().

Referenced by minsky::MinskyTCL::addIntegral().

  {
    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:

Here is the caller graph for this function:

addNewPublicationTab()

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

inline

Definition at line 158 of file minsky.h.

{publicationTabs.emplace_back(name);}

allGodleyFlowVars()

vector< string > minsky::Minsky::allGodleyFlowVars

(

)

const

Definition at line 820 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

(

)

return list of available asset classes

Definition at line 1610 of file minsky.cc.

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

autoLayout()

void minsky::Minsky::autoLayout

(

)

auto layout current open group and recentre

Definition at line 1625 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 357 of file minsky.h.

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

availableOperations()

vector< string > minsky::Minsky::availableOperations

(

)

list of available operations

Definition at line 1606 of file minsky.cc.

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

availableOperationsMapping()

Minsky::AvailableOperationsMapping minsky::Minsky::availableOperationsMapping

(

)

const

Definition at line 1613 of file minsky.cc.

References minsky::op, and minsky::to_string().

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

Here is the call graph for this function:

balanceColumns()

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

private

balance two Godley columns

Definition at line 645 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 753 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 450 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 1177 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 464 of file minsky.h.

{return OK;}

checkPushHistory()

void minsky::Minsky::checkPushHistory ( )

inline

called periodically to ensure history up to date

Definition at line 365 of file minsky.h.

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

CLASSDESC_ACCESS()

minsky::Minsky::CLASSDESC_ACCESS ( Minsky  )

private

classifyOp()

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

inline

Definition at line 495 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 127 of file minsky.cc.

References variablePane().

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

Here is the call graph for this function:

clearAllMaps() [2/2]

void minsky::Minsky::clearAllMaps ( )

inline

Definition at line 259 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 261 of file minsky.h.

{clearAllMaps(true);}

clearBusyCursor()

virtual void minsky::Minsky::clearBusyCursor ( )

inlinevirtual

Reimplemented in minsky::anonymous_namespace{addon.cc}::AddOnMinsky, and minsky::MinskyTCL.

Definition at line 445 of file minsky.h.

{}

clearHistory()

void minsky::Minsky::clearHistory ( )

inline

clear history

Definition at line 363 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 280 of file minsky.h.

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

closeLogFile()

void minsky::Minsky::closeLogFile ( )

inline

closes log file

Definition at line 300 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 1326 of file minsky.cc.

References minsky::getCommandData().

Referenced by minsky::RESTMinsky::commandHook(), and minsky::member_entry_hook().

  {
    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 call graph for this function:

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 393 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 1457 of file minsky.cc.

References TCLcmd::trap::init, minsky::isValueId(), and minsky::var.

Referenced by minsky::MinskyTCL::convertVarType(), 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 191 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 157 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 1159 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 349 of file minsky.h.

{return  ravel::Ravel::daysUntilExpired();}

defaultFont() [1/2]

string minsky::Minsky::defaultFont

(

)

the default used by Pango

Definition at line 1738 of file minsky.cc.

References minsky::_defaultFont.

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

defaultFont() [2/2]

string minsky::Minsky::defaultFont

(

const std::string &

x

)

the default used by Pango

Definition at line 1741 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 205 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 460 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 321 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 999 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 432 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 1230 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()

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

inline

Definition at line 338 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 169 of file minsky.h.

{return flags & is_edited;}

exportAllPlotsAsCSV()

void minsky::Minsky::exportAllPlotsAsCSV

(

const string &

prefix

)

const

export all plots

Definition at line 1563 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
	)

Definition at line 1106 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

(

)

an extra scaling factor of Pango fonts

Definition at line 1749 of file minsky.cc.

  {return ecolab::Pango::scaleFactor;}

fontScale() [2/2]

double minsky::Minsky::fontScale

(

double

s

)

an extra scaling factor of Pango fonts

Definition at line 1752 of file minsky.cc.

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

garbageCollect()

void minsky::Minsky::garbageCollect

(

)

Definition at line 375 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 540 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::MinskyTCL, and minsky::RESTMinsky.

Definition at line 379 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 618 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 1599 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 365 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 857 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 399 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 323 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 531 of file minsky.h.

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

latex()

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

Definition at line 1755 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 506 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 1637 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 469 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 1048 of file minsky.cc.

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

Referenced by minsky::MinskyTCL::load().

  {
    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:

Here is the caller graph for this function:

loggingEnabled()

bool minsky::Minsky::loggingEnabled ( ) const

inline

returns true if logging is in operation

Definition at line 304 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 108 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 338 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 173 of file minsky.h.

References variablePane().

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 call graph for this function:

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 567 of file minsky.cc.

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

Referenced by minsky::MinskyTCL::matchingTableColumns(), and 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 499 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, and minsky::MinskyTCL.

Definition at line 456 of file minsky.h.

{}

multipleEquities() [1/2]

bool minsky::Minsky::multipleEquities ( ) const

inline

Definition at line 165 of file minsky.h.

{return m_multipleEquities;}

multipleEquities() [2/2]

bool minsky::Minsky::multipleEquities

(

const bool &

m

)

Definition at line 90 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 530 of file minsky.h.

{namedItems[name]=canvas.item;}

numOpArgs()

int minsky::Minsky::numOpArgs

(

OperationType::Type

o

)

Definition at line 1774 of file minsky.cc.

References minsky::op.

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

openGroupInCanvas()

void minsky::Minsky::openGroupInCanvas ( )

inline

Definition at line 521 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 97 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 523 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 220 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

(

)

const

returns amount of memory installed on system

Definition at line 1713 of file minsky.cc.

Referenced by minsky::MinskyTCL::checkMemAllocation().

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

Here is the caller graph for this function:

popFlags()

void minsky::Minsky::popFlags ( )

inline

push and pop state of the flags

Definition at line 186 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 497 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 516 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 211 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 447 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 185 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 1265 of file minsky.cc.

References classdesc::xml_pack().

Referenced by minsky::PubTab::addNote(), minsky::Canvas::copyItem(), minsky::PhillipsDiagram::init(), minsky::member_entry_hook(), 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 1631 of file minsky.cc.

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

ravelAvailable()

static bool minsky::Minsky::ravelAvailable ( )

inlinestatic

Definition at line 347 of file minsky.h.

{return  ravel::Ravel::available();}

ravelExpired()

static bool minsky::Minsky::ravelExpired ( )

inlinestatic

Definition at line 348 of file minsky.h.

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

ravelVersion()

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

inline

Definition at line 339 of file minsky.h.

References minsky::to_string().

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

Here is the call graph for this function:

redrawAllGodleyTables()

void minsky::Minsky::redrawAllGodleyTables

(

)

request all Godley table windows to redraw

Definition at line 1703 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:

removeItems()

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

private

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

Definition at line 1648 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 545 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 1548 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->renderToSVG(prefix+"-"+p->title+".svg");
                             else
                               p->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 418 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 404 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 408 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 414 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 402 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 406 of file minsky.h.

{canvas.renderToSVG(filename);}

requestRedraw()

void minsky::Minsky::requestRedraw

(

)

requests a redraw of the curren active tab

Definition at line 487 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 467 of file minsky.cc.

References reset().

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 call graph for this function:

Here is the caller graph for this function:

reset()

void minsky::Minsky::reset

(

)

resets the variables back to their initial values

Definition at line 866 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 171 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 194 of file minsky.h.

References reset().

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

Here is the call graph for this function:

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 453 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

Reimplemented in minsky::MinskyTCL.

Definition at line 459 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 1014 of file minsky.cc.

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

  {
    // 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 267 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 214 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 281 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 1579 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 1780 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, and minsky::MinskyTCL.

Definition at line 444 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 1668 of file minsky.cc.

References minsky::UserFunction::expression, minsky::flipped(), 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 1587 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 215 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 217 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 219 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 223 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 428 of file minsky.h.

{::srand(seed);}

step()

vector< double > minsky::Minsky::step

(

)

step the equations (by n steps, default 1)

Definition at line 976 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 534 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 1401 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(), and minsky::MinskyTCL::undo().

  {
    // 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

(

)

list of available variable types

Definition at line 1608 of file minsky.cc.

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

Member Data Documentation

canvas

Canvas minsky::Minsky::canvas {model}

Definition at line 256 of file minsky.h.

Referenced by minsky::MinskyTCL::addGodley(), minsky::MinskyTCL::addGroup(), minsky::MinskyTCL::addIntegral(), minsky::MinskyTCL::addLock(), minsky::MinskyTCL::addNote(), minsky::MinskyTCL::addOperation(), minsky::MinskyTCL::addPlot(), minsky::MinskyTCL::addRavel(), minsky::MinskyTCL::addSheet(), minsky::MinskyTCL::addSwitch(), minsky::MinskyTCL::addVariable(), minsky::MinskyTCL::convertVarType(), minsky::Canvas::copyItem(), minsky::MinskyTCL::createGroup(), minsky::VariablePaneCell::emplace(), minsky::MinskyTCL::findObject(), minsky::MinskyTCL::findVariable(), minsky::MinskyTCL::findVariableDefinition(), minsky::MinskyTCL::getItemAt(), minsky::MinskyTCL::getItemAtFocus(), minsky::MinskyTCL::getWireAt(), minsky::Group::gotoBookmark_b(), minsky::VariableInstanceList::gotoInstance(), minsky::MinskyTCL::groupOfItem(), minsky::MinskyTCL::itemFocusFromItem(), minsky::MinskyTCL::itemFromItemFocus(), minsky::MinskyTCL::listAllInstances(), minsky::MinskyTCL::loadVariableFromCSV(), minsky::VariableBase::local(), minsky::MinskyTCL::openGodley(), minsky::MinskyTCL::openGroupInCanvas(), minsky::MinskyTCL::openModelInCanvas(), schema3::Minsky::populateMinsky(), minsky::MinskyTCL::resetItem(), minsky::MinskyTCL::retypeItem(), minsky::MinskyTCL::selectVar(), MathDAG::SystemOfEquations::SystemOfEquations(), minsky::MinskyTCL::TCLItem(), and minsky::GodleyTableEditor::update().

conversions

Conversions minsky::Minsky::conversions

Definition at line 202 of file minsky.h.

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

dimensions

Dimensions minsky::Minsky::dimensions

Definition at line 201 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 432 of file minsky.h.

displayValues

bool minsky::Minsky::displayValues =false

Definition at line 431 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 384 of file minsky.h.

equationDisplay

PannableTab<EquationDisplay> minsky::Minsky::equationDisplay

Definition at line 153 of file minsky.h.

fileVersion

std::string minsky::Minsky::fileVersion

Minsky version file was saved under.

Definition at line 351 of file minsky.h.

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

fontSampler

FontDisplay minsky::Minsky::fontSampler

Definition at line 154 of file minsky.h.

histogramResource

SVGRenderer minsky::Minsky::histogramResource

Definition at line 225 of file minsky.h.

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

lastRedraw

Exclude<ptime> minsky::Minsky::lastRedraw

private

Definition at line 142 of file minsky.h.

lastT

double minsky::Minsky::lastT {0}

previous timestep

Definition at line 320 of file minsky.h.

logVarList

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

set of variables (valueIds) to log

Definition at line 302 of file minsky.h.

m_multipleEquities

bool minsky::Minsky::m_multipleEquities =false

private

Definition at line 144 of file minsky.h.

maxFlowValue

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

Definition at line 205 of file minsky.h.

maxHistory

unsigned minsky::Minsky::maxHistory {100}

maximum no. of history states to save

Definition at line 353 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 204 of file minsky.h.

maxWaitMS

int minsky::Minsky::maxWaitMS =100

maximum wait in millisecond between redrawing canvas during simulation

Definition at line 354 of file minsky.h.

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

minskyVersion

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

static

return the AEGIS assigned version number

Definition at line 337 of file minsky.h.

Referenced by schema3::Minsky::Minsky(), and minsky::MinskyTCL::startRecording().

model

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

Definition at line 255 of file minsky.h.

Referenced by minsky::IntOp::description(), minsky::MinskyTCL::findObject(), minsky::MinskyTCL::findVariable(), minsky::Group::gotoBookmark_b(), minsky::PhillipsDiagram::init(), minsky::anonymous_namespace{group.cc}::isGlobal(), minsky::Ravel::joinLockGroup(), minsky::Ravel::lockGroupColours(), schema3::Minsky::Minsky(), minsky::MinskyTCL::openModelInCanvas(), 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 529 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 325 of file minsky.h.

phillipsDiagram

PhillipsDiagram minsky::Minsky::phillipsDiagram

Definition at line 155 of file minsky.h.

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

publicationTabs

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

Definition at line 156 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 253 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 526 of file minsky.h.

variablePane

VariablePane minsky::Minsky::variablePane

Definition at line 537 of file minsky.h.

variableValues

VariableValues minsky::Minsky::variableValues

Definition at line 200 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