civita Namespace Reference

Namespaces
	anonymous_namespace{tensorOp.cc}

Classes
struct	Average
	calculates the average along an axis or whole tensor More...
class	BinOp
	perform a binary operation elementwise over two tensor arguments. Arguments need to be conformal: at least one must be a scalar, or both arguments have the same shape More...
class	CachedTensorOp
struct	DimensionedArgCachedOp
struct	ElementWiseOp
	perform an operation elementwise over a tensor valued argument More...
class	InterpolateHC
	Interpolates its argument to its hypercube rank must equal arg->rank(), and xvectors type must match. More...
class	ITensor
class	Max
	calculate the maximum along an axis or whole tensor More...
class	Min
	calculate the minimum along an axis or whole tensor More...
class	PermuteAxis
class	Pivot
	corresponds to the OLAP pivot operation More...
struct	Product
	calculate the product along an axis or whole tensor More...
struct	ReduceAllOp
	reduce all elements to a single number More...
class	ReduceArguments
	elementwise reduction over a vector of arguments More...
class	ReductionOp
	compute the reduction along the indicated dimension, ignoring any missing entry (NaNs) More...
class	Scan
class	Slice
	corresponds to OLAP slice operation More...
class	SortByValue
	If a rank 1 argument, sort by the value of the argument. More...
class	SpreadBase
class	SpreadFirst
class	SpreadLast
struct	StdDeviation
	calculates the standard deviation along an axis or whole tensor More...
struct	Sum
	calculate the sum along an axis or whole tensor More...

Typedefs
using	TensorPtr = std::shared_ptr< ITensor >

Functions
vector< TensorPtr >	createRavelChain (const ravel::RavelState &, const TensorPtr &arg)
	creates a chain of tensor operations that represents a Ravel in state state, operating on arg More...

Typedef Documentation

TensorPtr

using civita::TensorPtr = typedef std::shared_ptr<ITensor>

Definition at line 34 of file tensorInterface.h.

Function Documentation

createRavelChain()

std::vector< TensorPtr > civita::createRavelChain	(	const ravel::RavelState &	state,
		const TensorPtr &	arg
	)

creates a chain of tensor operations that represents a Ravel in state state, operating on arg

Definition at line 497 of file tensorOp.cc.

References civita::anonymous_namespace{tensorOp.cc}::createReductionOp(), and minsky::str().

Referenced by MathDAG::LockDAG::addEvalOps(), minsky::TensorOpFactory::create(), minsky::RavelTensor::operator[](), and minsky::RavelTensor::setArgument().

  {
    set<string> outputHandles(state.outputHandles.begin(), state.outputHandles.end());
    vector<TensorPtr> chain{arg};
    // TODO sorts and calipers
    for (auto& i: state.handleStates)
      {
        if (i.order!=ravel::HandleSort::none || i.displayFilterCaliper)
        {
          //apply sorting/calipers
          auto permuteAxis=make_shared<PermuteAxis>();
          permuteAxis->setArgument(chain.back(), {i.description,0});
          auto& xv=chain.back()->hypercube().xvectors[permuteAxis->axis()];
          vector<size_t> perm;
          for (size_t i=0; i<xv.size(); ++i)
            perm.push_back(i);
          switch (i.order)
            {
            case ravel::HandleSort::none: break;
            case ravel::HandleSort::forward:
            case ravel::HandleSort::numForward:
            case ravel::HandleSort::timeForward:
              sort(perm.begin(), perm.end(),
                   [&](size_t i, size_t j) {return diff(xv[i],xv[j])<0;});
              break;
            case ravel::HandleSort::reverse:
            case ravel::HandleSort::numReverse:
            case ravel::HandleSort::timeReverse:
              sort(perm.begin(), perm.end(),
                   [&](size_t i, size_t j) {return diff(xv[i],xv[j])>0;});
              break;
            case ravel::HandleSort::custom:
              {
                map<string, size_t> offsets;
                for (size_t i=0; i<xv.size(); ++i)
                  offsets[str(xv[i], xv.dimension.units)]=i;
                perm.clear();
                for (auto& j: i.customOrder)
                  if (offsets.count(j))
                    perm.push_back(offsets[j]);
                break;
              }
//            case ravel::HandleSort::numForward: case ravel::HandleSort::numReverse:
//            case ravel::HandleSort::timeForward: case ravel::HandleSort::timeReverse:
//              throw runtime_error("deprecated sort order used");
            }
          if (i.displayFilterCaliper)
            {
              // remove any permutation items outside calipers
              if (!i.minLabel.empty())
                for (auto j=perm.begin(); j!=perm.end(); ++j)
                  if (str(xv[*j],xv.dimension.units) == i.minLabel)
                    {
                      perm.erase(perm.begin(), j);
                      break;
                    }
              if (!i.maxLabel.empty())
                for (auto j=perm.begin(); j!=perm.end(); ++j)
                  if (str(xv[*j],xv.dimension.units) == i.maxLabel)
                    {
                      perm.erase(j+1, perm.end());
                      break;
                    }
            }
          permuteAxis->setPermutation(move(perm));
          chain.push_back(permuteAxis);
        }
      if (!outputHandles.count(i.description))
        {
          auto arg=chain.back();
          if (i.collapsed)
            {
              chain.emplace_back(createReductionOp(i.reductionOp));
              chain.back()->setArgument(arg, {i.description,0});
            }
          else
            {
              chain.emplace_back(new Slice);
              auto& xv=arg->hypercube().xvectors;
              auto axisIt=find_if(xv.begin(), xv.end(),
                                  [&](const XVector& j){return j.name==i.description;});
              if (axisIt==xv.end()) throw runtime_error("axis "+i.description+" not found");
              auto sliceIt=find_if(axisIt->begin(), axisIt->end(),
                                   [&](const boost::any& j){return str(j,axisIt->dimension.units)==i.sliceLabel;});
              // determine slice index
              size_t sliceIdx=0;
              if (sliceIt!=axisIt->end())
                sliceIdx=sliceIt-axisIt->begin();
              chain.back()->setArgument(arg, {i.description, double(sliceIdx)});
            }
        }
      }
    
    if (chain.back()->rank()>1)
      {
        auto finalPivot=make_shared<Pivot>();
        finalPivot->setArgument(chain.back());
        finalPivot->setOrientation(state.outputHandles);
        chain.push_back(finalPivot);
      }
    return chain;
  }

Here is the call graph for this function:

Here is the caller graph for this function: