Minsky
Public Member Functions | Public Attributes | List of all members
minsky::TensorBinOp< op > Struct Template Reference
Inheritance diagram for minsky::TensorBinOp< op >:
Inheritance graph
Collaboration diagram for minsky::TensorBinOp< op >:
Collaboration graph

Public Member Functions

 TensorBinOp ()
 
void setState (const OperationPtr &state) override
 
void setArguments (const TensorPtr &a1, const TensorPtr &a2, const ITensor::Args &args={"", 0}) override
 
double dFlow (size_t ti, size_t fi) const override
 
double dStock (size_t ti, size_t si) const override
 
- Public Member Functions inherited from civita::BinOp
template<class F >
 BinOp (F f, const TensorPtr &arg1={}, const TensorPtr &arg2={})
 
void setArguments (const TensorPtr &a1, const TensorPtr &a2, const ITensor::Args &) override
 
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 setArgument (const TensorPtr &, const ITensor::Args &args={"", 0})
 
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})
 
- Public Member Functions inherited from minsky::DerivativeMixin
virtual double dFlow (std::size_t ti, std::size_t fi) const =0
 partial derivative of tensor component ti wrt flow variable fi More...
 
virtual double dStock (std::size_t ti, std::size_t si) const =0
 partial derivative of tensor component ti wrt stock variable si More...
 
- Public Member Functions inherited from minsky::SetState
virtual ~SetState ()
 

Public Attributes

EvalOp< op > eo
 

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::BinOp
std::function< double(double, double)> f
 
TensorPtr arg1
 
TensorPtr arg2
 
- Protected Attributes inherited from civita::ITensor
Hypercube m_hypercube
 
Index m_index
 

Detailed Description

template<OperationType::Type op>
struct minsky::TensorBinOp< op >

Definition at line 99 of file minskyTensorOps.cc.

Constructor & Destructor Documentation

◆ TensorBinOp()

template<OperationType::Type op>
minsky::TensorBinOp< op >::TensorBinOp ( )
inline

Definition at line 102 of file minskyTensorOps.cc.

102 : BinOp([this](double x,double y){return eo.evaluate(x,y);}) {}
civita::BinOp::BinOp
BinOp(F f, const TensorPtr &arg1={}, const TensorPtr &arg2={})
Definition: tensorOp.h:56
minsky::EvalOp::evaluate
double evaluate(double in1=0, double in2=0) const override

Member Function Documentation

◆ dFlow()

template<OperationType::Type op>
double minsky::TensorBinOp< op >::dFlow ( size_t  ti,
size_t  fi 
) const
inlineoverride

Definition at line 220 of file minskyTensorOps.cc.

220  {
221  auto deriv1=dynamic_cast<DerivativeMixin*>(arg1.get());
222  auto deriv2=dynamic_cast<DerivativeMixin*>(arg2.get());
223  if (!deriv1 || !deriv2) throw DerivativeNotDefined();
224  double r=0;
225  if (const double df=deriv1->dFlow(ti,fi))
226  r += eo.d1((*arg1)[ti])*df;
227  if (const double df=deriv2->dFlow(ti,fi))
228  r += eo.d2((*arg2)[ti])*df;
229  return r;
230  }
civita::BinOp::arg1
TensorPtr arg1
Definition: tensorOp.h:53
minsky::EvalOp::d1
double d1(double x1=0, double x2=0) const override
civita::BinOp::arg2
TensorPtr arg2
Definition: tensorOp.h:53
minsky::EvalOp::d2
double d2(double x1=0, double x2=0) const override

◆ dStock()

template<OperationType::Type op>
double minsky::TensorBinOp< op >::dStock ( size_t  ti,
size_t  si 
) const
inlineoverride

Definition at line 231 of file minskyTensorOps.cc.

231  {
232  auto deriv1=dynamic_cast<DerivativeMixin*>(arg1.get());
233  auto deriv2=dynamic_cast<DerivativeMixin*>(arg2.get());
234  if (!deriv1 || !deriv2) throw DerivativeNotDefined();
235  double r=0;
236  if (const double ds=deriv1->dStock(ti,si))
237  r += eo.d1((*arg1)[ti])*ds;
238  if (const double ds=deriv2->dStock(ti,si))
239  r += eo.d2((*arg2)[ti])*ds;
240  return r;
241  }
civita::BinOp::arg1
TensorPtr arg1
Definition: tensorOp.h:53
minsky::EvalOp::d1
double d1(double x1=0, double x2=0) const override
civita::BinOp::arg2
TensorPtr arg2
Definition: tensorOp.h:53
minsky::EvalOp::d2
double d2(double x1=0, double x2=0) const override

◆ setArguments()

template<OperationType::Type op>
void minsky::TensorBinOp< op >::setArguments ( const TensorPtr &  a1,
const TensorPtr &  a2,
const ITensor::Args &  args = {"",0} 
)
inlineoverridevirtual

Reimplemented from civita::ITensor.

Definition at line 104 of file minskyTensorOps.cc.

