MathDAG::SystemOfEquations Class Reference

#include <equations.h>

Collaboration diagram for MathDAG::SystemOfEquations:

Public Member Functions
	SystemOfEquations (const Minsky &, const Group &g)
	construct the system of equations More...
	SystemOfEquations (const Minsky &m)
ostream &	latex (ostream &) const
	render as a LaTeX eqnarray Use LaTeX brqn environment to wrap long lines More...
ostream &	latexWrapped (ostream &) const
ostream &	matlab (ostream &) const
	render as MatLab code create equations suitable for Runge-Kutta solver More...
void	populateEvalOpVector (EvalOpVector &equations, std::vector< Integral > &integrals)
void	updatePortVariableValue (EvalOpVector &equations)
template<class Expr >
NodePtr	derivative (const Expr &expr)
	symbolically differentiate expr More...
VariableDAGPtr	getNodeFromVar (const VariableBase &v)
VariableDAGPtr	getNodeFromValueId (const std::string &v)
VariableDAGPtr	getNodeFromIntVar (const std::string &valueId)
ostringstream	getDefFromIntVar (const VariableBase &v)
void	renderEquations (ecolab::cairo::Surface &, double height) const
	render equations into a cairo context More...
template<>
NodePtr	chainRule (const Expr &x, const Expr &deriv)
template<>
NodePtr	derivative (const VariableDAG &expr)
template<>
NodePtr	derivative (const ConstantDAG &)
template<>
NodePtr	derivative (const OperationDAG< OperationType::constant > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::add > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::subtract > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::multiply > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::divide > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::log > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::pow > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::lt > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::le > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::eq > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::and_ > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::or_ > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::not_ > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::min > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::max > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::time > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::euler > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::pi > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::zero > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::one > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::inf > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::percent > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::copy > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::integrate > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::differentiate > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::data > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::ravel > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::sqrt > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::exp > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::ln > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::sin > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::cos > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::tan > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::asin > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::acos > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::atan > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::sinh > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::cosh > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::tanh > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::abs > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::floor > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::frac > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::Gamma > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::polygamma > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::fact > &expr)
template<>
NodePtr	derivative (const OperationDAG< OperationType::userFunction > &expr)

Public Attributes
NodePtr	zero {new ConstantDAG("0")}
	useful constants to share More...
NodePtr	one {new ConstantDAG("1")}

Private Member Functions
NodePtr	makeDAG (const string &valueId, const string &name, VariableType::Type type)
	create a variable DAG. returns cached value if previously called More...
NodePtr	makeDAG (VariableBase &v)
NodePtr	makeDAG (const OperationBase &op)
	create an operation DAG. returns cached value if previously called More...
NodePtr	makeDAG (const SwitchIcon &op)
NodePtr	makeDAG (const Lock &op)
NodePtr	getNodeFromWire (const Wire &wire)
	returns cached subexpression node representing what feeds the wire, creating a new one if necessary More...
void	processGodleyTable (map< string, GodleyColumnDAG > &godleyVariables, const GodleyIcon &)
template<class Expr >
NodePtr	chainRule (const Expr &x, const Expr &deriv)
	applies the chain rule to expression x More...

Private Attributes
SubexpressionCache	expressionCache
vector< VariableDAG * >	variables
vector< VariableDAG * >	integrationVariables
set< string >	processedColumns
vector< pair< VariableDAGPtr, string > >	derivInputs
const Minsky &	minsky
std::set< std::string >	varNames
	used to rename ambiguous variables in different scopes More...
std::set< std::string >	processingDerivative
	keep track of derivatives of variables, to trap definition loops More...
std::map< std::string, std::string >	userDefinedFunctions
	table of user defined functions and their definitions More...

Detailed Description

Definition at line 358 of file equations.h.

Constructor & Destructor Documentation

SystemOfEquations() [1/2]

MathDAG::SystemOfEquations::SystemOfEquations	(	const Minsky &	m,
		const Group &	g
	)

construct the system of equations

Definition at line 460 of file equations.cc.

