minsky::VariableValues Class Reference

#include <variableValues.h>

Inheritance diagram for minsky::VariableValues:

Collaboration diagram for minsky::VariableValues:

Public Member Functions
	VariableValues ()
void	clear ()
std::string	newName (const std::string &name) const
	generate a new valueId not otherwise in the system More...
void	reset ()
	reset all variableValues to their initial conditions More...
void	resetValue (VariableValue &) const
	reset a give variable value to it's initial condition, in this context More...
TensorVal	initValue (const VariableValue &, std::set< std::string > &visited) const
	evaluates the initial value of a given variableValue in the context given by this. visited is used to check for circular definitions More...
TensorVal	initValue (const VariableValue &v) const
std::vector< Summary >	summarise () const
bool	validEntries () const
	checks that all entry names are valid More...
void	resetUnitsCache ()
Public Member Functions inherited from minsky::ConstMap< std::string, VariableValuePtr >
	ConstMap ()
	ConstMap (const T &x)
	ConstMap (const T &x, const U &y)
VariableValuePtr	operator[] (const std::string &k) const

Private Member Functions
	CLASSDESC_ACCESS (VariableValues)

Static Private Member Functions
static VariableValuePtr &	zero ()
static VariableValuePtr &	one ()

Detailed Description

Definition at line 40 of file variableValues.h.

Constructor & Destructor Documentation

VariableValues()

minsky::VariableValues::VariableValues ( )

inline

Definition at line 46 of file variableValues.h.

References clear().

{clear();}

Here is the call graph for this function:

Member Function Documentation

CLASSDESC_ACCESS()

minsky::VariableValues::CLASSDESC_ACCESS ( VariableValues  )

private

clear()

void minsky::VariableValues::clear ( )

inline

Definition at line 47 of file variableValues.h.

References one(), and zero().

Referenced by VariableValues().

                 {
      ConstMap<std::string, mapped_type>::clear();
      // add special values for zero and one, used for the derivative
      // operator in SystemOfEquations
      emplace("constant:zero", zero());
      emplace("constant:one", one());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

initValue() [1/2]

TensorVal minsky::VariableValues::initValue	(	const VariableValue &	v,
		std::set< std::string > &	visited
	)		const

evaluates the initial value of a given variableValue in the context given by this. visited is used to check for circular definitions

Definition at line 252 of file variableValue.cc.

References minsky::FlowCoef::coef, minsky::VariableValue::init(), minsky::VariableValueData::m_scope, minsky::VariableValueData::name, minsky::VariableValueData::tensorInit, minsky::trimWS(), and minsky::valueId().

Referenced by minsky::VariableValue::init(), initValue(), MathDAG::latexInit(), and MathDAG::matlabInit().

  {
    if (v.tensorInit.rank()>0)
      return v.tensorInit;
    
    const FlowCoef fc(v.init());
    if (trimWS(fc.name).empty())
      return fc.coef;

    // special generator functions handled here
    auto p=fc.name.find('(');
    if (p!=string::npos)
      {
        //        const string fn=fc.name.substr(0,p);
        // unpack args
        const char* x=fc.name.c_str()+p+1;
        char* e;
        vector<unsigned> dims;
        for (;;)
          {
            auto tmp=strtol(x,&e,10);
            if (tmp>0 && e>x && *e)
              {
                x=e+1;
                dims.push_back(tmp);
              }
            else
              break;
          }
        TensorVal r(dims);
        r.allocVal();

        if (fc.name.starts_with("iota"))
          for (size_t i=0; i<r.size(); ++i)
            r[i]=i;
        else if (fc.name.starts_with("one"))
          for (size_t i=0; i<r.size(); ++i)
            r[i]=1;
        else if (fc.name.starts_with("zero") || fc.name.starts_with("eye"))
          {
            for (size_t i=0; i<r.size(); ++i)
              r[i]=0;
            if (fc.name.starts_with("eye"))
              {
                // diagonal elements set to 1
                // find minimum dimension, and stride of diagonal elements
                size_t mind=r.size(), stride=1;
                for (auto i: dims)
                  mind=min(mind, size_t(i));
                for (size_t i=0; i<dims.size()-1; ++i)
                  stride*=(dims[i]+1);
                for (size_t i=0; i<mind; ++i)
                  r[stride*i]=1;
              }
          }
        else if (fc.name.starts_with("rand"))
          {
            for (size_t i=0; i<r.size(); ++i)
              r[i]=double(rand())/RAND_MAX; // NOLINT
          }
        return r;
      }
        
    // resolve name
    auto valueId=minsky::valueId(v.m_scope.lock(), fc.name);
    if (visited.contains(valueId))
      throw error("circular definition of initial value for %s",
                  fc.name.c_str());
    const VariableValues::const_iterator vv=find(valueId);
    if (vv==end())
      throw error("Unknown variable %s in initialisation of %s",fc.name.c_str(), v.name.c_str());

    visited.insert(valueId);
    return fc.coef*initValue(*vv->second, visited);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

initValue() [2/2]

TensorVal minsky::VariableValues::initValue ( const VariableValue &  v ) const

inline

Definition at line 65 of file variableValues.h.

References initValue().

                                                      {
      std::set<std::string> visited;
      return initValue(v, visited);
    }

Here is the call graph for this function:

newName()

string minsky::VariableValues::newName

(

const std::string &

name

)

const

generate a new valueId not otherwise in the system

Definition at line 355 of file variableValue.cc.

References minsky::valueId().

Referenced by minsky::IntOp::description().

  {
    int i=1;
    string trialName;
    do
      trialName=utf_to_utf<char>(name)+to_string(i++);
    while (count(valueId(trialName)));
    return trialName;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

one()

VariableValuePtr & minsky::VariableValues::one ( )

staticprivate

Definition at line 84 of file variableValue.cc.

Referenced by clear().

                                        {
    static VariableValuePtr s_one(make_shared<SpecialConst>("constant:one","1"));
    return s_one;
  }

Here is the caller graph for this function:

reset()

void minsky::VariableValues::reset

(

)

reset all variableValues to their initial conditions

Definition at line 365 of file variableValue.cc.

References minsky::VariableValue::allocValue(), minsky::VariableValue::idxInRange(), and minsky::VariableValue::reset_idx().

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

  {
    // reallocate all variables
    ValueVector::stockVars.clear();
    ValueVector::flowVars.clear();
    for (auto& v: *this) {
      v.second->reset_idx();  // Set idx of all flowvars and stockvars to -1 on reset. For ticket 1049          
      resetValue(v.second->allocValue());
      assert(v.second->idxInRange());
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

resetUnitsCache()

void minsky::VariableValues::resetUnitsCache ( )

inline

Definition at line 79 of file variableValues.h.

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

                           {
      for (auto& i: *this)
        i.second->unitsCached=false;
    }

Here is the caller graph for this function:

resetValue()

void minsky::VariableValues::resetValue

(

VariableValue &

v

)

const

reset a give variable value to it's initial condition, in this context

Definition at line 328 of file variableValue.cc.

References minsky::VariableValue::allocValue(), minsky::cminsky(), minsky::Minsky::definingVar(), minsky::Minsky::dimensions, minsky::VariableValue::idx(), minsky::VariableValue::idxInRange(), minsky::VariableValue::isFlowVar(), minsky::VariableValueData::tensorInit, and minsky::VariableValue::valueId().

Referenced by MathDAG::ConstantDAG::addEvalOps(), and minsky::VariableBase::init().

  {
    if (v.idx()<0) v.allocValue();
    // initialise variable only if its variable is not defined or it is a stock
    if (!v.isFlowVar() || !cminsky().definingVar(v.valueId()))
      {
        if (v.tensorInit.rank())
          {
            // ensure dimensions are correct
            auto hc=v.tensorInit.hypercube();
            for (auto& xv: hc.xvectors)
              {
                auto dim=cminsky().dimensions.find(xv.name);
                if (dim!=cminsky().dimensions.end())
                  xv.dimension=dim->second;
              }
            v.tensorInit.hypercube(hc);
          }
        if (v.tensorInit.rank())
          v=v.tensorInit;
        else
          v=initValue(v);
      }
    assert(v.idxInRange());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

summarise()

std::vector<Summary> minsky::VariableValues::summarise ( ) const

inline

Definition at line 70 of file variableValues.h.

                                         {
      std::vector<Summary> summary;
      for (auto& v: *this)
        summary.emplace_back(v.second->summary());
      return summary;
    }

validEntries()

bool minsky::VariableValues::validEntries

(

)

const

checks that all entry names are valid

Definition at line 377 of file variableValue.cc.

References minsky::isValueId().

  {
    return all_of(begin(), end(), [](const value_type& v){return isValueId(v.first);});
  }

Here is the call graph for this function:

zero()

VariableValuePtr & minsky::VariableValues::zero ( )

staticprivate

Definition at line 80 of file variableValue.cc.

Referenced by clear().

                                         {
    static VariableValuePtr s_zero(make_shared<SpecialConst>("constant:zero","0"));
    return s_zero;
  }

Here is the caller graph for this function:

---

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

• engine/variableValues.h
• engine/variableValue.cc