MathDAG::SubexpressionCache Class Reference

#include <equations.h>

Collaboration diagram for MathDAG::SubexpressionCache:

Public Member Functions
std::string	key (const OperationBase &x) const
std::string	key (const VariableBase &x) const
std::string	key (const SwitchIcon &x) const
std::string	key (const Lock &x) const
std::string	key (const string &x) const
	strings refer to variable names More...
template<class T >
bool	exists (const T &x)
template<class T >
NodePtr	operator[] (const T &x) const
template<class T >
const NodePtr &	insert (const T &x, const NodePtr &n)
void	insertIntegralInput (const string &name, const VariableDAGPtr &n)
VariableDAGPtr	getIntegralInput (const string &name) const
std::size_t	size () const
NodePtr	reverseLookup (const Node &x) const
	returns NodePtr corresponding to object , if it exists in cache, nullptr otherwise More...
NodePtr	insertAnonymous (NodePtr x)

Private Attributes
std::map< std::string, NodePtr >	cache
std::map< std::string, VariableDAGPtr >	integrationInputs
std::map< const Node *, NodePtr >	reverseLookupCache

Detailed Description

Definition at line 292 of file equations.h.

Member Function Documentation

exists()

template<class T >

bool MathDAG::SubexpressionCache::exists ( const T &  x )

inline

Definition at line 315 of file equations.h.

Referenced by MathDAG::SystemOfEquations::getNodeFromVar(), MathDAG::SystemOfEquations::getNodeFromWire(), and MathDAG::SystemOfEquations::makeDAG().

{return cache.count(key(x));}

Here is the caller graph for this function:

getIntegralInput()

VariableDAGPtr MathDAG::SubexpressionCache::getIntegralInput ( const string &  name ) const

inline

Definition at line 333 of file equations.h.

Referenced by MathDAG::SystemOfEquations::getDefFromIntVar(), MathDAG::SystemOfEquations::getNodeFromIntVar(), MathDAG::SystemOfEquations::latex(), MathDAG::SystemOfEquations::latexWrapped(), MathDAG::SystemOfEquations::matlab(), and MathDAG::SystemOfEquations::SystemOfEquations().

                                                              {
      auto r=integrationInputs.find("input:"+name);
      if (r!=integrationInputs.end())
        return r->second;
      else
        return VariableDAGPtr();
    }

Here is the caller graph for this function:

insert()

template<class T >

const NodePtr& MathDAG::SubexpressionCache::insert ( const T &  x, const NodePtr &  n  )

inline

Definition at line 325 of file equations.h.

Referenced by MathDAG::SystemOfEquations::makeDAG().

                                                        {
      reverseLookupCache[n.get()]=n;
      return cache.insert(make_pair(key(x),n)).first->second;
    }

Here is the caller graph for this function:

insertAnonymous()

NodePtr MathDAG::SubexpressionCache::insertAnonymous ( NodePtr  x )

inline

Definition at line 351 of file equations.h.

Referenced by MathDAG::CachedOp< T >::CachedOp(), MathDAG::Expr::Expr(), MathDAG::Expr::newNode(), MathDAG::Expr::operator*(), MathDAG::Expr::operator+(), MathDAG::Expr::operator-(), MathDAG::Expr::operator/(), and MathDAG::SystemOfEquations::SystemOfEquations().

                                       {
      assert(x);
      return reverseLookupCache.insert(make_pair(x.get(), x)).first->second;
    }

Here is the caller graph for this function:

insertIntegralInput()

void MathDAG::SubexpressionCache::insertIntegralInput ( const string &  name, const VariableDAGPtr &  n  )

inline

Definition at line 329 of file equations.h.

Referenced by MathDAG::SystemOfEquations::SystemOfEquations().

                                                                          {
      integrationInputs.insert(make_pair("input:"+name,n));
      reverseLookupCache[n.get()]=n;
    }

Here is the caller graph for this function:

key() [1/5]

std::string MathDAG::SubexpressionCache::key ( const OperationBase &  x ) const

inline

Definition at line 298 of file equations.h.

References minsky::Item::ports(), and minsky::to_string().

                                                {
      return "op:"+std::to_string(std::size_t(x.ports(0).lock().get()));
    }

Here is the call graph for this function:

key() [2/5]

std::string MathDAG::SubexpressionCache::key ( const VariableBase &  x ) const

inline

Definition at line 301 of file equations.h.

References minsky::VariableBase::valueId().

                                               {
      return "var:"+x.valueId();
    }

Here is the call graph for this function:

key() [3/5]

std::string MathDAG::SubexpressionCache::key ( const SwitchIcon &  x ) const

inline

Definition at line 304 of file equations.h.

References minsky::Item::ports(), and minsky::to_string().

                                             {
      return "switch:"+std::to_string(std::size_t(x.ports(0).lock().get()));
    }

Here is the call graph for this function:

key() [4/5]

std::string MathDAG::SubexpressionCache::key ( const Lock &  x ) const

inline

Definition at line 307 of file equations.h.

References minsky::Item::ports(), and minsky::to_string().

                                       {
      return "lock:"+std::to_string(std::size_t(x.ports(0).lock().get()));
    }

Here is the call graph for this function:

key() [5/5]

std::string MathDAG::SubexpressionCache::key ( const string &  x ) const

inline

strings refer to variable names

Definition at line 311 of file equations.h.

                                         {
      return "var:"+x;
    }

operator[]()

template<class T >

NodePtr MathDAG::SubexpressionCache::operator[] ( const T &  x ) const

inline

Definition at line 317 of file equations.h.

                                         {
      auto r=cache.find(key(x));
      if (r!=cache.end())
        return r->second;
      else
        return NodePtr();
    }

reverseLookup()

NodePtr MathDAG::SubexpressionCache::reverseLookup ( const Node &  x ) const

inline

returns NodePtr corresponding to object , if it exists in cache, nullptr otherwise

Definition at line 342 of file equations.h.

                                               {
      auto it=reverseLookupCache.find(&x);
      if (it==reverseLookupCache.end())
        return NodePtr();
      else
        return it->second;
    }

size()

std::size_t MathDAG::SubexpressionCache::size ( ) const

inline

Definition at line 340 of file equations.h.

Referenced by MathDAG::SystemOfEquations::SystemOfEquations().

{return cache.size()+integrationInputs.size();}

Here is the caller graph for this function:

Member Data Documentation

cache

std::map<std::string, NodePtr > MathDAG::SubexpressionCache::cache

private

Definition at line 294 of file equations.h.

integrationInputs

std::map<std::string, VariableDAGPtr> MathDAG::SubexpressionCache::integrationInputs

private

Definition at line 295 of file equations.h.

reverseLookupCache

std::map<const Node*, NodePtr> MathDAG::SubexpressionCache::reverseLookupCache

private

Definition at line 296 of file equations.h.

---

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

• engine/equations.h