References minsky::Minsky::canvas, derivInputs, expressionCache, MathDAG::SubexpressionCache::getIntegralInput(), getNodeFromWire(), minsky::GroupItems::groups, TCLcmd::trap::init, MathDAG::SubexpressionCache::insertAnonymous(), MathDAG::SubexpressionCache::insertIntegralInput(), integrationVariables, MathDAG::VariableDAG::intOp, minsky::Canvas::itemIndicator, minsky::GroupItems::items, makeDAG(), minsky::minsky(), minsky::Minsky::model, MathDAG::VariableDAG::name, one, processGodleyTable(), MathDAG::VariableDAG::rhs, MathDAG::SubexpressionCache::size(), minsky::VariableType::stock, minsky::VariableType::typeName(), minsky::uqName(), userDefinedFunctions, variables, minsky::Minsky::variableValues, and zero.

                                                                         : minsky(m)
  {
    expressionCache.insertAnonymous(zero);
    expressionCache.insertAnonymous(one);
    zero->result=m.variableValues.find("constant:zero")->second;
    one->result=m.variableValues.find("constant:one")->second;

    // store stock & integral variables for later reordering
    map<string, VariableDAG*> integVarMap;

    vector<pair<VariableDAGPtr,Wire*>> integralInputs;
    // list of stock vars whose input expression has not yet been calculated when the derivative operator is called.
    
    // search through operations looking for integrals
    group.recursiveDo
      (&Group::items,
       [&](const Items&, Items::const_iterator it){
         if (auto v=(*it)->variableCast())
           {
             // check variable is not multiply defined
             if (v->inputWired() && v!=minsky.definingVar(v->valueId()).get())
               {
                 minsky.displayErrorItem(*v);
                 throw runtime_error("Multiply defined");
               }
             // check that variable's type matches it's variableValue's type (see ticket #1087)
             if (auto vv=v->vValue())
               if (vv->type() != v->type())
                 {
                   minsky.displayErrorItem(*v);
                   throw error("type %s of variable %s doesn't match it's value's type %s",VariableType::typeName(v->type()).c_str(), v->name().c_str(), VariableType::typeName(vv->type()).c_str());
                 }
           }
         else if (IntOp* i=dynamic_cast<IntOp*>(it->get()))
           {
             if (const VariablePtr iv=i->intVar)
               {
                 // .get() OK here because object lifetime controlled by
                 // expressionCache
                 VariableDAG* v=integVarMap[iv->valueId()]=
                   dynamic_cast<VariableDAG*>(makeDAG(*iv).get());
                 v->intOp=i;
                 if (!i->ports(1).lock()->wires().empty())
                   {
                     // with integrals, we need to create a distinct variable to
                     // prevent infinite recursion of order() in the case of graph cycles
                     const VariableDAGPtr input(new IntegralInputVariableDAG);
                     input->name=iv->name();
                     variables.push_back(input.get());
                     // manage object's lifetime with expressionCache
                     expressionCache.insertIntegralInput(iv->valueId(), input);
                     try
                       {input->rhs=getNodeFromWire(*(i->ports(1).lock()->wires()[0]));}
                     catch (...)
                       {
                         // try again later
                         integralInputs.emplace_back(input,i->ports(1).lock()->wires()[0]);
                         // clear error indicator
                         minsky::minsky().canvas.itemIndicator.reset();
                       }
                   }
                
                 if (!i->ports(2).lock()->wires().empty())
                   {
                     // second port can be attached to a variable,
                     // which supplies an init string
                     NodePtr init;
                     try
                       {
                         init=getNodeFromWire(*(i->ports(2).lock()->wires()[0]));
                       }
                     catch (...) {}
                     if (auto v=dynamic_cast<VariableDAG*>(init.get()))
                       iv->init(uqName(v->name));
                     else if (auto c=dynamic_cast<ConstantDAG*>(init.get()))
                       {
                         // slightly convoluted to prevent sliderSet from overriding c->value
                         iv->init(c->value);
                         if (auto vv=iv->vValue()) vv->adjustSliderBounds();
                       }
                     else
                       throw error("only constants, parameters and variables can be connected to the initial value port");
                   }
                
               }
           }
         else if (auto fn=dynamic_cast<UserFunction*>(it->get()))
           {
             userDefinedFunctions.emplace(fn->description(), fn->expression);
           }
         return false;
       });

    // add groups to the userDefinedFunctions table
    group.recursiveDo
      (&Group::groups,
       [&](const Groups&, Groups::const_iterator it){
         if (!(*it)->name().empty())
           try
             {
               userDefinedFunctions.emplace((*it)->name()+(*it)->arguments(), (*it)->formula());
             }
           catch (const std::exception&)
             {/* if we can't generate a function definition, too bad, too sad. */}
         return false;
       });
    
    // add input variables for all stock variables to the expression cache
    group.recursiveDo
      (&Group::items,
       [&](const Items&, Items::const_iterator it){
        if (auto i=dynamic_cast<Variable<VariableType::stock>*>(it->get()))
          if (!expressionCache.getIntegralInput(i->valueId()))
            {
              const VariableDAGPtr input(new IntegralInputVariableDAG);
              input->name=i->name();
              variables.push_back(input.get());
              // manage object's lifetime with expressionCache
              expressionCache.insertIntegralInput(i->valueId(), input);
            }
        return false;
      });
    
    // wire up integral inputs, now that all integrals are defined, so that derivative works. See #511
    for (auto& i: integralInputs)
      i.first->rhs=getNodeFromWire(*i.second);

    // process the Godley tables
    derivInputs.clear();
    map<string, GodleyColumnDAG> godleyVars;
    group.recursiveDo
      (&Group::items,
       [&](const Items&, Items::const_iterator i)
       {
         if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
           processGodleyTable(godleyVars, *g);
         return false;
       });

    for (auto& g: godleyVars)
      {
        integVarMap[g.first]=dynamic_cast<VariableDAG*>
          (makeDAG(g.first,
                   g.second.name, VariableValue::stock).get());
        if (auto integralInput=expressionCache.getIntegralInput(g.first))
          integralInput->rhs=expressionCache.insertAnonymous(make_shared<GodleyColumnDAG>(g.second));
      }

    // fix up broken derivative computations, now that all stock vars
    // are defined. See ticket #1087
    for (auto& i: derivInputs)
      if (auto ii=expressionCache.getIntegralInput(i.second))
        {
          if (ii->rhs)
            {
              i.first->rhs=ii->rhs;
              continue;
            }
        }
      else
        throw runtime_error("Unable to differentiate "+i.second);
    
//    // check that all integral input variables now have a rhs defined,
//    // so that derivatives can be processed correctly
//    group.recursiveDo
//      (&Group::items,
//       [&](const Items&, Items::const_iterator i)
//       {
//         if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
//           for (auto& v: g->flowVars())
//             if (auto vv=minsky.definingVar(v->valueId()))
//               {
//                 auto vd=makeDAG(*vv);
//                 static_cast<VariableDAG*>(vd.get())->rhs=getNodeFromWire(*vv->ports[1]->wires()[0]);
//               }
//         return false;
//       });
    
      
    
    for (auto& v: integVarMap)
      integrationVariables.push_back(v.second);

    if (&group==m.model.get())
      {
        for (auto& v: m.variableValues)
          if (v.second->isFlowVar())
            if (auto vv=dynamic_cast<VariableDAG*>
                (makeDAG(v.first, v.second->name, v.second->type()).get()))
              variables.push_back(vv);
          
        // sort variables into their order of definition
        sort(variables.begin(), variables.end(), 
             VariableDefOrder(expressionCache.size()));
      }
    else
      {
        // now start with the variables, and work our way back to how they
        // are defined
        const VariableDefOrder variableDefOrder(expressionCache.size()+m.variableValues.size());
        set<VariableDAG*,VariableDefOrder> variableSet(variableDefOrder);
        group.recursiveDo
          (&Group::items,
           [&](const Items&, Items::const_iterator it){
             if (auto v=(*it)->variableCast())
               if (auto vv=v->vValue())
                 if (auto dag=dynamic_cast<VariableDAG*>
                     (makeDAG(v->valueId(), vv->name, vv->type()).get()))
                   variableSet.insert(dag);
             return false;
           });
        // TODO - if we can pass VariableDefOrder to the definition of variableSet, we don't need to resort...
        variables.insert(variables.end(), variableSet.begin(), variableSet.end());
      }
  }

Here is the call graph for this function:

SystemOfEquations() [2/2]

MathDAG::SystemOfEquations::SystemOfEquations

(

const Minsky &

m

)

Definition at line 457 of file equations.cc.

: SystemOfEquations(m,*m.model) {}

Member Function Documentation

chainRule() [1/2]

template<>

NodePtr MathDAG::SystemOfEquations::chainRule	(	const Expr &	x,
		const Expr &	deriv
	)

Definition at line 68 of file derivative.cc.

  {
    const NodePtr dx=x->derivative(*this);
    // perform some constant optimisation
    if (dx==zero) 
      return zero;
    if (dx==one)
      return deriv;
    return dx * deriv;
  }

chainRule() [2/2]

template<class Expr >

NodePtr MathDAG::SystemOfEquations::chainRule ( const Expr &  x, const Expr &  deriv  )

private

applies the chain rule to expression x

derivative() [1/49]

NodePtr MathDAG::SystemOfEquations::derivative

(

const VariableDAG &

expr

)

Definition at line 80 of file derivative.cc.

