minsky::TensorOpFactory Class Reference

As it says on the tin, this is a factory for creating a TensorOp which can compute the result of op applied to its arguments and so on until all the argument terminate in variables. More...

#include <minskyTensorOps.h>

Inheritance diagram for minsky::TensorOpFactory:

Collaboration diagram for minsky::TensorOpFactory:

Public Member Functions
	TensorOpFactory ()
std::shared_ptr< ITensor >	create (const ItemPtr &, const TensorsFromPort &tp={})
	create a tensor representation of the expression rooted at op. If expression doesn't contain any references variables, then the tp parameter may be omitted. More...

Private Types
enum	Type

Detailed Description

As it says on the tin, this is a factory for creating a TensorOp which can compute the result of op applied to its arguments and so on until all the argument terminate in variables.

Definition at line 72 of file minskyTensorOps.h.

Member Enumeration Documentation

Type

enum minsky::OperationType::Type

private

=>["constant","time","integrate","differentiate","data","ravel","add","subtract","multiply","divide","log","pow","lt","le","eq","min","max","and_","or_","copy","sqrt","exp","ln","sin","cos","tan","asin","acos","atan","sinh","cosh","tanh","abs","floor","frac","not_","sum","product","infimum","supremum","any","all","infIndex","supIndex","runningSum","runningProduct","difference","innerProduct","outerProduct","index","gather","numOps"]

and variable types with

/

Definition at line 29 of file operationType.h.

              {constant, // deprecated - left to support legacy schemas
               time,  // zero input port ops
               integrate, 
               differentiate, // with respect to time
               data, // an interpolated data item
               ravel, // Ravel™
               euler, pi, zero, one, inf, percent,// fundamental constants
               // multiwire binary ops
               add, subtract, multiply, divide, min, max, 
               // underscores to avoid C++ keywords. Can be filtered at UI
               and_, or_,
               // single wire binops
               log, pow, polygamma, 
               lt, le, eq,
               userFunction,
               // functions
               copy, sqrt, exp, ln, sin, cos, tan, asin, acos, atan,
               sinh, cosh, tanh, abs,
               floor, frac, not_, Gamma, fact,
               // reductions
               sum, product, infimum, supremum, any, all, infIndex, supIndex,
               // scans
               runningSum, runningProduct, difference, differencePlus,
               // other tensor ops
               innerProduct, outerProduct, index, gather, meld, merge, slice, size, shape, 
               // statistics
               mean, median, stdDev, moment, histogram, covariance, correlation, linearRegression,
               numOps // last operation, for iteration purposes
    };

Constructor & Destructor Documentation

TensorOpFactory()

minsky::TensorOpFactory::TensorOpFactory

(

)

Definition at line 328 of file minskyTensorOps.cc.

  {
    registerType<TimeOp>(OperationType::time);
    registerOps<MinskyTensorOp, OperationType::euler, OperationType::add>(*this);
    registerOps<MultiWireBinOp, OperationType::add, OperationType::log>(*this); 
    registerOps<TensorBinOp, OperationType::log, OperationType::copy>(*this);   
    registerOps<MinskyTensorOp, OperationType::copy, OperationType::sum>(*this);
    registerOps<GeneralTensorOp, OperationType::sum, OperationType::numOps>(*this);
  }

Member Function Documentation

create()

std::shared_ptr< ITensor > minsky::TensorOpFactory::create	(	const ItemPtr &	it,
		const TensorsFromPort &	tp = {}
	)

create a tensor representation of the expression rooted at op. If expression doesn't contain any references variables, then the tp parameter may be omitted.

Definition at line 1545 of file minskyTensorOps.cc.

References minsky::cminsky(), civita::createRavelChain(), minsky::Minsky::displayErrorItem(), minsky::TensorsFromPort::ev, minsky::op, minsky::TensorsFromPort::tensorsFromPort(), and minsky::TensorsFromPort::tensorsFromPorts().

Referenced by MathDAG::anonymous_namespace{equations.cc}::addTensorOp(), minsky::Ravel::exportAsCSV(), minsky::TensorEval::TensorEval(), and minsky::TensorsFromPort::tensorsFromPort().

  {
    if (auto ravel=dynamic_cast<const Ravel*>(it.get()))
            {
              auto r=make_shared<RavelTensor>(*ravel);
              r->setArguments(tfp.tensorsFromPorts(*it));
              return r;
            }
    if (auto op=it->operationCast())
      try
        {
          TensorPtr r{create(op->type())};
          if (auto ss=dynamic_cast<SetState*>(r.get()))
            ss->setState(dynamic_pointer_cast<OperationBase>(it));
          switch (op->portsSize())
            {
            case 2:
              r->setArguments(tfp.tensorsFromPort(*op->ports(1).lock()),{op->axis,op->arg});
            break;
            case 3:
              r->setArguments(tfp.tensorsFromPort(*op->ports(1).lock()), tfp.tensorsFromPort(*op->ports(2).lock()),{op->axis,op->arg});
              break;
            }
          return r;
        }
      catch (const InvalidType&)
        {return {};}
      catch (const TensorOpError&)
        {throw;}
      catch (const FallBackToScalar&)
        {throw;}
      catch (const std::exception& ex)
        {
          // mark op on canvas, and rethrow as TensorOpError to indicate op is marked
          cminsky().displayErrorItem(*op);
          throw TensorOpError(ex.what());
        }
    else if (auto v=it->variableCast())
      return make_shared<ConstTensorVarVal>(v->vValue(), tfp.ev);
    else if (auto sw=dynamic_cast<const SwitchIcon*>(it.get()))
      {
        auto r=make_shared<SwitchTensor>();
        r->setArguments(tfp.tensorsFromPorts(*it));
        return r;
      }
    else if (auto l=dynamic_cast<const Lock*>(it.get()))
      {
        if (l->locked())
          {
            if (auto r=l->ravelInput())
              if (auto p=r->ports(1).lock())
                {
                  assert(!tfp.tensorsFromPort(*p).empty());
                  auto chain=createRavelChain(l->lockedState, tfp.tensorsFromPort(*p)[0]);
                  if (!chain.empty())
                    return chain.back();
                }
          }
        else
          if (auto tensors=tfp.tensorsFromPort(*l->ports(1).lock()); !tensors.empty())
            return tensors.front();
      }
    return {};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• engine/minskyTensorOps.h
• engine/minskyTensorOps.cc