Doxygen/html/inmost__autodiff_8h_source.html

 #ifndef INMOST_AUTODIFF_H_INCLUDED

 #define INMOST_AUTODIFF_H_INCLUDED


 #include "inmost_common.h"

 #include "inmost_mesh.h"


 #if defined(USE_AUTODIFF) && defined(USE_MESH)


 namespace INMOST

 {

     class Automatizator; //forward declaration


     //return specific type with specific template

     template<class T> struct Demote;

     template<> struct Demote<INMOST_DATA_INTEGER_TYPE> {typedef INMOST_DATA_INTEGER_TYPE type;};

     template<> struct Demote<INMOST_DATA_REAL_TYPE> {typedef INMOST_DATA_REAL_TYPE type;};

     template<> struct Demote<unknown> {typedef unknown type;};

     template<> struct Demote<variable> {typedef unknown type;};

     template<> struct Demote<hessian_variable> {typedef unknown type;};


     class AbstractEntry

     {

         INMOST_DATA_ENUM_TYPE              reg_index;

         TagInteger                         offset_tag;

         MarkerType                         mask;

         bool                               inverse_mask;

         ElementType                        etype;

     public:

         AbstractEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false)

         : reg_index(ENUMUNDEF), offset_tag(Tag()), mask(mask), inverse_mask(inverse), etype(etype) {}

         MarkerType GetMask() const {return mask;}

         bool GetMaskInverse() const {return inverse_mask;}

         void SetMask(MarkerType _mask, bool inverse = false) {mask = _mask; inverse_mask = inverse;}

         ElementType GetElementType() const {return etype;}

         void SetElementType(ElementType _etype) {etype = _etype;}

         TagInteger GetOffsetTag() const {return offset_tag;}

         void SetOffsetTag(TagInteger tag) {offset_tag = tag;}

         bool isValid(const Storage & e) const {return reg_index != ENUMUNDEF && offset_tag.isDefined(e.GetElementType()) && (e.GetElementType() & etype) && (mask == 0 || (e->GetMarker(mask) ^ inverse_mask));}

         virtual INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const = 0;

         virtual INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) = 0;

         virtual INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const = 0;

         virtual unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const = 0;

         virtual Matrix<value_reference> Value(const Storage& e) = 0;

         virtual rMatrix Value(const Storage & e) const = 0;

         virtual iMatrix Index(const Storage & e) const = 0;

         virtual uMatrix Unknown(const Storage & e) const = 0;

         template<typename T>

         Matrix<typename Demote<T>::type>

         Access(const Storage &e) const;

         template<typename T>

         typename Demote<T>::type

         Access(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const;

         virtual uMatrix operator [](const Storage & e) const = 0;

         virtual INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const = 0;

         virtual INMOST_DATA_ENUM_TYPE Size() const = 0;

         virtual INMOST_DATA_ENUM_TYPE Size(const Storage & e) const = 0;

         virtual INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const = 0;

         virtual TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const = 0;

         virtual Mesh * GetMeshLink() const = 0;

         virtual AbstractEntry * Copy() const = 0;

         INMOST_DATA_ENUM_TYPE GetRegistrationIndex() const {return reg_index;}

         void SynchronizeData();

         virtual ~AbstractEntry() {}


         friend class Automatizator; //provide registration index from inside of Automatizator

         friend class Model; //provide registration index from inside of Model

     };


     class BlockEntry : public AbstractEntry

     {

         std::vector<TagRealArray>          unknown_tags;

         std::vector<INMOST_DATA_ENUM_TYPE> unknown_comp;

     public:

         BlockEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false) : AbstractEntry(etype,mask,inverse) {}

         void ClearTags() { unknown_tags.clear(); unknown_comp.clear(); }

         void AddTag(Tag value, INMOST_DATA_ENUM_TYPE comp = ENUMUNDEF);

         INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return unknown_tags[pos][e][unknown_comp[pos]];}

         INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) {return unknown_tags[pos][e][unknown_comp[pos]];}

         INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return isValid(e) ? GetOffsetTag()[e]+pos : ENUMUNDEF;}

         unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return unknown(Value(e,pos),Index(e,pos));}

         rMatrix Value(const Storage& e) const { rMatrix ret(MatrixSize(e), 1); for (unsigned k = 0; k < Size(); ++k) ret(k, 0) = Value(e, k); return ret; }

         Matrix<value_reference> Value(const Storage & e) {Matrix<value_reference> ret(MatrixSize(e),1); for(unsigned k = 0; k < Size(); ++k) new (&ret(k,0)) value_reference(Value(e,k)); return ret; }

         iMatrix Index(const Storage & e) const {iMatrix ret(MatrixSize(e),1); for(unsigned k = 0; k < Size(); ++k) ret(k,0) = Index(e,k); return ret; }

         uMatrix Unknown(const Storage & e) const {return BlockEntry::operator [](e);}

         uMatrix operator [](const Storage & e) const {uMatrix ret(MatrixSize(e),1); for(unsigned k = 0; k < Size(); ++k) ret(k,0) = Unknown(e,k); return ret; }

         INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const {(void)e; return Size();}

         INMOST_DATA_ENUM_TYPE Size() const {return (INMOST_DATA_ENUM_TYPE)unknown_tags.size();}

         INMOST_DATA_ENUM_TYPE Size(const Storage & e) const

         {

             INMOST_DATA_ENUM_TYPE ret = 0;

             for(unsigned k = 0; k < unknown_tags.size(); ++k)

                 if( e.HaveData(unknown_tags[k]) )   ret++;

             return ret;

         }

         INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const {return unknown_comp[unk];}

         TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const {return unknown_tags[unk];}

         Mesh * GetMeshLink() const {return unknown_tags.back().GetMeshLink();}

         AbstractEntry * Copy() const {BlockEntry * ret = new BlockEntry(GetElementType(),GetMask(),GetMaskInverse()); for(unsigned k = 0; k < Size(); ++k) ret->AddTag(unknown_tags[k],unknown_comp[k]); return ret; }

     };

     class SingleEntry : public AbstractEntry

     {

         TagRealArray          unknown_tag;

         INMOST_DATA_ENUM_TYPE unknown_comp;

     public:

         SingleEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false) : AbstractEntry(etype, mask, inverse) { unknown_comp = 0; }

         SingleEntry(ElementType etype, MarkerType mask, bool inverse, Tag unknown_tag, INMOST_DATA_ENUM_TYPE unknown_comp = 0) : AbstractEntry(etype,mask,inverse), unknown_tag(unknown_tag), unknown_comp(unknown_comp) {}

         void SetTag(Tag unknown_tag_in, INMOST_DATA_ENUM_TYPE unknown_comp_in = 0) {unknown_tag = unknown_tag_in; unknown_comp = unknown_comp_in;}

         INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {(void)pos; assert(pos==0); return unknown_tag[e][unknown_comp];}

         INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) {(void)pos; assert(pos==0); return unknown_tag[e][unknown_comp];}

         INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {(void)pos; assert(pos==0); return isValid(e) ? GetOffsetTag()[e] : ENUMUNDEF;}

         unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {assert(pos==0); return unknown(Value(e,pos),Index(e,pos));}

         Matrix<value_reference> Value(const Storage& e) { Matrix<value_reference> ret(1, 1); new (&ret(0, 0)) value_reference(Value(e, 0)); return ret; }

         rMatrix Value(const Storage & e) const { rMatrix ret(1,1); ret(0,0) = Value(e,0); return ret; }

         iMatrix Index(const Storage & e) const { iMatrix ret(1,1); ret(0,0) = Index(e,0); return ret; }

         uMatrix Unknown(const Storage & e) const {return SingleEntry::operator [](e);}

         uMatrix operator [](const Storage & e) const { uMatrix ret(1,1); ret(0,0) = Unknown(e,0); return ret; }

         INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const {(void)e; return 1;}

         INMOST_DATA_ENUM_TYPE Size() const {return 1;}

         INMOST_DATA_ENUM_TYPE Size(const Storage & e) const {(void)e; return e.HaveData(unknown_tag) ? 1 : 0;}

         INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const {(void)unk; assert(unk == 0); return unknown_comp;}

         TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const {(void)unk; assert(unk == 0); return unknown_tag;}

         Mesh * GetMeshLink() const {return unknown_tag.GetMeshLink();}

         AbstractEntry * Copy() const {return new SingleEntry(GetElementType(),GetMask(),GetMaskInverse(),unknown_tag,unknown_comp);}

     };

     class VectorEntry : public AbstractEntry

     {

         TagRealArray          unknown_tag;

     public:

         VectorEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false) : AbstractEntry(etype,mask,inverse) {}

         VectorEntry(ElementType etype, MarkerType mask, bool inverse, Tag unknown_tag) : AbstractEntry(etype,mask,inverse), unknown_tag(unknown_tag) {}

         void SetTag(Tag unknown_tag_in) {unknown_tag = unknown_tag_in;}

         INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {assert(pos<unknown_tag[e].size()); return unknown_tag[e][pos];}

         INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) {assert(pos<unknown_tag[e].size()); return unknown_tag[e][pos];}

         INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {assert(pos<unknown_tag[e].size()); return isValid(e) ? GetOffsetTag()[e]+pos : ENUMUNDEF;}

         unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {assert(pos<unknown_tag[e].size()); return unknown(Value(e,pos),Index(e,pos));}

         Matrix<value_reference> Value(const Storage& e) { Matrix<value_reference> ret(MatrixSize(e), 1); for (int k = 0; k < (int)unknown_tag[e].size(); ++k) new (&ret(k, 0)) value_reference(Value(e, k)); return ret; }

         rMatrix Value(const Storage & e) const { rMatrix ret(MatrixSize(e),1); for(int k = 0; k < (int)unknown_tag[e].size(); ++k) ret(k,0) = Value(e,k); return ret; }

         iMatrix Index(const Storage & e) const { iMatrix ret(MatrixSize(e),1); for(int k = 0; k < (int)unknown_tag[e].size(); ++k) ret(k,0) = Index(e,k); return ret; }

         uMatrix Unknown(const Storage & e) const {return VectorEntry::operator [](e);}

         uMatrix operator [](const Storage & e) const { uMatrix ret(MatrixSize(e),1); for(int k = 0; k < (int)unknown_tag[e].size(); ++k) ret(k,0) = Unknown(e,k); return ret; }

         INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const {return (INMOST_DATA_ENUM_TYPE)unknown_tag[e].size();}

         INMOST_DATA_ENUM_TYPE Size() const {return 1;}

         INMOST_DATA_ENUM_TYPE Size(const Storage & e) const {return e.HaveData(unknown_tag) ? (INMOST_DATA_ENUM_TYPE)unknown_tag[e].size() : 0;}

         INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const {(void)unk; assert(unk==0); return ENUMUNDEF;}

         TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const {(void)unk; assert(unk==0); return unknown_tag;}

         Mesh * GetMeshLink() const {return unknown_tag.GetMeshLink();}

         AbstractEntry * Copy() const {return new VectorEntry(GetElementType(),GetMask(),GetMaskInverse(),unknown_tag);}

     };

     class StatusBlockEntry : public AbstractEntry

     {

         std::vector<TagRealArray>          unknown_tags;

         std::vector<INMOST_DATA_ENUM_TYPE> unknown_comp;

         TagInteger                         status_tag;

         std::vector< std::vector<bool> >   status_tbl;

     public:

         StatusBlockEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false) : AbstractEntry(etype,mask,inverse), status_tag(Tag()) {}

         StatusBlockEntry(ElementType etype, MarkerType mask, bool inverse, TagInteger status_tag) : AbstractEntry(etype,mask,inverse), status_tag(status_tag) {}

         StatusBlockEntry(ElementType etype, MarkerType mask, bool inverse, TagInteger status_tag, const std::vector< std::vector<bool> >  & status_tbl) : AbstractEntry(etype,mask,inverse), status_tag(status_tag), status_tbl(status_tbl) {}

         void ClearTags() { unknown_tags.clear(); unknown_comp.clear(); }

         void AddTag(Tag value, INMOST_DATA_ENUM_TYPE comp = ENUMUNDEF);

         void AddStatus(const std::vector<bool> & stat) {status_tbl.push_back(stat);}

         void SetStatusTag(TagInteger input) {status_tag = input;}

         INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return unknown_tags[pos][e][unknown_comp[pos]];}

         INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) {return unknown_tags[pos][e][unknown_comp[pos]];}

         INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return isValid(e) && status_tbl[status_tag[e]][pos] ? GetOffsetTag()[e]+pos : ENUMUNDEF;}

         unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const {return unknown(Value(e,pos),Index(e,pos));}

         Matrix<value_reference> Value(const Storage& e) { Matrix<value_reference> ret(MatrixSize(e), 1); for (INMOST_DATA_ENUM_TYPE k = 0; k < Size(); ++k) new (&ret(k, 0)) value_reference(Value(e, k)); return ret; }

         rMatrix Value(const Storage & e) const {rMatrix ret(MatrixSize(e),1); for(INMOST_DATA_ENUM_TYPE k = 0; k < Size(); ++k) ret(k,0) = Value(e,k); return ret; }

         iMatrix Index(const Storage & e) const {iMatrix ret(MatrixSize(e),1); for(INMOST_DATA_ENUM_TYPE k = 0; k < Size(); ++k) ret(k,0) = Index(e,k); return ret; }

         uMatrix Unknown(const Storage & e) const {return StatusBlockEntry::operator [](e);}

         uMatrix operator [](const Storage & e) const {uMatrix ret(MatrixSize(e),1); for(INMOST_DATA_ENUM_TYPE k = 0; k < Size(); ++k) ret(k,0) = Unknown(e,k); return ret; }

         INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const {(void)e; return Size();}

         INMOST_DATA_ENUM_TYPE Size() const {return (INMOST_DATA_ENUM_TYPE)unknown_tags.size();}

         INMOST_DATA_ENUM_TYPE Size(const Storage & e) const;

         INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const {return unknown_comp[unk];}

         TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const {return unknown_tags[unk];}

         Mesh * GetMeshLink() const {return unknown_tags.back().GetMeshLink();}

         AbstractEntry * Copy() const;

     };

     class MultiEntry : public AbstractEntry

     {

         std::vector<AbstractEntry *> entries;

     public:

         MultiEntry(ElementType etype = NONE, MarkerType mask = 0, bool inverse = false) : AbstractEntry(etype,mask,inverse) {}

         ~MultiEntry() {for(unsigned k = 0; k < entries.size(); ++k) delete entries[k];}

         void AddEntry(const AbstractEntry & entry);

         AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE k) {return *entries[k];}

         const AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE k) const {return *entries[k];}

         INMOST_DATA_ENUM_TYPE NumEntries() const {return (INMOST_DATA_ENUM_TYPE)entries.size();}

         INMOST_DATA_REAL_TYPE Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const;

         INMOST_DATA_REAL_TYPE & Value(const Storage & e, INMOST_DATA_ENUM_TYPE pos);

         INMOST_DATA_ENUM_TYPE Index(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const;

         unknown Unknown(const Storage & e, INMOST_DATA_ENUM_TYPE pos) const;

         Matrix<value_reference> Value(const Storage& e);

         rMatrix Value(const Storage & e) const;

         iMatrix Index(const Storage & e) const;

         uMatrix Unknown(const Storage & e) const {return MultiEntry::operator [](e);}

         uMatrix operator [](const Storage & e) const;

         INMOST_DATA_ENUM_TYPE MatrixSize(const Storage & e) const;

         INMOST_DATA_ENUM_TYPE Size() const {INMOST_DATA_ENUM_TYPE ret = 0; for(unsigned k = 0; k < entries.size(); ++k) ret += entries[k]->Size(); return ret;}

         INMOST_DATA_ENUM_TYPE Size(const Storage & e) const {INMOST_DATA_ENUM_TYPE ret = 0; for(unsigned k = 0; k < entries.size(); ++k) ret += entries[k]->Size(e); return ret;}

         INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const;

         TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const;

         Mesh * GetMeshLink() const {assert(!entries.empty()); return entries.back()->GetMeshLink();}

         AbstractEntry * Copy() const;

     };

     class Automatizator

     {

     private:

         typedef std::vector<AbstractEntry *>       blk_enum;

         typedef std::vector<INMOST_DATA_ENUM_TYPE> del_enum;

         typedef std::vector<bool>                  act_enum;

     private:

         std::string           name;

         del_enum              del_blocks;

         blk_enum              reg_blocks;

         act_enum              act_blocks;

         INMOST_DATA_ENUM_TYPE first_num;

         INMOST_DATA_ENUM_TYPE last_num;

     public:

         Automatizator(const Automatizator & b);

         Automatizator & operator =(Automatizator const & b);

         Automatizator(std::string name = "");

         ~Automatizator();

         __INLINE INMOST_DATA_ENUM_TYPE GetFirstIndex() const { return first_num; }

         __INLINE INMOST_DATA_ENUM_TYPE GetLastIndex() const { return last_num; }

         INMOST_DATA_ENUM_TYPE RegisterTag(Tag t, ElementType typemask, MarkerType domain_mask = 0, bool inverse = false);

         INMOST_DATA_ENUM_TYPE RegisterEntry(const AbstractEntry & e);

         INMOST_DATA_ENUM_TYPE RegisterEntry(AbstractEntry & e);

         void UnregisterEntry(INMOST_DATA_ENUM_TYPE ind);

         void DeactivateEntry(INMOST_DATA_ENUM_TYPE ind);

         void ActivateEntry(INMOST_DATA_ENUM_TYPE ind);

         void EnumerateEntries(bool blocks = false);

         __INLINE bool isRegisteredEntry(INMOST_DATA_ENUM_TYPE ind) const {return reg_blocks[ind] != NULL;}

         INMOST_DATA_ENUM_TYPE GetIndex(const Storage & e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos = 0) const {return GetEntry(reg_index).Index(e,pos);}

         INMOST_DATA_REAL_TYPE GetValue(const Storage & e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos = 0) const {return GetEntry(reg_index).Value(e,pos);}

         unknown GetUnknown(const Storage & e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos = 0) const {return GetEntry(reg_index).Unknown(e,pos);}

         AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE ind) {return *reg_blocks[ind];}

         const AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE ind) const {return *reg_blocks[ind];}

         std::vector<INMOST_DATA_ENUM_TYPE> ListRegisteredEntries() const;

         void SynchronizeData();

     };

 } //namespace INMOST


 #endif //USE_AUTODIFF && USE_MESH


 #endif //INMOST_AUTODIFF_H_INCLUDED

