A helper to evaluate a variable value. More...

#include <minskyTensorOps.h>

Inheritance diagram for minsky::TensorEval:

Collaboration diagram for minsky::TensorEval:

Public Member Functions
Type	type () const override

	TensorEval (const std::shared_ptr< VariableValue > &v, const shared_ptr< EvalCommon > &ev, const TensorPtr &rhs)

	TensorEval (const std::shared_ptr< VariableValue > &dest, const std::shared_ptr< VariableValue > &src)

void	eval (double fv, std::size_t, const double sv) override

void	deriv (double df, std::size_t, const double ds, const double sv, const double fv) override

Private Attributes
TensorVarVal	result

TensorPtr	rhs

Detailed Description

A helper to evaluate a variable value.

Definition at line 157 of file minskyTensorOps.h.

Constructor & Destructor Documentation

◆ TensorEval() [1/2]

minsky::TensorEval::TensorEval	(	const std::shared_ptr< VariableValue > &	v,
		const shared_ptr< EvalCommon > &	ev,
		const TensorPtr &	rhs
	)

inline

Definition at line 166 of file minskyTensorOps.h.

References minsky::TensorVarVal::hypercube(), minsky::TensorVarValBase< VV, I >::idx(), minsky::TensorVarVal::index(), and minsky::TensorVarValBase< VV, I >::size().

                                     : result(v, ev), rhs(rhs) {
       result.index(rhs->index());
       assert(!rhs->index().empty() || rhs->hypercube().numElements()==rhs->size());
       result.hypercube(rhs->hypercube());
       assert(result.idx()>=0);
       assert(result.size()==rhs->size());
     } 

Here is the call graph for this function:

◆ TensorEval() [2/2]

minsky::TensorEval::TensorEval	(	const std::shared_ptr< VariableValue > &	dest,
		const std::shared_ptr< VariableValue > &	src
	)

Definition at line 1651 of file minskyTensorOps.cc.

References minsky::OperationType::copy, minsky::TensorOpFactory::create(), minsky::TensorVarValBase< VV, I >::ev, minsky::TensorVarVal::hypercube(), minsky::TensorVarVal::index(), result, rhs, civita::ITensor::setArgument(), minsky::TensorVarValBase< VV, I >::size(), and minsky::tensorOpFactory.

                                                                                                    :
     result(dest,make_shared<EvalCommon>())
   {
     result.index(src->index());
     result.hypercube(src->hypercube());
     const OperationPtr tmp(OperationType::copy);
     auto copy=dynamic_pointer_cast<ITensor>(tensorOpFactory.create(tmp));
     copy->setArgument(make_shared<ConstTensorVarVal>(src,result.ev));
     rhs=std::move(copy);
     assert(result.size()==rhs->size());
   }   

Here is the call graph for this function:

Member Function Documentation

◆ deriv()

void minsky::TensorEval::deriv	(	double *	df,
		std::size_t	,
		const double *	ds,
		const double *	sv,
		const double *	fv
	)

override

Definition at line 1689 of file minskyTensorOps.cc.

References minsky::TensorVarValBase< VV, I >::ev, minsky::ValueVector::flowVars, minsky::TensorVarValBase< VV, I >::idx(), result, rhs, minsky::TensorVarValBase< VV, I >::size(), and minsky::ValueVector::stockVars.

   {
     if (result.idx()<0) return;
     if (rhs)
       {
         result.ev->update(const_cast<double*>(fv), n, sv);
         if (auto deriv=dynamic_cast<DerivativeMixin*>(rhs.get()))
           {
             assert(result.idx()+rhs->size()<=n);
             for (size_t i=0; i<rhs->size(); ++i)
               {
                 df[result.idx()+i]=0;
                 for (int j=0; j<result.idx(); ++j)
                   df[result.idx()+i] += df[j]*deriv->dFlow(i,j);
                 // skip self variables
                 for (size_t j=result.idx()+result.size(); j<ValueVector::flowVars.size(); ++j)
                   df[result.idx()+i] += df[j]*deriv->dFlow(i,j);
                 for (size_t j=0; j<ValueVector::stockVars.size(); ++j)
                   df[result.idx()+i] += ds[j]*deriv->dStock(i,j);
               }
           }
       }
   }

Here is the call graph for this function:

◆ eval()

void minsky::TensorEval::eval	(	double *	fv,
		std::size_t	,
		const double *	sv
	)

override

Definition at line 1663 of file minskyTensorOps.cc.

References minsky::TensorVarValBase< VV, I >::ev, minsky::ValueVector::flowVars, minsky::TensorVarVal::hypercube(), minsky::TensorVarValBase< VV, I >::idx(), minsky::TensorVarVal::index(), minsky::anonymous_namespace{userFunction.cc}::isfinite(), result, rhs, and minsky::TensorVarValBase< VV, I >::size().

   {
     if (rhs)
       {
         assert(result.idx()>=0);
         const bool fvIsGlobalFlowVars=fv==ValueVector::flowVars.data();
         result.index(rhs->index());
         result.hypercube(rhs->hypercube());
         if (fvIsGlobalFlowVars) // hypercube operation may have resized flowVars, invalidating fv
           {
             fv=ValueVector::flowVars.data();
             n=ValueVector::flowVars.size();
           }
         else if (n!=ValueVector::flowVars.size())
           throw FlowVarsResized();
         result.ev->update(fv, n, sv);
         assert(result.size()==rhs->size());
         for (size_t i=0; i<rhs->size(); ++i)
           {
             auto v=(*rhs)[i];
             result[i]=v;
             assert(!isfinite(result[i]) || fv[result.idx()+i]==v);
           }
       }
   }