minsky Namespace Reference

Namespaces
	anonymous_namespace{addon.cc}
	anonymous_namespace{autoLayout.cc}
	anonymous_namespace{evalGodley.cc}
	anonymous_namespace{evalOp.cc}
	anonymous_namespace{getContext.cc}
	anonymous_namespace{godleyExport.cc}
	anonymous_namespace{godleyIcon.cc}
	anonymous_namespace{godleyTableWindow.cc}
	anonymous_namespace{grid.cc}
	anonymous_namespace{group.cc}
	anonymous_namespace{item.cc}
	anonymous_namespace{mdlReader.cc}
	anonymous_namespace{minsky.cc}
	anonymous_namespace{minskyTensorOps.cc}
	anonymous_namespace{operation.cc}
	anonymous_namespace{plotWidget.cc}
	anonymous_namespace{pubTab.cc}
	anonymous_namespace{ravelWrap.cc}
	anonymous_namespace{renderNativeWindow.cc}
	anonymous_namespace{saver.cc}
	anonymous_namespace{userFunction.cc}
	anonymous_namespace{userFunction_units.cc}
	anonymous_namespace{variableValue.cc}
	anonymous_namespace{windowInformation.cc}
	anonymous_namespace{wire.cc}
	OperationTypeInfo

Classes
struct	AccumArgs
struct	AccumArgs< OperationType::add >
struct	AccumArgs< OperationType::and_ >
struct	AccumArgs< OperationType::divide >
struct	AccumArgs< OperationType::max >
struct	AccumArgs< OperationType::min >
struct	AccumArgs< OperationType::multiply >
struct	AccumArgs< OperationType::or_ >
struct	AccumArgs< OperationType::subtract >
struct	BackgroundSaver
struct	Bookmark
struct	BottomRightResizerItem
class	BoundingBox
	bounding box information (at zoom=1 scale) More...
struct	BusyCursor
class	ButtonWidget
	supports +/-/←/→/↓/↑ widget More...