INMOST::AbstractEntry
This class is used to organize unknowns in abstract way, it should be registered with and managed by ...
Definition: inmost_autodiff.h:30

INMOST::AbstractEntry::Unknown
virtual uMatrix Unknown(const Storage &e) const =0
Return vector filled with unknowns of the block with their derivatives.

INMOST::AbstractEntry::GetMeshLink
virtual Mesh * GetMeshLink() const =0
Retrieve mesh pointer.

INMOST::AbstractEntry::Unknown
virtual unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const =0
Return unknown in vector of variables of the block at certain position.

INMOST::AbstractEntry::SetMask
void SetMask(MarkerType _mask, bool inverse=false)
Set mask for the block.
Definition: inmost_autodiff.h:44

INMOST::AbstractEntry::GetRegistrationIndex
INMOST_DATA_ENUM_TYPE GetRegistrationIndex() const
Retrieve a registration index.
Definition: inmost_autodiff.h:108

INMOST::AbstractEntry::Value
virtual INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const =0
Return value in vector of unknowns of the block at certain position.

INMOST::AbstractEntry::Size
virtual INMOST_DATA_ENUM_TYPE Size(const Storage &e) const =0
Total number of entries that this block expands to on given element, count variable-sized entries.

INMOST::AbstractEntry::MatrixSize
virtual INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const =0
The intended size of the matrix for this entry.

INMOST::AbstractEntry::~AbstractEntry
virtual ~AbstractEntry()
Destructor.
Definition: inmost_autodiff.h:113

INMOST::AbstractEntry::Copy
virtual AbstractEntry * Copy() const =0
Make a copy of the object.

INMOST::AbstractEntry::GetElementType
ElementType GetElementType() const
Retrieve element type of the block.
Definition: inmost_autodiff.h:46

INMOST::AbstractEntry::Index
virtual iMatrix Index(const Storage &e) const =0
Return vector filled with indices of unknowns of the block.

INMOST::AbstractEntry::SetOffsetTag
void SetOffsetTag(TagInteger tag)
Retrieve tag that stores enumeration offset on each element.
Definition: inmost_autodiff.h:52

INMOST::AbstractEntry::Access
Matrix< typename Demote< T >::type > Access(const Storage &e) const
Return vector filled with either values or indices or unknowns of the block, depending on the templat...

INMOST::AbstractEntry::GetValueComp
virtual INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const =0
Retrieve component of the tag related to unknown.

INMOST::AbstractEntry::isValid
bool isValid(const Storage &e) const
Check that the block is valid on given element.
Definition: inmost_autodiff.h:54

INMOST::AbstractEntry::SynchronizeData
void SynchronizeData()
Update variables contained in block on ghost elements of the grid.

INMOST::AbstractEntry::Value
virtual Matrix< value_reference > Value(const Storage &e)=0
Return vector filled with references to values of unknowns of the block.

INMOST::AbstractEntry::GetOffsetTag
TagInteger GetOffsetTag() const
Retrieve tag that stores enumeration offset on each element.
Definition: inmost_autodiff.h:50

INMOST::AbstractEntry::GetValueTag
virtual TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const =0
Retrieve tag related to unknown value.

INMOST::AbstractEntry::Value
virtual INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)=0
Return value in vector of unknowns of the block at certain position.

INMOST::AbstractEntry::SetElementType
void SetElementType(ElementType _etype)
Set element type for the block.
Definition: inmost_autodiff.h:48

INMOST::AbstractEntry::operator[]
virtual uMatrix operator[](const Storage &e) const =0
Return vector filled with unknowns of the block with their derivatives.

INMOST::AbstractEntry::Value
virtual rMatrix Value(const Storage &e) const =0
Return vector filled with values of unknowns of the block.

INMOST::AbstractEntry::Size
virtual INMOST_DATA_ENUM_TYPE Size() const =0
Number of tags in block.

INMOST::AbstractEntry::Access
Demote< T >::type Access(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return either value or index or unknown at specified position of the block, depending on the template...

INMOST::AbstractEntry::GetMask
MarkerType GetMask() const
Retrieve mask of the block.
Definition: inmost_autodiff.h:40

INMOST::AbstractEntry::GetMaskInverse
bool GetMaskInverse() const
Retrieve if the mask is inverted.
Definition: inmost_autodiff.h:42

INMOST::AbstractEntry::Index
virtual INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const =0
Return index in vector of indices of the block at certain position.

INMOST::Automatizator
The Automatizator class helps in defining primary unknowns of the model and enhances user experience ...
Definition: inmost_autodiff.h:392

INMOST::Automatizator::GetEntry
AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE ind)
Retrieve the block from automatizator by index.
Definition: inmost_autodiff.h:466

