civita::ReductionOp Class Reference

compute the reduction along the indicated dimension, ignoring any missing entry (NaNs) More...

#include <tensorOp.h>

Inheritance diagram for civita::ReductionOp:

Collaboration diagram for civita::ReductionOp:

Classes
struct	SOI

Public Member Functions
template<class F >
	ReductionOp (F f, double init, const TensorPtr &arg={}, const std::string &dimName="")
void	setArgument (const TensorPtr &a, const ITensor::Args &) override
double	operator[] (std::size_t i) const override
	return or compute data at a location More...
Public Member Functions inherited from civita::ReduceAllOp
template<class F >
	ReduceAllOp (F f, double init, const std::shared_ptr< ITensor > &arg={})
Timestamp	timestamp () const override
	timestamp indicating how old the dependendent data might be. Used in CachedTensorOp to determine when to invalidate the cache More...
Public Member Functions inherited from civita::ITensor
	CLASSDESC_ACCESS (ITensor)
	ITensor ()
	ITensor (const Hypercube &hc)
	ITensor (Hypercube &&hc)
	ITensor (const std::vector< unsigned > &dims)
	ITensor (const ITensor &)=default
	ITensor (ITensor &&)=default
ITensor &	operator= (const ITensor &)=default
ITensor &	operator= (ITensor &&)=default
virtual	~ITensor ()
virtual const Hypercube &	hypercube () const
	information describing the axes, types and labels of this tensor More...
virtual const Hypercube &	hypercube (const Hypercube &hc)
virtual const Hypercube &	hypercube (Hypercube &&hc)
std::size_t	rank () const
std::vector< unsigned >	shape () const
void	imposeDimensions (const Dimensions &dimensions)
	impose dimensions according to dimension map dimensions More...
virtual const Index &	index () const
	the index vector - assumed to be ordered and unique More...
virtual std::size_t	size () const
	return number of elements in tensor - maybe less than hypercube.numElements if sparse More...
double	atHCIndex (std::size_t hcIdx) const
	returns the data value at hypercube index hcIdx, or NaN if More...
template<class T >
std::size_t	hcIndex (const std::initializer_list< T > &indices) const
template<class T >
double	operator() (const std::initializer_list< T > &indices) const
virtual void	setArguments (const TensorPtr &, const TensorPtr &, const ITensor::Args &args={})
virtual void	setArguments (const std::vector< TensorPtr > &a, const ITensor::Args &args={"", 0})
virtual void	setArguments (const std::vector< TensorPtr > &a1, const std::vector< TensorPtr > &a2, const ITensor::Args &args={"", 0})

Private Attributes
std::size_t	dimension
std::map< std::size_t, std::vector< SOI > >	sumOverIndices

Additional Inherited Members
Public Types inherited from civita::ITensor
using	Timestamp = std::chrono::time_point< std::chrono::high_resolution_clock >
Public Attributes inherited from civita::ReduceAllOp
std::function< void(double &, double, std::size_t)>	f
double	init
std::shared_ptr< ITensor >	arg
Protected Member Functions inherited from civita::ITensor
void	notImpl () const
Protected Attributes inherited from civita::ITensor
Hypercube	m_hypercube
Index	m_index

Detailed Description

compute the reduction along the indicated dimension, ignoring any missing entry (NaNs)

Definition at line 113 of file tensorOp.h.

Constructor & Destructor Documentation

ReductionOp()

template<class F >

civita::ReductionOp::ReductionOp ( F  f, double  init, const TensorPtr &  arg = {}, const std::string &  dimName = ""  )

inline

Definition at line 121 of file tensorOp.h.

                                                       {}, const std::string& dimName=""):
      ReduceAllOp(f,init) {ReduceAllOp::setArgument(arg,{dimName,0});}

Member Function Documentation

operator[]()

double civita::ReductionOp::operator[] ( std::size_t  ) const

overridevirtual

return or compute data at a location

Reimplemented from civita::ReduceAllOp.

Reimplemented in civita::StdDeviation, and civita::Average.

Definition at line 137 of file tensorOp.cc.

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

Referenced by civita::Average::operator[](), civita::StdDeviation::operator[](), minsky::GeneralTensorOp< OperationType::median >::operator[](), and minsky::GeneralTensorOp< OperationType::moment >::operator[]().

  {
    assert(i<size());
    if (!arg) return init;
    if (dimension>arg->rank())
      return ReduceAllOp::operator[](i);

    double r=init;
    if (index().empty())
      {
        auto argDims=arg->shape();
        size_t stride=1;
        for (size_t j=0; j<dimension; ++j)
          stride*=argDims[j];
        auto quotRem=ldiv(i, stride); // quotient and remainder calc in one hit
        auto start=quotRem.quot*stride*argDims[dimension] + quotRem.rem;
        assert(stride*argDims[dimension]>0);
        for (size_t j=0; j<argDims[dimension]; ++j)
          {
            double x=arg->atHCIndex(j*stride+start);
            if (!isnan(x)) f(r,x,j);
          }
      }
    else
      {
        auto soi=sumOverIndices.find(index()[i]);
        assert(soi!=sumOverIndices.end());
        if (soi!=sumOverIndices.end())
          for (auto j: soi->second)
            {
              double x=(*arg)[j.index];
              if (!isnan(x)) f(r,x,j.dimIndex);
            }
      }
    return r;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

setArgument()

void civita::ReductionOp::setArgument ( const TensorPtr &  a, const ITensor::Args &  args  )

overridevirtual

Reimplemented from civita::ReduceAllOp.

Definition at line 101 of file tensorOp.cc.

References civita::ITensor::Args::dimension.

Referenced by minsky::GeneralTensorOp< OperationType::moment >::setArgument(), and minsky::GeneralTensorOp< OperationType::linearRegression >::setArguments().

  {
    arg=a;
    dimension=std::numeric_limits<size_t>::max();
    if (arg)
      {
        const auto& ahc=arg->hypercube();
        m_hypercube=ahc;
        auto& xv=m_hypercube.xvectors;
        for (auto i=xv.begin(); i!=xv.end(); ++i)
          if (i->name==args.dimension)
            dimension=i-xv.begin();
        if (dimension<arg->rank())
          {
            xv.erase(xv.begin()+dimension);
            // compute index - enter index elements that have any in the argument
            set<size_t> indices;
            for (size_t i=0; i<arg->size(); ++i)
              {
                auto splitIdx=ahc.splitIndex(arg->index()[i]);
                SOI soi{i,splitIdx[dimension]};
                splitIdx.erase(splitIdx.begin()+dimension);
                auto idx=m_hypercube.linealIndex(splitIdx);
                sumOverIndices[idx].emplace_back(soi);
                indices.insert(idx);
              }
            m_index=indices;
          }
        else
          m_hypercube.xvectors.clear(); //reduce all, return scalar
      }
    else
      m_hypercube.xvectors.clear();
  }

Here is the caller graph for this function:

Member Data Documentation

dimension

std::size_t civita::ReductionOp::dimension

private

Definition at line 115 of file tensorOp.h.

sumOverIndices

std::map<std::size_t, std::vector<SOI> > civita::ReductionOp::sumOverIndices

private

Definition at line 117 of file tensorOp.h.

---

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

• tensor/tensorOp.h
• tensor/tensorOp.cc