105  {"",0}) override
106  {
107  if (!a1 || a1->rank()==0 || !a2 || a2->rank()==0 || a1->hypercube()==a2->hypercube())
108  civita::BinOp::setArguments(a1,a2,args);
109  else
110  {
111  // pivot a1, a2 such that common axes are at end (resp beginning)
112  auto pivotArg1=make_shared<Pivot>(), pivotArg2=make_shared<Pivot>();
113  pivotArg1->setArgument(a1,{});
114  pivotArg2->setArgument(a2,{});
115 
116  set <string> a2Axes;
117  for (auto& xv: a2->hypercube().xvectors) a2Axes.insert(xv.name);
118 
119  // compute pivot orders and spread dimensions
120  std::vector<string> a1Order, common;
121  Hypercube hcSpread1, hcSpread2;
122  for (auto& i: a1->hypercube().xvectors)
123  if (a2Axes.contains(i.name))
124  {
125  common.push_back(i.name);
126  a2Axes.erase(i.name);
127  }
128  else
129  {
130  a1Order.push_back(i.name);
131  hcSpread2.xvectors.push_back(i);
132  }
133  for (auto& xv: a2->hypercube().xvectors)
134  if (a2Axes.contains(xv.name))
135  hcSpread1.xvectors.push_back(xv);
136  const size_t numCommonAxes=common.size();
137 
138  // append common dimensions to make up a1 final order
139  a1Order.insert(a1Order.end(), common.begin(), common.end());
140  pivotArg1->setOrientation(a1Order);
141  // add in remaining a2 axes to make up a2 order, reusing common.
142  common.insert(common.end(), a2Axes.begin(), a2Axes.end());
143  pivotArg2->setOrientation(common);
144 
145  // now spread pivoted arguments across remaining dimensions
146  auto spread1=make_shared<SpreadLast>();
147  spread1->setArgument(pivotArg1,{});
148  spread1->setSpreadDimensions(hcSpread1);
149  auto spread2=make_shared<SpreadFirst>();
150  spread2->setArgument(pivotArg2,{});
151  spread2->setSpreadDimensions(hcSpread2);
152 
153 #ifndef NDEBUG
154  {
155  auto& xv1=spread1->hypercube().xvectors;
156  auto& xv2=spread2->hypercube().xvectors;
157  assert(xv1.size()==xv2.size());
158  for (size_t i=0; i<xv1.size(); ++i)
159  {
160  assert(xv1[i].name==xv2[i].name);
161  assert(xv1[i].dimension.type==xv2[i].dimension.type);
162  }
163  }
164 #endif
165 
166  if (spread1->hypercube()==spread2->hypercube())
167  {
168  setArguments(spread1, spread2);
169  // calculate the sparsity pattern of the result
170  map<size_t,set<size_t>> p2i;
171  auto& xv=pivotArg2->hypercube().xvectors;
172  size_t commonElements=1;
173  for (size_t i=0; i<numCommonAxes; ++i) commonElements*=xv[i].size();
174  const size_t p1NumElements=pivotArg1->hypercube().numElements();
175  const size_t p1ExtraElements=p1NumElements/commonElements;
176  const size_t p2ExtraElements=pivotArg2->hypercube().numElements()/commonElements;
177  for (auto i: pivotArg2->index())
178  {
179  checkCancel();
180  auto r=lldiv(i,commonElements);
181  p2i[r.rem].insert(r.quot);
182  }
183  set<size_t> index;
184  for (auto i: pivotArg1->index())
185  for (size_t j=0; j<p2ExtraElements; ++j) // loop over all elements that extend pivot1
186  {
187  checkCancel();
188  auto s=p2i.find(i/p1ExtraElements);
189  if (s!=p2i.end())
190  if (s->second.contains(j))
191  index.insert(i+p1NumElements*j);
192  }
193  m_index=index;
194  }
195  else
196  { // hypercubes not equal, interpolate the second argument
197  Hypercube unionHC=spread1->hypercube();
198  civita::unionHypercube(unionHC,spread2->hypercube());
199  TensorPtr arg1=spread1, arg2=spread2;
200  spread1->setIndex();
201  spread2->setIndex();
202  if (unionHC!=spread1->hypercube())
203  {
204  auto interpolate=make_shared<PivotedInterpolateHC>();
205  interpolate->hypercube(unionHC);
206  interpolate->setArgument(spread1,{});
207  arg1=interpolate;
208  }
209  if (unionHC!=spread2->hypercube())
210  {
211  auto interpolate=make_shared<PivotedInterpolateHC>();
212  interpolate->hypercube(unionHC);
213  interpolate->setArgument(spread2,{});
214  arg2=interpolate;
215  }
216  civita::BinOp::setArguments(arg1, arg2, args);
217  }
218  }
219  }
civita::BinOp::arg1
TensorPtr arg1
Definition: tensorOp.h:53
civita::ITensor::index
virtual const Index & index() const
the index vector - assumed to be ordered and unique
Definition: tensorInterface.h:72
civita::ITensor::size
virtual std::size_t size() const
return number of elements in tensor - maybe less than hypercube.numElements if sparse ...
Definition: tensorInterface.h:76
minsky::TensorBinOp::setArguments
void setArguments(const TensorPtr &a1, const TensorPtr &a2, const ITensor::Args &args={"", 0}) override
Definition: minskyTensorOps.cc:104
civita::BinOp::setArguments
void setArguments(const TensorPtr &a1, const TensorPtr &a2, const ITensor::Args &) override
Definition: tensorOp.cc:28
civita::BinOp::arg2
TensorPtr arg2
Definition: tensorOp.h:53
civita::TensorPtr
std::shared_ptr< ITensor > TensorPtr
Definition: tensorInterface.h:34
MathDAG::anonymous_namespace{equationDisplayRender.cc}::Anchor::s

◆ setState()

template<OperationType::Type op>
void minsky::TensorBinOp< op >::setState ( const OperationPtr &  state)
inlineoverridevirtual

Implements minsky::SetState.

Definition at line 103 of file minskyTensorOps.cc.

103 {eo.state=state;}

Member Data Documentation

◆ eo

template<OperationType::Type op>
EvalOp<op> minsky::TensorBinOp< op >::eo

Definition at line 101 of file minskyTensorOps.cc.

The documentation for this struct was generated from the following file: