minsky::VariableValue Class Reference

#include <variableValue.h>

Inheritance diagram for minsky::VariableValue:

Collaboration diagram for minsky::VariableValue:

Public Member Functions
bool	lhs () const
	variable has an input port More...
bool	temp () const
	variable is a temporary More...
bool	isFlowVar () const
	returns true if variable's data is allocated on the flowVariables vector More...
bool	isZero () const
VariableType::Type	type () const
	value at the ith location of the vector/tensor. Default, (i=0) is right for scalar quantities More...
double	valueAt (size_t i) const
double	value () const
	set the value at the ith location More...
double	setValue (size_t i, double x)
double	setValue (double x)
int	idx () const
void	reset_idx ()
double	operator[] (std::size_t i) const override
double &	operator[] (std::size_t i) override
const Index &	index (Index &&i) override
template<class T >
void	hypercube_ (T x)
bool	idxInRange () const
const Hypercube &	hypercube () const override
const Hypercube &	hypercube (const Hypercube &hc) override
const Hypercube &	hypercube (Hypercube &&hc) override
	VariableValue (VariableType::Type type=VariableType::undefined, const std::string &name="", const GroupPtr &group=GroupPtr())
	VariableValue (VariableType::Type type, const VariableValue &vv)
	VariableValue (const VariableValue &)=delete
void	operator= (const VariableValue &)=delete
VariableValue &	operator= (TensorVal const &)
VariableValue &	operator= (const ITensor &x) override
VariableValue &	allocValue ()
	allocate space in the variable vector. More...
std::string	valueId () const
void	exportAsCSV (const std::string &filename, const std::string &comment="", bool tabular=false) const
	export this to a CSV file. If comment is non-empty, it is written as the first line of the file. If tabular is false, there is one data point per line, if true, the the longest dimension is written as a series on the line. More...
Summary	summary () const
const std::string &	init () const
const std::string &	init (const std::string &x)
void	sliderSet (double x)
	sets variable value (or init value) More...
void	incrSlider (double step)
	increment slider by step More...
void	adjustSliderBounds ()
	adjust slider bounds to encompass the current value More...
Public Member Functions inherited from minsky::VariableValueData
void	setUnits (const std::string &x)
Public Member Functions inherited from minsky::Slider
double	maxSliderSteps () const
	ensure there are at most 10000 steps between sliderMin and Max. see ticket 1255. More...

Protected Attributes
std::string	m_init
	the initial value of this variable More...

Private Member Functions
	CLASSDESC_ACCESS (VariableValue)
double &	valRef ()
	index into value vector More...
const double &	valRef () const
ITensor::Timestamp	timestamp () const override

Private Attributes
Type	m_type
int	m_idx =-1

Friends
class	VariableManager
struct	SchemaHelper

Additional Inherited Members
Public Types inherited from minsky::VariableType
enum	Type {   undefined, constant, parameter, flow,   integral, stock, tempFlow, numVarTypes }
Static Public Member Functions inherited from minsky::VariableType
static std::string	typeName (int t)
Public Attributes inherited from minsky::VariableValueData
TensorVal	tensorInit
	when init is a tensor of values, this overrides the init string More...
TensorPtr	rhs
	when the RHS is attached to a tensor expression, this is a reference to it More...
Units	units
	dimension units of this value More...
bool	unitsCached =false
std::string	detailedText
	long and short descriptions - common to all variables of a given name More...
std::string	tooltip
bool	godleyOverridden =false
std::string	name
classdesc::Exclude< std::weak_ptr< Group > >	m_scope
CSVDialog	csvDialog
	for importing CSV files More...
Public Attributes inherited from minsky::Slider
bool	sliderStepRel =false
double	sliderMin =std::numeric_limits<double>::max()
double	sliderMax =-sliderMin
double	sliderStep =0
bool	enableSlider =true

Detailed Description

Definition at line 70 of file variableValue.h.

Constructor & Destructor Documentation

VariableValue() [1/3]

minsky::VariableValue::VariableValue ( VariableType::Type  type = VariableType::undefined, const std::string &  name = "", const GroupPtr &  group = GroupPtr()  )

inline

Definition at line 156 of file variableValue.h.

References minsky::group, and minsky::scope().

                                                                                                                          : 
      m_type(type)
    {
      this->name=utf_to_utf<char>(name);
      m_scope=scope(group,name);
    }

Here is the call graph for this function:

VariableValue() [2/3]

minsky::VariableValue::VariableValue ( VariableType::Type  type, const VariableValue &  vv  )

inline

Definition at line 163 of file variableValue.h.

