MathDAG::anonymous_namespace{equations.cc} Namespace Reference

Classes
struct	NoArgument
struct	VariableDefOrder

Functions
bool	addTensorOp (const shared_ptr< VariableValue > &result, OperationDAGBase &nodeOp, EvalOpVector &ev)
void	cumulate (EvalOpVector &ev, const ItemPtr &state, VariableValuePtr &r, const vector< vector< VariableValuePtr > > &argIdx, OperationType::Type op, OperationType::Type accum, double groupIdentity)

Variables
OperationFactory< OperationDAGBase, OperationDAG, OperationType::numOps-1 >	operationDAGFactory

Function Documentation

addTensorOp()

bool MathDAG::anonymous_namespace{equations.cc}::addTensorOp	(	const shared_ptr< VariableValue > &	result,
		OperationDAGBase &	nodeOp,
		EvalOpVector &	ev
	)

Definition at line 88 of file equations.cc.

References minsky::TensorOpFactory::create(), MathDAG::OperationDAGBase::state, and minsky::tensorOpFactory.

Referenced by MathDAG::VariableDAG::addEvalOps(), MathDAG::OperationDAGBase::addEvalOps(), and MathDAG::VariableDAG::addTensorOp().

    {
      if (auto state=nodeOp.state)
        try
          {
            auto ec=make_shared<EvalCommon>();
            const TensorPtr rhs=tensorOpFactory.create(state,TensorsFromPort(ec));
            if (!rhs) return false;
            result->index(rhs->index());
            result->rhs=rhs;
            ev.emplace_back(EvalOpPtr(new TensorEval(result, ec, rhs)));
            return true;
          }
        catch(const FallBackToScalar&) {/* fall back to scalar processing */}
    return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

cumulate()

void MathDAG::anonymous_namespace{equations.cc}::cumulate	(	EvalOpVector &	ev,
		const ItemPtr &	state,
		VariableValuePtr &	r,
		const vector< vector< VariableValuePtr > > &	argIdx,
		OperationType::Type	op,
		OperationType::Type	accum,
		double	groupIdentity
	)

Definition at line 236 of file equations.cc.

References minsky::OperationType::add, minsky::OperationType::constant, minsky::OperationType::copy, minsky::OperationType::divide, minsky::OperationType::multiply, minsky::op, and minsky::VariableType::tempFlow.

Referenced by MathDAG::OperationDAGBase::addEvalOps().

    {
      assert(r);
      // check if any arguments have x-vectors, and if so, initialise r.xVector
      // For feature 47
      for (auto& i: argIdx)
        if (!i.empty())
          {
            // initialise r's xVector
            r->hypercube(i[0]->hypercube());
            break;
          }
      if (r->rank()>0)
        throw runtime_error("Scalar processing not supported in tensor code, try adding an intermediate variable");
      if (r->idx()==-1) r->allocValue();

      // short circuit multiplications if any of the terms are constant zero
      if (accum==OperationType::multiply)
        {
          if (op==OperationType::divide)
            for (auto& i: argIdx[1])
              if (i->isZero())
                throw runtime_error("divide by constant zero");
          for (auto& i: argIdx)
            for (auto& j: i)
              if (j->isZero())
                {
                  r=j;
                  return;
                }
        }

        {
          size_t i=0;
          if (accum==OperationType::add)
            while (!argIdx.empty() && i<argIdx[0].size() && argIdx[0][i]->isZero())
              i++;
          if (!argIdx.empty() && i<argIdx[0].size())
            {
              ev.push_back(EvalOpPtr(OperationType::copy, state, r, *argIdx[0][i]));
              for (++i; i<argIdx[0].size(); ++i)
                if (accum!=OperationType::add || !argIdx[0][i]->isZero())
                  ev.push_back(EvalOpPtr(accum, state, r, *r, *argIdx[0][i]));
            }
          else
            {
              //TODO: could be cleaned up if we don't need to support constant operators
              ev.push_back(EvalOpPtr(OperationType::constant, state, r));
              dynamic_cast<ConstantEvalOp&>(*ev.back()).value=groupIdentity;
            }
        }
 
      if (argIdx.size()>1)
        {
          if (argIdx[1].size()==1)
            // eliminate redundant copy operation when only one wire
            ev.push_back(EvalOpPtr(op, state, r, *r, *argIdx[1][0]));
          else if (argIdx[1].size()>1)
            {
              // multiple wires to second input port
              const VariableValuePtr tmp(VariableType::tempFlow);
              tmp->hypercube(r->hypercube());
              size_t i=0;
              if (accum==OperationType::add)
                while (i<argIdx[1].size() && argIdx[1][i]->isZero()) i++;
              if (i<argIdx[1].size())
                {
                  ev.push_back(EvalOpPtr(OperationType::copy, state, tmp, *argIdx[1][i]));
                  for (++i; i<argIdx[1].size(); ++i)
                    if (accum!=OperationType::add || !argIdx[1][i]->isZero())
                      ev.push_back(EvalOpPtr(accum, state, tmp, *tmp, *argIdx[1][i]));
                  ev.push_back(EvalOpPtr(op, state, r, *r, *tmp));
                }
            }
        }
    }

Here is the caller graph for this function:

Variable Documentation

operationDAGFactory

OperationFactory<OperationDAGBase, OperationDAG, OperationType::numOps-1> MathDAG::anonymous_namespace{equations.cc}::operationDAGFactory

Definition at line 174 of file equations.cc.

Referenced by MathDAG::OperationDAGBase::create().