References MathDAG::Node::derivative(), MathDAG::differentiateName(), minsky::VariableType::integral, MathDAG::VariableDAG::name, MathDAG::VariableDAG::rhs, minsky::VariableType::stock, minsky::VariableType::tempFlow, MathDAG::VariableDAG::type, and MathDAG::VariableDAG::valueId.

  {
    const string name=differentiateName(expr.name);
    // ensure variable value exists, even if only temporary
    const VariablePtr tmp(VariableType::tempFlow, name);
    VariableDAGPtr r(dynamic_pointer_cast<VariableDAG>(makeDAG(tmp->valueId(),tmp->name(),tmp->type())));
    if (expr.rhs)
      {
        if (processingDerivative.contains(expr.name))
          throw error("definition loop detected in processing derivative of %s",expr.name.c_str());
        processingDerivative.insert(expr.name);
        r->rhs=expr.rhs->derivative(*this);
        processingDerivative.erase(expr.name);
      }
    else if (expr.type==VariableType::integral || expr.type==VariableType::stock)
      {
        auto ii=expressionCache.getIntegralInput(expr.valueId);
        if (!ii)
          throw error("integral input %s not defined",expr.valueId.c_str());
        if (ii->rhs)
          r->rhs=ii->rhs; // elide input variable, in case this is a temporary
        else 
          derivInputs.emplace_back(r, expr.valueId);
      }
    else
      {
        r->rhs=zero;
        return zero;
      }
    assert(expressionCache.reverseLookup(*r));
    return r;
  }

Here is the call graph for this function:

derivative() [2/49]

NodePtr MathDAG::SystemOfEquations::derivative

(

const ConstantDAG &

)

Definition at line 114 of file derivative.cc.

  {
    return zero;
  }

derivative() [3/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::constant > &

expr

)

Definition at line 121 of file derivative.cc.

  {
    return zero;
  }

derivative() [4/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::add > &

expr

)

Definition at line 128 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    CachedOp<OperationType::add> r(expressionCache);
    r->arguments.resize(expr.arguments.size());
    for (size_t i=0; i<expr.arguments.size(); ++i)
      for (WeakNodePtr n: expr.arguments[i])
        {
          assert(expressionCache.reverseLookup(*n));
          r->arguments[i].push_back(n->derivative(*this));
          assert(expressionCache.reverseLookup(*r->arguments[i].back()));
        }
    assert(expressionCache.reverseLookup(*r));
    return r;
  }

derivative() [5/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::subtract > &

expr

)

Definition at line 145 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    CachedOp<OperationType::subtract> r(expressionCache);
    r->arguments.resize(expr.arguments.size());
    for (size_t i=0; i<expr.arguments.size(); ++i)
      for (WeakNodePtr n: expr.arguments[i])
        r->arguments[i].push_back(n->derivative(*this));
    assert(expressionCache.reverseLookup(*r));
    return r;
  }

derivative() [6/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::multiply > &

expr

)

Definition at line 158 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    // unfold arguments into a single list
    vector<WeakNodePtr> args;
    for (size_t i=0; i<expr.arguments.size(); ++i)
      for (const WeakNodePtr n: expr.arguments[i])
        args.push_back(n);

    // remember multiplies are n-ary, not binary. eg
    // (uvw)' = u'(vw)+v'(uw)+w'(uv)

    CachedOp<OperationType::add> r(expressionCache);
    assert(!r->arguments.empty());

    for (size_t i=0; i<args.size(); ++i)
      {
        const CachedOp<OperationType::multiply> p(expressionCache);
        r->arguments[0].push_back(p);
        assert(!p->arguments.empty());
        for (size_t j=0; j<args.size(); ++j)
          if (j!=i)
            p->arguments[0].push_back(args[j]);
        p->arguments[0].push_back(args[i]->derivative(*this));
        assert(expressionCache.reverseLookup(*p->arguments[0].back()));
      }

    assert(expressionCache.reverseLookup(*r));
    return r;
  }

derivative() [7/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::divide > &

expr

)

Definition at line 190 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    // remember divides are n-ary, not binary. So convert each
    // argument list into a product expression, and then perform the
    // standard binary quotient rule. u=numerator, v=denominator
    // d(u/v) = (vdu-udv)/v^2

    const CachedOp<OperationType::multiply> u1(expressionCache), v1(expressionCache);

    assert(expr.arguments.size()==2);
    assert(!u1->arguments.empty() && !v1->arguments.empty());

    // check all arguments are cached
#ifndef NDEBUG
    for (auto av: expr.arguments)
      for (auto a: av)
        assert(a && expressionCache.reverseLookup(*a));
#endif

    u1->arguments[0]=expr.arguments[0];
    v1->arguments[0]=expr.arguments[1];
    
    const Expr u(expressionCache,u1), v(expressionCache,v1);
    const Expr du(expressionCache, u->derivative(*this)), dv(expressionCache, v->derivative(*this));
    
    NodePtr r = (v*du-u*dv)/(v*v); 
    assert(expressionCache.reverseLookup(*r));
    return r;
  }

derivative() [8/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::log > &

expr

)

Definition at line 221 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::log().

  {
    // log_b(x) = ln(x)/ln(b)
    assert(expr.arguments.size()==2);
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expressionCache.reverseLookup(*expr.arguments[0][0]));
    if (expr.arguments[1].empty())
      return x->derivative(*this)/x;
    const Expr b(expressionCache, expressionCache.reverseLookup(*expr.arguments[1][0]));
    return (log(x)/log(b))->derivative(*this);
  }

Here is the call graph for this function:

derivative() [9/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::pow > &

expr

)

Definition at line 237 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, MathDAG::exp(), and MathDAG::log().

  {
    // x^y = exp(y*ln(x))
    assert(expr.arguments.size()==2);
    if (expr.arguments[0].empty())
      return zero;
    if (expr.arguments[1].empty())
      {
        const Expr x(expressionCache, expr.arguments[0][0]);
        const Expr dx(expressionCache, x->derivative(*this));
        return dx * x;
      }
    const Expr x(expressionCache, expr.arguments[0][0]);
    const Expr y(expressionCache,  expr.arguments[1][0]);
    return exp(y * log(x))->derivative(*this);
  }

Here is the call graph for this function:

derivative() [10/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::lt > &

expr

)

Definition at line 256 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    throw error("lt is not differentiable");
  }

derivative() [11/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::le > &

expr

)

Definition at line 265 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    throw error("le is not differentiable");
  }

derivative() [12/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::eq > &

expr

)

Definition at line 274 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    throw error("eq is not differentiable");
  }

derivative() [13/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::and_ > &

expr

)

Definition at line 283 of file derivative.cc.

  {
    return zero;
  }

derivative() [14/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::or_ > &

expr

)

