civita::Pivot Class Reference

corresponds to the OLAP pivot operation More...

#include <tensorOp.h>

Inheritance diagram for civita::Pivot:

Collaboration diagram for civita::Pivot:

Public Member Functions
void	setArgument (const TensorPtr &a, const ITensor::Args &args={"", 0}) override
void	setOrientation (const std::vector< std::string > &axes)
	set's the pivots orientation More...
double	operator[] (std::size_t i) const override
	return or compute data at a location More...
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 Member Functions
std::size_t	pivotIndex (std::size_t i) const

Private Attributes
std::vector< std::size_t >	permutation
std::vector< std::size_t >	permutedIndex
	permutation of axes More...
TensorPtr	arg
	argument indices corresponding to this indices, when sparse More...

Additional Inherited Members
Public Types inherited from civita::ITensor
using	Timestamp = std::chrono::time_point< std::chrono::high_resolution_clock >
Protected Member Functions inherited from civita::ITensor
void	notImpl () const
Protected Attributes inherited from civita::ITensor
Hypercube	m_hypercube
Index	m_index

Detailed Description

corresponds to the OLAP pivot operation

Definition at line 237 of file tensorOp.h.

Member Function Documentation

operator[]()

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

overridevirtual

return or compute data at a location

Implements civita::ITensor.

Definition at line 386 of file tensorOp.cc.

  {
    assert(i<size());
    if (index().empty())
      return arg->atHCIndex(pivotIndex(i));
    return (*arg)[permutedIndex[i]];
  }

pivotIndex()

size_t civita::Pivot::pivotIndex ( std::size_t  i ) const

private

Definition at line 377 of file tensorOp.cc.

  {
    auto idx=hypercube().splitIndex(i);
    auto pidx=idx;
    for (size_t i=0; i<idx.size(); ++i)
      pidx[permutation[i]]=idx[i];
    return arg->hypercube().linealIndex(pidx);
  }

setArgument()

void civita::Pivot::setArgument ( const TensorPtr &  a, const ITensor::Args &  args = {"",0}  )

overridevirtual

Reimplemented from civita::ITensor.

Definition at line 309 of file tensorOp.cc.

  {
    arg=a;
    vector<string> axes;
    for (auto& i: arg->hypercube().xvectors)
      axes.push_back(i.name);
    setOrientation(axes);
  }

setOrientation()

void civita::Pivot::setOrientation

(

const std::vector< std::string > &

axes

)

set's the pivots orientation

Parameters

axes	- list of axes that are the output

Definition at line 319 of file tensorOp.cc.

  {
    map<string,size_t> pMap;
    map<string,XVector> xVectorMap;
    auto& ahc=arg->hypercube();
    for (size_t i=0; i<ahc.xvectors.size(); ++i)
      {
        pMap[ahc.xvectors[i].name]=i;
        xVectorMap[ahc.xvectors[i].name]=ahc.xvectors[i];
      }
    Hypercube hc;
    permutation.clear();
    set<string> axisSet;
    map<size_t, size_t> invPermutation;
    for (auto& i: axes)
      {
        axisSet.insert(i);
        auto v=pMap.find(i);
        if (v==pMap.end())
          throw runtime_error("axis "+i+" not found in argument");
        invPermutation[v->second]=permutation.size();
        permutation.push_back(v->second);
        hc.xvectors.push_back(xVectorMap[i]);
      }
    // add remaining axes to permutation in found order
    for (size_t i=0; i<ahc.xvectors.size(); ++i)
      if (!axisSet.count(ahc.xvectors[i].name))
        {
          invPermutation[i]=permutation.size();
          permutation.push_back(i);
          hc.xvectors.push_back(ahc.xvectors[i]);
        }

    assert(hc.rank()==arg->rank());
    hypercube(move(hc));
    // permute the index vector
    map<size_t, size_t> pi;
    for (size_t i=0; i<arg->index().size(); ++i)
      {
        auto idx=arg->hypercube().splitIndex(arg->index()[i]);
        auto pidx=idx;
        for (size_t j=0; j<idx.size(); ++j)
          {
            assert(invPermutation.count(j));
            assert(invPermutation[j]<pidx.size());
            pidx[invPermutation[j]]=idx[j];
          }
        auto l=hypercube().linealIndex(pidx);
        assert(pi.count(l)==0);
        pi[l]=i;
      }
    m_index=pi;
    // convert to lineal indexing
    permutedIndex.clear();
    for (auto& i: pi) permutedIndex.push_back(i.second);
    if (!permutedIndex.empty()) permutation.clear(); // not used in sparse case
  }

timestamp()

Timestamp civita::Pivot::timestamp ( ) const

inlineoverridevirtual

timestamp indicating how old the dependendent data might be. Used in CachedTensorOp to determine when to invalidate the cache

Implements civita::ITensor.

Definition at line 250 of file tensorOp.h.

References arg.

{return arg->timestamp();}

Member Data Documentation

arg

TensorPtr civita::Pivot::arg

private

argument indices corresponding to this indices, when sparse

Definition at line 241 of file tensorOp.h.

Referenced by timestamp().

permutation

std::vector<std::size_t> civita::Pivot::permutation

private

Definition at line 239 of file tensorOp.h.

permutedIndex

std::vector<std::size_t> civita::Pivot::permutedIndex

private

permutation of axes

Definition at line 240 of file tensorOp.h.

---

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

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