struct	ButtonWidgetEnums
struct	CairoRenderer
struct	CallableFunction
class	Canvas
struct	ClickType
	represents whether a mouse click is on the item, on an output port (for wiring, or is actually outside the items boundary, and a lasso is intended More...
class	Clipboard
	An RAII wrapper around jtanx's libclipboard (https://github.com/jtanx/libclipboard) More...
struct	ConstantEvalOp
struct	ConstMap
class	Copy
struct	Correlation
class	CSVDialog
class	DataOp
	legacy data importer object More...
class	DataSpec
struct	DataSpecSchema
struct	DeflateZStream
class	Derivative
struct	DerivativeMixin
	support for partial derivatives needed for implicit method More...
struct	DerivativeNotDefined
struct	DrawBinOp
	helper class to draw port label symbols More...
struct	DummyBase
struct	EngNotation
class	EquationDisplay
class	EvalCommon
	A place to store common data shared between TensorVarVals within a give calculation. More...
class	EvalGodley
struct	EvalOp
	represents the operation when evaluating the equations More...
struct	EvalOpBase
struct	EvalOpPtr
struct	EvalOpVector
struct	EventInterface
struct	FailedToRewind
struct	FallBackToScalar
struct	FlowCoef
	represents a numerical coefficient times a variable (a "flow") More...
struct	FlowVarsResized
	exception throw if flowVars vector unexpectedly resized during evalEquations More...
class	FontDisplay
struct	GeneralTensorOp
struct	GeneralTensorOp< OperationType::all >
struct	GeneralTensorOp< OperationType::any >
struct	GeneralTensorOp< OperationType::correlation >
struct	GeneralTensorOp< OperationType::covariance >
struct	GeneralTensorOp< OperationType::difference >
struct	GeneralTensorOp< OperationType::differencePlus >
struct	GeneralTensorOp< OperationType::gather >
struct	GeneralTensorOp< OperationType::histogram >
struct	GeneralTensorOp< OperationType::index >
struct	GeneralTensorOp< OperationType::infimum >
struct	GeneralTensorOp< OperationType::infIndex >
struct	GeneralTensorOp< OperationType::innerProduct >
struct	GeneralTensorOp< OperationType::linearRegression >
struct	GeneralTensorOp< OperationType::mean >
struct	GeneralTensorOp< OperationType::median >
struct	GeneralTensorOp< OperationType::meld >
struct	GeneralTensorOp< OperationType::merge >
struct	GeneralTensorOp< OperationType::moment >
struct	GeneralTensorOp< OperationType::outerProduct >
struct	GeneralTensorOp< OperationType::product >
struct	GeneralTensorOp< OperationType::runningProduct >
struct	GeneralTensorOp< OperationType::runningSum >
struct	GeneralTensorOp< OperationType::shape >
struct	GeneralTensorOp< OperationType::size >
struct	GeneralTensorOp< OperationType::slice >
struct	GeneralTensorOp< OperationType::stdDev >
struct	GeneralTensorOp< OperationType::sum >
struct	GeneralTensorOp< OperationType::supIndex >
struct	GeneralTensorOp< OperationType::supremum >
struct	GetUtf8Char
struct	GodleyAssetClass
class	GodleyIcon
class	GodleyIteratorAdaptor
	adaptor suitable for initialiseGodleys More...
class	GodleyTable
class	GodleyTableEditor
class	GodleyTableWindow
class	Grid
class	Group
class	GroupItems
struct	HandleLockInfo
struct	has_empty
class	ICell
	Cell template parameter duck types this interface. More...
struct	IncrDecrCounter
	exception-safe increment/decrement of a counter in a block More...
struct	InflateFileZStream
struct	InflateZStream
struct	InputPort
class	Integral
	An integral is an additional stock variable, that integrates its flow variable. More...
class	IntOp
class	IntrusiveMap
struct	IntrusiveWrap
class	Item
struct	ItemExclude
	Item members excluded from reflection. More...
struct	ItemPortVector
struct	ItemT
struct	JustificationStruct
struct	KeyAssertion
struct	KeyAssertion< int >
struct	LassoBox
	represents rectangular region of a lasso operation More...
struct	LegendGeometry
struct	LocalMinsky
	RAII set the minsky object to a different one for the current scope. More...
class	Lock
class	Matrix
	convenience class for accessing matrix elements from a data array More...
class	Minsky
struct	MinskyExclude
struct	MinskyTensorOp
struct	MultiWireBinOp
struct	MultiWireInputPort
class	NamedOp
	base class for operations that have names More...
struct	NoAssign
class	NoteBase
struct	NSContext
struct	OnError
	handle reporting errors in loadValueFromCSVFileT when loading files More...
struct	OnStackExit
	arrange for a functional to be called on stack exit More...
class	Operation
class	OperationBase
class	OperationFactory
	factory class template, for creating objects of type T<O>. N is the maximum value of O More...
class	OperationPtr
	shared_ptr class for polymorphic operation objects. Note, you may assume that this pointer is always valid, although currently the implementation doesn't guarantee it (eg reset() is exposed). More...
struct	OperationType
struct	OpState
struct	Optional
	convenience class to omit writing XML records when data absent or empty More...
class	PannableTab
	Mixin implementing common panning functionality in tabs. More...
struct	PannableTabBase
struct	ParseCSV
class	PhillipsDiagram
class	PhillipsFlow
class	PhillipsStock
struct	PlotOptions
class	PlotWidget
	a container item for a plot widget More...
struct	PlotWidgetSuper
class	Port
struct	PortExclude
	components of Port excluded from reflection More...
class	Progress
class	ProgressUpdater
class	PubItem
class	PubTab
struct	PubTabBase
class	Ravel
class	RavelLockGroup
class	RavelPopup
class	RavelTensor
class	Reflect
class	RenderNativeWindow
class	RenderVariable
struct	RESTMinsky
struct	RKdata
class	Rotate
	rotate (x,y) by rot (in degrees) around the origin (x0, y0) can be used for rotating multiple points once constructed More...
class	RungeKutta
struct	RungeKuttaExclude
	components excluded from reflection More...
struct	Saver
struct	ScalarEvalOp
	Legacy EvalOp base interface. More...
struct	SchemaHelper
struct	Selection
	represents items that have been selected More...
struct	SetState
struct	SharedColumnCheck
	for checking shared columns between tables More...
class	Sheet
struct	Simulation
struct	Slider
	data structure supporting sliders - shared between constant operations and variables More...
struct	Summary
	summary for the variable tab (aka summary tab). More...
class	SVGRenderer
class	SwitchIcon
class	SwitchTensor
struct	TensorBinOp
class	TensorEval
	A helper to evaluate a variable value. More...
class	TensorOpFactory
	As it says on the tin, this is a factory for creating a TensorOp which can compute the result of op applied to its arguments and so on until all the argument terminate in variables. More...
struct	TensorsFromPort
struct	TensorVarVal
struct	TensorVarValBase
class	Time
struct	TimeOp
struct	TrackedIntrusiveMap
struct	Units
	represents the units (in sense of dimensional analysis) of a variable. More...
struct	UnitsExpressionWalker
class	UserFunction
struct	ValueVector
struct	VarConstant
class	Variable
class	VariableBase
class	VariableCaches
	caches need copy operations to be nobbled, because they hold a reference to the derived variable More...
class	VariableInstanceList
class	VariablePane
class	VariablePaneBase
class	VariablePaneCell
class	VariablePtr
struct	VariableType
class	VariableValue
struct	VariableValueData
struct	VariableValuePtr
	a shared_ptr that default constructs a default target, and is always valid More...
class	VariableValues
struct	ViewImpl
class	WindowInformation
struct	Winfo
class	Wire
struct	ZStream

Typedefs
typedef boost::geometry::model::d2::point_xy< float >	Point
typedef std::vector< GroupPtr >	Groups
typedef std::shared_ptr< Item >	ItemPtr
typedef std::vector< ItemPtr >	Items
using	FlowVar = Variable< VariableType::flow >
using	StockVar = Variable< VariableType::stock >
typedef std::shared_ptr< Group >	GroupPtr
typedef std::shared_ptr< Wire >	WirePtr
typedef std::vector< WirePtr >	Wires
using	ConstTensorVarVal = TensorVarValBase<>

Enumerations
enum	ShowSlice { ShowSlice::head, ShowSlice::headAndTail, ShowSlice::tail }
enum	ItemType {   wire, op, var, group,   godley, plot }

Functions
template<class T >
T	sqr (T x)
double	clamp360 (double x)
	return x modulo 360 More...
int	quadrant (double x)
	return quadrant x is in: 0=[-45,45),1=[45,135), etc More...
bool	flipped (double rotation)
	returns if the angle (in degrees) is in the second or third quadrant More...
template<class T >
std::string	str (T x)
	utility function to create a string representation of a numeric type More...
bool	IsNotalnum (char x)
void	stripNonAlnum (std::string &x)
std::string	trimWS (const std::string &s)
std::string	stripActive (const std::string &s)
	repaces characters that cause interpretation by TCL, backslashes are replaced by the set minus operator ∖, and spaces are replaced by ␣, as they cause problems More...
template<class F >
OnStackExit< F >	onStackExit (F f)
	generator function More...
template<class T , class V >
void	remove (std::vector< T > &x, const V &v)
	remove an element from a vector. V must be comparable to a T More...
template<class T , class D >
std::unique_ptr< T, D >	uniqueDeleter (T *x, D d)
unsigned	numBytes (unsigned char x)
	a wrapper around std::ofstream that checks the write succeeded, throwing an exception if not More...
size_t	prevIndex (const std::string &str, size_t index)
	return index of previous character to index More...
std::istream &	operator>> (std::istream &i, const GetUtf8Char &g)
void	stripByteOrderingMarker (std::istream &s)
	checks if the input stream has the UTF-8 byte ordering marker, and removes it if present More...
std::string	CSVQuote (const std::string &x, char sep)
	quotes a string if it contains a separator character, and double quotes quotes More...
std::ostream &	operator<< (std::ostream &o, OperationType::Type t)
classdesc::pack_t	decode (const classdesc::CDATA &)
	decode ascii-encoded representation to binary data More...
CDATA	encode (const pack_t &buf)
template<class PreviousSchema , class CurrentSchema >
void	loadSchema (CurrentSchema &currentSchema, classdesc::xml_unpack_t &data, const std::string &rootElement)
classdesc::CDATA	encode (const classdesc::pack_t &)
	encode binary data to ascii-encoded More...
std::ostream &	operator<< (std::ostream &o, const Units &u)
std::ostream &	operator<< (std::ostream &o, VariableType::Type t)
void	randomizeLayout (Group &)
	randomly place items on canvas More...
void	layoutGroup (Group &)
	auto layout group items More...
void	drawTriangle (cairo_t *cairo, double x, double y, const ecolab::cairo::Colour &col, double angle=0)
bool	isNumerical (const std::string &s)
constexpr char	control (char x)
void	asgClonedPort (shared_ptr< Port > &p, const map< Item *, ItemPtr > &cloneMap)
template<class G , class M , class O >
bool	GroupRecursiveDo (G &gp, M GroupItems::*map, O op)
Minsky &	minsky ()
	global minsky object More...
const Minsky &	cminsky ()
	const version to help in const correctness More...
double	yearToPTime (double x)
void	macOSXRedraw (RenderNativeWindow &window, const std::shared_ptr< std::lock_guard< std::mutex >> &lock)
void	zoom (float &val, float origin, float factor)
	base zooming transformation More...
void	chomp (string &buf)
bool	getWholeLine (istream &input, string &line, const DataSpec &spec)
void	escapeDoubledQuotes (std::string &, const DataSpec &)
	replace doubled quotes with escaped quotes More...
template<class P , class E , class S >
void	loadValueFromCSVFileT (VariableValue &vv, S &stream, const DataSpec &spec, E &onError)
template<class S >
void	loadValueFromCSVFileS (VariableValue &v, S &filenames, const DataSpec &spec)
void	loadValueFromCSVFile (VariableValue &, const std::vector< std::string > &filenames, const DataSpec &)
	load a variableValue from a list of files according to data spec More...
void	loadValueFromCSVFile (VariableValue &, std::istream &input, const DataSpec &)
	load a variableValue from a stream according to data spec More...
template<class P >
void	reportFromCSVFileT (istream &input, ostream &output, const DataSpec &spec, uintmax_t fileSize)
void	reportFromCSVFile (std::istream &input, std::ostream &output, const DataSpec &spec, uintmax_t fileSize)
	creates a report CSV file from input, with errors sorted at begining of file, with a column for error messages More...
EngNotation	engExp (double value)
	return formatted mantissa and exponent in engineering format More...
std::string	mantissa (double value, const EngNotation &, int digits=3)
std::string	expMultiplier (int exp)
void	doOneEvent (bool idleTasksOnly)
	checks if any GUI events are waiting, and proces an event if so More...
template<class T >
GodleyIteratorAdaptor< T >	makeGodleyIt (const T &it)
bool	operator> (std::size_t x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	root (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	pow (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	checkDimensionless (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	checkSameDims (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
void	exportToCSV (std::ostream &s, const GodleyTable &g)
void	exportToLaTeX (std::ostream &f, const GodleyTable &g)
string	defang (char c)
string	latexToPangoNonItalicised (const char *input)
std::string	latexToPangoNonItalicised (const std::string &x)
std::string	latexToPango (const char *s)
std::string	latexToPango (const std::string &x)
	interprets LaTeX sequences within, returning result as UTF-8 containing Pango markup. Only a small subset of LaTeX is implemented. More...
std::string	defang (const std::string &s)
void	readMdl (Group &group, Simulation &simParms, std::istream &mdlFile)
	import a Vensim mdl file into group, also populating simParms from the control block More...
template<template< OperationType::Type > class T, int op, int to>
classdesc::enable_if< Not< is_equal< op, to > >, void >::T	registerOps (TensorOpFactory &tensorOpFactory)
template<template< OperationType::Type > class T, int op, int to>
classdesc::enable_if< is_equal< op, to >, void >::T	registerOps (TensorOpFactory &tensorOpFactory)
bool	isValueId (const std::string &name)
	check that name is a valid valueId (useful for assertions) More...
string	canonicalName (const std::string &name)
	convert a raw name into a canonical name - this is not idempotent. More...
string	valueIdCanonical (size_t scope, const std::string &name)
	construct a valueId @ name should be canonicalised More...
string	valueId (const std::string &name)
	construct a valueId from fully qualified name @ name should not be canonicalised More...
string	valueId (const GroupPtr &ref, const std::string &name)
	construct a valueId. @ name should not be canonicalised if name has leading :, then heirarchy is searched for matching local name More...
size_t	scope (const std::string &name)
	extract scope from a qualified variable name More...
GroupPtr	scope (GroupPtr ref, const std::string &name)
	starting from reference group ref, applying scoping rules to determine the actual scope of name If name prefixed by :, then search up group heirarchy for locally scoped var, otherwise return ref More...
string	valueIdFromScope (const GroupPtr &scope, const std::string &name)
	value Id from scope and canonical name name More...
std::string	uqName (const std::string &name)
	extract unqualified portion of name More...

Variables
constexpr float	portRadius =6
	radius of circle marking ports at zoom=1 More...
constexpr float	portRadiusMult =2.0f*portRadius
static std::unique_ptr< char[]>	_defaultFont
static ptime	epoch =microsec_clock::local_time()
static ptime	accumulatedBlitTime =epoch
static const size_t	maxNumTensorElementsToPlot =10
const double	yearLength = 3600*24*365.2525
UnitsExpressionWalker	timeUnit
TensorOpFactory	tensorOpFactory
const char *	schemaURL ="http://minsky.sf.net/minsky"
constexpr float	sliderHandleRadius =3

Detailed Description

Support the CSV import dialog

Provide support for the Godley Table spreadsheet window

A simple spreadsheet view

Utilities for walking an exprtk expression object.

To use, define the actions you want to happen for each type of expression

Typedef Documentation

ConstTensorVarVal

using minsky::ConstTensorVarVal = typedef TensorVarValBase<>

Definition at line 123 of file minskyTensorOps.h.

FlowVar

using minsky::FlowVar = typedef Variable<VariableType::flow>

Definition at line 32 of file phillipsDiagram.h.

GroupPtr

typedef std::shared_ptr< Group > minsky::GroupPtr

Definition at line 32 of file port.h.

Groups

typedef std::vector<GroupPtr> minsky::Groups

Definition at line 52 of file group.h.

ItemPtr

typedef std::shared_ptr<Item> minsky::ItemPtr

Definition at line 55 of file item.h.

Items

typedef std::vector<ItemPtr> minsky::Items

Definition at line 360 of file item.h.

Point

typedef boost::geometry::model::d2::point_xy<float> minsky::Point

Definition at line 34 of file geometry.h.

StockVar

using minsky::StockVar = typedef Variable<VariableType::stock>

Definition at line 33 of file phillipsDiagram.h.

WirePtr

typedef std::shared_ptr<Wire> minsky::WirePtr

Definition at line 98 of file wire.h.

Wires

typedef std::vector<WirePtr> minsky::Wires

Definition at line 99 of file wire.h.

Enumeration Type Documentation

ItemType

enum minsky::ItemType

Enumerator
wire
op
var
group
godley
plot

Definition at line 117 of file minsky.h.

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

ShowSlice

enum minsky::ShowSlice

strong

Enumerator
head
headAndTail
tail

Definition at line 25 of file showSlice.h.

{head, headAndTail, tail};

Function Documentation

asgClonedPort()

void minsky::asgClonedPort	(	shared_ptr< Port > &	p,
		const map< Item *, ItemPtr > &	cloneMap
	)

Definition at line 106 of file group.cc.

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

  {
    auto clone=cloneMap.find(&p->item());
    if (clone!=cloneMap.end())
      {
        for (size_t i=0; i<p->item().portsSize(); ++i)
          if (p->item().ports(i).lock()==p)
            {
              // set the new port to have the equivalent position in the clone
              p=clone->second->ports(i).lock();
              assert(p);
            }
      }
  }

Here is the caller graph for this function:

canonicalName()

std::string minsky::canonicalName

(

const string &

name

)

convert a raw name into a canonical name - this is not idempotent.

Definition at line 63 of file valueId.cc.

References latexToPangoNonItalicised(), stripActive(), trimWS(), and uqName().

Referenced by minsky::UserFunction::compile(), minsky::Minsky::constructEquations(), minsky::VariableBase::name(), scope(), minsky::UserFunction::units(), valueId(), minsky::VariableValue::valueId(), and minsky::anonymous_namespace{minsky.cc}::GodleyIt::valueId().

  {
    return utf_to_utf<char>(stripActive(trimWS(latexToPangoNonItalicised(uqName(name)))));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

checkDimensionless()

UnitsExpressionWalker minsky::checkDimensionless ( const UnitsExpressionWalker &  x, const UnitsExpressionWalker &  y  )

inline

Definition at line 67 of file expressionWalker.h.

References minsky::UnitsExpressionWalker::checkDimensionless().

  {x.checkDimensionless(); y.checkDimensionless(); return x;}

Here is the call graph for this function:

checkSameDims()

UnitsExpressionWalker minsky::checkSameDims ( const UnitsExpressionWalker &  x, const UnitsExpressionWalker &  y  )

inline

Definition at line 70 of file expressionWalker.h.

References minsky::UnitsExpressionWalker::checkSameDims(), and minsky::UnitsExpressionWalker::units.

  {x.checkSameDims(y); auto tmp=x; tmp.units.clear(); return tmp;}

Here is the call graph for this function:

chomp()

void minsky::chomp

(

string &

buf

)

Definition at line 577 of file CSVParser.cc.

Referenced by getWholeLine().

  {
    if (!buf.empty() && buf.back()=='\r')
      buf.erase(buf.size()-1);
  }

Here is the caller graph for this function:

clamp360()

double minsky::clamp360 ( double  x )

inline

return x modulo 360

Definition at line 87 of file geometry.h.

Referenced by quadrant().

  {
    // adjust x to be positive before taking modulus
    if (x<0)
      x+=(size_t(-x)/360+1)*360;
    return std::fmod(x,360);
  }

Here is the caller graph for this function:

cminsky()

const Minsky& minsky::cminsky ( )

inline

const version to help in const correctness

Definition at line 538 of file minsky.h.

References minsky().

Referenced by minsky::PlotWidget::addConstantCurves(), minsky::Group::addIOVar(), minsky::PlotWidget::addPlotPt(), minsky::GroupItems::addWire(), minsky::GodleyTableEditor::copy(), minsky::TensorOpFactory::create(), minsky::VariableBase::definition(), minsky::Ravel::dimension(), minsky::Ravel::dimensionType(), minsky::Ravel::dimensionUnitsFormat(), minsky::ButtonWidget< row >::draw(), minsky::GodleyTableEditor::draw(), minsky::VariableBase::draw(), minsky::anonymous_namespace{minsky.cc}::Network::followWire(), minsky::Group::gotoBookmark_b(), minsky::Ravel::hypercube(), minsky::VariableValue::hypercube(), minsky::Operation< minsky::OperationType::integrate >::iconDraw(), minsky::PhillipsDiagram::init(), minsky::VariableBase::init(), minsky::VariableValue::init(), minsky::ButtonWidget< row >::invoke(), minsky::anonymous_namespace{group.cc}::isGlobal(), minsky::Ravel::joinLockGroup(), MathDAG::latexInit(), loadValueFromCSVFileT(), minsky::VariableBase::local(), minsky::Ravel::lockGroupColours(), minsky::VariablePtr::makeConsistentWithValue(), MathDAG::matlabInit(), minsky::GodleyTable::nameUnique(), minsky::GodleyTableEditor::paste(), minsky::Group::renameAllInstances(), minsky::Canvas::renameItem(), minsky::VariableValues::resetValue(), minsky::PlotWidget::scalePlot(), minsky::Ravel::setDimension(), minsky::VariableBase::sliderVisible(), minsky::GodleyIcon::stockVarUnits(), minsky::VariableValue::summary(), MathDAG::VariableDAG::tensorEval(), minsky::Item::throw_error(), minsky::UserFunction::units(), minsky::IntOp::units(), minsky::Time::units(), minsky::Derivative::units(), minsky::VariableBase::units(), minsky::VariablePane::update(), minsky::VariableBase::value(), and minsky::VariableBase::vValue().

{return minsky();}

Here is the call graph for this function:

control()

constexpr char minsky::control ( char  x )

inline

Definition at line 631 of file godleyTableWindow.cc.

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

{return x-'`';}

Here is the caller graph for this function:

CSVQuote()

std::string minsky::CSVQuote ( const std::string &  x, char  sep  )

inline

quotes a string if it contains a separator character, and double quotes quotes

Definition at line 162 of file str.h.

Referenced by minsky::VariableValue::exportAsCSV(), and minsky::Minsky::openLogFile().

  {
    std::string r;
    bool needsQuoting=false;
    for (auto c: x)
      {
        r+=c;
        if (c=='"') {r+='"'; needsQuoting=true;}
        if (c==sep) needsQuoting=true;
      }
    if (needsQuoting) return "\""+r+"\"";
    return r;
  }

Here is the caller graph for this function:

decode()

classdesc::pack_t minsky::decode

(

const classdesc::CDATA &

data

)

decode ascii-encoded representation to binary data

Definition at line 34 of file schemaHelper.cc.

References a85::from_a85(), and a85::size_for_bin().

Referenced by schema3::Item::convertTensorDataFromSchema2(), and schema3::Minsky::populateGroup().

  {
    string trimmed; //trim whitespace
    for (auto c: data)
      if (!isspace(c)) trimmed+=c;
    
    vector<unsigned char> zbuf(a85::size_for_bin(trimmed.size()));
    // reverse transformation required to avoid the escape sequence ']]>'
    replace(trimmed.begin(),trimmed.end(),'~',']'); 
    a85::from_a85(trimmed.data(), trimmed.size(),zbuf.data());

    InflateZStream zs(zbuf);
    zs.inflate();
    return std::move(zs.output);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

defang() [1/2]

std::string minsky::defang ( const std::string &  s )

inline

Definition at line 39 of file latexMarkup.h.

References defang().

                                              {
    std::string r;
    for (auto& c: s) r+=defang(c);
    return r;
  }

Here is the call graph for this function:

defang() [2/2]

std::string minsky::defang

(

char

c

)

Definition at line 842 of file latexMarkup.cc.

Referenced by minsky::PlotWidget::addConstantCurves(), defang(), minsky::GodleyTableEditor::draw(), anonymous_namespace{latexMarkup.cc}::Result::processLaTeX(), minsky::GodleyTableEditor::textIdx(), and anonymous_namespace{latexMarkup.cc}::utf8char().

    {
      switch (c)
        {
        case '<': return "&lt;";
        case '>': return "&gt;";
        case '&': return "&amp;";
        case '\'': return "&apos;";
        case '\"': return "&quot;";
        default: return string{&c,1};
        }
    }

Here is the caller graph for this function:

doOneEvent()

void minsky::doOneEvent

(

bool

idleTasksOnly

)

checks if any GUI events are waiting, and proces an event if so

Definition at line 550 of file addon.cc.

Referenced by MathDAG::ConstantDAG::addEvalOps(), MathDAG::VariableDAG::addEvalOps(), MathDAG::IntegralInputVariableDAG::addEvalOps(), MathDAG::OperationDAGBase::addEvalOps(), and minsky::RungeKutta::rkstep().

{}

Here is the caller graph for this function:

drawTriangle()

void minsky::drawTriangle	(	cairo_t *	cairo,
		double	x,
		double	y,
		const ecolab::cairo::Colour &	col,
		double	angle = 0
	)

Referenced by minsky::SwitchIcon::draw(), minsky::Ravel::draw(), and minsky::PlotWidget::draw().

Here is the caller graph for this function:

encode() [1/2]

CDATA minsky::encode

(

const pack_t &

buf

)

Definition at line 51 of file schemaHelper.cc.

References a85::size_for_a85(), and a85::to_a85().

Referenced by schema3::Item::convertTensorDataFromSchema2(), and schema3::Item::packTensorInit().

  {
    vector<unsigned char> zbuf(buf.size());
    DeflateZStream zs(buf, zbuf);
    zs.deflate();
    
    vector<char> cbuf(a85::size_for_a85(zs.total_out,false));
    a85::to_a85(zbuf.data(),zs.total_out, cbuf.data(), false);
    // this ensures that the escape sequence ']]>' never appears in the data
    replace(cbuf.begin(),cbuf.end(),']','~');
    return CDATA(cbuf.begin(),cbuf.end());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

encode() [2/2]

classdesc::CDATA minsky::encode

(

const classdesc::pack_t &

)

encode binary data to ascii-encoded

engExp()

EngNotation minsky::engExp

(

double

value

)

return formatted mantissa and exponent in engineering format

Definition at line 383 of file variableValue.cc.

References minsky::EngNotation::engExp, MathDAG::log(), and minsky::EngNotation::sciExp.

Referenced by minsky::GodleyTableEditor::draw(), minsky::VariableBase::draw(), and minsky::VariableBase::engExp().

  {
    EngNotation r;
    r.sciExp=(v!=0)? floor(log(fabs(v))/log(10)): 0;
    if (r.sciExp==3) // special case for dates
      r.engExp=0;
    else
      r.engExp=r.sciExp>=0? 3*(r.sciExp/3): 3*((r.sciExp+1)/3-1);
    return r;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

escapeDoubledQuotes()

void minsky::escapeDoubledQuotes	(	std::string &	line,
		const DataSpec &	spec
	)

replace doubled quotes with escaped quotes

Definition at line 605 of file CSVParser.cc.

References minsky::DataSpecSchema::escape, minsky::DataSpecSchema::quote, and minsky::DataSpecSchema::separator.

Referenced by getWholeLine().

  {
    // replace doubled quotes with escape quote
    for (size_t i=1; i<line.size(); ++i)
      if (line[i]==spec.quote && line[i-1]==spec.quote &&
          ((i==1 && (i==line.size()-1|| line[i+1]!=spec.quote)) ||                                       // deal with leading ""
           (i>1 &&
            ((line[i-2]!=spec.quote && line[i-2]!=spec.escape &&
              (line[i-2]!=spec.separator || i==line.size()-1|| line[i+1]!=spec.quote))  // deal with ,''
             ||            // deal with "" middle or end
             (line[i-2]==spec.quote && (i==2 || line[i-3]==spec.separator || line[i-3]==spec.escape)))))) // deal with leading """
        line[i-1]=spec.escape;
  }

Here is the caller graph for this function:

expMultiplier()

string minsky::expMultiplier

(

int

exp

)

Definition at line 413 of file variableValue.cc.

References MathDAG::exp().

Referenced by minsky::GodleyTableEditor::draw(), minsky::VariableBase::draw(), and minsky::RenderVariable::RenderVariable().

  {return exp!=0? "×10<sup>"+std::to_string(exp)+"</sup>": "";}

Here is the call graph for this function:

Here is the caller graph for this function:

exportToCSV()

void minsky::exportToCSV	(	std::ostream &	s,
		const GodleyTable &	g
	)

Definition at line 61 of file godleyExport.cc.

References minsky::GodleyTable::assetClass(), minsky::GodleyTable::cols(), minsky::GodleyTable::doubleEntryCompliant, minsky::anonymous_namespace{godleyExport.cc}::fcStr(), minsky::GodleyTable::getCell(), latexToPango(), minsky::GodleyTable::rows(), minsky::anonymous_namespace{godleyExport.cc}::trim(), and uqName().

Referenced by minsky::GodleyTable::exportToCSV().

  {
    s<<'"'<<g.getCell(0,0)<<'"';
    for (unsigned i=1; i<g.cols(); ++i)
      s<<",\""<<trim(latexToPango(uqName(g.getCell(0,i))))<<'"';
    s<<'\n';
    if (g.doubleEntryCompliant)
      {
        s<<"Asset Class";
        for (unsigned i=1; i<g.cols(); ++i)
          s<<","<<enum_keysData<GodleyAssetClass::AssetClass>::
            keysData[g.assetClass(i)].name;
        s<<"\n";
      }
    for (unsigned r=1; r<g.rows(); ++r)
      {
        s<<g.getCell(r,0);
        for (unsigned c=1; c<g.cols(); ++c)
          s<<",\""<<trim(latexToPango(fcStr(FlowCoef(g.getCell(r,c)))))<<'"';
        s<<'\n';
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

exportToLaTeX()

void minsky::exportToLaTeX	(	std::ostream &	f,
		const GodleyTable &	g
	)

Definition at line 84 of file godleyExport.cc.

References minsky::GodleyTable::assetClass(), minsky::GodleyTable::cols(), minsky::GodleyTable::doubleEntryCompliant, f, minsky::anonymous_namespace{godleyExport.cc}::fcStr(), minsky::GodleyTable::getCell(), minsky::GodleyTable::rows(), and uqName().

Referenced by minsky::GodleyTable::exportToLaTeX().

  {
    f<<"\\documentclass{article}\n\\begin{document}\n";
    f<<"\\begin{tabular}{|c|";
    for (unsigned i=1; i<g.cols(); ++i)
      f<<'c';
    f<<"|}\n\\hline\n";
    f<<"Flows $\\downarrow$ / Stock Variables $\\rightarrow$";
    for (unsigned i=1; i<g.cols(); ++i)
      f<<"&\\multicolumn{1}{|c|}{$"<<uqName(g.getCell(0,i))<<"$}";

    // asset class descriptors
    if (g.doubleEntryCompliant)
      {
        f<<"\\\\\\cline{2-"<<g.cols()<<"}Asset Class";
        unsigned repeat=0;
        GodleyAssetClass::AssetClass asset=GodleyAssetClass::noAssetClass;

        auto outputAC=[&]() {
          if (repeat>0)
            f<<"&\\multicolumn{"<<repeat<<"}{|c|}{"<<
              enum_keysData<GodleyAssetClass::AssetClass>::
              keysData[asset].name<<'}';
        };
          
        for (unsigned i=1; i<g.cols(); ++i)
          if (g.assetClass(i)!=asset)
            {
              outputAC();
              asset=g.assetClass(i);
              repeat=1;
            }
          else
            repeat++;

        // now output last column
        outputAC();
      }

    f<<"\\\\\\hline\n";
    for (unsigned r=1; r<g.rows(); ++r)
      {
        f<<g.getCell(r,0);
        for (unsigned c=1; c<g.cols(); ++c)
          f<<"&$"<<fcStr(FlowCoef(g.getCell(r,c)))<<'$';
        f<<"\\\\\n";
      }
    f<<"\\hline\n\\end{tabular}\n";
    f<<"\\end{document}\n";
  }

Here is the call graph for this function:

Here is the caller graph for this function:

flipped()

bool minsky::flipped ( double  rotation )

inline

returns if the angle (in degrees) is in the second or third quadrant

Definition at line 102 of file geometry.h.

Referenced by minsky::VariableBase::clickType(), minsky::SwitchIcon::draw(), minsky::OperationBase::draw(), minsky::VariableBase::draw(), minsky::Group::draw(), minsky::Item::draw(), minsky::DrawBinOp::drawPort(), minsky::OperationBase::drawUserFunction(), schema3::populateItem(), minsky::Item::rotationAsRadians(), minsky::Minsky::setDefinition(), and minsky::Canvas::zoomToFit().

  {
    const double fm=std::fmod(rotation,360);
    return std::abs(fm)>90 && std::abs(fm)<270;
  }

Here is the caller graph for this function:

getWholeLine()

bool minsky::getWholeLine	(	istream &	input,
		string &	line,
		const DataSpec &	spec
	)

Definition at line 584 of file CSVParser.cc.

References chomp(), escapeDoubledQuotes(), and minsky::DataSpecSchema::quote.

Referenced by minsky::ParseCSV< P >::parse(), and reportFromCSVFileT().

  {
    line.clear();
    bool r=getline(input,line).good();
    chomp(line);
    while (r)
      {
        int quoteCount=0;
        for (auto i: line)
          if (i==spec.quote)
            ++quoteCount;
        if (quoteCount%2==0) break; // data line correctly terminated
        string buf;
        r=getline(input,buf).good(); // read next line and append
        chomp(buf);
        line+=buf;
      }
    escapeDoubledQuotes(line,spec);
    return r || !line.empty();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GroupRecursiveDo()

template<class G , class M , class O >

bool minsky::GroupRecursiveDo	(	G &	gp,
		M GroupItems::*	map,
		O	op
	)

Definition at line 201 of file group.h.

References op.

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

    {
      for (auto i=(gp.*map).begin(); i!=(gp.*map).end(); ++i)
        {
          assert(*i);
          if (op(gp.*map,i))
            return true;
        }
      for (auto& g: gp.groups)
        {
          assert(g);
          if (g->recursiveDo(map, op))
            return true;
        }
      return false;
    }

Here is the caller graph for this function:

IsNotalnum()

bool minsky::IsNotalnum ( char  x )

inline

Definition at line 42 of file str.h.

Referenced by stripNonAlnum().

{return !std::isalnum(x);}

Here is the caller graph for this function:

isNumerical()

bool minsky::isNumerical

(

const std::string &

s

)

Definition at line 338 of file CSVParser.cc.

References anonymous_namespace{CSVParser.cc}::quotedStoD(), and anonymous_namespace{CSVParser.cc}::stripWSAndDecimalSep().

Referenced by minsky::CSVDialog::classifyColumns().

  {
    size_t charsProcd=0;
    const string stripped=stripWSAndDecimalSep(s);
    try
      {
        quotedStoD(stripped, charsProcd);
      }
    catch (...) {return false;}
    return charsProcd==stripped.size();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

isValueId()

bool minsky::isValueId

(

const string &

name

)

check that name is a valid valueId (useful for assertions)

Definition at line 33 of file valueId.cc.

Referenced by MathDAG::VariableDAG::addEvalOps(), minsky::Minsky::convertVarType(), minsky::VariableBase::ensureValueExists(), minsky::VariableBase::init(), MathDAG::SystemOfEquations::makeDAG(), MathDAG::SystemOfEquations::populateEvalOpVector(), minsky::VariableBase::setUnits(), minsky::VariableValues::validEntries(), and minsky::VariableBase::value().

  {
    // original code, left for reference
    //    static regex pattern("((constant)?\\d*:[^:\\ \f\n\r\t\v]+)");
    //    return name.length()>1 && name.substr(name.length()-2)!=":_" &&
    //      regex_match(utf_to_utf<char>(name), pattern);   // Leave curly braces in valueIds. For ticket 1165
    if (name.substr(name.length()-2)==":_") return false;
    
    static const string constantPrefix="constant:", tempPrefix="temp:";
    auto nameCStr=name.c_str();
    const char* endp=nullptr;
    strtoull(nameCStr,&const_cast<char*&>(endp),10);
    if (*endp==':' || name.starts_with(constantPrefix)||name.starts_with(tempPrefix))
      {
        if (*endp!=':')
          {
            if (name[constantPrefix.length()-1]==':')
              endp=nameCStr+constantPrefix.length()-1;
            else
              endp=nameCStr+tempPrefix.length()-1;
          }
        // check unqualified name portion has no verboten characters
        for (auto c=endp+1; *c!='\0'; ++c)
          if (strchr(":\\ \f\n\r\t\v",*c))
            return false;
        return true;
      }
    return false;
  }

Here is the caller graph for this function:

latexToPango() [1/2]

std::string minsky::latexToPango ( const char *  s )

inline

Definition at line 30 of file latexMarkup.h.

References latexToPangoNonItalicised().

Referenced by minsky::Item::displayTooltip(), minsky::Wire::draw(), minsky::GodleyTableEditor::draw(), minsky::GodleyIcon::draw(), minsky::PlotWidget::draw(), minsky::Item::draw(), minsky::OperationBase::drawUserFunction(), exportToCSV(), minsky::PlotWidget::labelPen(), minsky::Minsky::latex2pango(), latexToPango(), MathDAG::ConstantDAG::render(), MathDAG::VariableDAG::render(), MathDAG::OperationDAG< OperationType::subtract >::render(), MathDAG::SystemOfEquations::renderEquations(), minsky::RenderVariable::RenderVariable(), minsky::GeneralTensorOp< OperationType::merge >::setArguments(), and MathDAG::anonymous_namespace{equationDisplayRender.cc}::variableRender().

  {return "<i>"+latexToPangoNonItalicised(s)+"</i>";}

Here is the call graph for this function:

Here is the caller graph for this function:

latexToPango() [2/2]

std::string minsky::latexToPango ( const std::string &  x )

inline

interprets LaTeX sequences within, returning result as UTF-8 containing Pango markup. Only a small subset of LaTeX is implemented.

Definition at line 34 of file latexMarkup.h.

References latexToPango().

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

Here is the call graph for this function:

latexToPangoNonItalicised() [1/2]

std::string minsky::latexToPangoNonItalicised ( const std::string &  x )

inline

Definition at line 27 of file latexMarkup.h.

References latexToPangoNonItalicised().

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

Here is the call graph for this function:

latexToPangoNonItalicised() [2/2]

std::string minsky::latexToPangoNonItalicised

(

const char *

input

)

Definition at line 855 of file latexMarkup.cc.

References anonymous_namespace{latexMarkup.cc}::utf8char().

Referenced by canonicalName(), latexToPango(), latexToPangoNonItalicised(), minsky::PlotWidget::xlabel(), minsky::PlotWidget::y1label(), and minsky::PlotWidget::ylabel().

  {
    if (input[0]=='\0')
      return ""; // do not wrap with italic environment
    Result r;
    while (*input!='\0')
      switch (*input)
        {
        case '\\':
          r.processLaTeX(input);
          break;
        case '_':
          r.push("sub", ++input);
          break;
        case '^':
          r.push("sup", ++input);
          break;
        case '{':
          r.push("{", ++input);
          break;  
        case '}':
          input++;
          r.pop();
          break;
        default:
          r+=utf8char(input);
          break;
        }

    // take care of mismatched braces
    while (!r.stack.empty()) r.pop();
    return r;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

layoutGroup()

void minsky::layoutGroup

(

Group &

g

)

auto layout group items

Definition at line 101 of file autoLayout.cc.

References minsky::GroupItems::groups, minsky::GroupItems::items, pyminsky::minsky, minsky::Item::moveTo(), minsky::ProgressUpdater::setProgress(), MathDAG::sqrt(), minsky::anonymous_namespace{autoLayout.cc}::totalArea(), and minsky::GroupItems::wires.

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

  {
    if (g.items.size()+g.groups.size()<2) return;
    const double layoutSize=sqrt(10*totalArea(g)); //half width of square to emplace the items
   
    Graph gg;
    map<Item*, decltype(gg.add_vertex())> vertexMap;
    for (auto& i: g.items)
      vertexMap.emplace(i.get(), gg.add_vertex(i.get())); 
    for (auto& i: g.groups)
      {
        vertexMap.emplace(i.get(), gg.add_vertex(i.get()));
        // add I/O variables, as these may be wired too.
        for (auto& j: i->inVariables)
          vertexMap.emplace(j.get(), gg.add_vertex(j.get()));
        for (auto& j: i->outVariables)
          vertexMap.emplace(j.get(), gg.add_vertex(j.get()));
      }

    for (auto& w: g.wires)
      gg.add_edge(vertexMap[&w->from()->item()], vertexMap[&w->to()->item()]);

    // add some additional vertices representing classes: functions, parameters, flowVars, stockVars etc
    Item functions, parameters, flowVars, intVars;
    functions.moveTo(-0.5*layoutSize,-0.5*layoutSize);
    parameters.moveTo(-0.5*layoutSize,0.5*layoutSize);
    flowVars.moveTo(-0.5*layoutSize,0.5*layoutSize);
    intVars.moveTo(0.5*layoutSize,0.5*layoutSize);
    vertexMap.emplace(&functions, gg.add_vertex(&functions)); 
    vertexMap.emplace(&parameters, gg.add_vertex(&parameters)); 
    vertexMap.emplace(&flowVars, gg.add_vertex(&flowVars)); 
    vertexMap.emplace(&intVars, gg.add_vertex(&intVars)); 

    // now bind items without outputs to this fixtures
    for (auto& i: g.items)
      {
        if (dynamic_cast<UserFunction*>(i.get()) && i->ports(0).lock()->wires().empty())
          gg.add_edge(vertexMap[&functions], vertexMap[i.get()]);
        else if (auto v=i->variableCast())
          if ((i->portsSize()>0 && i->ports(0).lock()->wires().empty()) || (i->portsSize()>1 && !i->ports(1).lock()->wires().empty()))
            switch (v->type())
              {
              case VariableType::parameter:
                gg.add_edge(vertexMap[&parameters], vertexMap[i.get()]);
                break;
              case VariableType::flow:
                gg.add_edge(vertexMap[&flowVars], vertexMap[i.get()]);
                break;
              case VariableType::integral:
                gg.add_edge(vertexMap[&intVars], vertexMap[i.get()]);
                break;
              default:
                break;
              }
      }

    
    using Topology=square_topology<>;
    
    using PosMap=std::map<decltype(gg.add_vertex()), Topology::point_type>;
    PosMap positions;
    const boost::associative_property_map<PosMap> pm(positions);

    for (auto& i: vertexMap)
      {
        Topology::point_type p;
        p[0]=i.first->x();
        p[1]=i.first->y();
        positions[i.second]=p;
      }

    double temp=10;
    // use the cooling schedule to drive the progress bar
    ProgressUpdater pu(minsky().progressState, "Autolaying out...", 100);
    fruchterman_reingold_force_directed_layout
      (gg,pm, Topology(layoutSize), attractive_force(WireForce()).repulsive_force(RepulsiveForce()).
       cooling([&temp,&pu](){pu.setProgress(0.1*(10-temp)); return std::max(0., temp-=0.1);}));
    // maybe not needed
    //.force_pairs(boost::all_force_pairs())
    
    // move items to result of algorithm
    auto vertexRange=vertices(gg);
    for (auto i=vertexRange.first; i!=vertexRange.second; ++i)
      {
        auto p=pm[*i];
        gg[*i]->moveTo(p[0]+layoutSize,p[1]+layoutSize);
      }

    // TODO should we recursively descend into groups or not? If so,
    // then we need to be aware of group's size
//    for (auto& i: g.groups)
//      layoutGroup(*i);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

loadSchema()

template<class PreviousSchema , class CurrentSchema >

void minsky::loadSchema	(	CurrentSchema &	currentSchema,
		classdesc::xml_unpack_t &	data,
		const std::string &	rootElement
	)

Definition at line 99 of file schemaHelper.h.

References xml_unpack().

  {
    xml_unpack(data, rootElement, currentSchema);
    if (currentSchema.schemaVersion < currentSchema.version)
      {
        PreviousSchema prevSchema(data);
        currentSchema=prevSchema;
      }
    else if (currentSchema.schemaVersion > currentSchema.version)
      throw error("Minsky schema version %d not supported",currentSchema.schemaVersion);
  }

Here is the call graph for this function:

loadValueFromCSVFile() [1/2]

void minsky::loadValueFromCSVFile	(	VariableValue &	v,
		const vector< string > &	filenames,
		const DataSpec &	spec
	)

load a variableValue from a list of files according to data spec

Definition at line 1058 of file CSVParser.cc.

References loadValueFromCSVFileS().

Referenced by minsky::VariableBase::importFromCSV(), and minsky::VariableBase::reloadCSV().

  {loadValueFromCSVFileS(v,filenames,spec);}

Here is the call graph for this function:

Here is the caller graph for this function:

loadValueFromCSVFile() [2/2]

void minsky::loadValueFromCSVFile	(	VariableValue &	v,
		istream &	input,
		const DataSpec &	spec
	)

load a variableValue from a stream according to data spec

Definition at line 1060 of file CSVParser.cc.

References loadValueFromCSVFileS().

  {loadValueFromCSVFileS(v,input,spec);}

Here is the call graph for this function:

loadValueFromCSVFileS()

template<class S >

void minsky::loadValueFromCSVFileS	(	VariableValue &	v,
		S &	filenames,
		const DataSpec &	spec
	)

Definition at line 1049 of file CSVParser.cc.

References minsky::DataSpecSchema::separator.

Referenced by loadValueFromCSVFile().

  {
    OnError onError;
    if (spec.separator==' ')
      loadValueFromCSVFileT<SpaceSeparatorParser>(v,filenames,spec,onError);
    else
      loadValueFromCSVFileT<Parser>(v,filenames,spec,onError);
  }

Here is the caller graph for this function:

loadValueFromCSVFileT()

template<class P , class E , class S >

void minsky::loadValueFromCSVFileT	(	VariableValue &	vv,
		S &	stream,
		const DataSpec &	spec,
		E &	onError
	)

Definition at line 925 of file CSVParser.cc.

References minsky::Minsky::abort, cminsky(), minsky::DataSpecSchema::dimensionCols, minsky::DataSpecSchema::dimensionNames, minsky::ParseCSV< P >::dimLabels, minsky::ParseCSV< P >::hc, minsky::DataSpecSchema::horizontalDimName, minsky::VariableValue::hypercube(), minsky::VariableValue::index(), minsky::anonymous_namespace{userFunction.cc}::isnan(), MathDAG::log(), minsky(), minsky::DataSpecSchema::missingValue, minsky::VariableValueData::tensorInit, and minsky::ParseCSV< P >::tmpData.

  {
    const BusyCursor busy(minsky());
    const ProgressUpdater pu(minsky().progressState, "Importing CSVs",4);

    {
      // check dimension names are all distinct
      set<string> dimNames{spec.horizontalDimName};
      for (auto i: spec.dimensionCols)
        if (!dimNames.insert(spec.dimensionNames[i]).second)
          throw runtime_error("Duplicate dimension: "+spec.dimensionNames[i]);
    }
    
    try
      {
        ParseCSV<P> parseCSV(stream,spec,0/*not used*/,onError);

        auto& tmpData=parseCSV.tmpData;
        auto& dimLabels=parseCSV.dimLabels;
        auto& hc=parseCSV.hc;

        // remove zero length dimensions
        auto d=dimLabels.begin();
        assert(hc.xvectors.size()==dimLabels.size());
        for (auto i=hc.xvectors.begin(); i!=hc.xvectors.end();)
          if (i->size()<2)
            {
              hc.xvectors.erase(i);
            }
          else
            {
              ++i;
              ++d;
            }
        assert(hc.xvectors.size()<=dimLabels.size());
        
        for (auto& xv: hc.xvectors)
          xv.imposeDimension();
        ++minsky().progressState;

        if (hc.logNumElements()>log(numeric_limits<size_t>::max()))
          throw runtime_error("Hypercube dimensionality exceeds maximum size, results are likely to be garbage.\n"
                              "Suggest rolling up one or more axes by ignoring them, and setting 'Duplicate Key Action' as appropriate");
            
        if (log(tmpData.size())-hc.logNumElements()>=log(0.5)) 
          { // dense case
            vv.index({});
            if (cminsky().checkMemAllocation(2*hc.numElements()*sizeof(double))==Minsky::abort)
              throw MemoryExhausted();            
            vv.hypercube(hc);
            // stash the data into vv tensorInit field
            vv.tensorInit.index({});
            vv.tensorInit.hypercube(hc);
            for (auto& i: vv.tensorInit)
              i=spec.missingValue;
            auto dims=vv.hypercube().dims();
            const ProgressUpdater pu(minsky().progressState,"Loading data",tmpData.size());
            for (auto& i: tmpData)
              {
                size_t idx=0;
                assert (hc.rank()<=i.first.size());
                assert(dimLabels.size()>=hc.rank());
                int j=hc.rank()-1, k=i.first.size()-1; 
                while (j>=0 && k>=0)
                  {
                    while (dimLabels[k].size()<2) --k; // skip over elided dimensions
                    auto dimLabel=dimLabels[k].find(i.first[k]);
                    assert(dimLabel!=dimLabels[k].end());
                    idx = (idx*dims[j]) + dimLabel->second;
                    --j; --k;
                  }
                vv.tensorInit[idx]=i.second;
                ++minsky().progressState;
              }
          }    
        else 
          { // sparse case      
            if (cminsky().checkMemAllocation(6*tmpData.size()*sizeof(double))==Minsky::abort)
              throw MemoryExhausted();                          
            auto dims=hc.dims();
            const ProgressUpdater pu(minsky().progressState,"Indexing and loading",tmpData.size()+1);
              
            map<size_t,double,less<size_t>,LibCAllocator<pair<const size_t,double>>> indexValue; // intermediate stash to sort index vector
            {
              for (auto& i: tmpData)
                {
                  size_t idx=0;
                  assert (dims.size()<=i.first.size());
                  assert(dimLabels.size()>=dims.size());
                  int j=dims.size()-1, k=i.first.size()-1;
                  while (j>=0 && k>=0) // changed from for loop to while loop at CodeQL's insistence
                    {
                      while (dimLabels[k].size()<2) --k; // skip over elided dimensions
                      auto dimLabel=dimLabels[k].find(i.first[k]);
                      assert(dimLabel!=dimLabels[k].end());
                      idx = (idx*dims[j]) + dimLabel->second;
                      --j;
                      --k;
                    }
                  if (!isnan(i.second))
                    indexValue.emplace(idx, i.second);
                  ++minsky().progressState;
                }

              vv.tensorInit=indexValue;
              vv.index(indexValue);
              vv.tensorInit.hypercube(hc);
              ++minsky().progressState;
            }
          }
        minsky().progressState.title="Cleaning up";
        minsky().progressState.displayProgress();
      }
    catch (const std::bad_alloc&)
      { // replace with a more user friendly error message
        throw MemoryExhausted();
      }
    catch (const std::length_error&)
      { // replace with a more user friendly error message
        throw MemoryExhausted();
      }
  }  

Here is the call graph for this function:

macOSXRedraw()

void minsky::macOSXRedraw	(	RenderNativeWindow &	window,
		const std::shared_ptr< std::lock_guard< std::mutex >> &	lock
	)

Definition at line 96 of file renderNativeWindow.cc.

References minsky::RenderNativeWindow::winInfoPtr.

Referenced by minsky::anonymous_namespace{addon.cc}::AddOnMinsky::macOSXDrawNativeWindows().

  {
#ifdef MAC_OSX_TK
    if (!window.winInfoPtr.get()) return;
    window.winInfoPtr->lock=lock;
    window.winInfoPtr->requestRedraw();
#endif
  }

Here is the caller graph for this function:

makeGodleyIt()

template<class T >

GodleyIteratorAdaptor<T> minsky::makeGodleyIt

(

const T &

it

)

Definition at line 88 of file evalGodley.h.

  {return GodleyIteratorAdaptor<T>(it);}

mantissa()

string minsky::mantissa	(	double	value,
		const EngNotation &	e,
		int	digits = 3
	)

Definition at line 394 of file variableValue.cc.

References pow().

Referenced by minsky::GodleyTableEditor::draw(), minsky::VariableBase::draw(), and minsky::VariableBase::mantissa().

  {
    int width, decimal_places;
    digits=std::max(digits, 3);
    switch (e.sciExp-e.engExp)
      {
      case -3: width=digits+4; decimal_places=digits+1; break;
      case -2: width=digits+3; decimal_places=digits; break;
      case 0: case -1: width=digits+2; decimal_places=digits-1; break;
      case 1: width=digits+2; decimal_places=digits-2; break;
      case 2: case 3: width=digits+2; decimal_places=digits-3; break;
      default: return ""; // shouldn't be here...
      }
    char val[80];
    const char conv[]="%*.*f";
    snprintf(val,sizeof(val),conv,width,decimal_places,value*pow(10,-e.engExp));
    return val;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

minsky()

Minsky & minsky::minsky

(

)

global minsky object

Definition at line 545 of file addon.cc.

References minsky::anonymous_namespace{addon.cc}::l_minsky.

Referenced by MathDAG::ConstantDAG::addEvalOps(), MathDAG::VariableDAG::addEvalOps(), MathDAG::OperationDAGBase::addEvalOps(), minsky::anonymous_namespace{userFunction.cc}::addTimeVariables(), cminsky(), minsky::Ravel::collapseAllHandles(), minsky::UserFunction::compile(), minsky::IntOp::description(), minsky::Progress::displayProgress(), minsky::Sheet::draw(), minsky::VariablePaneCell::emplace(), anonymous_namespace{sheet.cc}::formattedStr(), minsky::DataSpec::givenTFguessRemainder(), minsky::VariableInstanceList::gotoInstance(), handleSignal(), minsky::PhillipsDiagram::init(), loadValueFromCSVFileT(), MathDAG::SystemOfEquations::makeDAG(), minsky::GodleyTable::markEdited(), minsky::RavelPopup::mouseOver(), minsky::PhillipsDiagram::mouseUp(), MathDAG::anonymous_namespace{equations.cc}::NoArgument::NoArgument(), minsky::Ravel::onKeyPress(), minsky::ParseCSV< P >::parse(), minsky::ParseCSV< P >::ParseCSV(), minsky::Ravel::pickSliceLabels(), minsky::Ravel::Ravel(), minsky::PubTab::removeSelf(), reportFromCSVFileT(), minsky::Ravel::setDimension(), minsky::Ravel::sortByValue(), MathDAG::SystemOfEquations::SystemOfEquations(), minsky::IntOp::toggleCoupled(), minsky::Lock::toggleLocked(), and minsky::GodleyIcon::updateVars().

{return *l_minsky;}

Here is the caller graph for this function:

numBytes()

unsigned minsky::numBytes ( unsigned char  x )

inline

a wrapper around std::ofstream that checks the write succeeded, throwing an exception if not

number of bytes in a UTF-8 character encoding

Definition at line 100 of file str.h.

Referenced by minsky::GodleyTableEditor::handleBackspace(), minsky::GodleyTableEditor::handleDelete(), minsky::GodleyTableEditor::keyPress(), operator>>(), prevIndex(), and minsky::GodleyTableEditor::textIdx().

  {
    if ((x&0xF8) == 0xF0)
      return 4;
    if ((x&0xF0) == 0xE0)
      return 3;
    if ((x&0xE0) == 0xC0)
      return 2;
    return 1;
  }

Here is the caller graph for this function:

onStackExit()

template<class F >

OnStackExit<F> minsky::onStackExit

(

F

f

)

generator function

Definition at line 85 of file str.h.

References f.

Referenced by minsky::Minsky::reset().

{return OnStackExit<F>(f);}

Here is the caller graph for this function:

operator<<() [1/3]

std::ostream& minsky::operator<< ( std::ostream &  o, VariableType::Type  t  )

inline

Definition at line 31 of file variableType.h.

References minsky::VariableType::typeName().

  {return o<<VariableType::typeName(t);}

Here is the call graph for this function:

operator<<() [2/3]

std::ostream& minsky::operator<< ( std::ostream &  o, const Units &  u  )

inline

Definition at line 51 of file units.h.

  {
    bool first=true;
    for (auto& i: u)
      {
        if (i.first.empty() || i.second==0) continue; // don't display empty units
        if (!first) o<<" ";
        first=false;
        o<<i.first;
        if (i.second!=1)
          o<<"^"<<i.second;
      }
    return o;
  }

operator<<() [3/3]

std::ostream& minsky::operator<< ( std::ostream &  o, OperationType::Type  t  )

inline

Definition at line 70 of file operationType.h.

References minsky::OperationType::typeName().

  {return o<<OperationType::typeName(t);}

Here is the call graph for this function:

operator>()

bool minsky::operator> ( std::size_t  x, const UnitsExpressionWalker &  y  )

inline

Definition at line 33 of file expressionWalker.h.

References minsky::UnitsExpressionWalker::value.

{return x>y.value;}

operator>>()

std::istream& minsky::operator>> ( std::istream &  i, const GetUtf8Char &  g  )

inline

Definition at line 128 of file str.h.

References minsky::GetUtf8Char::c, and numBytes().

  {
    char c;
    g.c->clear();
    if (i.get(c))
      {
        *g.c+=c;
        unsigned n=numBytes(c)-1;
        for (unsigned j=0; j<n; ++j)
          {
            if (i.get(c))
              *g.c+=c;
          }
      }
    return i;
  }

Here is the call graph for this function:

pow()

UnitsExpressionWalker minsky::pow ( const UnitsExpressionWalker &  x, const UnitsExpressionWalker &  y  )

inline

Definition at line 51 of file expressionWalker.h.

References minsky::UnitsExpressionWalker::checkDimensionless(), root(), and minsky::UnitsExpressionWalker::value.

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), minsky::EvalOp< minsky::OperationType::constant >::d2(), minsky::OperationBase::draw(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), minsky::GeneralTensorOp< OperationType::moment >::GeneralTensorOp(), MathDAG::latex(), mantissa(), and minsky::OperationBase::unitsBinOpCase().

  {
    if (y.value<1) return root(x,1/y.value);
    auto exponent=int(y.value);
    if (exponent==y.value)
      {
        auto tmp=x;
        for (auto& i: tmp.units)
          i.second*=exponent;
        return tmp;
      }
    x.checkDimensionless();
    y.checkDimensionless();
    return x;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

prevIndex()

size_t minsky::prevIndex ( const std::string &  str, size_t  index  )

inline

return index of previous character to index

Definition at line 112 of file str.h.

References numBytes(), and str().

Referenced by minsky::GodleyTableEditor::handleBackspace(), and minsky::GodleyTableEditor::keyPress().

  {
    if (index>str.length()) return prevIndex(str, str.length());
    for (size_t i=4; i>1; --i)
      if (index>=i && numBytes(str[index-i])==i)
        return index-i;
    return index>0? index-1: 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

quadrant()

int minsky::quadrant ( double  x )

inline

return quadrant x is in: 0=[-45,45),1=[45,135), etc

Definition at line 96 of file geometry.h.

References clamp360().

Referenced by minsky::BottomRightResizerItem::resizeHandleCoords().

  {
    return int(clamp360(x+45)/90);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

randomizeLayout()

void minsky::randomizeLayout

(

Group &

g

)

randomly place items on canvas

Definition at line 88 of file autoLayout.cc.

References minsky::GroupItems::groups, minsky::GroupItems::items, MathDAG::sqrt(), and minsky::anonymous_namespace{autoLayout.cc}::totalArea().

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

  {
    const double layoutSize=sqrt(3*totalArea(g));
    default_random_engine gen;
    uniform_real_distribution<double> rng(0,1);
    for (auto& i: g.items)
      i->moveTo(layoutSize*rng(gen), layoutSize*rng(gen));
    for (auto& i: g.groups)
      i->moveTo(layoutSize*rng(gen), layoutSize*rng(gen));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

readMdl()

void minsky::readMdl	(	Group &	group,
		Simulation &	simParms,
		istream &	mdlFile
	)

import a Vensim mdl file into group, also populating simParms from the control block

Definition at line 250 of file mdlReader.cc.

References minsky::anonymous_namespace{mdlReader.cc}::addDefinitionToPort(), minsky::anonymous_namespace{mdlReader.cc}::collapseWS(), minsky::anonymous_namespace{mdlReader.cc}::defineLookupFunction(), minsky::anonymous_namespace{mdlReader.cc}::functionsAdded, group, minsky::anonymous_namespace{mdlReader.cc}::identifier(), minsky::anonymous_namespace{mdlReader.cc}::readToken(), minsky::Simulation::stepMax, minsky::Simulation::t0, minsky::Simulation::timeUnit, minsky::Simulation::tmax, and trimWS().

Referenced by minsky::Minsky::importVensim().

  {
    set<string> integrationVariables;
    const regex integ(R"(\s*integ\s*\(([^,]*),([^,]*)\))");
    const regex number(R"(\d*\.?\d+[Ee]?\d*)");
    const regex unitFieldPattern(R"(([^\[\]]*)(\[.*\])?)");
    const regex sliderSpecPattern(R"(\[([^,]*),?([^,]*),?([^,]*)\])");
    const regex lookupPattern(R"(([^(]*)\((.*)\))");
    smatch match;
    functionsAdded.clear();

    string c;
    string currentMDLGroup;
    while (mdlFile>>GetUtf8Char(c))
      {
        if (isspace(c[0])) continue;
        switch (c[0])
          {
          case '{':
              // check this is a UTF-8 file
            if (trimWS(readToken(mdlFile,'}'))!="UTF-8")
              throw runtime_error("only UTF-8 file encoding is supported");
            continue;
        
          case '*':
            // group leadin
            for (; c[0]=='*'; mdlFile>>GetUtf8Char(c));
            currentMDLGroup=trimWS(readToken(mdlFile,'*'));
              
            while (mdlFile>>GetUtf8Char(c))
              if (c[0]=='|')
                {
                  c.clear();
                  break; // end of group leadin
                }
            break;
          }
        
        // macros?
        // read variable name
        string nameStr=readToken(mdlFile,'=',true /* append delimiter */);
        const string name=collapseWS(trimWS(c+nameStr.substr(0,nameStr.length()-1)));
        if (name.substr(0,9)==R"(\\\---///)")
          break; // we don't parse the sketch information - not used in Minsky
        string definition;
        if (nameStr.back()=='=')
          // only read definition if this was a variable definition
          definition=collapseWS(trimWS(readToken(mdlFile,'~')));
        switch (definition[0])
          {
          case '=': case ':': // for now, treat constant assignment and data assignment equally to numeric assignment
            definition.erase(definition.begin());
            break;
          default:
            break;
          }
        auto unitField=trimWS(readToken(mdlFile,'~'));
        regex_match(unitField,match,unitFieldPattern);
        const string units=trimWS(match[1]);
        string sliderSpec;
        if (match.size()>1)
          sliderSpec=match[2];
        
        const string comments=trimWS(readToken(mdlFile,'|'));


        if (currentMDLGroup==".Control")
          {
            if (name=="timeStep")
              {
                simParms.timeUnit=units;
                if (regex_match(definition,match,number))
                  simParms.stepMax=stod(definition);
              }
            if (!regex_match(definition,match,number)) continue;
            if (name=="initialTime") simParms.t0=stod(definition);
            if (name=="finalTime") simParms.tmax=stod(definition);
            continue;
          }
        if (regex_match(name,match,lookupPattern))
          defineLookupFunction(group, match[1], match[2]);
        else if (regex_match(definition,match,integ))
          {
            auto intOp=new IntOp;
            group.addItem(intOp);
            intOp->description(name);
            intOp->detailedText(comments);
            auto& v=intOp->intVar;
            integrationVariables.insert(name);
            auto integrand=match[1].str();
            addDefinitionToPort(group, intOp->ports(1).lock(), "Integrand of "+name,integrand);

            auto init=match[2].str();
            if (regex_match(init,match,identifier))
              v->init(init);
            else
              {
                // we need to add another variable, and attach it to a function block
                addDefinitionToPort(group, intOp->ports(2).lock(), "Initial value of "+name, init);
              }
            try  // absorb any errors in units - we have a chance to fix these later
              {
                v->setUnits(units);
              }
            catch (...) {}
            v->detailedText(comments);

          }
        else if (regex_match(definition,match,number))
          {
            const VariablePtr v(VariableBase::parameter, name);
            group.addItem(v);
            v->init(definition);
            try  // absorb any errors in units - we have a chance to fix these later
              {
                v->setUnits(units);
              }
            catch (...) {}
            v->detailedText(comments);
            if (auto vv=v->vValue())
              {
                if (regex_match(sliderSpec,match,sliderSpecPattern))
                  {
                    vector<string> spec;
                    for (size_t i=1; i<=match.size(); ++i) spec.push_back(match[i]);
                    if (!spec.empty() && regex_match(spec[0],match,number))
                      vv->sliderMin=stod(spec[0]);
                    else
                      vv->sliderMin=0.1*stod(definition);
                    if (spec.size()>1 && regex_match(spec[1],match,number))
                      vv->sliderMax=stod(spec[1]);
                    else
                      vv->sliderMax=10*stod(definition);
                    if (spec.size()>2 && regex_match(spec[2],match,number))
                      vv->sliderStep=stod(spec[2]);
                  }
                vv->adjustSliderBounds();
              }
          }
        else
          {
            const VariablePtr v(VariableBase::flow, name);
            group.addItem(v);
            addDefinitionToPort(group, v->ports(1).lock(), "Def: "+name, definition);
            try  // absorb any errors in units - we have a chance to fix these later
              {
                v->setUnits(units);
              }
            catch (...) {}
            v->detailedText(comments);
          }
      }

  }

Here is the call graph for this function:

Here is the caller graph for this function:

registerOps() [1/2]

template<template< OperationType::Type > class T, int op, int to>

classdesc::enable_if<Not<is_equal<op, to> >, void>::T minsky::registerOps

(

TensorOpFactory &

tensorOpFactory

)

Definition at line 317 of file minskyTensorOps.cc.

References op, and tensorOpFactory.

  {
    tensorOpFactory.registerType<T<OperationType::Type(op)>>(OperationType::Type(op));
    registerOps<T, op+1, to>(tensorOpFactory);
  }

registerOps() [2/2]

template<template< OperationType::Type > class T, int op, int to>

classdesc::enable_if<is_equal<op, to>, void>::T minsky::registerOps

(

TensorOpFactory &

tensorOpFactory

)

Definition at line 325 of file minskyTensorOps.cc.

  {}  //terminates recursion

remove()

template<class T , class V >

void minsky::remove	(	std::vector< T > &	x,
		const V &	v
	)

remove an element from a vector. V must be comparable to a T

Definition at line 89 of file str.h.

Referenced by minsky::Minsky::save(), classdesc::typescriptTypep(), anonymous_namespace{CSVDialog.cc}::CacheEntry::~CacheEntry(), and minsky::Minsky::~Minsky().

  {x.erase(std::remove(x.begin(),x.end(),v),x.end());}

Here is the caller graph for this function:

reportFromCSVFile()

void minsky::reportFromCSVFile	(	istream &	input,
		ostream &	output,
		const DataSpec &	spec,
		uintmax_t	fileSize
	)

creates a report CSV file from input, with errors sorted at begining of file, with a column for error messages

Definition at line 1161 of file CSVParser.cc.

References minsky::DataSpecSchema::separator.

Referenced by minsky::CSVDialog::reportFromFile().

  {
    if (spec.separator==' ')
      reportFromCSVFileT<SpaceSeparatorParser>(input,output,spec,fileSize);
    else
      reportFromCSVFileT<Parser>(input,output,spec,fileSize);
  }

Here is the caller graph for this function:

reportFromCSVFileT()

template<class P >

void minsky::reportFromCSVFileT	(	istream &	input,
		ostream &	output,
		const DataSpec &	spec,
		uintmax_t	fileSize
	)

update a map of keys to first rows for duplicate key processing

Definition at line 1069 of file CSVParser.cc.

References getWholeLine(), minsky::DataSpecSchema::headerRow, minsky(), minsky::DataSpec::nRowAxes(), minsky::DataSpecSchema::separator, and minsky::ProgressUpdater::setProgress().

  {
    const BusyCursor busy(minsky());
    const ProgressUpdater pu(minsky().progressState, "Generating report",3);
    // set up off-heap memory allocator, and ensure it is torn down at exit
//    TrackingAllocatorBase::allocatePool();
//    auto onExit=onStackExit([](){TrackingAllocatorBase::deallocatePool();});

    struct ErrorReporter //: public OnError // using duck typing, not dynamic polymorphism
    {
      Map<size_t> firstRow;
      map<size_t,Key> duplicates;
      map<size_t,string> invalidData;
      void operator()(const DuplicateKey& ex, size_t row) {
        duplicates.emplace(firstRow[ex.key],ex.key);
        duplicates.emplace(row,ex.key);
      }
      void operator()(const InvalidData& ex, size_t row) {invalidData.emplace(row, ex.msg);}
      void operator()(const ShortLine& ex, size_t row) {invalidData.emplace(row, ex.msg);}
      void rowKeyInsert(const Key& key, size_t row) {firstRow.emplace(key,row);}
    } onError;

    // parse file to extract error locations
    const ParseCSV<P> parseCSV(input, spec, fileSize, onError, /*checkValues=*/true);

    input.clear();
    input.seekg(0);
    if (!input) throw FailedToRewind();
    string buf;
    size_t row=0;
    const string sep{spec.separator};
    multimap<Key,string> duplicateLines;
    vector<string> invalidDataLines;

    {
      // extract all error lines  
      ProgressUpdater pu(minsky().progressState, "Extracting errors",3);
      size_t bytesRead=0;
      for (;  getWholeLine(input, buf, spec); ++row)
        {
          if (onError.duplicates.contains(row))
            {
              string msg="Duplicate key";
              msg+=sep; msg+=buf;
              duplicateLines.emplace(onError.duplicates[row],msg);
            }
          if (onError.invalidData.contains(row))
            {
              string msg=onError.invalidData[row];
              msg+=sep; msg+=buf;
              invalidDataLines.push_back(msg);
            }
          bytesRead+=buf.size();
          pu.setProgress(double(bytesRead)/fileSize);
        }
    }
    
    // now output report
    input.clear();
    input.seekg(0);
    if (!input) throw FailedToRewind();
    {
      ProgressUpdater pu(minsky().progressState, "Writing report",3);
      size_t bytesRead=0;
      // process header
      for (row=0; row<spec.nRowAxes() && getWholeLine(input, buf, spec); ++row)
        {
          if (row==spec.headerRow)
            output<<"Error"<<sep;
          output<<buf<<endl;
          bytesRead+=buf.size();
          pu.setProgress(double(bytesRead)/fileSize);
        }
      
    // process invalid data
    for (auto& i: invalidDataLines)
      output<<i<<endl;
    // process duplicates
    for (auto& i: duplicateLines)
      output<<i.second<<endl;
    // process remaining good part of the file
    for (; getWholeLine(input, buf, spec); ++row)
      {
        if (!onError.duplicates.contains(row) && !onError.invalidData.contains(row))
          output<<sep+buf<<endl;
        bytesRead+=buf.size();
        pu.setProgress(double(bytesRead)/fileSize);
      }
    }
  }

Here is the call graph for this function:

root()

UnitsExpressionWalker minsky::root ( const UnitsExpressionWalker &  x, const UnitsExpressionWalker &  y  )

inline

Definition at line 35 of file expressionWalker.h.

References minsky::UnitsExpressionWalker::units, and minsky::UnitsExpressionWalker::value.

Referenced by pow(), and exprtk::details::numeric::root().

  {
    if (x.units.empty()) return {};
    int index=y.value;
    if (index!=y.value)
      throw std::runtime_error("index must be an integer for roots of dimensioned quanitites");
    UnitsExpressionWalker r;
    for (auto& i: x.units)
      {
        if (i.second % index)
          throw std::runtime_error("input dimension "+i.first+" not a power to the index "+std::to_string(index));
        r.units[i.first]=i.second/index;
      }
    return r;
  }                                 

Here is the caller graph for this function:

scope() [1/2]

size_t minsky::scope

(

const std::string &

name

)

extract scope from a qualified variable name

Exceptions

if	name is unqualified

Definition at line 83 of file valueId.cc.

Referenced by minsky::Minsky::balanceColumns(), minsky::VariableBase::ensureValueExists(), minsky::Minsky::matchingTableColumns(), minsky::Group::renameAllInstances(), minsky::VariableValue::summary(), minsky::VariableValue::VariableValue(), and minsky::VariableValuePtr::VariableValuePtr().

  {
    if (name.starts_with("temp:")) return 0; // temporaries are "global"
    auto nm=utf_to_utf<char>(name);
    auto nameCStr=nm.c_str();
    char* endp=nullptr;
    const size_t r=strtoull(nameCStr,&endp,10);
    if (endp && *endp==':')
      return r;
    throw error("scope requested for local variable");
    // old implementation left for reference
    // smatch m;
    //    if (regex_search(nm, m, regex(R"((\d*)]?:.*)")))
    //      if (m.size()>1 && m[1].matched && !m[1].str().empty())
    //        return stoull(m[1].str());
    //      else
    //        return 0;
    //    else
    //      // no scope information is present
    //      throw error("scope requested for local variable");
  }

Here is the caller graph for this function:

scope() [2/2]

GroupPtr minsky::scope	(	GroupPtr	scope,
		const string &	a_name
	)

starting from reference group ref, applying scoping rules to determine the actual scope of name If name prefixed by :, then search up group heirarchy for locally scoped var, otherwise return ref

Definition at line 105 of file valueId.cc.

References canonicalName().

Referenced by valueId(), valueIdCanonical(), and valueIdFromScope().

  {
    auto name=canonicalName(a_name);
    if (a_name[0]==':' && scope)
      {
        // find maximum enclosing scope that has this same-named variable
        for (auto g=scope->group.lock(); g; g=g->group.lock())
          for (auto& i: g->items)
            if (auto v=i->variableCast())
              {
                if (v->canonicalName()==name)
                  {
                    scope=g;
                    goto break_outerloop;
                  }
              }
        scope.reset(); // global var
      break_outerloop: ;
      }
    return scope;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

sqr()

template<class T >

T minsky::sqr ( T  x )

inline

Definition at line 36 of file geometry.h.

Referenced by minsky::Canvas::closestInPort(), minsky::Item::closestInPort(), minsky::Wire::coords(), minsky::EvalOp< minsky::OperationType::constant >::d1(), minsky::EvalOp< minsky::OperationType::constant >::d2(), minsky::anonymous_namespace{wire.cc}::d2(), minsky::Canvas::itemAt(), and minsky::anonymous_namespace{wire.cc}::segNear().

{return x*x;}

Here is the caller graph for this function:

str()

template<class T >

std::string minsky::str

(

T

x

)

utility function to create a string representation of a numeric type

Definition at line 33 of file str.h.

Referenced by minsky::PlotWidget::addConstantCurves(), minsky::anonymous_namespace{operation.cc}::CheckConsistent::CheckConsistent(), anonymous_namespace{sheet.cc}::ClippedPango::ClippedPango(), minsky::GodleyTableEditor::copy(), civita::createRavelChain(), minsky::anonymous_namespace{mdlReader.cc}::defineLookupFunction(), minsky::GodleyTableEditor::delSelection(), MathDAG::differentiateName(), minsky::Sheet::draw(), minsky::Minsky::exportAllPlotsAsCSV(), minsky::VariableValue::exportAsCSV(), minsky::anonymous_namespace{godleyExport.cc}::fcStr(), anonymous_namespace{sheet.cc}::formattedStr(), minsky::GodleyTableEditor::handleBackspace(), minsky::GodleyTableEditor::handleDelete(), minsky::Item::id(), minsky::GodleyTableEditor::keyPress(), MathDAG::latex(), MathDAG::latexInit(), MathDAG::matlabInit(), minsky::GodleyTableEditor::mouseDown(), minsky::anonymous_namespace{plotWidget.cc}::TimeFormatter::operator()(), schema3::pack(), minsky::ParseCSV< P >::parse(), minsky::GodleyTableEditor::paste(), minsky::OperationBase::portValues(), prevIndex(), minsky::Minsky::renderAllPlotsAsSVG(), minsky::GodleyIcon::rowSum(), minsky::FlowCoef::str(), minsky::GodleyTableEditor::textIdx(), minsky::VarConstant::value(), and minsky::VarConstant::valueId().

                                        {
    std::ostringstream s;
    s<<x;
    return s.str();
  }

Here is the caller graph for this function:

stripActive()

std::string minsky::stripActive ( const std::string &  s )

inline

repaces characters that cause interpretation by TCL, backslashes are replaced by the set minus operator ∖, and spaces are replaced by ␣, as they cause problems

Definition at line 63 of file str.h.

Referenced by canonicalName().

                                                   {
    std::string r; r.reserve(s.length());
    for (size_t i=0; i<s.length(); ++i)
      if (s[i]=='\\')        
        r+="∖";
      else if (isspace(s[i]))
        r+="␣";
      else
        r+=s[i];
    if (r.empty()) return "_";
    return r;
  }

Here is the caller graph for this function:

stripByteOrderingMarker()

void minsky::stripByteOrderingMarker ( std::istream &  s )

inline

checks if the input stream has the UTF-8 byte ordering marker, and removes it if present

Definition at line 147 of file str.h.

Referenced by minsky::DataSpec::guessFromFile(), minsky::Minsky::insertGroupFromFile(), minsky::Minsky::load(), minsky::CSVDialog::loadFileFromName(), and minsky::CSVDialog::reportFromFile().

  {
    char bom[4]="\0\0\0";
    s.get(bom,4);
    if (strcmp(bom,"\357\273\277")==0) return; //skipped BOM
    if (memcmp(bom,"\0\0\376",3)==0)
      if (s && s.get()=='\377') // UTF-32(BE) file detected
        throw std::runtime_error("Only UTF-8 encoded files supported");
    if (strncmp(bom,"\376\377",2)==0 || strncmp(bom,"\377\376",2)==0)
      // UTF-16 or UTF-32(LE) file detected
      throw std::runtime_error("Only UTF-8 encoded files supported");
    s.seekg(0); //rewind input stream
  }

Here is the caller graph for this function:

stripNonAlnum()

void minsky::stripNonAlnum ( std::string &  x )

inline

Definition at line 44 of file str.h.

References IsNotalnum().

                                          {
    x.erase(std::remove_if(x.begin(), x.end(), IsNotalnum), x.end());
  } 

Here is the call graph for this function:

trimWS()

std::string minsky::trimWS ( const std::string &  s )

inline

Definition at line 49 of file str.h.

Referenced by minsky::Minsky::balanceColumns(), minsky::Minsky::balanceDuplicateColumns(), canonicalName(), minsky::Sheet::draw(), minsky::FlowCoef::FlowCoef(), minsky::GodleyTable::getColumnVariables(), minsky::Minsky::importDuplicateColumn(), minsky::EvalGodley::initialiseGodleys(), minsky::VariableValues::initValue(), minsky::ParseCSV< P >::parse(), MathDAG::SystemOfEquations::processGodleyTable(), readMdl(), minsky::GodleyIcon::rowSum(), and minsky::GodleyIcon::update().

  {
    int start=0, end=s.length()-1;
    while (start<int(s.length()) && isspace(s[start])) ++start;
    while (end>=0 && isspace(s[end])) --end;
    if (end>=start)
      return s.substr(start,end-start+1);
    else
      return "";
  }

Here is the caller graph for this function:

uniqueDeleter()

template<class T , class D >

std::unique_ptr<T,D> minsky::uniqueDeleter	(	T *	x,
		D	d
	)

Definition at line 93 of file str.h.

  {return std::unique_ptr<T,D>(x,d);}

uqName()

std::string minsky::uqName

(

const std::string &

name

)

extract unqualified portion of name

Definition at line 135 of file valueId.cc.

Referenced by minsky::Group::addIOVar(), minsky::PlotWidget::availableMarkers(), minsky::Minsky::balanceColumns(), canonicalName(), exportToCSV(), exportToLaTeX(), minsky::anonymous_namespace{godleyExport.cc}::fcStr(), MathDAG::SystemOfEquations::makeDAG(), MathDAG::SystemOfEquations::processGodleyTable(), minsky::PlotWidget::scalePlot(), and MathDAG::SystemOfEquations::SystemOfEquations().

  {
    const string::size_type p=name.rfind(':');
    if (p==string::npos)
      return utf_to_utf<char>(name);
    return utf_to_utf<char>(name).substr(p+1);
  }

Here is the caller graph for this function:

valueId() [1/2]

std::string minsky::valueId

(

const string &

name

)

construct a valueId from fully qualified name @ name should not be canonicalised

Definition at line 75 of file valueId.cc.

References canonicalName(), scope(), and valueIdCanonical().

Referenced by minsky::PlotWidget::addConstantCurves(), MathDAG::VariableDAG::addEvalOps(), minsky::PlotWidget::addPlotPt(), minsky::Minsky::definingVar(), minsky::IntOp::description(), minsky::GodleyTableEditor::draw(), minsky::VariableBase::ensureValueExists(), minsky::VariableBase::exportAsCSV(), MathDAG::SystemOfEquations::getNodeFromIntVar(), minsky::VariableValue::hypercube(), minsky::VariableBase::init(), minsky::VariableValue::init(), minsky::VariableValues::initValue(), minsky::VariablePtr::makeConsistentWithValue(), MathDAG::SystemOfEquations::makeDAG(), minsky::VariableBase::name(), minsky::VariableValues::newName(), minsky::Minsky::paste(), MathDAG::SystemOfEquations::processGodleyTable(), minsky::Canvas::renameAllInstances(), minsky::Group::renameAllInstances(), minsky::GroupItems::renameVar(), minsky::VariableBase::retype(), minsky::GodleyIcon::rowSum(), minsky::Minsky::setDefinition(), minsky::VariableBase::setUnits(), minsky::VariableBase::sliderVisible(), minsky::GodleyIcon::stockVarUnits(), minsky::VariableValue::summary(), MathDAG::VariableDAG::tensorEval(), minsky::VariableBase::units(), minsky::GodleyIcon::update(), minsky::VariableBase::value(), minsky::GodleyIcon::valueId(), minsky::VariableBase::valueId(), minsky::VariableBase::valueIdInCurrentScope(), minsky::VariableInstanceList::VariableInstanceList(), and minsky::VariableBase::vValue().

  {
    return valueIdCanonical(scope(name), canonicalName(name));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

valueId() [2/2]

std::string minsky::valueId	(	const GroupPtr &	ref,
		const string &	name
	)

construct a valueId. @ name should not be canonicalised if name has leading :, then heirarchy is searched for matching local name

Definition at line 80 of file valueId.cc.

References canonicalName(), scope(), and valueIdFromScope().

  {return valueIdFromScope(scope(ref,utf_to_utf<char>(name)), canonicalName(name));}

Here is the call graph for this function:

valueIdCanonical()

std::string minsky::valueIdCanonical	(	size_t	scope,
		const string &	name
	)

construct a valueId @ name should be canonicalised

Definition at line 68 of file valueId.cc.

References scope().

Referenced by valueId(), and valueIdFromScope().

  {
    auto tmp=":"+name;
    if (scope==0) return tmp;
    return to_string(scope)+tmp;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

valueIdFromScope()

std::string minsky::valueIdFromScope	(	const GroupPtr &	scope,
		const std::string &	name
	)

value Id from scope and canonical name name

Definition at line 128 of file valueId.cc.

References scope(), and valueIdCanonical().

Referenced by minsky::UserFunction::compile(), minsky::Minsky::constructEquations(), minsky::UserFunction::units(), valueId(), minsky::VariableValue::valueId(), and minsky::anonymous_namespace{minsky.cc}::GodleyIt::valueId().

  {
    if (name.empty() || !scope || !scope->group.lock())
      return valueIdCanonical(0,name); // retain previous global var id
    return valueIdCanonical(size_t(scope.get()), name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yearToPTime()

double minsky::yearToPTime ( double  x )

inline

Definition at line 37 of file plotWidget.h.

References yearLength.

Referenced by minsky::PlotWidget::addConstantCurves(), minsky::PlotWidget::addPlotPt(), and minsky::PlotWidget::scalePlot().

{return (x-1970)*yearLength;}

Here is the caller graph for this function:

zoom()

void minsky::zoom ( float &  val, float  origin, float  factor  )

inline

base zooming transformation

Definition at line 26 of file zoom.h.

Referenced by minsky::Group::gotoBookmark_b(), and minsky::Group::zoom().

  {val = (val-origin)*factor + origin;}

Here is the caller graph for this function:

Variable Documentation

_defaultFont

std::unique_ptr<char[]> minsky::_defaultFont

static

Definition at line 1748 of file minsky.cc.

Referenced by minsky::Minsky::defaultFont().

accumulatedBlitTime

ptime minsky::accumulatedBlitTime =epoch

static

Definition at line 431 of file plotWidget.cc.

Referenced by minsky::PlotWidget::addPlotPt().

epoch

ptime minsky::epoch =microsec_clock::local_time()

static

Definition at line 431 of file plotWidget.cc.

maxNumTensorElementsToPlot

const size_t minsky::maxNumTensorElementsToPlot =10

static

Definition at line 433 of file plotWidget.cc.

Referenced by minsky::PlotWidget::addConstantCurves(), and minsky::PlotWidget::addPlotPt().

portRadius

constexpr float minsky::portRadius =6

radius of circle marking ports at zoom=1

Definition at line 67 of file item.h.

Referenced by minsky::PlotWidget::clickType(), minsky::Item::clickType(), minsky::Item::drawPorts(), and minsky::Item::resizeHandleSize().

portRadiusMult

constexpr float minsky::portRadiusMult =2.0f*portRadius

Definition at line 68 of file item.h.

schemaURL

const char * minsky::schemaURL ="http://minsky.sf.net/minsky"

Definition at line 26 of file saver.cc.

Referenced by minsky::Minsky::copy(), and minsky::Minsky::exportSchema().

sliderHandleRadius

constexpr float minsky::sliderHandleRadius =3

Definition at line 24 of file slider.h.

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

tensorOpFactory

TensorOpFactory minsky::tensorOpFactory

Definition at line 42 of file minskyTensorOps.cc.

Referenced by MathDAG::anonymous_namespace{equations.cc}::addTensorOp(), minsky::Ravel::exportAsCSV(), registerOps(), minsky::TensorEval::TensorEval(), and minsky::TensorsFromPort::tensorsFromPort().

timeUnit

UnitsExpressionWalker minsky::timeUnit

Definition at line 42 of file userFunction_units.cc.

Referenced by minsky::PlotWidget::addPlotPt(), minsky::Minsky::constructEquations(), minsky::Minsky::deleteAllUnits(), minsky::PlotWidget::scalePlot(), minsky::UserFunction::units(), minsky::IntOp::units(), and minsky::Derivative::units().

yearLength

const double minsky::yearLength = 3600*24*365.2525

Definition at line 36 of file plotWidget.h.

Referenced by yearToPTime().