References init().

                                                                 :  VariableValueData(vv) {
      m_type=type;
      init(vv.init());
    }

Here is the call graph for this function:

VariableValue() [3/3]

minsky::VariableValue::VariableValue ( const VariableValue &  )

delete

Member Function Documentation

adjustSliderBounds()

void minsky::VariableValue::adjustSliderBounds

(

)

adjust slider bounds to encompass the current value

Definition at line 237 of file variableValue.cc.

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

  {
    if (size()==1 && !isnan(value()))
      {
        if (!isfinite(sliderMax) ||sliderMax<value())
          sliderMax=value()? abs(10*value()):1;
        if (!isfinite(sliderMin) || sliderMin>=value())
          sliderMin=value()? -abs(10*value()):-1;
        assert(sliderMin<sliderMax);
        sliderStep=maxSliderSteps(); 
      }
  }

Here is the call graph for this function:

allocValue()

VariableValue & minsky::VariableValue::allocValue

(

)

allocate space in the variable vector.

Returns

reference to this

Definition at line 121 of file variableValue.cc.

Referenced by minsky::VariableValues::reset(), and minsky::VariableValues::resetValue().

  {    
    switch (m_type)
      {
      case undefined:
        m_idx=-1;
        break;
      case flow:
      case tempFlow:
      case constant:
      case parameter:
        m_idx=ValueVector::flowVars.size();
        assert(size());
        // return a more meaningful error message to the user than what STL does
        if (ValueVector::flowVars.max_size()-ValueVector::flowVars.size()<size())
          throw runtime_error("Maximum processing data exceeded.");
        ValueVector::flowVars.resize(ValueVector::flowVars.size()+size());
        break;
      case stock:
      case integral:
        m_idx=ValueVector::stockVars.size();
        assert(size());
        // return a more meaningful error message to the user than what STL does
        if (ValueVector::stockVars.max_size()-ValueVector::stockVars.size()<size())
          throw runtime_error("Maximum processing data exceeded.");
        ValueVector::stockVars.resize(ValueVector::stockVars.size()+size());
        break;
      default: break;
      }
    return *this;
  }

Here is the caller graph for this function:

CLASSDESC_ACCESS()

minsky::VariableValue::CLASSDESC_ACCESS ( VariableValue  )

private

exportAsCSV()

void minsky::VariableValue::exportAsCSV	(	const std::string &	filename,
		const std::string &	comment = "",
		bool	tabular = false
	)		const

export this to a CSV file. If comment is non-empty, it is written as the first line of the file. If tabular is false, there is one data point per line, if true, the the longest dimension is written as a series on the line.

Definition at line 417 of file variableValue.cc.

References minsky::CSVQuote(), minsky::anonymous_namespace{userFunction.cc}::isfinite(), and minsky::str().

Referenced by minsky::Sheet::exportAsCSV(), and minsky::Ravel::exportAsCSV().

  {
    ofstream of(filename);
    if (!of)
      throw runtime_error("Unable to open "+filename+" for writing.");
    if (!comment.empty())
      of<<R"(""")"<<comment<<R"(""")"<<endl;
               
    // calculate longest dimension
    auto dims=hypercube().dims();
    auto longestDim=max_element(dims.begin(),dims.end())-dims.begin();

    const auto& xv=hypercube().xvectors;
    
    ostringstream os;
    for (const auto& i: xv)
      {
        if (&i>xv.data()) os<<",";
        os<<json(static_cast<const NamedDimension&>(i));
      }
    of<<quoted("RavelHypercube=["+os.str()+"]")<<endl;
    if (tabular && rank()>0)
      of<<"HorizontalDimension="<<quoted(xv[longestDim].name)<<endl;
    
    for (size_t i=0; i<xv.size(); ++i)
      if (!tabular || i!=longestDim)
        of<<CSVQuote(xv[i].name,',')<<",";

    if (tabular && rank()>0)
      for (size_t k=0; k<dims[longestDim]; ++k)
        {
          if (k>0) of<<",";
          of<<CSVQuote(str(xv[longestDim][k],xv[longestDim].dimension.units),',');
        }
    else
      of<<"value$";
    of<<"\n";

    auto idxv=index();

    if (tabular && rank()>0)
      {
        size_t stride=1;
        for (size_t i=0; i<longestDim; ++i)
          stride*=dims[i];
        for (size_t i=0; i<hypercube().numElements(); i+=stride*dims[longestDim])
          for (size_t j=0; j<stride; ++j)
            {
              // collect elements in a buffer, which can be discarded if no data on line
              bool isData=false;
              vector<double> data;
              data.reserve(dims[longestDim]);
              for (size_t k=0; k<stride*dims[longestDim]; k+=stride)
                {
                  data.push_back(this->atHCIndex(i+j+k));
                  if (isfinite(data.back())) isData=true;
                }
              if (isData)
                {
                  auto idx=i+j;
                  for (size_t k=0; k<rank(); ++k)
                    {
                      auto div=std::div(idx, ssize_t(dims[k]));
                      if (k!=longestDim)
                        {
                          if (k>1 || (k>0 && longestDim>0)) of<<",";
                          of << "\""<<str(xv[k][div.rem], xv[k].dimension.units) << "\"";
                        }
                      idx=div.quot;
                    }
                  for (auto d: data)
                    {
                      of<<",";
                      if (isfinite(d)) of<<d;
                    }
                  of<<"\n";
                }
            }
      }
    else
      {
        size_t i=0;
        for (auto d=begin(); d!=end(); ++i, ++d)
          if (isfinite(*d))
            {
              ssize_t idx=idxv.empty()? i: idxv[i];
              for (size_t j=0; j<rank(); ++j)
                {
                  auto div=std::div(idx, ssize_t(dims[j]));
                  of << "\""<<str(xv[j][div.rem], xv[j].dimension.units) << "\",";
                  idx=div.quot;
                }
              of << *d << "\n";
            }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

hypercube() [1/3]

const Hypercube & minsky::VariableValue::hypercube ( ) const

override

Definition at line 213 of file variableValue.cc.

References minsky::cminsky(), minsky::Minsky::definingVar(), and minsky::valueId().

Referenced by minsky::Ravel::exportAsCSV(), minsky::loadValueFromCSVFileT(), and minsky::Minsky::populateMissingDimensionsFromVariable().

  {
    if (rhs) return rhs->hypercube();
    // return the initialisation hypercube if not a defined flowVar
    if (tensorInit.rank()>0 && (!isFlowVar() || m_type==parameter || !cminsky().definingVar(valueId())))
      return tensorInit.hypercube();
    return m_hypercube;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

hypercube() [2/3]

const Hypercube& minsky::VariableValue::hypercube ( const Hypercube &  hc )

inlineoverride

Definition at line 150 of file variableValue.h.

    {hypercube_(hc); return m_hypercube;}

hypercube() [3/3]

const Hypercube& minsky::VariableValue::hypercube ( Hypercube &&  hc )

inlineoverride

Definition at line 152 of file variableValue.h.

    {hypercube_(hc); return m_hypercube;}

hypercube_()

template<class T >

void minsky::VariableValue::hypercube_ ( T  x )

inline

Definition at line 138 of file variableValue.h.

                         {    
      assert(idx()==-1||idxInRange());
      std::size_t prevNumElems = size();
      ITensor::hypercube(x);    
      if (idx()==-1 || (prevNumElems<size()))    
        allocValue();
      assert(idxInRange());
    }

idx()

int minsky::VariableValue::idx ( ) const

inline

Definition at line 121 of file variableValue.h.

Referenced by minsky::EvalOpPtr::EvalOpPtr(), and minsky::VariableValues::resetValue().

{return m_idx;}

Here is the caller graph for this function:

idxInRange()

bool minsky::VariableValue::idxInRange

(

)

const

Definition at line 89 of file variableValue.cc.

Referenced by minsky::VariableValues::reset(), and minsky::VariableValues::resetValue().

  {return m_type==undefined || idx()+size()<=
      (isFlowVar()?ValueVector::flowVars.size(): ValueVector::stockVars.size());}

Here is the caller graph for this function:

incrSlider()

void minsky::VariableValue::incrSlider

(

double

step

)

increment slider by step

Definition at line 232 of file variableValue.cc.

  {
    sliderSet(value()+step*(sliderStepRel? value(): 1)*sliderStep);
  }

index()

const Index& minsky::VariableValue::index ( Index &&  i )

inlineoverride

Definition at line 127 of file variableValue.h.

Referenced by minsky::loadValueFromCSVFileT().

                                           {
      std::size_t prevNumElems = size();
      m_index=i;
      if (idx()==-1 || !idxInRange() || (prevNumElems<size()))    
        allocValue();
      assert(idxInRange());
      return m_index;
    }

Here is the caller graph for this function:

init() [1/2]

const std::string& minsky::VariableValue::init ( ) const

inline

Definition at line 185 of file variableValue.h.

Referenced by minsky::VariableBase::init(), minsky::VariableValues::initValue(), MathDAG::latexInit(), MathDAG::matlabInit(), minsky::GodleyIcon::update(), and VariableValue().

{return m_init;}

Here is the caller graph for this function:

init() [2/2]

const std::string & minsky::VariableValue::init

(

const std::string &

x

)

Definition at line 201 of file variableValue.cc.

References minsky::cminsky(), minsky::Minsky::definingVar(), minsky::VariableValues::initValue(), minsky::valueId(), and minsky::Minsky::variableValues.

                                                          {
    m_init=x;
    // don't reallocate if initialisation will be ignored (eg wired flow)
    if (x.empty() || (m_type!=parameter && isFlowVar() && cminsky().definingVar(valueId())))
      return m_init;
    auto tensorInit=cminsky().variableValues.initValue(*this);
    if (tensorInit.size()>size()) m_idx=-1; // force reallocation
    index(tensorInit.index());
    hypercube(tensorInit.hypercube());
    return m_init;
  }

Here is the call graph for this function:

isFlowVar()

bool minsky::VariableValue::isFlowVar ( ) const

inline

returns true if variable's data is allocated on the flowVariables vector

Definition at line 96 of file variableValue.h.

Referenced by minsky::EvalOpPtr::EvalOpPtr(), and minsky::VariableValues::resetValue().

                           {
      return m_type!=stock && m_type!=integral && m_type!=undefined;
    }

Here is the caller graph for this function:

isZero()

bool minsky::VariableValue::isZero ( ) const

inline

Definition at line 99 of file variableValue.h.

                        {
      return m_type==constant && (init().empty() || init()=="0");
    }

lhs()

bool minsky::VariableValue::lhs ( ) const

inline

variable has an input port

Definition at line 90 of file variableValue.h.

                     {
      return m_type==flow || m_type==tempFlow;}

operator=() [1/3]

void minsky::VariableValue::operator= ( const VariableValue &  )

delete

operator=() [2/3]

VariableValue& minsky::VariableValue::operator=

(

TensorVal const &

)

operator=() [3/3]

VariableValue & minsky::VariableValue::operator= ( const ITensor &  x )

override

Definition at line 111 of file variableValue.cc.

References civita::ITensor::hypercube(), civita::ITensor::index(), and civita::ITensor::size().

  {
    index(x.index());
    hypercube(x.hypercube());
    assert(idxInRange());
    for (size_t i=0; i<x.size(); ++i)
      (*this)[i]=x[i];
    return *this;
  }

Here is the call graph for this function:

operator[]() [1/2]

double minsky::VariableValue::operator[] ( std::size_t  i ) const

inlineoverride

Definition at line 124 of file variableValue.h.

{return *(&valRef()+i);}

operator[]() [2/2]

double& minsky::VariableValue::operator[] ( std::size_t  i )

override

reset_idx()

void minsky::VariableValue::reset_idx ( )

inline

Definition at line 122 of file variableValue.h.

Referenced by minsky::VariableValues::reset().

{m_idx=-1;}    

Here is the caller graph for this function:

setValue() [1/2]

double minsky::VariableValue::setValue ( size_t  i, double  x  )

inline

Definition at line 115 of file variableValue.h.

                                        {
      if (i>=size())
        throw std::runtime_error("Index out of range");
      return operator[](i)=x;
    }

setValue() [2/2]

double minsky::VariableValue::setValue ( double  x )

inline

Definition at line 120 of file variableValue.h.

References setValue().

Referenced by setValue().

{return setValue(0,x);}

Here is the call graph for this function:

Here is the caller graph for this function:

sliderSet()

void minsky::VariableValue::sliderSet

(

double

x

)

sets variable value (or init value)

Definition at line 222 of file variableValue.cc.

References minsky::anonymous_namespace{userFunction.cc}::isfinite().

  {
    if (!isfinite(x)) return;
    if (x<sliderMin) x=sliderMin;
    if (x>sliderMax) x=sliderMax;
    sliderStep=maxSliderSteps();    
    init(to_string(x));
    setValue(x);
  }

Here is the call graph for this function:

summary()

Summary minsky::VariableValue::summary

(

)

const

Definition at line 514 of file variableValue.cc.

References minsky::cminsky(), MathDAG::SystemOfEquations::getNodeFromIntVar(), MathDAG::SystemOfEquations::getNodeFromValueId(), minsky::Minsky::model, minsky::scope(), minsky::valueId(), and minsky::var.

  {
    MathDAG::SystemOfEquations system(cminsky());
    MathDAG::VariableDAGPtr varNode;
    switch (type())
      {
      case integral:
      case stock:
        varNode=system.getNodeFromIntVar(valueId());
        break;
      default:
        varNode=system.getNodeFromValueId(valueId());
        break;
      }

    string scopeName=":";
    if (auto scope=m_scope.lock())
      if (scope!=cminsky().model)
        scopeName=scope->title.empty()? scope->id(): scope->title;

    string godleyName;
    string definition=varNode && varNode->rhs? varNode->rhs->latexStr(): "";
    string udfDefinition;
    try
      {
        udfDefinition=varNode && varNode->rhs? varNode->rhs->matlabStr():"";
      }
    catch (const std::exception& ex)
      {
        udfDefinition=ex.what(); // if matlabStr fails, insert error message
      }
    if (auto var=cminsky().definingVar(valueId()))
      {
        if (auto controller=dynamic_pointer_cast<GodleyIcon>(var->controller.lock()))
          godleyName=controller->table.title.empty()? controller->id(): controller->table.title;
        if (auto p=var->ports(1).lock())
          if (!p->wires().empty())
            if (auto udf=dynamic_cast<UserFunction*>(&p->wires().front()->from()->item()))
              {
                definition="\\text{"+udf->expression+"}";
                udfDefinition=udf->expression;
              }
      }

    
    return Summary{
      valueId(),
      name,
      type(),
      definition,
      udfDefinition,
      init(),
      sliderStep, sliderMin, sliderMax,
      value(),
      scopeName,
      godleyName,
      hypercube().dims(),
      units.latexStr()
    };
    
  }

Here is the call graph for this function:

temp()

bool minsky::VariableValue::temp ( ) const

inline

variable is a temporary

Definition at line 93 of file variableValue.h.

                      {
      return type()==tempFlow || type()==undefined;}

timestamp()

ITensor::Timestamp minsky::VariableValue::timestamp ( ) const

inlineoverrideprivate

Definition at line 83 of file variableValue.h.

{return Timestamp::clock::now();}

type()

VariableType::Type minsky::VariableValue::type ( ) const

inline

value at the ith location of the vector/tensor. Default, (i=0) is right for scalar quantities

Definition at line 103 of file variableValue.h.

valRef() [1/2]

double & minsky::VariableValue::valRef ( )

private

index into value vector

Definition at line 177 of file variableValue.cc.

  {
    if (m_idx==-1)
      allocValue();
    switch (m_type)
      {
      case flow:
      case tempFlow:
      case constant:
      case parameter:
        assert(idxInRange());
        if (size_t(m_idx+size())<=ValueVector::flowVars.size())
          return ValueVector::flowVars[m_idx]; 
      case stock:
      case integral: 
        assert(idxInRange());
        if (size_t(m_idx+size())<=ValueVector::stockVars.size())
          return ValueVector::stockVars[m_idx]; 
        break;
      default: break;
      }
    throw error("invalid access of variable value reference: %s",name.c_str());
  }

valRef() [2/2]

const double & minsky::VariableValue::valRef ( ) const

private

Definition at line 153 of file variableValue.cc.

  {
    switch (m_type)
      {
      case flow:
      case tempFlow:
      case constant:
      case parameter:
        //assert(idxInRange()); // assertions fail after cancelled reset()
        if (size_t(m_idx)<ValueVector::flowVars.size())
          return ValueVector::flowVars[m_idx];
        break;
      case stock:
      case integral:
        //assert(idxInRange()); // assertions fail after cancelled reset()
        if (size_t(m_idx)<ValueVector::stockVars.size())
          return ValueVector::stockVars[m_idx];
        break;
      default: break;
      }
    static const double zero=0;
    return zero;
  }

value()

double minsky::VariableValue::value ( ) const

inline

set the value at the ith location

Definition at line 113 of file variableValue.h.

valueAt()

double minsky::VariableValue::valueAt ( size_t  i ) const

inline

Definition at line 108 of file variableValue.h.

                                   {
      if (i>=size())
        throw std::runtime_error("Index out of range");
      return operator[](i);
    }

valueId()

std::string minsky::VariableValue::valueId ( ) const

inline

Definition at line 178 of file variableValue.h.

References minsky::canonicalName(), and minsky::valueIdFromScope().

Referenced by minsky::VariableValues::resetValue().

{return valueIdFromScope(m_scope.lock(),canonicalName(name));}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

SchemaHelper

friend struct SchemaHelper

friend

Definition at line 80 of file variableValue.h.

VariableManager

friend class VariableManager

friend

Definition at line 79 of file variableValue.h.

Member Data Documentation

m_idx

int minsky::VariableValue::m_idx =-1

private

Definition at line 75 of file variableValue.h.

m_init

std::string minsky::VariableValue::m_init

protected

the initial value of this variable

Definition at line 87 of file variableValue.h.

m_type

Type minsky::VariableValue::m_type

private

Definition at line 74 of file variableValue.h.

---

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

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