Definition at line 290 of file derivative.cc.

  {
    return zero;
  }

derivative() [15/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::not_ > &

expr

)

Definition at line 297 of file derivative.cc.

  {
    return zero;
  }

derivative() [16/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::min > &

expr

)

Definition at line 306 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    assert(expr.arguments.size()==2);
    auto tmp=make_shared<OperationDAG<OperationType::min>>(expr);
    // combine all arguments
    tmp->arguments[1].clear();
    for (auto i: expr.arguments[1])
      tmp->arguments[0].push_back(i);
    
    switch (tmp->arguments[0].size())
      {
      case 0:
        return zero;
      case 1:
        return tmp->arguments[0][0]->derivative(*this);
      default:
        {
          const Expr x(expressionCache,tmp->arguments[0].back());
          tmp->arguments[0].pop_back();
          const Expr y(expressionCache,NodePtr(tmp));
          return (x<=y)*x->derivative(*this) +
            (1-(x<=y))*y->derivative(*this);
        }
      };
  }

derivative() [17/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::max > &

expr

)

Definition at line 336 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    assert(expr.arguments.size()==2);
    auto tmp=make_shared<OperationDAG<OperationType::max>>(expr);
    // combine all arguments
    tmp->arguments[1].clear();
    for (auto i: expr.arguments[1])
      tmp->arguments[0].push_back(i);
    
    switch (tmp->arguments[0].size())
      {
      case 0:
        return zero;
      case 1:
        return tmp->arguments[0][0]->derivative(*this);
      default:
        {
          const Expr x(expressionCache,tmp->arguments[0].back());
          tmp->arguments[0].pop_back();
          const Expr y(expressionCache,NodePtr(tmp));
          return (x<=y)*y->derivative(*this) +
            (1-(x<=y))*x->derivative(*this);
        }
      };
  }

derivative() [18/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::time > &

expr

)

Definition at line 364 of file derivative.cc.

  {
    return one;
  }

derivative() [19/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::euler > &

expr

)

Definition at line 371 of file derivative.cc.

  {
    return zero;
  }

derivative() [20/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::pi > &

expr

)

Definition at line 378 of file derivative.cc.

  {
    return zero;
  }

derivative() [21/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::zero > &

expr

)

Definition at line 385 of file derivative.cc.

  {
    return zero;
  }

derivative() [22/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::one > &

expr

)

Definition at line 392 of file derivative.cc.

  {
    return zero;
  }  

derivative() [23/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::inf > &

expr

)

Definition at line 399 of file derivative.cc.

  {
    return zero;
  }  

derivative() [24/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::percent > &

expr

)

Definition at line 406 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return (100*x)->derivative(*this);
  }

derivative() [25/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::copy > &

expr

)

Definition at line 416 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (!expr.arguments[0].empty() && expr.arguments[0][0])
      return expr.arguments[0][0]->derivative(*this);
    return zero;
  }

derivative() [26/49]

template<class Expr >

NodePtr MathDAG::SystemOfEquations::derivative

(

const Expr &

expr

)

symbolically differentiate expr

derivative() [27/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::integrate > &

expr

)

Definition at line 425 of file derivative.cc.

  {
    throw error("shouldn't be executed");
  }

derivative() [28/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::differentiate > &

expr

)

Definition at line 432 of file derivative.cc.

  {
    throw error("shouldn't be executed");
  }

derivative() [29/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::data > &

expr

)

Definition at line 439 of file derivative.cc.

  {
    throw error("cannot differentiate an empirical curve");
  }

derivative() [30/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::ravel > &

expr

)

Definition at line 446 of file derivative.cc.

  {
    throw error("cannot differentiate an empirical curve");
  }

derivative() [31/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::sqrt > &

expr

)

Definition at line 453 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::sqrt().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, 0.5/sqrt(x));
  }

Here is the call graph for this function:

derivative() [32/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::exp > &

expr

)

Definition at line 463 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::exp().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    const Expr expx(expressionCache, expressionCache.reverseLookup(expr));
    return chainRule(x, exp(x));
  }

Here is the call graph for this function:

derivative() [33/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::ln > &

expr

)

Definition at line 474 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, 1/x);
  }

derivative() [34/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::sin > &

expr

)

Definition at line 484 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::cos().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x,cos(x));
  }

Here is the call graph for this function:

derivative() [35/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::cos > &

expr

)

Definition at line 494 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::sin().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x,-1*sin(x));
  }

Here is the call graph for this function:

derivative() [36/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::tan > &

expr

)

Definition at line 505 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::cos().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    const Expr secx=1/cos(x);
    return chainRule(x,secx * secx);
  }

Here is the call graph for this function:

derivative() [37/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::asin > &

expr

)

Definition at line 516 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::sqrt().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, 1/sqrt(1-x*x));
  }

Here is the call graph for this function:

derivative() [38/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::acos > &

expr

)

Definition at line 526 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::sqrt().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, -1/sqrt(1-x*x));
  }

Here is the call graph for this function:

derivative() [39/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::atan > &

expr

)

Definition at line 536 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, 1/(1+x*x));
  }

derivative() [40/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::sinh > &

expr

)

Definition at line 546 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::cosh().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, cosh(x));
  }

Here is the call graph for this function:

derivative() [41/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::cosh > &

expr

)

Definition at line 556 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::sinh().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, sinh(x));
  }

Here is the call graph for this function:

derivative() [42/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::tanh > &

expr

)

Definition at line 566 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::cosh().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    const Expr sech=1/cosh(x);
    return chainRule(x, sech*sech);
  }

Here is the call graph for this function:

derivative() [43/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::abs > &

expr

)

Definition at line 577 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x, (one-2*(x<=zero)));
  }

derivative() [44/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::floor > &

expr

)

Definition at line 587 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    // should really be δ(x-⌊x⌋) 
    throw error("floor is not differentiable");
  }

derivative() [45/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::frac > &

expr

)

Definition at line 597 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments.

  {
    if (expr.arguments[0].empty())
      return zero;
    throw error("frac is not differentiable");
  }

derivative() [46/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::Gamma > &

expr

)

Definition at line 606 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, MathDAG::Gamma(), and MathDAG::polygamma().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x,polygamma(x,Expr(expressionCache,zero))*Gamma(x)); 
  }                                                                                         

Here is the call graph for this function:

derivative() [47/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::polygamma > &

expr

)

Definition at line 616 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, and MathDAG::polygamma().

  {
      assert(expr.arguments.size()==2);
      if (expr.arguments[0].empty())
        return zero;
      const Expr x(expressionCache, expressionCache.reverseLookup(*expr.arguments[0][0]));
      if (expr.arguments[1].empty())
        return chainRule(x,polygamma(x,Expr(expressionCache, one)));
      return chainRule(x,polygamma(x,1+Expr(expressionCache, expr.arguments[1][0])));
    }

Here is the call graph for this function:

derivative() [48/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::fact > &

expr

)

Definition at line 629 of file derivative.cc.

References MathDAG::OperationDAGBase::arguments, MathDAG::Gamma(), and MathDAG::polygamma().

  {
    if (expr.arguments[0].empty())
      return zero;
    const Expr x(expressionCache, expr.arguments[0][0]);
    return chainRule(x,polygamma(1+x,Expr(expressionCache,zero))*Gamma(1+x));
  }    

Here is the call graph for this function:

derivative() [49/49]

template<>

NodePtr MathDAG::SystemOfEquations::derivative

(

const OperationDAG< OperationType::userFunction > &

expr

)

Definition at line 639 of file derivative.cc.

  {throw error("Derivatives of user defined functions not implemented");}

getDefFromIntVar()

ostringstream MathDAG::SystemOfEquations::getDefFromIntVar

(

const VariableBase &

v

)

Definition at line 891 of file equations.cc.

References expressionCache, MathDAG::SubexpressionCache::getIntegralInput(), and minsky::VariableBase::valueId().

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

  {
    ostringstream o;
         
    const VariableDAGPtr input=expressionCache.getIntegralInput(v.valueId());    
    if (input && input->rhs) input->rhs->latex(o);    
    
    return o;
  }        

Here is the call graph for this function:

Here is the caller graph for this function:

getNodeFromIntVar()

VariableDAGPtr MathDAG::SystemOfEquations::getNodeFromIntVar ( const std::string &  valueId )

inline

Definition at line 423 of file equations.h.

References MathDAG::SubexpressionCache::getIntegralInput(), and minsky::valueId().

Referenced by minsky::VariableValue::summary().

    {return expressionCache.getIntegralInput(valueId);}

Here is the call graph for this function:

Here is the caller graph for this function:

getNodeFromValueId()

VariableDAGPtr MathDAG::SystemOfEquations::getNodeFromValueId ( const std::string &  v )

inline

Definition at line 421 of file equations.h.

Referenced by minsky::VariableValue::summary().

    {return dynamic_pointer_cast<VariableDAG>(expressionCache[v]);}

Here is the caller graph for this function:

getNodeFromVar()

VariableDAGPtr MathDAG::SystemOfEquations::getNodeFromVar

(

const VariableBase &

v

)

Definition at line 882 of file equations.cc.

References MathDAG::SubexpressionCache::exists(), expressionCache, makeDAG(), and minsky::VariableType::undefined.

Referenced by minsky::Group::arguments(), minsky::VariableBase::definition(), and minsky::Group::formula().

  {
    NodePtr r;
    if (expressionCache.exists(v))
      return dynamic_pointer_cast<VariableDAG>(expressionCache[v]);
    if (v.type()!=VariableBase::undefined) r=makeDAG(const_cast<VariableBase&>(v));
    return dynamic_pointer_cast<VariableDAG>(r);
  }         

Here is the call graph for this function:

Here is the caller graph for this function:

getNodeFromWire()

NodePtr MathDAG::SystemOfEquations::getNodeFromWire ( const Wire &  wire )

private

returns cached subexpression node representing what feeds the wire, creating a new one if necessary

Definition at line 846 of file equations.cc.

References MathDAG::SubexpressionCache::exists(), expressionCache, makeDAG(), minsky::VariableType::undefined, and minsky::wire.

Referenced by makeDAG(), SystemOfEquations(), and updatePortVariableValue().

  {
    if (auto p=wire.from())
      {
        auto& item=p->item();
        if (auto o=item.operationCast())
          {
            if (expressionCache.exists(*o))
              return expressionCache[*o];
            // we're wired to an operation
            return makeDAG(*o);
          }
        if (auto v=item.variableCast())
          {
            if (expressionCache.exists(*v))
              return expressionCache[*v];
            if (v && v->type()!=VariableBase::undefined) 
              // we're wired to a variable
              return makeDAG(*v);
          }
        else if (auto s=dynamic_cast<SwitchIcon*>(&item))
          {
            if (expressionCache.exists(*s))
              return expressionCache[*s];
            return makeDAG(*s);
          }
        else if (auto l=dynamic_cast<Lock*>(&item))
          {
            if (expressionCache.exists(*l))
              return expressionCache[*l];
            return makeDAG(*l);
          }
      }
    return {};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

latex()

ostream & MathDAG::SystemOfEquations::latex

(

ostream &

o

)

const

render as a LaTeX eqnarray Use LaTeX brqn environment to wrap long lines

Definition at line 902 of file equations.cc.

References minsky::VariableType::constant, expressionCache, MathDAG::SubexpressionCache::getIntegralInput(), integrationVariables, MathDAG::latexInit(), MathDAG::mathrm(), minsky::VariableType::tempFlow, userDefinedFunctions, and variables.

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

  {
    o << "\\begin{eqnarray*}\n";
    // output user defined functions
    for (auto& i: userDefinedFunctions)
      o<<i.first<<"(x,y)&=&"<<i.second<<"\\\\\n";
    for (const VariableDAG* i: variables)
      {
        if (dynamic_cast<const IntegralInputVariableDAG*>(i) ||
            !i || i->type==VariableType::constant || i->type==VariableType::tempFlow) continue;
        o << i->latex() << "&=&";
        if (i->rhs) 
          i->rhs->latex(o);
        else
          o<<latexInit(i->init);
        o << "\\\\\n";
      }

    for (const VariableDAG* i: integrationVariables)
      {
        o << mathrm(i->name)<<"(0)&=&"<<latexInit(i->init)<<"\\\\\n";
        o << "\\frac{ d " << mathrm(i->name) << 
          "}{dt} &=&";
        const VariableDAGPtr input=expressionCache.getIntegralInput(i->valueId);
        if (input && input->rhs)
          input->rhs->latex(o);
        o << "\\\\\n";
      }
    return o << "\\end{eqnarray*}\n";
  }

Here is the call graph for this function:

Here is the caller graph for this function:

latexWrapped()

ostream & MathDAG::SystemOfEquations::latexWrapped

(

ostream &

o

)

const

Definition at line 933 of file equations.cc.

References minsky::VariableType::constant, expressionCache, MathDAG::SubexpressionCache::getIntegralInput(), integrationVariables, MathDAG::latexInit(), MathDAG::mathrm(), minsky::VariableType::tempFlow, and variables.

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

  {
    o << "\\begin{dgroup*}\n";
    for (const VariableDAG* i: variables)
      {
        if (dynamic_cast<const IntegralInputVariableDAG*>(i)) continue;
        if (!i || i->type==VariableType::constant || i->type==VariableType::tempFlow) continue;
        o<<"\\begin{dmath*}\n";
        o << i->latex() << "=";
        if (i->rhs) 
          i->rhs->latex(o);
        else
          o<<latexInit(i->init);
        o << "\n\\end{dmath*}\n";
      }

    for (const VariableDAG* i: integrationVariables)
      {
        o<<"\\begin{dmath*}\n";
        o << mathrm(i->name)<<"(0)="<<latexInit(i->init)<<"\n\\end{dmath*}\n";
        o << "\\begin{dmath*}\n\\frac{ d " << mathrm(i->name) << 
          "}{dt} =";
        const VariableDAGPtr input=expressionCache.getIntegralInput(i->valueId);
        if (input && input->rhs)
          input->rhs->latex(o);
        o << "\\end{dmath*}\n";
      }
    return o << "\\end{dgroup*}\n";
  }

Here is the call graph for this function:

Here is the caller graph for this function:

makeDAG() [1/5]

NodePtr MathDAG::SystemOfEquations::makeDAG ( const string &  valueId, const string &  name, VariableType::Type  type  )

private

create a variable DAG. returns cached value if previously called

Definition at line 676 of file equations.cc.

References minsky::VariableType::constant, MathDAG::SubexpressionCache::exists(), expressionCache, getNodeFromWire(), MathDAG::SubexpressionCache::insert(), minsky::VariableType::integral, minsky::isValueId(), minsky::to_string(), minsky::valueId(), and varNames.

Referenced by getNodeFromVar(), getNodeFromWire(), makeDAG(), and SystemOfEquations().

  {
    if (expressionCache.exists(valueId))
      return expressionCache[valueId];

    if (!isValueId(valueId)||!minsky.variableValues.contains(valueId))
      throw runtime_error("Invalid valueId: "+valueId);
    auto vv=minsky.variableValues[valueId];

    if (type==VariableType::constant)
      {
        NodePtr r(new ConstantDAG(vv->init()));
        r->result=vv;
        expressionCache.insert(valueId, r);
        return r;
      }

    // ensure name is unique
    string nm=name;
    for (unsigned i=0; varNames.contains(nm); ++i)
      nm=name+"_"+to_string(i);
    varNames.insert(nm);
    
    shared_ptr<VariableDAG> r(new VariableDAG(valueId, nm, type));
    expressionCache.insert(valueId, r);
    r->init=vv->init();
    if (auto v=minsky.definingVar(valueId))
      if (v->type()!=VariableType::integral && v->numPorts()>1 && !v->ports(1).lock()->wires().empty())
        r->rhs=getNodeFromWire(*v->ports(1).lock()->wires()[0]);
    return r;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

makeDAG() [2/5]

NodePtr MathDAG::SystemOfEquations::makeDAG ( VariableBase &  v )

inlineprivate

Definition at line 371 of file equations.h.

References minsky::VariableBase::ensureValueExists(), minsky::VariableBase::name(), minsky::VariableBase::type(), minsky::uqName(), minsky::VariableBase::valueId(), and minsky::VariableBase::vValue().

    {v.ensureValueExists(v.vValue().get(),v.name()); return makeDAG(v.valueId(),uqName(v.name()),v.type());}

Here is the call graph for this function:

makeDAG() [3/5]

NodePtr MathDAG::SystemOfEquations::makeDAG ( const OperationBase &  op )

private

create an operation DAG. returns cached value if previously called

Definition at line 708 of file equations.cc.

References MathDAG::OperationDAGBase::create(), minsky::OperationType::differentiate, minsky::Minsky::displayErrorItem(), MathDAG::SubexpressionCache::exists(), expressionCache, getNodeFromWire(), MathDAG::SubexpressionCache::insert(), makeDAG(), minsky::minsky(), minsky::op, and minsky::valueId().

  {
    if (expressionCache.exists(op))
      return dynamic_pointer_cast<OperationDAGBase>(expressionCache[op]);

    if (op.type()==OperationType::differentiate)
      {
        assert(op.portsSize()==2);
        NodePtr expr;
        if (op.ports(1).lock()->wires().empty() || !(expr=getNodeFromWire(*op.ports(1).lock()->wires()[0])))
          op.throw_error("derivative not wired");
        try
          {
            return expressionCache.insert
              (op, expr->derivative(*this));
          }
        catch (...)
          {
            minsky::minsky().displayErrorItem(op);          
            throw;
          }
      }
    else
      {
        shared_ptr<OperationDAGBase> r(OperationDAGBase::create(op.type()));
        expressionCache.insert(op, NodePtr(r));
        r->state=minsky.model->findItem(op);
        assert(r->state);

        r->arguments.resize(op.numPorts()-1);
        for (size_t i=1; i<op.portsSize(); ++i)
          if (auto p=op.ports(i).lock())
            for (auto w: p->wires())
              r->arguments[i-1].push_back(getNodeFromWire(*w));
        if (auto uf=dynamic_cast<const UserFunction*>(&op))
          {
            // add external variable references as additional "arguments" in order to determine the correct evaluation order
            r->arguments.emplace_back();
            for (auto& i: uf->symbolNames())
              {
                auto vv=minsky.variableValues.find(valueId(op.group.lock(), i));
                if (vv!=minsky.variableValues.end())
                  {
                    r->arguments.back().emplace_back(makeDAG(vv->first,vv->second->name,vv->second->type()));
                  }
              }
          }
        return r;
      }
  }

Here is the call graph for this function:

makeDAG() [4/5]

NodePtr MathDAG::SystemOfEquations::makeDAG ( const SwitchIcon &  op )

private

Definition at line 759 of file equations.cc.

References expressionCache, getNodeFromWire(), and MathDAG::SubexpressionCache::insert().

  {
    // grab list of input wires
    vector<Wire*> wires;
    for (unsigned i=1; i<sw.portsSize(); ++i)
      {
        auto& w=sw.ports(i).lock()->wires();
        if (w.empty())
          {
            minsky.displayErrorItem(sw);
            throw error("input port not wired");
          }
        // shouldn't be more than 1 wire, ignore extraneous wires is present
        assert(w.size()==1);
        wires.push_back(w[0]);
      }

    assert(wires.size()==sw.numCases()+1);
    const Expr input(expressionCache, getNodeFromWire(*wires[0]));

    auto r=make_shared<OperationDAG<OperationType::add>>();
    r->state=minsky.model->findItem(sw);
    assert(r->state);
    expressionCache.insert(sw, r);
    r->arguments[0].resize(sw.numCases());

    // implemented as a sum of step functions
    r->arguments[0][0]=getNodeFromWire(*wires[1])*(input<1);        
    for (unsigned i=1; i<sw.numCases()-1; ++i)
      r->arguments[0][i]=getNodeFromWire
        (*wires[i+1])*((input<i+1) - (input<i));
    r->arguments[0][sw.numCases()-1]=getNodeFromWire
      (*wires[sw.numCases()])*(1-(input<sw.numCases()-1));
    return r;
  };

Here is the call graph for this function:

makeDAG() [5/5]

NodePtr MathDAG::SystemOfEquations::makeDAG ( const Lock &  op )

private

Definition at line 828 of file equations.cc.

References expressionCache, getNodeFromWire(), MathDAG::SubexpressionCache::insert(), minsky::Lock::locked(), minsky::Item::ports(), and minsky::Lock::ravelInput().

  {
    auto r=make_shared<LockDAG>(l);
    expressionCache.insert(l,r);
    auto ravel=l.ravelInput();
    if (ravel && l.locked())
      {
        if (auto p=ravel->ports(1).lock())
          if (!p->wires().empty())
            r->rhs=getNodeFromWire(*p->wires()[0]);
      }
    else
      if (auto p=l.ports(1).lock())
        if (!p->wires().empty())
          r->rhs=getNodeFromWire(*p->wires()[0]);
    return r;
  }

Here is the call graph for this function:

matlab()

ostream & MathDAG::SystemOfEquations::matlab

(

ostream &

o

)

const

render as MatLab code create equations suitable for Runge-Kutta solver

Parameters

vector	of equations to be constructed
vector	of integrals to be constructed
portValMap	- map of flowVar ids assigned with an output port

Definition at line 963 of file equations.cc.

References minsky::VariableType::constant, expressionCache, MathDAG::SubexpressionCache::getIntegralInput(), integrationVariables, MathDAG::matlabInit(), userDefinedFunctions, and variables.

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

  {
    // output user defined functions
    for (auto& i: userDefinedFunctions)
      {
        o<<"function f="<<i.first<<"\n";
        o<<"f="<<i.second<<"\nendfunction;\n\n";
      }
    o<<"function f=f(x,t)\n";
    // define names for the components of x for reference
    int j=1;
    for (const VariableDAG*  i: integrationVariables)
      o<<i->matlab()<<"=x("<<j++<<");\n";

    for (const VariableDAG* i: variables)
      {
        if (dynamic_cast<const IntegralInputVariableDAG*>(i) ||
            !i || i->type==VariableType::constant) continue;
        o << i->matlab() << "=";
        if (i->rhs)
          o << i->rhs->matlab();
        else
          o << matlabInit(i->init);
        o<<";\n";
      }

    j=1;
    for (const VariableDAG* i: integrationVariables)
      {
        o << "f("<<j++<<")=";
        const VariableDAGPtr input=expressionCache.getIntegralInput(i->valueId);
        if (input && input->rhs)
          input->rhs->matlab(o);
        else
          o<<0;
        o<<";\n";
      }
    o<<"endfunction;\n\n";

    // now write out the initial conditions
    j=1;
    for (const VariableDAG* i: integrationVariables)
      o << "x0("<<j++<<")="<<matlabInit(i->init)<<";\n";
   
    return o;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateEvalOpVector()

void MathDAG::SystemOfEquations::populateEvalOpVector	(	EvalOpVector &	equations,
		std::vector< Integral > &	integrals
	)

Definition at line 1011 of file equations.cc.

References minsky::isValueId().

Referenced by minsky::Minsky::constructEquations(), and minsky::Group::operator()().

  {
    equations.clear();
    integrals.clear();

    for (VariableDAG* i: variables)
      {
        i->addEvalOps(equations,i->result);
        assert(minsky.variableValues.validEntries());
      }

    for (const VariableDAG* i: integrationVariables)
      {
        const string vid=i->valueId;
        integrals.push_back(Integral());
        assert(isValueId(vid));
        assert(minsky.variableValues.count(vid));
        integrals.back().stock=minsky.variableValues[vid];
        integrals.back().operation=dynamic_cast<IntOp*>(i->intOp);
        const VariableDAGPtr iInput=expressionCache.getIntegralInput(vid);
        if (iInput && iInput->rhs)
          integrals.back().setInput(iInput->rhs->addEvalOps(equations));
      }
    assert(minsky.variableValues.validEntries());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

processGodleyTable()

void MathDAG::SystemOfEquations::processGodleyTable ( map< string, GodleyColumnDAG > &  godleyVariables, const GodleyIcon &  gi  )

private

Definition at line 1074 of file equations.cc.

References MathDAG::OperationDAGBase::arguments, minsky::VariableType::flow, MathDAG::GodleyColumnDAG::name, minsky::GodleyIcon::table, minsky::trimWS(), minsky::uqName(), and minsky::valueId().

Referenced by SystemOfEquations().

  {
    auto& godley=gi.table;
    for (size_t c=1; c<godley.cols(); ++c)
      {
        string colName=trimWS(godley.cell(0,c));
        if (uqName(colName).empty())
          continue; // ignore empty Godley columns
        // resolve scope
        colName=valueId(gi.group.lock(), colName);
        if (processedColumns.contains(colName)) continue; //skip shared columns
        processedColumns.insert(colName);
        GodleyColumnDAG& gd=godleyVariables[colName];
        gd.name=trimWS(godley.cell(0,c));
        gd.arguments.resize(2);
        const vector<WeakNodePtr>& arguments=gd.arguments[0];
        for (size_t r=1; r<godley.rows(); ++r)
          {
            if (godley.initialConditionRow(r)) continue;
            const FlowCoef fc(godley.cell(r,c));
            if (fc.name.empty()) continue;

            const VariablePtr v(VariableType::flow, fc.name);
            v->group=gi.group;

            if (abs(fc.coef)==1)
              gd.arguments[fc.coef<0? 1: 0].push_back(WeakNodePtr(makeDAG(*v)));
            else
              {
                OperationDAG<OperationType::multiply>* term=
                  new OperationDAG<OperationType::multiply>;
                gd.arguments[fc.coef<0? 1: 0].push_back
                  (expressionCache.insertAnonymous(NodePtr(term)));

                term->arguments.resize(2);
                term->arguments[0].push_back
                  (expressionCache.insertAnonymous(NodePtr(new ConstantDAG(abs(fc.coef)))));
                term->arguments[1].push_back(WeakNodePtr(makeDAG(*v)));
              }
          }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

renderEquations()

void MathDAG::SystemOfEquations::renderEquations	(	ecolab::cairo::Surface &	,
		double	height
	)		const

render equations into a cairo context

Definition at line 141 of file equationDisplayRender.cc.

References MathDAG::latexInit(), minsky::latexToPango(), MathDAG::mathrm(), MathDAG::anonymous_namespace{equationDisplayRender.cc}::print(), and MathDAG::anonymous_namespace{equationDisplayRender.cc}::variableRender().

Referenced by minsky::EquationDisplay::redraw().

  {
    double x, y; // starting position of current line
    cairo_get_current_point(dest.cairo(),&x,&y);
    const double origin=-y;
    Pango den(dest.cairo());
    den.setMarkup("dt");

    const double fontHeight=30;
    const int baseEqn=origin/fontHeight;
    int eqnNo=0;
    
    for (const VariableDAG* i: variables)
      {
        if (dynamic_cast<const IntegralInputVariableDAG*>(i)) continue;
        if (!i || i->type==VariableType::constant) continue;
        if (eqnNo++ < baseEqn) continue;
        RecordingSurface line;
        variableRender(line,*i);
        cairo_move_to(dest.cairo(), x, y-line.top());
        variableRender(dest,*i);
        y+=line.height()+4;
        cairo_move_to(dest.cairo(), x, y);
        if (y>height) return;
       }

    for (const VariableDAG* i: integrationVariables)
      {
        if (eqnNo++ < baseEqn) continue;
        // initial conditions
        cairo_move_to(dest.cairo(), x, y); // needed to define a current point on the equations tab. for ticket 1256
        y+=print(dest.cairo(), latexToPango(mathrm(i->name))+"(0) = "+
                 latexToPango(latexInit(i->init)),Anchor::nw);   
        
        // differential equation
        Pango num(dest.cairo());
        num.setMarkup("d"+latexToPango(mathrm(i->name)));
        double lineSpacing=num.height()+den.height()+2;

        const VariableDAGPtr input=expressionCache.getIntegralInput(i->valueId);
        if (input && input->rhs)
          { // adjust linespacing to allow enough height for RHS
          RecordingSurface rhs;
          input->rhs->render(rhs);
          lineSpacing = max(rhs.height(), lineSpacing);
        }

        // vertical location of the = sign
        const double eqY=y+max(num.height(), 0.5*lineSpacing);

        cairo_move_to(dest.cairo(), x, eqY-num.height());
        num.show();
        cairo_move_to(dest.cairo(), x, eqY);
        const double solidusLength = max(num.width(),den.width());
        cairo_rel_line_to(dest.cairo(), solidusLength, 0);
        cairo_stroke(dest.cairo());
        cairo_move_to(dest.cairo(), x+solidusLength, eqY);
        // display RHS here
        if (input && input->rhs)
          {
            print(dest.cairo()," = ", Anchor::w);
            input->rhs->render(dest);
          }
        else
          print(dest.cairo()," = 0", Anchor::w);
        cairo_move_to(dest.cairo(), x+0.5*(num.width()-den.width()), eqY);
        den.show();
        cairo_move_to(dest.cairo(), x, y+=lineSpacing);// move to next line

        if (y>height) return;
      }
  } 

Here is the call graph for this function:

Here is the caller graph for this function:

updatePortVariableValue()

void MathDAG::SystemOfEquations::updatePortVariableValue

(

EvalOpVector &

equations

)

Definition at line 1037 of file equations.cc.

References getNodeFromWire(), minsky::GroupItems::items, and minsky::VariableType::undefined.

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

  {
    // ensure all variables have their output port's variable value up to date
    minsky.model->recursiveDo
      (&Group::items,
       [&](Items&, Items::iterator i)
       {
         if (auto v=(*i)->variableCast())
           {
             if (v->type()==VariableType::undefined)
               throw error("variable %s has undefined type",v->name().c_str());
             assert(minsky.variableValues.count(v->valueId()));
             if (v->portsSize()>0)
               v->ports(0).lock()->setVariableValue(minsky.variableValues[v->valueId()]);
           }
         else if (auto pw=(*i)->plotWidgetCast())
           for (size_t port=0; port<pw->portsSize(); ++port)
             for (auto w: pw->ports(port).lock()->wires())
               // ensure plot inputs are evaluated
               w->from()->setVariableValue(getNodeFromWire(*w)->addEvalOps(equations));
         else if (auto s=dynamic_cast<Sheet*>(i->get()))
           {
             for (auto w: s->ports(0).lock()->wires())
               // ensure sheet inputs are evaluated
               w->from()->setVariableValue(getNodeFromWire(*w)->addEvalOps(equations));
             s->computeValue();
           }
         else if (auto r=dynamic_cast<Ravel*>(i->get()))
           for (auto w: r->ports(1).lock()->wires())
               // ensure sheet inputs are evaluated
               w->from()->setVariableValue(getNodeFromWire(*w)->addEvalOps(equations));

         return false;
       });
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

derivInputs

vector<pair<VariableDAGPtr,string> > MathDAG::SystemOfEquations::derivInputs

private

Definition at line 365 of file equations.h.

Referenced by SystemOfEquations().

expressionCache

SubexpressionCache MathDAG::SystemOfEquations::expressionCache

private

Definition at line 360 of file equations.h.

Referenced by getDefFromIntVar(), getNodeFromVar(), getNodeFromWire(), latex(), latexWrapped(), makeDAG(), matlab(), and SystemOfEquations().

integrationVariables

vector<VariableDAG*> MathDAG::SystemOfEquations::integrationVariables

private

Definition at line 363 of file equations.h.

Referenced by latex(), latexWrapped(), matlab(), and SystemOfEquations().

minsky

const Minsky& MathDAG::SystemOfEquations::minsky

private

Definition at line 367 of file equations.h.

one

NodePtr MathDAG::SystemOfEquations::one {new ConstantDAG("1")}

Definition at line 418 of file equations.h.

Referenced by SystemOfEquations().

processedColumns

set<string> MathDAG::SystemOfEquations::processedColumns

private

Definition at line 364 of file equations.h.

processingDerivative

std::set<std::string> MathDAG::SystemOfEquations::processingDerivative

private

keep track of derivatives of variables, to trap definition loops

Definition at line 391 of file equations.h.

userDefinedFunctions

std::map<std::string, std::string> MathDAG::SystemOfEquations::userDefinedFunctions

private

table of user defined functions and their definitions

Definition at line 393 of file equations.h.

Referenced by latex(), matlab(), and SystemOfEquations().

variables

vector<VariableDAG*> MathDAG::SystemOfEquations::variables

private

Definition at line 362 of file equations.h.

Referenced by latex(), latexWrapped(), matlab(), and SystemOfEquations().

varNames

std::set<std::string> MathDAG::SystemOfEquations::varNames

private

used to rename ambiguous variables in different scopes

Definition at line 389 of file equations.h.

Referenced by makeDAG().

zero

NodePtr MathDAG::SystemOfEquations::zero {new ConstantDAG("0")}

useful constants to share

Definition at line 418 of file equations.h.

Referenced by SystemOfEquations().

---

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

• engine/equations.h
• engine/derivative.cc
• engine/equationDisplayRender.cc
• engine/equations.cc