INMOST::Automatizator::Automatizator
Automatizator(const Automatizator &b)
Make a copy.

INMOST::Automatizator::EnumerateEntries
void EnumerateEntries(bool blocks=false)
Set index for every data entry of dynamic tag.

INMOST::Automatizator::isRegisteredEntry
__INLINE bool isRegisteredEntry(INMOST_DATA_ENUM_TYPE ind) const
Check whether the tag is still registered.
Definition: inmost_autodiff.h:458

INMOST::Automatizator::DeactivateEntry
void DeactivateEntry(INMOST_DATA_ENUM_TYPE ind)
Swith a registered tag to be non-active, in this case it's unknowns are considered to be constant.

INMOST::Automatizator::ActivateEntry
void ActivateEntry(INMOST_DATA_ENUM_TYPE ind)
Swith a registered tag to be active, in this case it's unknowns are considered to be variable.

INMOST::Automatizator::GetFirstIndex
__INLINE INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Retrieve first index of unknowns, local to the processor.
Definition: inmost_autodiff.h:421

INMOST::Automatizator::RegisterEntry
INMOST_DATA_ENUM_TYPE RegisterEntry(const AbstractEntry &e)
Register block with the automatizator.

INMOST::Automatizator::GetLastIndex
__INLINE INMOST_DATA_ENUM_TYPE GetLastIndex() const
Retrieve last index of unknowns, local to the processor.
Definition: inmost_autodiff.h:423

INMOST::Automatizator::GetIndex
INMOST_DATA_ENUM_TYPE GetIndex(const Storage &e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos=0) const
Get index of the unknown associated with the entry on element.
Definition: inmost_autodiff.h:460

INMOST::Automatizator::SynchronizeData
void SynchronizeData()
Update variables contained in all block of automatizator on ghost elements of the grid.

INMOST::Automatizator::UnregisterEntry
void UnregisterEntry(INMOST_DATA_ENUM_TYPE ind)
Erase a registered tag.

INMOST::Automatizator::GetValue
INMOST_DATA_REAL_TYPE GetValue(const Storage &e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos=0) const
Get value of the unknown associated with the entry on element.
Definition: inmost_autodiff.h:462

INMOST::Automatizator::~Automatizator
~Automatizator()
Destructor for the automatizator, deletes all the tags corresponding to indices from respective meshe...

INMOST::Automatizator::operator=
Automatizator & operator=(Automatizator const &b)
Performs assignment.

INMOST::Automatizator::GetUnknown
unknown GetUnknown(const Storage &e, INMOST_DATA_ENUM_TYPE reg_index, INMOST_DATA_ENUM_TYPE pos=0) const
Get unknown associated with the entry on element.
Definition: inmost_autodiff.h:464

INMOST::Automatizator::GetEntry
const AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE ind) const
Retrieve the block from automatizator by index.
Definition: inmost_autodiff.h:468

INMOST::Automatizator::ListRegisteredEntries
std::vector< INMOST_DATA_ENUM_TYPE > ListRegisteredEntries() const
Lists all the indices of registered tags.

INMOST::Automatizator::Automatizator
Automatizator(std::string name="")
Makes an empty Automatizator.

INMOST::Automatizator::RegisterTag
INMOST_DATA_ENUM_TYPE RegisterTag(Tag t, ElementType typemask, MarkerType domain_mask=0, bool inverse=false)
Set data of tag t defined on domain_mask to be dynamic data.

INMOST::BlockEntry
This class is used to organize unknowns into blocks, blocks enumeration are managed by class Automati...
Definition: inmost_autodiff.h:124

INMOST::BlockEntry::operator[]
uMatrix operator[](const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:153

INMOST::BlockEntry::Value
rMatrix Value(const Storage &e) const
Return vector filled with values of unknowns of the block.
Definition: inmost_autodiff.h:145

INMOST::BlockEntry::GetValueComp
INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const
Retrieve component of the tag related to unknown.
Definition: inmost_autodiff.h:167

INMOST::BlockEntry::BlockEntry
BlockEntry(ElementType etype=NONE, MarkerType mask=0, bool inverse=false)
Default constructor.
Definition: inmost_autodiff.h:129

INMOST::BlockEntry::Value
Matrix< value_reference > Value(const Storage &e)
Return vector filled with references to values of unknowns of the block.
Definition: inmost_autodiff.h:147

INMOST::BlockEntry::Unknown
uMatrix Unknown(const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:151

INMOST::BlockEntry::AddTag
void AddTag(Tag value, INMOST_DATA_ENUM_TYPE comp=ENUMUNDEF)
Add a component of the tag as unknown, by default all components of the tag are added.

INMOST::BlockEntry::Index
iMatrix Index(const Storage &e) const
Return vector filled with indices of unknowns of the block.
Definition: inmost_autodiff.h:149

INMOST::BlockEntry::Value
INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:139

INMOST::BlockEntry::Size
INMOST_DATA_ENUM_TYPE Size() const
Number of tags in block.
Definition: inmost_autodiff.h:157

INMOST::BlockEntry::GetValueTag
TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const
Retrieve tag related to unknown value.
Definition: inmost_autodiff.h:169

INMOST::BlockEntry::ClearTags
void ClearTags()
Remove all existing tags.
Definition: inmost_autodiff.h:131

INMOST::BlockEntry::Copy
AbstractEntry * Copy() const
Make a copy of the object.
Definition: inmost_autodiff.h:173

INMOST::BlockEntry::MatrixSize
INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const
The intended size of the matrix for this entry.
Definition: inmost_autodiff.h:155

INMOST::BlockEntry::Value
INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:137

INMOST::BlockEntry::Unknown
unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return unknown in vector of variables of the block at certain position.
Definition: inmost_autodiff.h:143

INMOST::BlockEntry::Size
INMOST_DATA_ENUM_TYPE Size(const Storage &e) const
Number of entries for each tag in the block.
Definition: inmost_autodiff.h:159

INMOST::BlockEntry::GetMeshLink
Mesh * GetMeshLink() const
Retrieve mesh pointer.
Definition: inmost_autodiff.h:171

INMOST::BlockEntry::Index
INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return index in vector of indices of the block at certain position.
Definition: inmost_autodiff.h:141

INMOST::Matrix
Class for linear algebra operations on dense matrices.
Definition: inmost_dense.h:1434

INMOST::Mesh
Definition: inmost_mesh.h:1304

INMOST::Model
A class to organize a model.
Definition: inmost_model.h:186

INMOST::MultiEntry
Stack together multiple objects of AbstractEntry class.
Definition: inmost_autodiff.h:331

INMOST::MultiEntry::Unknown
unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return unknown in vector of variables of the block at certain position.

INMOST::MultiEntry::GetValueTag
TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const
Retrieve tag related to unknown value.

INMOST::MultiEntry::operator[]
uMatrix operator[](const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.

INMOST::MultiEntry::Unknown
uMatrix Unknown(const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:361

INMOST::MultiEntry::GetEntry
const AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE k) const
Retrieve entry from block of entries.
Definition: inmost_autodiff.h:343

INMOST::MultiEntry::Value
INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)
Return value in vector of unknowns of the block at certain position.

INMOST::MultiEntry::Index
INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return index in vector of indices of the block at certain position.

INMOST::MultiEntry::NumEntries
INMOST_DATA_ENUM_TYPE NumEntries() const
Total number of entries.
Definition: inmost_autodiff.h:345

INMOST::MultiEntry::Copy
AbstractEntry * Copy() const
Make a copy of the object.

INMOST::MultiEntry::GetValueComp
INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const
Retrieve component of the tag related to unknown.

INMOST::MultiEntry::Value
Matrix< value_reference > Value(const Storage &e)
Return vector filled with references to values of unknowns of the block.

INMOST::MultiEntry::Value
rMatrix Value(const Storage &e) const
Return vector filled with values of unknowns of the block.

INMOST::MultiEntry::Size
INMOST_DATA_ENUM_TYPE Size(const Storage &e) const
Number of entries for each tag in the block.
Definition: inmost_autodiff.h:369

INMOST::MultiEntry::GetEntry
AbstractEntry & GetEntry(INMOST_DATA_ENUM_TYPE k)
Retrieve entry from block of entries.
Definition: inmost_autodiff.h:341

INMOST::MultiEntry::GetMeshLink
Mesh * GetMeshLink() const
Retrieve mesh pointer.
Definition: inmost_autodiff.h:375

INMOST::MultiEntry::Size
INMOST_DATA_ENUM_TYPE Size() const
Number of tags in block.
Definition: inmost_autodiff.h:367

INMOST::MultiEntry::~MultiEntry
~MultiEntry()
Destructor.
Definition: inmost_autodiff.h:337

INMOST::MultiEntry::AddEntry
void AddEntry(const AbstractEntry &entry)
Add entry into block of entries.

INMOST::MultiEntry::Value
INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return value in vector of unknowns of the block at certain position.

INMOST::MultiEntry::Index
iMatrix Index(const Storage &e) const
Return vector filled with indices of unknowns of the block.

INMOST::MultiEntry::MatrixSize
INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const
The intended size of the matrix for this entry.

INMOST::MultiEntry::MultiEntry
MultiEntry(ElementType etype=NONE, MarkerType mask=0, bool inverse=false)
Default constructor.
Definition: inmost_autodiff.h:335

INMOST::SingleEntry
This class is used to organize a single unknown.
Definition: inmost_autodiff.h:177

INMOST::SingleEntry::MatrixSize
INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const
The intended size of the matrix for this entry.
Definition: inmost_autodiff.h:206

INMOST::SingleEntry::Size
INMOST_DATA_ENUM_TYPE Size() const
Number of tags in block.
Definition: inmost_autodiff.h:208

INMOST::SingleEntry::Unknown
unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return unknown in vector of variables of the block at certain position.
Definition: inmost_autodiff.h:194

INMOST::SingleEntry::GetValueTag
TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const
Retrieve tag related to unknown value.
Definition: inmost_autodiff.h:214

INMOST::SingleEntry::Value
INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:188

INMOST::SingleEntry::Value
INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:190

INMOST::SingleEntry::GetValueComp
INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const
Retrieve component of the tag related to unknown.
Definition: inmost_autodiff.h:212

INMOST::SingleEntry::Copy
AbstractEntry * Copy() const
Make a copy of the object.
Definition: inmost_autodiff.h:218

INMOST::SingleEntry::GetMeshLink
Mesh * GetMeshLink() const
Retrieve mesh pointer.
Definition: inmost_autodiff.h:216

INMOST::SingleEntry::Value
rMatrix Value(const Storage &e) const
Return vector filled with values of unknowns of the block.
Definition: inmost_autodiff.h:198

INMOST::SingleEntry::SingleEntry
SingleEntry(ElementType etype=NONE, MarkerType mask=0, bool inverse=false)
Default constructor.
Definition: inmost_autodiff.h:182

INMOST::SingleEntry::Index
iMatrix Index(const Storage &e) const
Return vector filled with indices of unknowns of the block.
Definition: inmost_autodiff.h:200

INMOST::SingleEntry::Size
INMOST_DATA_ENUM_TYPE Size(const Storage &e) const
Number of entries for each tag in the block.
Definition: inmost_autodiff.h:210

INMOST::SingleEntry::Unknown
uMatrix Unknown(const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:202

INMOST::SingleEntry::SingleEntry
SingleEntry(ElementType etype, MarkerType mask, bool inverse, Tag unknown_tag, INMOST_DATA_ENUM_TYPE unknown_comp=0)
Constructor with tag.
Definition: inmost_autodiff.h:184

INMOST::SingleEntry::SetTag
void SetTag(Tag unknown_tag_in, INMOST_DATA_ENUM_TYPE unknown_comp_in=0)
Provide tag.
Definition: inmost_autodiff.h:186

INMOST::SingleEntry::Index
INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return index in vector of indices of the block at certain position.
Definition: inmost_autodiff.h:192

INMOST::SingleEntry::operator[]
uMatrix operator[](const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:204

INMOST::SingleEntry::Value
Matrix< value_reference > Value(const Storage &e)
Return vector filled with references to values of unknowns of the block.
Definition: inmost_autodiff.h:196

INMOST::StatusBlockEntry
This class is used to organize unknowns into blocks and provides mechanisms to change activation stat...
Definition: inmost_autodiff.h:269

INMOST::StatusBlockEntry::StatusBlockEntry
StatusBlockEntry(ElementType etype, MarkerType mask, bool inverse, TagInteger status_tag, const std::vector< std::vector< bool > > &status_tbl)
Constructor with status tag and status table.
Definition: inmost_autodiff.h:280

INMOST::StatusBlockEntry::operator[]
uMatrix operator[](const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:308

INMOST::StatusBlockEntry::StatusBlockEntry
StatusBlockEntry(ElementType etype, MarkerType mask, bool inverse, TagInteger status_tag)
Constructor with status tag.
Definition: inmost_autodiff.h:278

INMOST::StatusBlockEntry::Unknown
unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return unknown in vector of variables of the block at certain position.
Definition: inmost_autodiff.h:298

INMOST::StatusBlockEntry::Copy
AbstractEntry * Copy() const
Make a copy of the object.

INMOST::StatusBlockEntry::GetValueTag
TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const
Retrieve tag related to unknown value.
Definition: inmost_autodiff.h:318

INMOST::StatusBlockEntry::GetValueComp
INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const
Retrieve component of the tag related to unknown.
Definition: inmost_autodiff.h:316

INMOST::StatusBlockEntry::Value
INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:294

INMOST::StatusBlockEntry::Value
INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:292

INMOST::StatusBlockEntry::AddStatus
void AddStatus(const std::vector< bool > &stat)
Add status into table.
Definition: inmost_autodiff.h:288

INMOST::StatusBlockEntry::AddTag
void AddTag(Tag value, INMOST_DATA_ENUM_TYPE comp=ENUMUNDEF)
Add a component of the tag as unknown, by default all components of the tag are added.

INMOST::StatusBlockEntry::Index
iMatrix Index(const Storage &e) const
Return vector filled with indices of unknowns of the block.
Definition: inmost_autodiff.h:304

INMOST::StatusBlockEntry::Size
INMOST_DATA_ENUM_TYPE Size(const Storage &e) const
Number of entries for each tag in the block.

INMOST::StatusBlockEntry::Index
INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return index in vector of indices of the block at certain position.
Definition: inmost_autodiff.h:296

INMOST::StatusBlockEntry::Unknown
uMatrix Unknown(const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:306

INMOST::StatusBlockEntry::SetStatusTag
void SetStatusTag(TagInteger input)
Set status tag.
Definition: inmost_autodiff.h:290

INMOST::StatusBlockEntry::Value
rMatrix Value(const Storage &e) const
Return vector filled with values of unknowns of the block.
Definition: inmost_autodiff.h:302

INMOST::StatusBlockEntry::ClearTags
void ClearTags()
Remove all existing tags.
Definition: inmost_autodiff.h:282

INMOST::StatusBlockEntry::Size
INMOST_DATA_ENUM_TYPE Size() const
Number of tags in block.
Definition: inmost_autodiff.h:312

INMOST::StatusBlockEntry::GetMeshLink
Mesh * GetMeshLink() const
Retrieve mesh pointer.
Definition: inmost_autodiff.h:320

INMOST::StatusBlockEntry::StatusBlockEntry
StatusBlockEntry(ElementType etype=NONE, MarkerType mask=0, bool inverse=false)
Default constructor.
Definition: inmost_autodiff.h:276

INMOST::StatusBlockEntry::Value
Matrix< value_reference > Value(const Storage &e)
Return vector filled with references to values of unknowns of the block.
Definition: inmost_autodiff.h:300

INMOST::StatusBlockEntry::MatrixSize
INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const
The intended size of the matrix for this entry.
Definition: inmost_autodiff.h:310

INMOST::Storage
Base class for Mesh, Element, and ElementSet classes.
Definition: inmost_data.h:310

INMOST::Storage::HaveData
__INLINE bool HaveData(const Tag &tag) const
Check if any data is associated with Tag.
Definition: inmost_mesh.h:3928

INMOST::TagInteger
Definition: inmost_data.h:650

INMOST::TagRealArray
Definition: inmost_data.h:687

INMOST::Tag
This class provides the access to the individual mesh datum and general information about it.
Definition: inmost_data.h:193

INMOST::VectorEntry
This class is used to organize multiple unknowns resided on single tag of variable or static size.
Definition: inmost_autodiff.h:222

INMOST::VectorEntry::Index
iMatrix Index(const Storage &e) const
Return vector filled with indices of unknowns of the block.
Definition: inmost_autodiff.h:244

INMOST::VectorEntry::Copy
AbstractEntry * Copy() const
Make a copy of the object.
Definition: inmost_autodiff.h:262

INMOST::VectorEntry::GetMeshLink
Mesh * GetMeshLink() const
Retrieve mesh pointer.
Definition: inmost_autodiff.h:260

INMOST::VectorEntry::Value
INMOST_DATA_REAL_TYPE Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:232

INMOST::VectorEntry::Value
Matrix< value_reference > Value(const Storage &e)
Return vector filled with references to values of unknowns of the block.
Definition: inmost_autodiff.h:240

INMOST::VectorEntry::Value
rMatrix Value(const Storage &e) const
Return vector filled with values of unknowns of the block.
Definition: inmost_autodiff.h:242

INMOST::VectorEntry::Unknown
unknown Unknown(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return unknown in vector of variables of the block at certain position.
Definition: inmost_autodiff.h:238

INMOST::VectorEntry::GetValueTag
TagRealArray GetValueTag(INMOST_DATA_ENUM_TYPE unk) const
Retrieve tag related to unknown value.
Definition: inmost_autodiff.h:258

INMOST::VectorEntry::Size
INMOST_DATA_ENUM_TYPE Size(const Storage &e) const
Number of entries for each tag in the block.
Definition: inmost_autodiff.h:254

INMOST::VectorEntry::VectorEntry
VectorEntry(ElementType etype=NONE, MarkerType mask=0, bool inverse=false)
Default constructor.
Definition: inmost_autodiff.h:226

INMOST::VectorEntry::MatrixSize
INMOST_DATA_ENUM_TYPE MatrixSize(const Storage &e) const
The intended size of the matrix for this entry.
Definition: inmost_autodiff.h:250

INMOST::VectorEntry::Value
INMOST_DATA_REAL_TYPE & Value(const Storage &e, INMOST_DATA_ENUM_TYPE pos)
Return value in vector of unknowns of the block at certain position.
Definition: inmost_autodiff.h:234

INMOST::VectorEntry::operator[]
uMatrix operator[](const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:248

INMOST::VectorEntry::Unknown
uMatrix Unknown(const Storage &e) const
Return vector filled with unknowns of the block with their derivatives.
Definition: inmost_autodiff.h:246

INMOST::VectorEntry::VectorEntry
VectorEntry(ElementType etype, MarkerType mask, bool inverse, Tag unknown_tag)
Constructor with tag.
Definition: inmost_autodiff.h:228

INMOST::VectorEntry::SetTag
void SetTag(Tag unknown_tag_in)
Provide tag.
Definition: inmost_autodiff.h:230

INMOST::VectorEntry::Size
INMOST_DATA_ENUM_TYPE Size() const
Number of tags in block.
Definition: inmost_autodiff.h:252

INMOST::VectorEntry::GetValueComp
INMOST_DATA_ENUM_TYPE GetValueComp(INMOST_DATA_ENUM_TYPE unk) const
Retrieve component of the tag related to unknown.
Definition: inmost_autodiff.h:256

INMOST::VectorEntry::Index
INMOST_DATA_ENUM_TYPE Index(const Storage &e, INMOST_DATA_ENUM_TYPE pos) const
Return index in vector of indices of the block at certain position.
Definition: inmost_autodiff.h:236

INMOST::hessian_multivar_expression
A class that represents a variable with multiple first order and second order variations.
Definition: inmost_expression.h:408

INMOST::multivar_expression
A class that represents a variable with multiple first order variations.
Definition: inmost_expression.h:131

INMOST::value_reference
Definition: inmost_expression.h:871

INMOST::var_expression
Definition: inmost_expression.h:86

INMOST::Demote
Definition: inmost_autodiff.h:15