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 137 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 148 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 126 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 173 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 160 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(), TCLcmd::trap::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 120 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(), TCLcmd::trap::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 100 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 103 of file expr.h.

                                                      {
    return x*NodePtr(y);
  }

operator*() [3/3]

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

inline

Definition at line 106 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 77 of file expr.h.

                                                         {
    return y+x;
  }

operator+() [2/3]

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

inline

Definition at line 80 of file expr.h.

                                                      {
    return x+NodePtr(y);
  }

operator+() [3/3]

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

inline

Definition at line 83 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 87 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 90 of file expr.h.

                                                      {
    return x-NodePtr(y);
  }

operator-() [3/4]

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

inline

Definition at line 93 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 96 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 110 of file expr.h.

                                                      {
    return x/NodePtr(y);
  }

operator/() [2/3]

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

inline

Definition at line 113 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 116 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 193 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 200 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 203 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 179 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 186 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 189 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 166 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 131 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 142 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 154 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: