MathDAG::OperationDAGBase Struct Reference

#include <equations.h>

Inheritance diagram for MathDAG::OperationDAGBase:

Collaboration diagram for MathDAG::OperationDAGBase:

Public Member Functions
	OperationDAGBase (const string &name="")
virtual Type	type () const =0
int	order (unsigned maxOrder) const override
	returns evaluation order in sequence of variable defintions More...
bool	tensorEval (std::set< const Node *> &) const override
	returns true if the evaluation of this involves tensor processing More...
VariableValuePtr	addEvalOps (EvalOpVector &, const VariableValuePtr &) override
	adds EvalOps to an EvalOpVector representing this node. More...
void	checkArg (unsigned i, unsigned j) const
virtual bool	tensorEval (std::set< const Node * > &visited) const=0
	returns true if the evaluation of this involves tensor processing More...
bool	tensorEval ()
	returns true if the evaluation of this involves tensor processing More...
Public Member Functions inherited from MathDAG::Node
virtual	~Node ()
virtual int	BODMASlevel () const =0
	algebraic heirarchy level, used for working out whether brackets are necessary. More...
virtual ostream &	latex (ostream &) const =0
	writes LaTeX representation of this DAG to the stream More...
std::string	latexStr () const
virtual ostream &	matlab (ostream &) const =0
	writes a matlab representation of this DAG to the stream More...
std::string	matlabStr () const
virtual void	render (ecolab::cairo::Surface &surf) const =0
	renders a visual representation of this node to surf graphic extends right from the current pen position (which needs to be defined), and pen is moved to the right edge of the graphic. The determine bounding box, render into a recording surface, and use width()/height() More...
bool	tensorEval ()
	returns true if the evaluation of this involves tensor processing More...
LaTeXManip	latex () const
	used within io streaming More...
MatlabManip	matlab () const
virtual std::shared_ptr< Node >	derivative (SystemOfEquations &) const =0
	support for the derivative operator. More...

Static Public Member Functions
static OperationDAGBase *	create (Type type, const string &name="")
	factory method More...
Static Public Member Functions inherited from minsky::OperationType
static std::string	typeName (int type)
	return the symbolic name of type More...
static Group	classify (Type t)

Public Attributes
vector< vector< WeakNodePtr > >	arguments
string	name
string	init ="0"
ItemPtr	state
Public Attributes inherited from MathDAG::Node
int	cachedOrder =-1
VariableValuePtr	result
	reference to where this node's value is stored More...

Additional Inherited Members
Public Types inherited from minsky::OperationType
enum	Type {   constant, time, integrate, differentiate,   data, ravel, euler, pi,   zero, one, inf, percent,   add, subtract, multiply, divide,   min, max, and_, or_,   log, pow, polygamma, lt,   le, eq, userFunction, copy,   sqrt, exp, ln, sin,   cos, tan, asin, acos,   atan, sinh, cosh, tanh,   abs, floor, frac, not_,   Gamma, fact, sum, product,   infimum, supremum, any, all,   infIndex, supIndex, runningSum, runningProduct,   difference, differencePlus, innerProduct, outerProduct,   index, gather, meld, merge,   slice, size, shape, mean,   median, stdDev, moment, histogram,   covariance, correlation, linearRegression, numOps }
enum	Group {   general, constop, binop, function,   reduction, scan, tensor, statistics }

Detailed Description

Definition at line 217 of file equations.h.

Constructor & Destructor Documentation

OperationDAGBase()

MathDAG::OperationDAGBase::OperationDAGBase ( const string &  name = "" )

inline

Definition at line 223 of file equations.h.

                                           : 
      name(name) {}

Member Function Documentation

addEvalOps()

VariableValuePtr MathDAG::OperationDAGBase::addEvalOps ( EvalOpVector &  , const VariableValuePtr &  result  )

overridevirtual

adds EvalOps to an EvalOpVector representing this node.

Returns

a variable where the result is stored. If a flowVariable has been provided in result, that may be used directly, otherwise a copy operation is added to ensure it receives the result.

Implements MathDAG::Node.

Definition at line 317 of file equations.cc.

References MathDAG::anonymous_namespace{equations.cc}::addTensorOp(), MathDAG::anonymous_namespace{equations.cc}::cumulate(), minsky::Minsky::displayErrorItem(), minsky::doOneEvent(), minsky::minsky(), minsky::VariableType::tempFlow, and minsky::VariableType::undefined.

  {
    assert(result);
    if (result->type()==VariableType::undefined)
      {
        assert(!dynamic_cast<IntOp*>(state.get()));
        if (r->type()!=VariableType::undefined && r->isFlowVar())
          result=r;
        else
          {
            result=VariableValuePtr(VariableType::tempFlow);
            result->allocValue();
          }
        if (tensorEval() && addTensorOp(result, *this, ev))
          return result;
        assert(result->type()!=VariableType::undefined);
        assert(result->idx()>=0);
        
        // prepare argument expressions
        vector<vector<VariableValuePtr> > argIdx(arguments.size());
        for (size_t i=0; type()!=integrate && i<arguments.size(); ++i)
          for (size_t j=0; j<arguments[i].size(); ++j)
            if (arguments[i][j])
              argIdx[i].push_back(arguments[i][j]->addEvalOps(ev));
            else
              {
                argIdx[i].emplace_back(VariableType::tempFlow);
                argIdx[i].back()->allocValue();
              }

        try
          {
            // basic arithmetic is handled in a cumulative fashion
            switch (type())
              {
              case add:
                cumulate(ev, state, result, argIdx, add, add, 0);
                break;
              case subtract:
                cumulate(ev, state, result, argIdx, subtract, add, 0);
                break;
              case multiply:
                cumulate(ev, state, result, argIdx, multiply, multiply, 1);
                break;
              case divide:
                cumulate(ev, state, result, argIdx, divide, multiply, 1);
                break;
              case min:
                cumulate(ev, state, result, argIdx, min, min, numeric_limits<double>::max());
                break;
              case max:
                cumulate(ev, state, result, argIdx, max, max, -numeric_limits<double>::max());
                break;
              case and_:
                cumulate(ev, state, result, argIdx, and_, and_, 1);
                break;
              case or_:
                cumulate(ev, state, result, argIdx, or_, or_, 0);
                break;
              case constant:
                if (state) minsky::minsky().displayErrorItem(*state);
                throw error("Constant deprecated");
              case lt: case le: case eq:
                for (size_t i=0; i<arguments.size(); ++i)
                  if (arguments[i].empty())
                    {
                      argIdx[i].emplace_back(VariableType::tempFlow);
                      argIdx[i].back()->allocValue();
                      // ensure units are compatible (as we're doing comparisons with zero)
                      if (i>0)
                        argIdx[i][0]->units=argIdx[i-1][0]->units;
                      else if (arguments.size()>1 && !argIdx[1].empty())
                        argIdx[0][0]->units=argIdx[1][0]->units;
                    }
                ev.push_back(EvalOpPtr(type(), state, result, *argIdx[0][0], *argIdx[1][0])); 
                break;
              case userFunction:
                for (size_t i=0; i<arguments.size(); ++i)
                  if (arguments[i].empty())
                    {
                      argIdx[i].emplace_back(VariableType::tempFlow);
                      argIdx[i].back()->allocValue();
                    }
                ev.push_back(EvalOpPtr(type(), state, result, *argIdx[0][0], *argIdx[1][0])); 
                break;
              case data:
                if (!argIdx.empty() && argIdx[0].size()==1)
                  ev.push_back(EvalOpPtr(type(), state, result, *argIdx[0][0])); 
                else
                  throw error("inputs for highlighted operations incorrectly wired");
                break;            
              default:
                switch (classify(type()))
                  {
                  case reduction: case scan: case tensor:
                    if (result->idx()==-1) result->allocValue();
                    break; // TODO handle tensor properly later
                  default:
                    {
                      // sanity check that the correct number of arguments is provided 
                      bool correctlyWired=true;
                      for (size_t i=0; i<arguments.size(); ++i)
                        correctlyWired &= arguments[i].size()==1;
                      if (!correctlyWired)
                        throw error("inputs for highlighted operations incorrectly wired");
            
                      switch (arguments.size())
                        {
                        case 0:
                          ev.push_back(EvalOpPtr(type(), state, result));
                          break;
                        case 1:
                          ev.push_back(EvalOpPtr(type(), state, result, *argIdx[0][0]));
                          break;
                        case 2:
                          ev.push_back(EvalOpPtr(type(), state, result, *argIdx[0][0], *argIdx[1][0]));
                          break;
                        default:
                          throw error("Too many arguments");
                        }
                    }
                  }
              }
          }
        catch (const std::exception&)
          {
            if (state) minsky::minsky().displayErrorItem(*state);
            throw;
          }
      }
    if (type()!=integrate && r->type()!=VariableType::undefined && r->isFlowVar() && result!=r)
      ev.emplace_back(EvalOpPtr(new TensorEval(r,result)));
    if (state && state->portsSize()>0)
      if (auto statePort=state->ports(0).lock()) 
        statePort->setVariableValue(result);
    assert(result->idx()>=0);
    doOneEvent(true);
    return result;
  }

