MathDAG Namespace Reference

Namespaces
	anonymous_namespace{equationDisplayRender.cc}
	anonymous_namespace{equations.cc}
	anonymous_namespace{node_latex.cc}
	anonymous_namespace{node_matlab.cc}

Classes
struct	CachedOp
struct	ConstantDAG
struct	Expr
struct	GodleyColumnDAG
	represents a Godley column More...
struct	IntegralInputVariableDAG
	represents the input of an integration operation - differs from Variable DAG in that it doesn't refer to the VariableValue More...
struct	LaTeXManip
	a manipulator to make iostream expressions easy More...
struct	LockDAG
struct	MatlabManip
struct	Node
struct	OperationDAG
struct	OperationDAGBase
class	SubexpressionCache
class	SystemOfEquations
class	VariableDAG
struct	WeakNodePtr
	weak reference into subexpression cache More...

Typedefs
typedef std::shared_ptr< Node >	NodePtr
typedef shared_ptr< VariableDAG >	VariableDAGPtr

Functions
string	differentiateName (const std::string &x)
	creates a new name to represent the derivative of a variable More...
string	latex (double)
	convert double to a LaTeX string representing that value More...
string	latexInit (const string &)
	convert an initialisation string into a matlab expression More...
string	mathrm (const string &nm)
	wraps in if nm has more than one letter - and also takes into account LaTeX subscript/superscripts More...
string	matlabInit (const string &)
	convert an initialisation string into a matlab expression More...
ostream &	operator<< (ostream &o, LaTeXManip m)
ostream &	operator<< (ostream &o, MatlabManip m)
Expr	operator+ (const NodePtr &x, const Expr &y)
Expr	operator+ (const Expr &x, const Expr &y)
Expr	operator+ (double x, const Expr &y)
Expr	operator- (const NodePtr &x, const Expr &y)
Expr	operator- (const Expr &x, const Expr &y)
Expr	operator- (double x, const Expr &y)
Expr	operator- (const Expr &x, double y)
Expr	operator* (const NodePtr &x, const Expr &y)
Expr	operator* (const Expr &x, const Expr &y)
Expr	operator* (double x, const Expr &y)
Expr	operator/ (const Expr &x, const Expr &y)
Expr	operator/ (const NodePtr &x, const Expr &y)
Expr	operator/ (double x, const Expr &y)
Expr	log (const Expr &x)
Expr	exp (const Expr &x)
Expr	sin (const Expr &x)
Expr	cos (const Expr &x)
Expr	sinh (const Expr &x)
Expr	cosh (const Expr &x)
Expr	sqrt (const Expr &x)
Expr	Gamma (const Expr &x)
Expr	polygamma (const Expr &x, const Expr &y)
Expr	fact (const Expr &x)
Expr	operator<= (const Expr &x, const NodePtr &y)
Expr	operator<= (const Expr &x, double y)
Expr	operator<= (double x, const Expr &y)
Expr	operator< (const Expr &x, const NodePtr &y)
Expr	operator< (const Expr &x, double y)
Expr	operator< (double x, const Expr &y)

Typedef Documentation

NodePtr

typedef std::shared_ptr<Node> MathDAG::NodePtr

Definition at line 131 of file equations.h.

VariableDAGPtr

typedef shared_ptr<VariableDAG> MathDAG::VariableDAGPtr

Definition at line 208 of file equations.h.

Function Documentation

cos()

Expr MathDAG::cos ( const Expr &  x )

inline

Definition at line 136 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::cos, and MathDAG::Expr::newNode().

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), minsky::VariableBase::draw(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), minsky::RenderVariable::inImage(), minsky::Group::inIORegion(), minsky::PhillipsDiagram::init(), minsky::VariableBase::onMouseMotion(), and minsky::Group::rotFactor().

                                 {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::cos));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

cosh()

Expr MathDAG::cosh ( const Expr &  x )

inline

Definition at line 147 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::cosh, and MathDAG::Expr::newNode().

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), and minsky::EvalOp< minsky::OperationType::constant >::evaluate().

                                  {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::cosh));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

differentiateName()

std::string MathDAG::differentiateName

(

const string &

x

)

creates a new name to represent the derivative of a variable

Definition at line 39 of file derivative.cc.

References minsky::str().

Referenced by MathDAG::SystemOfEquations::derivative().

  {
    int order=0; // current derivative order
    string varName=x; // base variable name
    const regex singleDeriv(R"(d(.*)/dt)"),
      higherOrderDeriv(R"(d\^\{(\d*)\}(.*)/dt\^\{(\d*)\})");
    smatch m;
    if (regex_match(x,m,singleDeriv))
      {
        order=1;
        varName=m[1];
      }
    else if(regex_match(x,m,higherOrderDeriv) && m[1]==m[3])
      { 
        // for some reason, stoi is missing on MXE, so fake it
        order=atoi(m[3].str().c_str());
        varName=m[2];
      }
    order++;
    ostringstream r;
    if (order==1)
      r<<"d"<<varName<<"/dt";
    else
      r<<"d^{"<<order<<"}"<<varName<<"/dt^{"<<order<<"}";
    return r.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

exp()

Expr MathDAG::exp ( const Expr &  x )

inline

Definition at line 125 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::exp, and MathDAG::Expr::newNode().

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), and minsky::expMultiplier().

                                 {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::exp));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

fact()

Expr MathDAG::fact ( const Expr &  x )

inline

Definition at line 172 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::fact, and MathDAG::Expr::newNode().

                                  {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::fact));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }   

Here is the call graph for this function:

Gamma()

Expr MathDAG::Gamma ( const Expr &  x )

inline

Definition at line 159 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::Gamma, and MathDAG::Expr::newNode().

Referenced by MathDAG::SystemOfEquations::derivative().

                                   {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::Gamma));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }       

Here is the call graph for this function:

Here is the caller graph for this function:

latex()

string MathDAG::latex

(

double

x

)

convert double to a LaTeX string representing that value

Definition at line 28 of file node_latex.cc.

References minsky::pow(), and minsky::str().

Referenced by MathDAG::OperationDAG< OperationType::subtract >::latex(), and MathDAG::Node::latexStr().

  {
    if (abs(x)>0 && (abs(x)>=1e5 || abs(x)<=1e-4))
      {
        int exponent=static_cast<int>(log10(abs(x)));
        if (exponent<0) exponent++;
        return str(x/pow(10.0,exponent))+"\\times10^{"+str(exponent)+"}";
      }
    return str(x);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

latexInit()

string MathDAG::latexInit

(

const string &

init

)

convert an initialisation string into a matlab expression

Definition at line 73 of file node_latex.cc.

References minsky::cminsky(), minsky::VariableValue::init(), minsky::VariableValues::initValue(), minsky::str(), and minsky::Minsky::variableValues.

Referenced by MathDAG::SystemOfEquations::latex(), MathDAG::SystemOfEquations::latexWrapped(), MathDAG::SystemOfEquations::renderEquations(), and MathDAG::anonymous_namespace{equationDisplayRender.cc}::variableRender().

  {
    if (init.empty()) return "0";
    VariableValue v;
    v.init(init);
    auto t=cminsky().variableValues.initValue(v);
    string r;
    switch (t.rank())
      {
      case 0: return str(t[0]);
      case 1: r="(";
        for (size_t i=0; i<5 && i<t.size(); ++i)
          {
            if (i>0) r+=' ';
            r+=str(t[i]);
          }
        if (t.size()>5)
          r+="\\ldots";
        return r+")";
      default:
        return "\\ldots"; //TODO can we represent this stuff reasonably?
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

log()

Expr MathDAG::log ( const Expr &  x )

inline

Definition at line 119 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::ln, and MathDAG::Expr::newNode().

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), minsky::EvalOp< minsky::OperationType::constant >::d2(), MathDAG::SystemOfEquations::derivative(), minsky::engExp(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), minsky::loadValueFromCSVFileT(), and minsky::OperationBase::unitsBinOpCase().

                                 {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::ln));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

mathrm()

string MathDAG::mathrm

(

const string &

nm

)

wraps in if nm has more than one letter - and also takes into account LaTeX subscript/superscripts

Definition at line 41 of file node_latex.cc.

Referenced by MathDAG::OperationDAG< OperationType::subtract >::latex(), MathDAG::VariableDAG::latex(), MathDAG::SystemOfEquations::latex(), MathDAG::SystemOfEquations::latexWrapped(), MathDAG::VariableDAG::render(), MathDAG::OperationDAG< OperationType::subtract >::render(), and MathDAG::SystemOfEquations::renderEquations().

  {
    // process super/sub scripts
    string::size_type ss;
    if ((ss=nm.find_first_of("_^"))!=string::npos)
      return mathrm(nm.substr(0, ss)) + nm[ss] + "{"+mathrm(nm.substr(ss+1))+"}";
      
    // process % chars
    string::size_type pc;
    if ((pc=nm.find_first_of('%'))!=string::npos)
      if (pc>0 && nm[pc-1]!='\\')
        return mathrm(nm.substr(0, pc)) + "\\" + nm[pc] + mathrm(nm.substr(pc+1));      
    
    // if its a single letter variable, or contains LaTeX codes, process as is
    if (nm.length()==1 || nm.find('\\')!=string::npos)
      return nm;
    return "\\mathrm{"+nm+"}";
  }

Here is the caller graph for this function:

matlabInit()

string MathDAG::matlabInit

(

const string &

init

)

convert an initialisation string into a matlab expression

Definition at line 45 of file node_matlab.cc.

References minsky::cminsky(), minsky::VariableValue::init(), minsky::VariableValues::initValue(), minsky::str(), and minsky::Minsky::variableValues.

Referenced by MathDAG::SystemOfEquations::matlab().

  {
    if (init.empty()) return "0";
    VariableValue v;
    v.init(init);
    auto t=cminsky().variableValues.initValue(v);
    string r;
    switch (t.rank())
      {
      case 0: return str(t[0]);
      case 1: r="[";
        for (auto i: t) r+=str(i)+",";
        return r+"]";
      case 2:
        r="[";
        for (size_t i=0; i<t.hypercube().xvectors[1].size(); ++i)
          {
            for (size_t j=0; j<t.hypercube().xvectors[0].size(); ++j)
              r+=str(t[i*t.hypercube().xvectors[0].size()+j])+",";
            r+=";";
          }
        return r+"]";
      default:
        throw error("high rank tensors not supported in Matlab");
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

operator*() [1/3]

Expr MathDAG::operator* ( const NodePtr &  x, const Expr &  y  )

inline

Definition at line 99 of file expr.h.

Referenced by minsky::anonymous_namespace{minsky.cc}::GodleyIt::assetClass(), minsky::anonymous_namespace{minsky.cc}::GodleyIt::data(), minsky::anonymous_namespace{minsky.cc}::GodleyIt::initialConditionRow(), minsky::IntrusiveMap< Key, Val >::iterator::operator*(), minsky::anonymous_namespace{minsky.cc}::GodleyIt::operator*(), minsky::anonymous_namespace{minsky.cc}::GodleyIt::operator->(), and minsky::anonymous_namespace{minsky.cc}::GodleyIt::signConventionReversed().

                                                         {
    return y*x;
  }

Here is the caller graph for this function:

operator*() [2/3]

Expr MathDAG::operator* ( const Expr &  x, const Expr &  y  )

inline

Definition at line 102 of file expr.h.

                                                      {
    return x*NodePtr(y);
  }

operator*() [3/3]

Expr MathDAG::operator* ( double  x, const Expr &  y  )

inline

Definition at line 105 of file expr.h.

                                                 {
    return y*NodePtr(new ConstantDAG(x));
  }

operator+() [1/3]

Expr MathDAG::operator+ ( const NodePtr &  x, const Expr &  y  )

inline

Definition at line 76 of file expr.h.

                                                         {
    return y+x;
  }

operator+() [2/3]

Expr MathDAG::operator+ ( const Expr &  x, const Expr &  y  )

inline

Definition at line 79 of file expr.h.

                                                      {
    return x+NodePtr(y);
  }

operator+() [3/3]

Expr MathDAG::operator+ ( double  x, const Expr &  y  )

inline

Definition at line 82 of file expr.h.

                                                 {
    return y+NodePtr(new ConstantDAG(x));
  }

operator-() [1/4]

Expr MathDAG::operator- ( const NodePtr &  x, const Expr &  y  )

inline

Definition at line 86 of file expr.h.

References MathDAG::Expr::cache.

                                                         {
    return Expr(y.cache, x)-NodePtr(y);
  }

operator-() [2/4]

Expr MathDAG::operator- ( const Expr &  x, const Expr &  y  )

inline

Definition at line 89 of file expr.h.

                                                      {
    return x-NodePtr(y);
  }

operator-() [3/4]

Expr MathDAG::operator- ( double  x, const Expr &  y  )

inline

Definition at line 92 of file expr.h.

                                                 {
    return NodePtr(new ConstantDAG(x))-y;
  }

operator-() [4/4]

Expr MathDAG::operator- ( const Expr &  x, double  y  )

inline

Definition at line 95 of file expr.h.

                                                 {
    return x-NodePtr(new ConstantDAG(y));
  }

operator/() [1/3]

Expr MathDAG::operator/ ( const Expr &  x, const Expr &  y  )

inline

Definition at line 109 of file expr.h.

                                                      {
    return x/NodePtr(y);
  }

operator/() [2/3]

Expr MathDAG::operator/ ( const NodePtr &  x, const Expr &  y  )

inline

Definition at line 112 of file expr.h.

References MathDAG::Expr::cache.

                                                         {
    return Expr(y.cache, x)/y;
  }

operator/() [3/3]

Expr MathDAG::operator/ ( double  x, const Expr &  y  )

inline

Definition at line 115 of file expr.h.

                                                 {
    return NodePtr(new ConstantDAG(x))/y;
  }

operator<() [1/3]

Expr MathDAG::operator< ( const Expr &  x, const NodePtr &  y  )

inline

Definition at line 192 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::lt, and MathDAG::Expr::newNode().

                                                         {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::lt));
    r->arguments[0].push_back(x);    
    r->arguments[1].push_back(y);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

operator<() [2/3]

Expr MathDAG::operator< ( const Expr &  x, double  y  )

inline

Definition at line 199 of file expr.h.

References MathDAG::Expr::cache.

                                                 {
    return x < Expr(x.cache, NodePtr(new ConstantDAG(y)));
  }

operator<() [3/3]

Expr MathDAG::operator< ( double  x, const Expr &  y  )

inline

Definition at line 202 of file expr.h.

References MathDAG::Expr::cache.

                                                 {
    return Expr(y.cache, NodePtr(new ConstantDAG(x))) < y;
  }

operator<<() [1/2]

ostream& MathDAG::operator<< ( ostream &  o, LaTeXManip  m  )

inline

Definition at line 150 of file equations.h.

References MathDAG::Node::latex(), and MathDAG::LaTeXManip::node.

  {return m.node.latex(o);}

Here is the call graph for this function:

operator<<() [2/2]

ostream& MathDAG::operator<< ( ostream &  o, MatlabManip  m  )

inline

Definition at line 152 of file equations.h.

References MathDAG::Node::matlab(), and MathDAG::MatlabManip::node.

  {return m.node.matlab(o);}

Here is the call graph for this function:

operator<=() [1/3]

Expr MathDAG::operator<= ( const Expr &  x, const NodePtr &  y  )

inline

Definition at line 178 of file expr.h.

References MathDAG::Expr::cache, minsky::OperationType::le, and MathDAG::Expr::newNode().

                                                          {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::le));
    r->arguments[0].push_back(x);    
    r->arguments[1].push_back(y);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

operator<=() [2/3]

Expr MathDAG::operator<= ( const Expr &  x, double  y  )

inline

Definition at line 185 of file expr.h.

References MathDAG::Expr::cache.

                                                  {
    return x <= Expr(x.cache, NodePtr(new ConstantDAG(y)));
  }

operator<=() [3/3]

Expr MathDAG::operator<= ( double  x, const Expr &  y  )

inline

Definition at line 188 of file expr.h.

References MathDAG::Expr::cache.

                                                  {
    return Expr(y.cache, NodePtr(new ConstantDAG(x))) <= y;
  }

polygamma()

Expr MathDAG::polygamma ( const Expr &  x, const Expr &  y  )

inline

Definition at line 165 of file expr.h.

References MathDAG::Expr::cache, MathDAG::Expr::newNode(), and minsky::OperationType::polygamma.

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), and minsky::OperationBase::unitsBinOpCase().

                                                      {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::polygamma));
    r->arguments[0].push_back(x);
    r->arguments[1].push_back(y);    
    return Expr(x.cache,r);
  }     

Here is the call graph for this function:

Here is the caller graph for this function:

sin()

Expr MathDAG::sin ( const Expr &  x )

inline

Definition at line 130 of file expr.h.

References MathDAG::Expr::cache, MathDAG::Expr::newNode(), and minsky::OperationType::sin.

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), minsky::VariableBase::draw(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), minsky::RenderVariable::inImage(), minsky::Group::inIORegion(), and minsky::PhillipsDiagram::init().

                                 {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::sin));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

sinh()

Expr MathDAG::sinh ( const Expr &  x )

inline

Definition at line 141 of file expr.h.

References MathDAG::Expr::cache, MathDAG::Expr::newNode(), and minsky::OperationType::sinh.

Referenced by minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), and minsky::EvalOp< minsky::OperationType::constant >::evaluate().

                                  {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::sinh));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

sqrt()

Expr MathDAG::sqrt ( const Expr &  x )

inline

Definition at line 153 of file expr.h.

References MathDAG::Expr::cache, MathDAG::Expr::newNode(), and minsky::OperationType::sqrt.

Referenced by minsky::Wire::coords(), minsky::EvalOp< minsky::OperationType::constant >::d1(), MathDAG::SystemOfEquations::derivative(), minsky::EvalOp< minsky::OperationType::constant >::evaluate(), minsky::Operation< minsky::OperationType::integrate >::iconDraw(), minsky::layoutGroup(), civita::StdDeviation::operator[](), minsky::GeneralTensorOp< OperationType::correlation >::operator[](), minsky::randomizeLayout(), minsky::Group::rotFactor(), and minsky::anonymous_namespace{wire.cc}::segNear().

                                  {
    shared_ptr<OperationDAGBase> r(x.newNode(OperationType::sqrt));
    r->arguments[0].push_back(x);
    return Expr(x.cache,r);
  }

Here is the call graph for this function:

Here is the caller graph for this function: