minsky::ScalarEvalOp Struct Reference

Legacy EvalOp base interface. More...

#include <evalOp.h>

Inheritance diagram for minsky::ScalarEvalOp:

Collaboration diagram for minsky::ScalarEvalOp:

Public Member Functions
virtual int	numArgs () const =0
void	deriv (double df[], std::size_t n, const double ds[], const double sv[], const double fv[]) override
void	eval (double fv[], std::size_t, const double sv[]) override
	evaluate expression on sv and current value of fv, storing result in output variable (of fv) More...
virtual double	evaluate (double in1=0, double in2=0) const =0
	evaluate expression on given arguments, returning result More...
virtual double	d1 (double x1=0, double x2=0) const =0
virtual double	d2 (double x1=0, double x2=0) const =0
Public Member Functions inherited from minsky::EvalOpBase
void	throw_error (const std::string &msg) const
virtual	~EvalOpBase ()
virtual void	setTensorParams (const VariableValue &, const OperationBase &)
	set additional tensor operation related parameters More...

Static Public Member Functions
static ScalarEvalOp *	create (Type op, const ItemPtr &state)
	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
std::shared_ptr< VariableValue >	result
	lifetime management of the resultant variableValue number of arguments to this operation More...
Public Attributes inherited from minsky::EvalOpBase
int	out =-1
	indexes into the flow/stock variables vector More...
std::vector< unsigned >	in1
std::vector< std::vector< Support > >	in2
bool	flow1 =true
	indicate whether in1/in2 are flow variables (out is always a flow variable) More...
bool	flow2 =true
bool	xflow =true
std::shared_ptr< OperationBase >	state
	state data (for those ops that need it) More...

Additional Inherited Members
Public Types inherited from minsky::EvalOpBase
typedef OperationType::Type	Type
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 }
Static Public Attributes inherited from minsky::EvalOpBase
static double	t
static std::string	timeUnit

Detailed Description

Legacy EvalOp base interface.

Definition at line 111 of file evalOp.h.

Member Function Documentation

create()

ScalarEvalOp * minsky::ScalarEvalOp::create ( Type  op, const ItemPtr &  state  )

static

factory method

Definition at line 617 of file evalOp.cc.

References minsky::anonymous_namespace{evalOp.cc}::evalOpFactory, f, and minsky::op.

  {
    switch (classify(op))
      {
      case general:
      case binop:
      case constop:
      case function:
        switch (op)
          {
          case constant:
            return new ConstantEvalOp;
          case numOps:
            return nullptr;
          case userFunction:
            if (auto f=dynamic_cast<UserFunction*>(state.get()))
              f->compile();
            [[fallthrough]];
          default:
            auto r=evalOpFactory.create(op);
            r->state=dynamic_pointer_cast<OperationBase>(state);
            return r;
          }
      case reduction:
      case scan:
      case tensor:
      case statistics:
        return nullptr; //TODO should we be here?
      }
    assert(false); //shouldn't be here
    return nullptr;
  }

d1()

virtual double minsky::ScalarEvalOp::d1 ( double  x1 = 0, double  x2 = 0  ) const

pure virtual

derivatives with respect to 1st and second argument

d2()

virtual double minsky::ScalarEvalOp::d2 ( double  x1 = 0, double  x2 = 0  ) const

pure virtual

derivatives with respect to 1st and second argument

deriv()

void minsky::ScalarEvalOp::deriv ( double  df[], std::size_t  n, const double  ds[], const double  sv[], const double  fv[]  )

overridevirtual

total derivate with respect to a variable, which is a function of the stock variables.

Parameters

sv	- stock variables
fv	- flow variables (function of stock variables, computed by eval)
ds	- derivative of stock variables
df	- derivative of flow variables (updated by this function)
n	- size of df array

To compute the partial derivatives with respect to stock variable i, seed ds with 1 in the ith position, 0 every else, and initialise df to zero.

Implements minsky::EvalOpBase.

Definition at line 93 of file evalOp.cc.

References minsky::anonymous_namespace{wire.cc}::d2(), and minsky::anonymous_namespace{userFunction.cc}::isfinite().

  {
    assert(out>=0 && size_t(out)<n);
    switch (numArgs())
      {
      case 0:
        df[out]=0;
        return;
      case 1:
        {
          assert((flow1 && in1[0]<ValueVector::flowVars.size()) || 
                 (!flow1 && in1[0]<ValueVector::stockVars.size()));
          const double x1=flow1? fv[in1[0]]: sv[in1[0]];
          const double dx1=flow1? df[in1[0]]: ds[in1[0]];
          df[out] = dx1!=0? dx1 * d1(x1,0): 0;
          break;
        }
      case 2:
        {
          assert((flow1 && in1[0]<ValueVector::flowVars.size()) || 
                 (!flow1 && in1[0]<ValueVector::stockVars.size()));
          assert((flow2 && in2[0][0].idx<ValueVector::flowVars.size()) || 
                 (!flow2 && in2[0][0].idx<ValueVector::stockVars.size()));
          const double x1=flow1? fv[in1[0]]: sv[in1[0]];
          const double x2=flow2? fv[in2[0][0].idx]: sv[in2[0][0].idx];
          const double dx1=flow1? df[in1[0]]: ds[in1[0]];
          const double dx2=flow2? df[in2[0][0].idx]: ds[in2[0][0].idx];
          df[out] = (dx1!=0? dx1 * d1(x1,x2): 0) +
            (dx2!=0? dx2 * d2(x1,x2): 0);
          break;
        }
      }
    if (!std::isfinite(df[out]))
      throw error("Invalid operation detected on a %s operation",
                  OperationBase::typeName(type()).c_str());
  }

Here is the call graph for this function:

eval()

void minsky::ScalarEvalOp::eval ( double  fv[], std::size_t  n, const double  sv[]  )

overridevirtual

evaluate expression on sv and current value of fv, storing result in output variable (of fv)

Parameters

n	- size of fv array

Implements minsky::EvalOpBase.

Definition at line 40 of file evalOp.cc.

  {
    assert(out>=0);
    switch (numArgs())
      {
      case 0:
        assert(size_t(out)<n);
        fv[out]=evaluate(0,0);
        break;
      case 1:
        assert(out+in1.size()<=n);
        for (unsigned i=0; i<in1.size(); ++i)
          fv[out+i]=evaluate(flow1? fv[in1[i]]: sv[in1[i]], 0);
        break;
      case 2:
        assert(out+in1.size()<=n);
        for (unsigned i=0; i<in1.size(); ++i)
          {
            double x2=0;
            const double* v=flow2? fv: sv;
            for (auto& j: in2[i])
              x2+=j.weight*v[j.idx];
            fv[out+i]=evaluate(flow1? fv[in1[i]]: sv[in1[i]], x2);
          }
        break;
      }

    // This check may well be obsolete. ecolab::Plot will now elide
    // non-finite data, and it appears that the RK solver can
    // integrate through infinities. Leaving the code here for now,
    // just in case we decide to enable it via a user preference.
//    // check for NaNs only on scalars. For tensors, NaNs just means
//    // element not present
//    if (in1.size()==1)
//      for (unsigned i=0; i<in1.size(); ++i)
//        if (!std::isfinite(fv[out+i]))
//          {
//            if (state)
//              cminsky().displayErrorItem(*state);
//            string msg="Invalid: ";
//            if (auto uf=dynamic_cast<UserFunction*>(state.get()))
//              msg+=uf->description()+"(";
//            else
//              msg+=OperationBase::typeName(type())+"(";
//            if (numArgs()>0)
//              msg+=std::to_string(flow1? fv[in1[i]]: sv[in1[i]]);
//            if (numArgs()>1)
//              msg+=","+std::to_string(flow2? fv[in2[i][0].idx]: sv[in2[i][0].idx]);
//            msg+=")";
//            throw runtime_error(msg.c_str());
//          }
  };

evaluate()

virtual double minsky::ScalarEvalOp::evaluate ( double  in1 = 0, double  in2 = 0  ) const

pure virtual

evaluate expression on given arguments, returning result

numArgs()

virtual int minsky::ScalarEvalOp::numArgs ( ) const

pure virtual

Member Data Documentation

result

std::shared_ptr<VariableValue> minsky::ScalarEvalOp::result

lifetime management of the resultant variableValue number of arguments to this operation

Definition at line 113 of file evalOp.h.

---

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

• engine/evalOp.h
• engine/evalOp.cc