Here is the call graph for this function:

checkArg()

void MathDAG::OperationDAGBase::checkArg	(	unsigned	i,
		unsigned	j
	)		const

Definition at line 227 of file equations.cc.

  {
    if (arguments.size()<=i || arguments[i].size()<=j || !arguments[i][j])
      throw NoArgument(state, i, j);
  }

create()

OperationDAGBase * MathDAG::OperationDAGBase::create ( Type  type, const string &  name = ""  )

static

factory method

Definition at line 176 of file equations.cc.

References MathDAG::anonymous_namespace{equations.cc}::operationDAGFactory.

Referenced by MathDAG::SystemOfEquations::makeDAG(), and MathDAG::Expr::newNode().

  {
    auto r=operationDAGFactory.create(type);
    r->name=name;
    return r;
  }

Here is the caller graph for this function:

order()

int MathDAG::OperationDAGBase::order ( unsigned  maxOrder ) const

overridevirtual

returns evaluation order in sequence of variable defintions

Parameters

maxOrder

is used to limit the recursion depth

Implements MathDAG::Node.

Reimplemented in MathDAG::GodleyColumnDAG.

Definition at line 185 of file equations.cc.

  {
    if (type()==integrate)
      return 0; //integrals have already been evaluated
    if (cachedOrder>=0) return cachedOrder;

    if (maxOrder==0)
      throw error("maximum order recursion reached");

    
    // constants have order one, as they must be ordered after the
    // "fake" variables have been initialised
    int order=type()==constant? 1: 0;
    for (size_t i=0; i<arguments.size(); ++i)
      for (size_t j=0; j<arguments[i].size(); ++j)
        {
          checkArg(i,j);
          order=std::max(order, arguments[i][j]->order(maxOrder-1));
        }
    return cachedOrder=order;
  }

tensorEval() [1/3]

bool MathDAG::OperationDAGBase::tensorEval ( std::set< const Node *> &  visited ) const

overridevirtual

returns true if the evaluation of this involves tensor processing

Parameters

visited

set to break graph cycles

Implements MathDAG::Node.

Definition at line 207 of file equations.cc.

References minsky::OperationType::classify().

  {
    if (!visited.insert(this).second)
      return false; // cycle detected, break
    switch (OperationType::classify(type()))
      {
      case reduction: case scan: case tensor: case statistics:
        return true;
      case general: case binop: case constop: case function:
        for (auto& i: arguments)
          for (auto j: i)
            if (j && j->tensorEval(visited)) return true;
        return false;
      default:
        assert(false);// above cases should exhaust
        return false;
      }
  }

Here is the call graph for this function:

tensorEval() [2/3]

bool MathDAG::Node::tensorEval

inline

returns true if the evaluation of this involves tensor processing

Definition at line 116 of file equations.h.

{std::set<const Node*> visited; return tensorEval(visited);}

tensorEval() [3/3]

virtual bool MathDAG::Node::tensorEval

returns true if the evaluation of this involves tensor processing

Parameters

visited

set to break graph cycles

type()

virtual Type MathDAG::OperationDAGBase::type ( ) const

pure virtual

Implemented in MathDAG::OperationDAG< T >, and MathDAG::OperationDAG< OperationType::subtract >.

Member Data Documentation

arguments

vector<vector<WeakNodePtr> > MathDAG::OperationDAGBase::arguments

Definition at line 219 of file equations.h.

Referenced by MathDAG::SystemOfEquations::derivative(), MathDAG::OperationDAG< OperationType::subtract >::latex(), MathDAG::SystemOfEquations::processGodleyTable(), and MathDAG::OperationDAG< OperationType::subtract >::render().

init

string MathDAG::OperationDAGBase::init ="0"

Definition at line 221 of file equations.h.

name

string MathDAG::OperationDAGBase::name

Definition at line 220 of file equations.h.

state

ItemPtr MathDAG::OperationDAGBase::state

Definition at line 222 of file equations.h.

Referenced by MathDAG::anonymous_namespace{equations.cc}::addTensorOp().

---

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

• engine/equations.h
• engine/equations.cc