diff --git a/src/ma_functional.cc b/src/ma_functional.cc new file mode 100644 index 0000000..c86247a --- /dev/null +++ b/src/ma_functional.cc @@ -0,0 +1,52 @@ +// -*- C++ -*- + +#include "ma_functional.h" + +namespace MultiArrayTools +{ + namespace + { + + template + struct MapEvaluation + { + template + static void eval(OutIndex& oi, const MapTuple& mt) + { + oi.template getIndex() = std::get(mt); + MapEvaluation::eval(oi, mt); + } + }; + + template <> + struct MapEvaluation<0> + { + template + static void eval(OutIndex& oi, const MapTuple& mt) + { + oi.template getIndex<0>() = std::get<0>(mt); + } + }; + + } // anonymous namespace + + + template + void IndexMapFunction::linkIndicesTo(IndefinitIndexBase* target) + { + /*!!!!*/ + } + + template + void IndexMapFunction::eval() + { + MapEvaluation::eval(mOIndex, mMap); + } + + template + IndefinitIndexBase& IndexMapFunction::index() + { + return mOIndex; + } + +} diff --git a/src/ma_functional.h b/src/ma_functional.h new file mode 100644 index 0000000..ca87bb6 --- /dev/null +++ b/src/ma_functional.h @@ -0,0 +1,38 @@ +// -*- C++ -*- + +#ifndef __ma_functional_h__ +#define __ma_functional_h__ + +#include +#include +#include + +#include "base_def.h" + +namespace MultiArrayTools +{ + + // Maps... are ConstMultiArrayOperationRoots where the corresponding MultiArray defines the map + template + class IndexMapFunction + { + public: + + typedef std::tuple MapType; + + void linkIndicesTo(IndefinitIndexBase* target); + void eval(); + + IndefinitIndexBase& index(); + + private: + + MapType mMap; + OutIndex mOIndex; + }; + +} + +#include "ma_functional.cc" + +#endif diff --git a/src/multi_array.cc b/src/multi_array.cc index ca01b44..779a24f 100644 --- a/src/multi_array.cc +++ b/src/multi_array.cc @@ -555,4 +555,38 @@ namespace MultiArrayTools mb.execute(); } */ + + + /**************************** + * FunctionalMultiArray * + ****************************/ + + template + FunctionalMultiArray::FunctionalMultiArray(const Range& range) : + MultiArrayBase(range), mFunc() {} + + template + FunctionalMultiArray::FunctionalMultiArray(const Range& range, + const Function& func) : + MultiArrayBase(range), mFunc(func) {} + + template + const T& FunctionalMultiArray::operator[](const typename Range::IndexType& i) const + { + mVal = mFunc(i); + return mVal; + } + + template + bool FunctionalMultiArray::isConst() const + { + return true; + } + + template + bool FunctionalMultiArray::isSlice() const + { + return false; + } + } diff --git a/src/multi_array.h b/src/multi_array.h index d31d1b2..0fb9f4d 100644 --- a/src/multi_array.h +++ b/src/multi_array.h @@ -233,7 +233,7 @@ namespace MultiArrayTools std::vector mCont; }; - template + template class FunctionalMultiArray : public MultiArrayBase { public: @@ -241,15 +241,17 @@ namespace MultiArrayTools typedef typename MultiArrayBase::const_iterator const_iterator; DEFAULT_MEMBERS(FunctionalMultiArray); - FunctionalMultiArray(const Range& range, /*Function*/); + FunctionalMultiArray(const Range& range); + FunctionalMultiArray(const Range& range, const Function& func); - T& operator[](const typename Range::IndexType& i) override; - const T& operator[](const typename Range::IndexType& i) const override; + virtual const T& operator[](const typename Range::IndexType& i) const override; virtual bool isConst() const override; virtual bool isSlice() const override; protected: + mutable T mVal; + Function mFunc; // FUNCTION !!!! }; diff --git a/src/multi_array_operation.cc b/src/multi_array_operation.cc index 0b65ea4..6fadf0b 100644 --- a/src/multi_array_operation.cc +++ b/src/multi_array_operation.cc @@ -532,11 +532,13 @@ namespace MultiArrayTools } template - MultiArrayOperationMap& operator=(const ConstMultiArrayOperationRoot& in) + MultiArrayOperationMap& MultiArrayOperationMap:: + operator=(const ConstMultiArrayOperationRoot& in) { mIndex = dynamic_cast( in.getIndex() ); MAOB::mIibPtr = &mIndex; mNm = in.name(); + mIndex.name(mNm); // to be sure... mIndex.setPos( mIndex.max() ); typename OutRange::IndexType endIndex = mIndex; @@ -546,34 +548,51 @@ namespace MultiArrayTools MultiArray cnt(mRoot->range()); auto cnto = cnt(mRoot.name(), true); - cnto.linkIndicesTo( &mMF.index() ) + cnto.linkIndicesTo( &mMF.index() ); - for(mIndex.setPos(0); mIndex != endIndex; ++mIndex){ - mRoot.get() += in.get(); + for(mIndex.setPos(0), mMF.eval(); mIndex != endIndex; ++mIndex, mMF.eval()){ + get() += in.get(); ++cnto.get(); } + // CHECK whether T / size_t mixture works!! mRoot /= cnto; } template - virtual size_t argNum() const override; + size_t MultiArrayOperationMap::argNum() const + { + return 1; + } template - virtual IndefinitIndexBase* getLinked(const std::string& name) const override; + IndefinitIndexBase* MultiArrayOperationMap:: + getLinked(const std::string& name) const + { + return mRoot.getLinked(name); + } template - virtual void linkIndicesTo(IndefinitIndexBase* target) const override; + void MultiArrayOperationMap::linkIndicesTo(IndefinitIndexBase* target) const + { + mRoot.linkIndicesTo(target); + } template - virtual void setInternalLinks() const override; + void MultiArrayOperationMap::setInternalLinks() const + { } template - virtual const T& get() const override; + const T& MultiArrayOperationMap::get() const + { + return mRoot.get(); + } template - virtual T& get() override; - - + T& MultiArrayOperationMap::get() + { + return mRoot.get(); + } + /***************************** * MultiArrayOperation * *****************************/ @@ -625,6 +644,10 @@ namespace MultiArrayTools -> decltype(op(std::get<0>(tp).get(), args.get()...)) { return op(std::get<0>(tp).get(), args.get()...); + /* + return op(static_cast( std::get<0>(tp).get() ), + static_cast( args.get() )...); + */ } template diff --git a/src/multi_array_operation.h b/src/multi_array_operation.h index ad2dd8f..896207a 100644 --- a/src/multi_array_operation.h +++ b/src/multi_array_operation.h @@ -18,6 +18,8 @@ namespace MultiArrayTools { public: + typedef T ValType; + MultiArrayOperationBase() /*{ CHECK; }*/ = default; virtual ~MultiArrayOperationBase();