Doxygen/html/inmost__sparse_8h_source.html

 #ifndef INMOST_SPARSE_INCLUDED

 #define INMOST_SPARSE_INCLUDED


 #include "inmost_common.h"

 #include <unordered_map>

 #include "robin_hood.h"


 namespace INMOST

 {

     namespace Sparse

     {

 #if defined(USE_SOLVER) || defined(USE_AUTODIFF)

         INMOST_MPI_Type GetRowEntryType();

         void CreateRowEntryType();

         void DestroyRowEntryType();

         bool HaveRowEntryType();

         class AnnotationService

         {

             interval<INMOST_DATA_ENUM_TYPE,std::string> text;

         public:

             AnnotationService(INMOST_DATA_ENUM_TYPE start = 0, INMOST_DATA_ENUM_TYPE end = 0) { if( end != start ) SetInterval(start,end); }

             AnnotationService(const AnnotationService & other) : text(other.text) { }

             AnnotationService & operator = (AnnotationService const & other) {text = other.text; return *this;}

             ~AnnotationService() {}

             INMOST_DATA_ENUM_TYPE  GetFirstIndex() const {return text.get_interval_beg();}

             INMOST_DATA_ENUM_TYPE  GetLastIndex() const {return text.get_interval_end();}

             bool                   Empty() const {return text.empty();}

             void                   SetInterval(INMOST_DATA_ENUM_TYPE beg, INMOST_DATA_ENUM_TYPE end) { text.set_interval_beg(beg); text.set_interval_end(end); }

             void                   GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = text.get_interval_beg(); end = text.get_interval_end();}

             std::string &          GetAnnotation(INMOST_DATA_ENUM_TYPE row) {assert(!text.empty()); return text[row];}

             const std::string &    GetAnnotation(INMOST_DATA_ENUM_TYPE row) const {assert(!text.empty()); return text[row];}

             void                   SetAnnotation(INMOST_DATA_ENUM_TYPE row, std::string str) {assert(!text.empty()); text[row] = str;}

         };

 #endif

 #if defined(USE_SOLVER)

         class Vector

         {

         public:

             typedef interval<INMOST_DATA_ENUM_TYPE,INMOST_DATA_REAL_TYPE> Entries;

             typedef Entries::iterator iterator;

             typedef Entries::const_iterator const_iterator;

         private:

             INMOST_MPI_Comm comm;

             Entries data;

             std::string name;

             bool is_parallel;

         public:

             Vector(std::string _name = "", INMOST_DATA_ENUM_TYPE start = 0, INMOST_DATA_ENUM_TYPE end = 0, INMOST_MPI_Comm _comm = INMOST_MPI_COMM_WORLD);

             Vector(const Vector & other);

             Vector & operator =(Vector const & other);

             ~Vector();

             INMOST_DATA_REAL_TYPE & operator [](INMOST_DATA_ENUM_TYPE i) {return data[i];}

             INMOST_DATA_REAL_TYPE   operator [](INMOST_DATA_ENUM_TYPE i) const {return data[i];}

             INMOST::Matrix<INMOST_DATA_REAL_TYPE> operator [](const INMOST::AbstractMatrix<INMOST_DATA_INTEGER_TYPE> & rows) const;

 #if defined(USE_AUTODIFF)

             INMOST::Matrix<value_reference> operator [](const INMOST::AbstractMatrix<INMOST_DATA_INTEGER_TYPE>& rows);

 #endif //USE_AUTODIFF

             INMOST_DATA_ENUM_TYPE  Size() const { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             iterator             Begin() {return data.begin();}

             const_iterator       Begin() const {return data.begin();}

             iterator             End() {return data.end();}

             const_iterator       End() const {return data.end();}

             bool                 Empty() const {return data.empty();}

             void                 SetInterval(INMOST_DATA_ENUM_TYPE   start, INMOST_DATA_ENUM_TYPE   end)       {assert(start<=end); data.set_interval_beg(start); data.set_interval_end(end);}

             void                 GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = data.get_interval_beg(); end = data.get_interval_end();}

             void                 ShiftInterval(INMOST_DATA_ENUM_TYPE shift) {data.shift_interval(shift);}

             INMOST_DATA_ENUM_TYPE  GetFirstIndex() const {return data.get_interval_beg();}

             INMOST_DATA_ENUM_TYPE  GetLastIndex() const {return data.get_interval_end();}

             INMOST_MPI_Comm        GetCommunicator() const {return comm;}

             void Swap(Vector & other) {data.swap(other.data); name.swap(other.name); std::swap(is_parallel,other.is_parallel); std::swap(comm,other.comm);}

             void                 Save(std::string file);

             void                 Load(std::string file, INMOST_DATA_ENUM_TYPE mbeg = ENUMUNDEF, INMOST_DATA_ENUM_TYPE mend = ENUMUNDEF, std::string file_ord = "");

             bool                 & isParallel() {return is_parallel;}

             std::string          GetName() {return name;}

             void Clear() {data.clear();}

         };


 #endif //defined(USE_SOLVER)

 #if defined(USE_SOLVER) || defined(USE_AUTODIFF)

         class Row

         {

         public:

 //#pragma pack(push,r1,4)

             typedef struct entry_s

             {

                 INMOST_DATA_ENUM_TYPE first;

                 INMOST_DATA_REAL_TYPE second;

                 bool operator < (const entry_s & other) const { return first < other.first || (first == other.first && second < other.second); }

                 //entry_s& operator =(entry_s const& b) { first = b.first; second = b.second; return *this; }

                 //entry_s(const entry_s& b) : first(b.first), second(b.second) {}

                 entry_s() : first(ENUMUNDEF), second(0.0) {}

             } entry;

 //#pragma pack(pop,r1)

             __INLINE static entry make_entry(INMOST_DATA_ENUM_TYPE ind, INMOST_DATA_REAL_TYPE val)

             {

                 entry ret;

                 ret.first = ind;

                 ret.second = val;

                 return ret;

             }

         private:

             typedef std::vector<entry> Entries;

         public:

             typedef Entries::iterator iterator;

             typedef Entries::const_iterator const_iterator;

             typedef Entries::reverse_iterator reverse_iterator;

             typedef Entries::const_reverse_iterator const_reverse_iterator;

         private:

             Entries data;

         public:

             Row() : data() {}

             Row(const Row & other) : data(other.data) {}

             Row(entry * pbegin, entry * pend)  :data(pbegin, pend) {}

             ~Row() {}

             Row & operator = (Row const & other) { data = other.data; return *this; }

             INMOST_DATA_REAL_TYPE & operator [](INMOST_DATA_ENUM_TYPE i)

             {

                 for(Entries::size_type it = 0; it < data.size(); ++it)

                     if( data[it].first == i ) return data[it].second;

                 data.push_back(make_entry(i,0));

                 return data.back().second;

             }

             INMOST_DATA_REAL_TYPE operator[](INMOST_DATA_ENUM_TYPE i) const

             {

                 for (Entries::size_type it = 0; it < data.size(); ++it) if (data[it].first == i) return data[it].second;

                 //you should not come here

                 assert(false);

                 return 1.0e20;

             }

             INMOST_DATA_REAL_TYPE get_safe(INMOST_DATA_ENUM_TYPE i) const

             {

                 for (Entries::size_type it = 0; it < data.size(); ++it) if (data[it].first == i) return data[it].second;

                 return 0.0;

             }

             void                    Clear() { data.clear(); }

             void                    Swap(Row & other) { data.swap(other.data); }

             INMOST_DATA_ENUM_TYPE   Size() const { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             bool                    Empty() const { return data.empty(); }

             INMOST_DATA_ENUM_TYPE & GetIndex(INMOST_DATA_ENUM_TYPE k) {assert(k < data.size()); return (data.begin()+k)->first;}

             INMOST_DATA_REAL_TYPE & GetValue(INMOST_DATA_ENUM_TYPE k) {assert(k < data.size()); return (data.begin()+k)->second;}

             INMOST_DATA_ENUM_TYPE   GetIndex(INMOST_DATA_ENUM_TYPE k) const {assert(k < data.size()); return (data.begin()+k)->first;}

             INMOST_DATA_REAL_TYPE   GetValue(INMOST_DATA_ENUM_TYPE k) const {assert(k < data.size()); return (data.begin()+k)->second;}

             //void                    GetInterval(INMOST_DATA_ENUM_TYPE& beg, INMOST_DATA_ENUM_TYPE& end, INMOST_DATA_ENUM_TYPE& cnt) const;

             iterator                Begin() {return data.begin();}

             iterator                End() {return data.end();}

             const_iterator          Begin() const {return data.begin();}

             const_iterator          End() const {return data.end();}

             reverse_iterator        rBegin() { return data.rbegin(); }

             reverse_iterator        rEnd() { return data.rend(); }

             const_reverse_iterator  rBegin() const { return data.rbegin(); }

             const_reverse_iterator  rEnd() const { return data.rend(); }

 #if defined(USE_SOLVER)

             INMOST_DATA_REAL_TYPE   RowVec(Vector & x) const; // returns A(row) * x

 #endif

             void                    MoveRow(Row & source) {data = source.data;} //here move constructor and std::move may be used in future

             void                    Zero() {for(iterator it = Begin(); it != End(); ++it) it->second = 0;}

             void                    Push(INMOST_DATA_ENUM_TYPE ind, INMOST_DATA_REAL_TYPE val) {data.push_back(make_entry(ind,val));}

             void                    Pop() { data.pop_back(); }

             void                    Resize(INMOST_DATA_ENUM_TYPE size) {data.resize(size);}

             void                    Print(double eps = -1, std::ostream & sout = std::cout) const

             {

                 int k = 0;

                 for(const_iterator it = Begin(); it != End(); ++it) if( fabs(it->second) > eps ) {sout << "(" << it->first << "," << it->second << ") "; k++; }

                 if( k ) sout << std::endl;

             }

             void                    Sort() { std::sort(data.begin(), data.end()); }

             bool                    isSorted() const;

             static void             MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const Row & left, INMOST_DATA_REAL_TYPE beta, const Row & right, Row & output);

         };


 #endif //defined(USE_SOLVER) || defined(USE_AUTODIFF)


 #if defined(USE_SOLVER) || defined(USE_AUTODIFF)

         class HessianRow

         {

         public:

             typedef struct hessian_index_s

             {

                 INMOST_DATA_ENUM_TYPE first;

                 INMOST_DATA_ENUM_TYPE second;

                 bool operator < (const hessian_index_s & other) const {return first < other.first || (first == other.first && second < other.second); }

                 bool operator ==(const hessian_index_s & other) const {return first == other.first && second == other.second;}

             } index;

             __INLINE static index make_index(INMOST_DATA_ENUM_TYPE _first, INMOST_DATA_ENUM_TYPE _second)

             {

                 index ret;

                 ret.first = _first >_second ? _second : _first;

                 ret.second = _first < _second ? _second : _first;

                 return ret;

             }

             typedef struct hessian_entry_s

             {

                 index first;

                 INMOST_DATA_REAL_TYPE second;

                 bool operator < (const hessian_entry_s & other) const { return first < other.first || (first == other.first && second < other.second); }

             } entry;

             __INLINE static entry make_entry(index ind, INMOST_DATA_REAL_TYPE val)

             {

                 entry ret;

                 ret.first = ind;

                 ret.second = val;

                 return ret;

             }

         private:

             typedef std::vector<entry> Entries; //replace later with more memory-efficient chunk_array, with first chunk in stack

         public:

             typedef Entries::iterator iterator;

             typedef Entries::const_iterator const_iterator;

             typedef Entries::reverse_iterator reverse_iterator;

             typedef Entries::const_reverse_iterator const_reverse_iterator;

         private:

             Entries data;

         public:

             HessianRow() : data() {}

             HessianRow(const HessianRow & other) : data(other.data) {}

             HessianRow(entry * pbegin, entry * pend) : data(pbegin,pend) {}

             ~HessianRow() {}

             HessianRow & operator = (HessianRow const & other) {data = other.data; return *this;}

             INMOST_DATA_REAL_TYPE & operator [](index i) // use to fill matrix, not to access individual elements

             {

                 for(Entries::size_type it = 0; it < data.size(); ++it)

                     if( data[it].first == i ) return data[it].second;

                 data.push_back(make_entry(i,0));

                 return data.back().second;

             }

             INMOST_DATA_REAL_TYPE operator[](index i) const

             {

                 for (Entries::size_type it = 0; it < data.size(); ++it) if (data[it].first == i) return data[it].second;

                 //you should not come here

                 assert(false);

                 return 1.0e20;

             }

             INMOST_DATA_REAL_TYPE get_safe(index i) const

             {

                 for (Entries::size_type it = 0; it < data.size(); ++it) if (data[it].first == i) return data[it].second;

                 return 0.0;

             }

             //void           Reserve(INMOST_DATA_ENUM_TYPE num) { data.reserve(num);}

             void                    Clear() { data.clear(); }

             void                    Swap(HessianRow & other) { data.swap(other.data); }

             INMOST_DATA_ENUM_TYPE   Size() const { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             bool                    Empty() const { return data.empty(); }

             index                 & GetIndex(INMOST_DATA_ENUM_TYPE k) {assert(k < data.size()); return (data.begin()+k)->first;}

             INMOST_DATA_REAL_TYPE & GetValue(INMOST_DATA_ENUM_TYPE k) {assert(k < data.size()); return (data.begin()+k)->second;}

             index                   GetIndex(INMOST_DATA_ENUM_TYPE k) const {assert(k < data.size()); return (data.begin()+k)->first;}

             INMOST_DATA_REAL_TYPE   GetValue(INMOST_DATA_ENUM_TYPE k) const {assert(k < data.size()); return (data.begin()+k)->second;}

             iterator                Begin() {return data.begin();}

             iterator                End() {return data.end();}

             const_iterator          Begin() const {return data.begin();}

             const_iterator          End() const {return data.end();}

             reverse_iterator        rBegin() { return data.rbegin(); }

             reverse_iterator        rEnd() { return data.rend(); }

             const_reverse_iterator  rBegin() const { return data.rbegin(); }

             const_reverse_iterator  rEnd() const { return data.rend(); }

             void                    RowVec(INMOST_DATA_REAL_TYPE alpha, const Row & rU, INMOST_DATA_REAL_TYPE beta, Row & rJ) const; // returns A(row) * x

             void                    MoveRow(HessianRow & new_pos) {data = new_pos.data;} //here move constructor and std::move may be used in future

             void                    Zero() {for(iterator it = Begin(); it != End(); ++it) it->second = 0;}

             void                    Push(index ind, INMOST_DATA_REAL_TYPE val) {data.push_back(make_entry(ind,val));}

             void                    Resize(INMOST_DATA_ENUM_TYPE size) {data.resize(size);}

             void                    Print() const

             {

                 for(const_iterator it = Begin(); it != End(); ++it) std::cout << "(" << it->first.first << "," << it->first.second << "," << it->second << ") ";

                 std::cout << std::endl;

             }

             bool                    isSorted() const;

             static void             MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const HessianRow & left, INMOST_DATA_REAL_TYPE beta, const HessianRow & right, HessianRow & output);

             static void             MergeJacobianHessian(INMOST_DATA_REAL_TYPE a, const Row & JL, const Row & JR, INMOST_DATA_REAL_TYPE b, const HessianRow & HL, INMOST_DATA_REAL_TYPE c, const HessianRow & HR, HessianRow & output);

             static void             MergeJacobianHessian(INMOST_DATA_REAL_TYPE a, const Row & JL, const Row & JR, INMOST_DATA_REAL_TYPE b, const HessianRow & H, HessianRow & output);

         };


 #endif //defined(USE_SOLVER) || defined(USE_AUTODIFF)


 #if defined(USE_SOLVER)


         class LockService

         {

             interval<INMOST_DATA_ENUM_TYPE,INMOST_OMP_LOCK_T> locks;

             void DestroyLocks();

         public:

             LockService(INMOST_DATA_ENUM_TYPE start = 0, INMOST_DATA_ENUM_TYPE end = 0) { if( end != start ) SetInterval(start,end); }

             LockService(const LockService & other) { SetInterval(other.GetFirstIndex(),other.GetLastIndex()); }

             LockService & operator = (LockService const & other) { SetInterval(other.GetFirstIndex(),other.GetLastIndex()); return *this;}

             ~LockService() {DestroyLocks();}

             INMOST_DATA_ENUM_TYPE  GetFirstIndex() const;

             INMOST_DATA_ENUM_TYPE  GetLastIndex() const;

             bool Empty() const;

             void SetInterval(INMOST_DATA_ENUM_TYPE beg, INMOST_DATA_ENUM_TYPE end);

             void GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const;

             bool HaveLocks() const;

             bool Lock(INMOST_DATA_ENUM_TYPE row);

             bool TestLock(INMOST_DATA_ENUM_TYPE row);

             bool UnLock(INMOST_DATA_ENUM_TYPE row);

         };


         class Matrix

         {

             typedef interval<INMOST_DATA_ENUM_TYPE,Row> Rows;

         public:

             typedef Rows::iterator iterator;

             typedef Rows::const_iterator const_iterator;

         private:

             INMOST_MPI_Comm comm;

             Rows data;

             std::string name;

             bool is_parallel;

         public:

             Matrix(std::string _name = "", INMOST_DATA_ENUM_TYPE start = 0, INMOST_DATA_ENUM_TYPE end = 0, INMOST_MPI_Comm _comm = INMOST_MPI_COMM_WORLD);

             Matrix(const Matrix & other);

             Matrix & operator =(Matrix const & other);

             ~Matrix();

             Row & operator [](INMOST_DATA_ENUM_TYPE i) {return data[i];}

             const Row & operator [](INMOST_DATA_ENUM_TYPE i) const {return data[i];}

             INMOST_DATA_ENUM_TYPE  Size() const { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             bool                   Empty() const {return data.empty();}

             iterator               Begin() {return data.begin();}

             iterator               End()   {return data.end();}

             const_iterator         Begin() const {return data.begin();}

             const_iterator         End() const   {return data.end();}

             void                   SetInterval(INMOST_DATA_ENUM_TYPE   start, INMOST_DATA_ENUM_TYPE   end) {data.set_interval_beg(start); data.set_interval_end(end);}

             void                   GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = data.get_interval_beg(); end = data.get_interval_end();}

             void                   ShiftInterval(INMOST_DATA_ENUM_TYPE shift) {data.shift_interval(shift);}

             INMOST_DATA_ENUM_TYPE  GetFirstIndex() const {return data.get_interval_beg();}

             INMOST_DATA_ENUM_TYPE  GetLastIndex() const {return data.get_interval_end();}

             INMOST_MPI_Comm        GetCommunicator() const {return comm;}

             void                   MoveRows(INMOST_DATA_ENUM_TYPE from, INMOST_DATA_ENUM_TYPE to, INMOST_DATA_ENUM_TYPE size); //for parallel

             void                   Swap(Matrix & other);

             void MatVec(INMOST_DATA_REAL_TYPE alpha, Vector & x, INMOST_DATA_REAL_TYPE beta, Vector & y) const;

             void MatVecTranspose(INMOST_DATA_REAL_TYPE alpha, Vector & x, INMOST_DATA_REAL_TYPE beta, Vector & y) const;

             void Clear() {for(Matrix::iterator it = Begin(); it != End(); ++it) it->Clear(); data.clear();}

             INMOST_DATA_ENUM_TYPE Nonzeros() {INMOST_DATA_ENUM_TYPE nnz = 0; for(Matrix::iterator it = Begin(); it != End(); ++it) nnz += it->Size(); return nnz;}

             void                 Load(std::string file, INMOST_DATA_ENUM_TYPE beg = ENUMUNDEF, INMOST_DATA_ENUM_TYPE end = ENUMUNDEF, std::string file_ord = "");

             void                 Save(std::string file, const AnnotationService * annotation = NULL);

             bool &               isParallel() { return is_parallel; }

             const bool &         isParallel() const { return is_parallel; }

             std::string          GetName() const {return name;}

             void                 Sort() { for (iterator it = Begin(); it != End(); ++it) it->Sort(); }

             INMOST_DATA_REAL_TYPE Residual(Sparse::Vector &RHS, Sparse::Vector &SOL);

             static void ZAXPBY(INMOST_DATA_REAL_TYPE alpha, const Sparse::Matrix& X, INMOST_DATA_REAL_TYPE beta, const Sparse::Matrix& Y, Sparse::Matrix& Z);

         };


 #endif //defined(USE_SOLVER)


 #if defined(USE_SOLVER)


         class HessianMatrix

         {

         public:

             typedef interval<INMOST_DATA_ENUM_TYPE,HessianRow> HessianRows;

             typedef HessianRows::iterator iterator;

             typedef HessianRows::const_iterator const_iterator;

         private:

             INMOST_MPI_Comm comm;

             HessianRows data;

             std::string name;

             bool is_parallel;

         public:

             HessianMatrix(std::string _name = "", INMOST_DATA_ENUM_TYPE start = 0, INMOST_DATA_ENUM_TYPE end = 0, INMOST_MPI_Comm _comm = INMOST_MPI_COMM_WORLD);

             HessianMatrix(const HessianMatrix & other);

             HessianMatrix & operator =(HessianMatrix const & other);

             ~HessianMatrix();

             HessianRow & operator [](INMOST_DATA_ENUM_TYPE i) {return data[i];}

             const HessianRow & operator [](INMOST_DATA_ENUM_TYPE i) const {return data[i];}

             INMOST_DATA_ENUM_TYPE  Size() const { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             bool                   Empty() const {return data.empty();}

             iterator               Begin() {return data.begin();}

             iterator               End()   {return data.end();}

             const_iterator         Begin() const {return data.begin();}

             const_iterator         End() const   {return data.end();}

             void                   SetInterval(INMOST_DATA_ENUM_TYPE   start, INMOST_DATA_ENUM_TYPE   end) {data.set_interval_beg(start); data.set_interval_end(end);}

             void                   GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = data.get_interval_beg(); end = data.get_interval_end();}

             void                   ShiftInterval(INMOST_DATA_ENUM_TYPE shift) {data.shift_interval(shift);}

             INMOST_DATA_ENUM_TYPE  GetFirstIndex() const {return data.get_interval_beg();}

             INMOST_DATA_ENUM_TYPE  GetLastIndex() const {return data.get_interval_end();}

             INMOST_MPI_Comm        GetCommunicator() const {return comm;}

             void                   MoveRows(INMOST_DATA_ENUM_TYPE from, INMOST_DATA_ENUM_TYPE to, INMOST_DATA_ENUM_TYPE size); //for parallel

             void                   Swap(HessianMatrix & other);

             void MatVec(INMOST_DATA_REAL_TYPE alpha, const Matrix & U, INMOST_DATA_REAL_TYPE beta, Matrix & J) const;

             void Clear() {for(HessianMatrix::iterator it = Begin(); it != End(); ++it) it->Clear(); data.clear();}

             void                 Load(std::string file, INMOST_DATA_ENUM_TYPE beg = ENUMUNDEF, INMOST_DATA_ENUM_TYPE end = ENUMUNDEF);

             void                 Save(std::string file, const AnnotationService * annotation = NULL);

             bool &               isParallel() { return is_parallel; }

             const bool &         isParallel() const { return is_parallel; }

             std::string          GetName() const {return name;}

         };


 #endif //defined(USE_SOLVER)


 #if defined(USE_SOLVER) || defined(USE_AUTODIFF)

         class RowMerger

         {

             //typedef robin_hood::unordered_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE> container;

             //typedef robin_hood::unordered_flat_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE> container;

             //typedef robin_hood::unordered_node_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE> container;

             //typedef std::unordered_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE> container;

             //typedef robin_hood::unordered_flat_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> container;

         public:

             const INMOST_DATA_ENUM_TYPE EOL = ENUMUNDEF-1;

             //const INMOST_DATA_ENUM_TYPE UNDEF = ENUMUNDEF; ///< Value not defined in linked list.

             class iterator

             {

             private:

                 INMOST_DATA_ENUM_TYPE pos;

                 RowMerger * merger;

                 iterator(RowMerger* pmerger) : pos(pmerger->First), merger(pmerger) {}

                 iterator(INMOST_DATA_ENUM_TYPE pos, RowMerger* pmerger) : pos(pos), merger(pmerger) {}

             public:

                 iterator(const iterator & other) : pos(other.pos), merger(other.merger) {}

                 ~iterator() {}

                 //INMOST_DATA_REAL_TYPE & operator *() {return merger->vals[merger->pos[pos]];}

                 //INMOST_DATA_REAL_TYPE operator *() const {return merger->vals[merger->pos[pos]];}

                 //INMOST_DATA_REAL_TYPE * operator ->() {return &merger->vals[merger->pos[pos]];}

                 //const INMOST_DATA_REAL_TYPE * operator ->() const {return &merger->vals[merger->pos[pos]];}

                 //iterator& operator ++() { pos = merger->next[merger->[pos]]; return *this; }

                 //iterator operator ++(int) { return iterator(merger->next[merger->[pos]], merger); }

                 INMOST_DATA_REAL_TYPE& operator *() { return merger->vals[merger->get_pos(pos)]; }

                 INMOST_DATA_REAL_TYPE operator *() const { return merger->vals[merger->get_pos(pos)]; }

                 INMOST_DATA_REAL_TYPE* operator ->() { return &merger->vals[merger->get_pos(pos)]; }

                 const INMOST_DATA_REAL_TYPE* operator ->() const { return &merger->vals[merger->get_pos(pos)]; }

                 iterator & operator ++(){ pos = merger->next[merger->get_pos(pos)]; return *this;}

                 iterator operator ++(int) { return iterator(merger->next[merger->get_pos(pos)], merger); }

                 iterator & operator = (const iterator & other) {merger = other.merger; pos = other.pos; return *this;}

                 bool operator ==(const iterator & other) const {return merger == other.merger && pos == other.pos;}

                 bool operator !=(const iterator & other) const {return merger != other.merger || pos != other.pos;}

                 bool operator < (const iterator & other) const {return merger == other.merger && pos < other.pos;}

                 bool operator <=(const iterator & other) const {return merger == other.merger && pos <= other.pos;}

                 bool operator > (const iterator & other) const {return merger == other.merger && pos > other.pos;}

                 bool operator >=(const iterator & other) const {return merger == other.merger && pos >= other.pos;}

                 friend class RowMerger;

             };

             //typedef container::iterator iterator;

         private:

             INMOST_DATA_ENUM_TYPE Nonzeros;

             INMOST_DATA_ENUM_TYPE First;

             //std::unordered_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> pos; //Position in vals and next array (huge array)

             //typedef std::unordered_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> map_container;

             typedef robin_hood::unordered_flat_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> map_container;

             //typedef judyLArray<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> map_container;

             //typedef tsl::hopscotch_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> map_container;

             //typedef tsl::bhopscotch_map<INMOST_DATA_ENUM_TYPE, INMOST_DATA_ENUM_TYPE> map_container;

             map_container pos;  //Position in vals and next array (huge array)

             //mutable void* judy_array;

             std::vector<INMOST_DATA_REAL_TYPE> vals; //Values at the position (small array)

             std::vector<INMOST_DATA_ENUM_TYPE> next; //Next nonzero position (small array)

             //interval< INMOST_DATA_ENUM_TYPE, Row::entry > LinkedList; ///< Storage for linked list.

             //container data;

             INMOST_DATA_ENUM_TYPE get_pos(INMOST_DATA_ENUM_TYPE pos) const;

             INMOST_DATA_ENUM_TYPE get_pos(INMOST_DATA_ENUM_TYPE pos);

             void ins_pos(INMOST_DATA_ENUM_TYPE pos, INMOST_DATA_ENUM_TYPE k);

         public:

             RowMerger();

             //RowMerger(INMOST_DATA_ENUM_TYPE interval_begin, INMOST_DATA_ENUM_TYPE interval_end);

             ~RowMerger();

             //void Resize(INMOST_DATA_ENUM_TYPE interval_begin, INMOST_DATA_ENUM_TYPE interval_end);

             void Resize(INMOST_DATA_ENUM_TYPE size);

 #if defined(USE_SOLVER)

             RowMerger(const Matrix & A);

             void Resize(const Matrix & A);

 #endif //USE_SOLVER

             void Clear();// { data.clear(); }

             void PushRow(INMOST_DATA_REAL_TYPE coef, const Row & r);

             void AddRow(INMOST_DATA_REAL_TYPE coef, const Row & r);

             void Multiply(INMOST_DATA_REAL_TYPE coef);

             void RetrieveRow(Row & r) const;

             //INMOST_DATA_REAL_TYPE ScalarProd(RowMerger & other);

             INMOST_DATA_ENUM_TYPE Size() const {return Nonzeros;}// { return static_cast<INMOST_DATA_ENUM_TYPE>(data.size()); }

             bool Empty() const { return Nonzeros == 0; }

             //bool Empty() const { return data.empty(); }

             INMOST_DATA_REAL_TYPE& operator [] (INMOST_DATA_ENUM_TYPE pos) { return vals[get_pos(pos)]; }

             INMOST_DATA_REAL_TYPE operator [] (INMOST_DATA_ENUM_TYPE pos) const { return vals[get_pos(pos)]; }

             void Merge(Row & c, INMOST_DATA_REAL_TYPE alpha, const Row & a, INMOST_DATA_REAL_TYPE beta, const Row & b)

             {

                 PushRow(alpha,a);

                 AddRow(beta,b);

                 RetrieveRow(c);

                 Clear();

             }

             iterator Begin() {return iterator(this);}

             //iterator Begin() { return data.begin(); }

             iterator End() {iterator ret(this); ret.pos = EOL; return ret;}

             //iterator End() { return data.end(); }

         };

 #endif //defined(USE_SOLVER) || defined(USE_AUTODIFF)

     } //namespace Sparse

 } //namespace INMOST


 #endif //INMOST_SPARSE_INCLUDED

INMOST::AbstractMatrix
Abstract class for a matrix, used to abstract away all the data storage and access and provide common...
Definition: inmost_dense.h:647

INMOST::Matrix< INMOST_DATA_REAL_TYPE >

INMOST::Sparse::AnnotationService
This class can be used to annotate the matrix.
Definition: inmost_sparse.h:28

INMOST::Sparse::AnnotationService::operator=
AnnotationService & operator=(AnnotationService const &other)
Assign annotations for the matrix.
Definition: inmost_sparse.h:40

INMOST::Sparse::AnnotationService::~AnnotationService
~AnnotationService()
Destroy annotations for the matrix.
Definition: inmost_sparse.h:42

INMOST::Sparse::AnnotationService::GetInterval
void GetInterval(INMOST_DATA_ENUM_TYPE &start, INMOST_DATA_ENUM_TYPE &end) const
Retrieve interval of the local matrix.
Definition: inmost_sparse.h:56

INMOST::Sparse::AnnotationService::AnnotationService
AnnotationService(INMOST_DATA_ENUM_TYPE start=0, INMOST_DATA_ENUM_TYPE end=0)
Create a new annotation for local matrix.
Definition: inmost_sparse.h:34

INMOST::Sparse::AnnotationService::GetLastIndex
INMOST_DATA_ENUM_TYPE GetLastIndex() const
Get the last row index of the distributed matrix interval.
Definition: inmost_sparse.h:46

INMOST::Sparse::AnnotationService::Empty
bool Empty() const
Check whether the interval of the local matrix was specified and non-empty.
Definition: inmost_sparse.h:48

INMOST::Sparse::AnnotationService::SetAnnotation
void SetAnnotation(INMOST_DATA_ENUM_TYPE row, std::string str)
Specify the text to a certain row of the matrix.
Definition: inmost_sparse.h:66

INMOST::Sparse::AnnotationService::GetAnnotation
std::string & GetAnnotation(INMOST_DATA_ENUM_TYPE row)
Retrieve the text corresponding to a certain row of the matrix.
Definition: inmost_sparse.h:59

INMOST::Sparse::AnnotationService::SetInterval
void SetInterval(INMOST_DATA_ENUM_TYPE beg, INMOST_DATA_ENUM_TYPE end)
Specify interval of the local matrix.
Definition: inmost_sparse.h:52

INMOST::Sparse::AnnotationService::GetAnnotation
const std::string & GetAnnotation(INMOST_DATA_ENUM_TYPE row) const
Retrieve the text corresponding to a certain row of the matrix without right of modification.
Definition: inmost_sparse.h:62

INMOST::Sparse::AnnotationService::AnnotationService
AnnotationService(const AnnotationService &other)
Copy annotations for the matrix.
Definition: inmost_sparse.h:37

INMOST::Sparse::AnnotationService::GetFirstIndex
INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Get the first row index of the distributed matrix interval.
Definition: inmost_sparse.h:44

INMOST::Sparse::HessianMatrix
Class to store the distributed sparse hessian hyper matrix by compressed symmetric matrices.
Definition: inmost_sparse.h:563

INMOST::Sparse::HessianMatrix::SetInterval
void SetInterval(INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end)
Set the start and the end row numbers of the distributed matrix interval.
Definition: inmost_sparse.h:595

INMOST::Sparse::HessianMatrix::GetInterval
void GetInterval(INMOST_DATA_ENUM_TYPE &start, INMOST_DATA_ENUM_TYPE &end) const
Get the start and the end row numbers of the distributed matrix interval.
Definition: inmost_sparse.h:597

INMOST::Sparse::HessianMatrix::HessianMatrix
HessianMatrix(std::string _name="", INMOST_DATA_ENUM_TYPE start=0, INMOST_DATA_ENUM_TYPE end=0, INMOST_MPI_Comm _comm=INMOST_MPI_COMM_WORLD)
Main constructor of the Matrix class.

INMOST::Sparse::HessianMatrix::Save
void Save(std::string file, const AnnotationService *annotation=NULL)
Save the distributed matrix to a single data file in MTX format using parallel MPI I/O.

INMOST::Sparse::HessianMatrix::Size
INMOST_DATA_ENUM_TYPE Size() const
Return the total number of rows in the matrix.
Definition: inmost_sparse.h:588

INMOST::Sparse::HessianMatrix::GetCommunicator
INMOST_MPI_Comm GetCommunicator() const
Get the communicator which the matrix is associated with.
Definition: inmost_sparse.h:604

INMOST::Sparse::HessianMatrix::GetLastIndex
INMOST_DATA_ENUM_TYPE GetLastIndex() const
Get the last row index of the distributed matrix interval.
Definition: inmost_sparse.h:602

INMOST::Sparse::HessianMatrix::operator[]
HessianRow & operator[](INMOST_DATA_ENUM_TYPE i)
Return reference to i-th Row of the matrix.
Definition: inmost_sparse.h:584

INMOST::Sparse::HessianMatrix::Load
void Load(std::string file, INMOST_DATA_ENUM_TYPE beg=ENUMUNDEF, INMOST_DATA_ENUM_TYPE end=ENUMUNDEF)
Load the matrix from a single data file in MTX format using the specified interval.

INMOST::Sparse::HessianMatrix::isParallel
bool & isParallel()
Check that matrix is in parallel state.
Definition: inmost_sparse.h:623

INMOST::Sparse::HessianMatrix::Clear
void Clear()
Clear all data of the matrix.
Definition: inmost_sparse.h:614

INMOST::Sparse::HessianMatrix::GetFirstIndex
INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Get the first row index of the distributed matrix interval.
Definition: inmost_sparse.h:600

INMOST::Sparse::HessianMatrix::MatVec
void MatVec(INMOST_DATA_REAL_TYPE alpha, const Matrix &U, INMOST_DATA_REAL_TYPE beta, Matrix &J) const
HyperMatrix-Matrix product of the form: J = alpha*H*U + beta * J.

INMOST::Sparse::HessianMatrix::GetName
std::string GetName() const
Get the matrix name specified in the main constructor.
Definition: inmost_sparse.h:626

INMOST::Sparse::HessianRow
Class to store the compressed symmetric matrix of a hessian row.
Definition: inmost_sparse.h:334

INMOST::Sparse::HessianRow::operator[]
INMOST_DATA_REAL_TYPE & operator[](index i)
The operator [] used to fill the sparse matrix row, but not to access individual elements of the row.
Definition: inmost_sparse.h:380

INMOST::Sparse::HessianRow::Clear
void Clear()
Clear all data of the current row.
Definition: inmost_sparse.h:402

INMOST::Sparse::HessianRow::Resize
void Resize(INMOST_DATA_ENUM_TYPE size)
Resize row to specified size.
Definition: inmost_sparse.h:431

INMOST::Sparse::HessianRow::MergeSortedRows
static void MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const HessianRow &left, INMOST_DATA_REAL_TYPE beta, const HessianRow &right, HessianRow &output)
output = alpha * left + beta *right

INMOST::Sparse::HessianRow::operator[]
INMOST_DATA_REAL_TYPE operator[](index i) const
The operator [] used to access individual elements of the row.
Definition: inmost_sparse.h:388

INMOST::Sparse::HessianRow::Size
INMOST_DATA_ENUM_TYPE Size() const
The size of the sparse row, i.e. the total number of nonzero elements.
Definition: inmost_sparse.h:405

INMOST::Sparse::HessianRow::Zero
void Zero()
Set the vector entries by zeroes.
Definition: inmost_sparse.h:423

INMOST::Sparse::HessianRow::index
struct INMOST::Sparse::HessianRow::hessian_index_s index
Entry of the sparse matrix row.

INMOST::Sparse::HessianRow::RowVec
void RowVec(INMOST_DATA_REAL_TYPE alpha, const Row &rU, INMOST_DATA_REAL_TYPE beta, Row &rJ) const
Return the scalar product of the current sparse row by a dense Vector.

INMOST::Sparse::HessianRow::Push
void Push(index ind, INMOST_DATA_REAL_TYPE val)
Push specified element into sparse row.
Definition: inmost_sparse.h:426

INMOST::Sparse::LockService
This class can be used for shared access to matrix with OpenMP.
Definition: inmost_sparse.h:450

INMOST::Sparse::LockService::GetLastIndex
INMOST_DATA_ENUM_TYPE GetLastIndex() const
Get the last row index of the distributed matrix interval.

INMOST::Sparse::LockService::GetFirstIndex
INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Get the first row index of the distributed matrix interval.

INMOST::Sparse::Matrix
Class to store the distributed sparse matrix by compressed rows.
Definition: inmost_sparse.h:475

INMOST::Sparse::Matrix::isParallel
bool & isParallel()
Check that matrix is in parallel state.
Definition: inmost_sparse.h:537

INMOST::Sparse::Matrix::GetFirstIndex
INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Get the first row index of the distributed matrix interval.
Definition: inmost_sparse.h:512

INMOST::Sparse::Matrix::MatVec
void MatVec(INMOST_DATA_REAL_TYPE alpha, Vector &x, INMOST_DATA_REAL_TYPE beta, Vector &y) const
Matrix-vector product of the form: y = alpha*A*x + beta * y.

INMOST::Sparse::Matrix::Size
INMOST_DATA_ENUM_TYPE Size() const
Return the total number of rows in the matrix.
Definition: inmost_sparse.h:500

INMOST::Sparse::Matrix::MatVecTranspose
void MatVecTranspose(INMOST_DATA_REAL_TYPE alpha, Vector &x, INMOST_DATA_REAL_TYPE beta, Vector &y) const
Matrix-vector product with transposed matrix of the form: y = alpha*A^T*x + beta * y.

INMOST::Sparse::Matrix::Nonzeros
INMOST_DATA_ENUM_TYPE Nonzeros()
Count number of nonzeros in matrix.
Definition: inmost_sparse.h:528

INMOST::Sparse::Matrix::operator[]
Row & operator[](INMOST_DATA_ENUM_TYPE i)
Return reference to i-th Row of the matrix.
Definition: inmost_sparse.h:496

INMOST::Sparse::Matrix::ZAXPBY
static void ZAXPBY(INMOST_DATA_REAL_TYPE alpha, const Sparse::Matrix &X, INMOST_DATA_REAL_TYPE beta, const Sparse::Matrix &Y, Sparse::Matrix &Z)
ZAXPBY operation for sparse matrices Z = alpha * X + beta * Y.

INMOST::Sparse::Matrix::GetLastIndex
INMOST_DATA_ENUM_TYPE GetLastIndex() const
Get the last row index of the distributed matrix interval.
Definition: inmost_sparse.h:514

INMOST::Sparse::Matrix::Save
void Save(std::string file, const AnnotationService *annotation=NULL)
Save the distributed matrix to a single data file in MTX format using parallel MPI I/O.

INMOST::Sparse::Matrix::GetName
std::string GetName() const
Get the matrix name specified in the main constructor.
Definition: inmost_sparse.h:540

INMOST::Sparse::Matrix::Clear
void Clear()
Clear all data of the matrix.
Definition: inmost_sparse.h:526

INMOST::Sparse::Matrix::Matrix
Matrix(std::string _name="", INMOST_DATA_ENUM_TYPE start=0, INMOST_DATA_ENUM_TYPE end=0, INMOST_MPI_Comm _comm=INMOST_MPI_COMM_WORLD)
Main constructor of the Matrix class.

INMOST::Sparse::Matrix::SetInterval
void SetInterval(INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end)
Set the start and the end row numbers of the distributed matrix interval.
Definition: inmost_sparse.h:507

INMOST::Sparse::Matrix::Residual
INMOST_DATA_REAL_TYPE Residual(Sparse::Vector &RHS, Sparse::Vector &SOL)
Calculate the real residual.

INMOST::Sparse::Matrix::GetCommunicator
INMOST_MPI_Comm GetCommunicator() const
Get the communicator which the matrix is associated with.
Definition: inmost_sparse.h:516

INMOST::Sparse::Matrix::GetInterval
void GetInterval(INMOST_DATA_ENUM_TYPE &start, INMOST_DATA_ENUM_TYPE &end) const
Get the start and the end row numbers of the distributed matrix interval.
Definition: inmost_sparse.h:509

INMOST::Sparse::Matrix::Load
void Load(std::string file, INMOST_DATA_ENUM_TYPE beg=ENUMUNDEF, INMOST_DATA_ENUM_TYPE end=ENUMUNDEF, std::string file_ord="")
Load the matrix from a single data file in MTX format using the specified interval.

INMOST::Sparse::Matrix::Sort
void Sort()
Sort rows.
Definition: inmost_sparse.h:542

INMOST::Sparse::RowMerger::iterator
Definition: inmost_sparse.h:648

INMOST::Sparse::RowMerger
This class may be used to sum multiple sparse rows.
Definition: inmost_sparse.h:638

INMOST::Sparse::RowMerger::Begin
iterator Begin()
Retrive iterator for the first element.
Definition: inmost_sparse.h:781

INMOST::Sparse::RowMerger::Resize
void Resize(const Matrix &A)
Resize linked list for new matrix, including non-local mapping.

INMOST::Sparse::RowMerger::AddRow
void AddRow(INMOST_DATA_REAL_TYPE coef, const Row &r)
Add a row with a coefficient into non-empty linked list.

INMOST::Sparse::RowMerger::Merge
void Merge(Row &c, INMOST_DATA_REAL_TYPE alpha, const Row &a, INMOST_DATA_REAL_TYPE beta, const Row &b)
Operation of the form c = alpha a + beta b.
Definition: inmost_sparse.h:773

INMOST::Sparse::RowMerger::Empty
bool Empty() const
Check if linked list is empty.
Definition: inmost_sparse.h:755

INMOST::Sparse::RowMerger::End
iterator End()
Retrive iterator for the position beyond the last element.
Definition: inmost_sparse.h:784

INMOST::Sparse::RowMerger::Size
INMOST_DATA_ENUM_TYPE Size() const
Get current number of nonzeros from linked list.
Definition: inmost_sparse.h:753

INMOST::Sparse::RowMerger::RetrieveRow
void RetrieveRow(Row &r) const
Place entries from linked list into row.

INMOST::Sparse::RowMerger::EOL
const INMOST_DATA_ENUM_TYPE EOL
End of linked list.
Definition: inmost_sparse.h:645

INMOST::Sparse::RowMerger::RowMerger
RowMerger()
Default constructor without size specified.

INMOST::Sparse::RowMerger::Resize
void Resize(INMOST_DATA_ENUM_TYPE size)
Resize linked list for new interval.

INMOST::Sparse::RowMerger::~RowMerger
~RowMerger()
Constructor with size specified.

INMOST::Sparse::RowMerger::Clear
void Clear()
Clear linked list.

INMOST::Sparse::RowMerger::Multiply
void Multiply(INMOST_DATA_REAL_TYPE coef)
Multiply all entries of linked list by a coefficient.

INMOST::Sparse::RowMerger::operator[]
INMOST_DATA_REAL_TYPE & operator[](INMOST_DATA_ENUM_TYPE pos)
Retrive/add an entry from/to linked list.
Definition: inmost_sparse.h:759

INMOST::Sparse::RowMerger::RowMerger
RowMerger(const Matrix &A)
Constructor that gets sizes from the matrix, including non-local mapping.

INMOST::Sparse::RowMerger::PushRow
void PushRow(INMOST_DATA_REAL_TYPE coef, const Row &r)
Add a row with a coefficient into empty linked list.

INMOST::Sparse::Row
Class to store the sparse matrix row.
Definition: inmost_sparse.h:162

INMOST::Sparse::Row::MoveRow
void MoveRow(Row &source)
An optimized assignment of the row, when the content of the source row may not be preserved.
Definition: inmost_sparse.h:296

INMOST::Sparse::Row::Sort
void Sort()
Sort row.
Definition: inmost_sparse.h:317

INMOST::Sparse::Row::Empty
bool Empty() const
Checks are there any nonzero entries in the row.
Definition: inmost_sparse.h:255

INMOST::Sparse::Row::Swap
void Swap(Row &other)
Exchange all the data with another row.
Definition: inmost_sparse.h:251

INMOST::Sparse::Row::operator[]
INMOST_DATA_REAL_TYPE operator[](INMOST_DATA_ENUM_TYPE i) const
Finds and returns value with specified index.
Definition: inmost_sparse.h:231

INMOST::Sparse::Row::get_safe
INMOST_DATA_REAL_TYPE get_safe(INMOST_DATA_ENUM_TYPE i) const
Finds and returns value with specified index.
Definition: inmost_sparse.h:242

INMOST::Sparse::Row::make_entry
static __INLINE entry make_entry(INMOST_DATA_ENUM_TYPE ind, INMOST_DATA_REAL_TYPE val)
Assemble an entry of entry_s type.
Definition: inmost_sparse.h:180

INMOST::Sparse::Row::Row
Row()
Construct an empty row.
Definition: inmost_sparse.h:198

INMOST::Sparse::Row::Clear
void Clear()
Clear all data of the current row.
Definition: inmost_sparse.h:248

INMOST::Sparse::Row::Row
Row(const Row &other)
Copy all data from another row.
Definition: inmost_sparse.h:201

INMOST::Sparse::Row::Pop
void Pop()
Remove last element.
Definition: inmost_sparse.h:303

INMOST::Sparse::Row::GetValue
INMOST_DATA_REAL_TYPE & GetValue(INMOST_DATA_ENUM_TYPE k)
Retrieve a value corresponding to certain position in the array of pairs of index and value.
Definition: inmost_sparse.h:263

INMOST::Sparse::Row::const_reverse_iterator
Entries::const_reverse_iterator const_reverse_iterator
Iterator over constant pairs of index and value running in backward direction.
Definition: inmost_sparse.h:193

INMOST::Sparse::Row::operator=
Row & operator=(Row const &other)
Copy all data from another row.
Definition: inmost_sparse.h:210

INMOST::Sparse::Row::Print
void Print(double eps=-1, std::ostream &sout=std::cout) const
Output all entries of the row.
Definition: inmost_sparse.h:310

INMOST::Sparse::Row::GetIndex
INMOST_DATA_ENUM_TYPE GetIndex(INMOST_DATA_ENUM_TYPE k) const
Retrieve an index corresponding to certain position in the array of pairs of index and value.
Definition: inmost_sparse.h:267

INMOST::Sparse::Row::rBegin
reverse_iterator rBegin()
An iterator pointing to the last position in the array of pairs of index and value.
Definition: inmost_sparse.h:283

INMOST::Sparse::Row::iterator
Entries::iterator iterator
Iterator over pairs of index and value.
Definition: inmost_sparse.h:190

INMOST::Sparse::Row::Row
Row(entry *pbegin, entry *pend)
Construct a row from array of pairs of indices and values.
Definition: inmost_sparse.h:205

INMOST::Sparse::Row::isSorted
bool isSorted() const
Check whether the row is sorted.

INMOST::Sparse::Row::operator[]
INMOST_DATA_REAL_TYPE & operator[](INMOST_DATA_ENUM_TYPE i)
Finds and returns value with specified index.
Definition: inmost_sparse.h:217

INMOST::Sparse::Row::Resize
void Resize(INMOST_DATA_ENUM_TYPE size)
Resize row to specified size.
Definition: inmost_sparse.h:308

INMOST::Sparse::Row::MergeSortedRows
static void MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const Row &left, INMOST_DATA_REAL_TYPE beta, const Row &right, Row &output)
Add up two rows.

INMOST::Sparse::Row::End
const_iterator End() const
An iterator pointing behind the last position in the array of constant pairs of index and value.
Definition: inmost_sparse.h:281

INMOST::Sparse::Row::entry
struct INMOST::Sparse::Row::entry_s entry
Entry of the sparse matrix row.

INMOST::Sparse::Row::End
iterator End()
An iterator pointing behind the last position in the array of pairs of index and value.
Definition: inmost_sparse.h:277

INMOST::Sparse::Row::reverse_iterator
Entries::reverse_iterator reverse_iterator
Iterator over pairs of index and value running in backward direction.
Definition: inmost_sparse.h:192

INMOST::Sparse::Row::Size
INMOST_DATA_ENUM_TYPE Size() const
The size of the sparse row, i.e. the total number of nonzero elements.
Definition: inmost_sparse.h:253

INMOST::Sparse::Row::GetValue
INMOST_DATA_REAL_TYPE GetValue(INMOST_DATA_ENUM_TYPE k) const
Retrieve a value corresponding to certain position in the array of pairs of index and value.
Definition: inmost_sparse.h:271

INMOST::Sparse::Row::const_iterator
Entries::const_iterator const_iterator
Iterator over constant pairs of index and value.
Definition: inmost_sparse.h:191

INMOST::Sparse::Row::rEnd
const_reverse_iterator rEnd() const
An iterator pointing before the first position in the array of constant pairs of index and value.
Definition: inmost_sparse.h:289

INMOST::Sparse::Row::rEnd
reverse_iterator rEnd()
An iterator pointing before the first position in the array of pairs of index and value.
Definition: inmost_sparse.h:285

INMOST::Sparse::Row::RowVec
INMOST_DATA_REAL_TYPE RowVec(Vector &x) const
Return the scalar product of the current sparse row by a dense Vector.

INMOST::Sparse::Row::rBegin
const_reverse_iterator rBegin() const
An iterator pointing to the last position in the array of constant pairs of index and value.
Definition: inmost_sparse.h:287

INMOST::Sparse::Row::~Row
~Row()
Release all data.
Definition: inmost_sparse.h:207

INMOST::Sparse::Row::Begin
iterator Begin()
Retrive interval of nonzeroes.
Definition: inmost_sparse.h:275

INMOST::Sparse::Row::GetIndex
INMOST_DATA_ENUM_TYPE & GetIndex(INMOST_DATA_ENUM_TYPE k)
Retrieve an index corresponding to certain position in the array of pairs of index and value.
Definition: inmost_sparse.h:259

INMOST::Sparse::Row::Zero
void Zero()
Set the vector entries by zeroes.
Definition: inmost_sparse.h:298

INMOST::Sparse::Row::Begin
const_iterator Begin() const
An iterator pointing to the first position in the array of constant pairs of index and value.
Definition: inmost_sparse.h:279

INMOST::Sparse::Row::Push
void Push(INMOST_DATA_ENUM_TYPE ind, INMOST_DATA_REAL_TYPE val)
Push specified element into sparse row.
Definition: inmost_sparse.h:301

INMOST::Sparse::Vector
Distributed vector class.
Definition: inmost_sparse.h:75

INMOST::Sparse::Vector::Empty
bool Empty() const
Test is there any data in the vector.
Definition: inmost_sparse.h:121

INMOST::Sparse::Vector::Save
void Save(std::string file)
Save the distributed vector to a single data file using parallel MPI I/O.

INMOST::Sparse::Vector::SetInterval
void SetInterval(INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end)
Set the start and the end of the distributed vector interval.
Definition: inmost_sparse.h:125

INMOST::Sparse::Vector::GetLastIndex
INMOST_DATA_ENUM_TYPE GetLastIndex() const
Get the last index of the distributed vector interval.
Definition: inmost_sparse.h:136

INMOST::Sparse::Vector::Vector
Vector(std::string _name="", INMOST_DATA_ENUM_TYPE start=0, INMOST_DATA_ENUM_TYPE end=0, INMOST_MPI_Comm _comm=INMOST_MPI_COMM_WORLD)
Main constructor of the Vector class.

INMOST::Sparse::Vector::Clear
void Clear()
Clear all data of the current vector.
Definition: inmost_sparse.h:153

INMOST::Sparse::Vector::Begin
const_iterator Begin() const
Iterator pointing to the first constant value of the vector.
Definition: inmost_sparse.h:115

INMOST::Sparse::Vector::ShiftInterval
void ShiftInterval(INMOST_DATA_ENUM_TYPE shift)
Move starting position of local indexes.
Definition: inmost_sparse.h:132

INMOST::Sparse::Vector::Begin
iterator Begin()
Iterator pointing to the first value of the vector.
Definition: inmost_sparse.h:113

INMOST::Sparse::Vector::operator=
Vector & operator=(Vector const &other)
Assignment operator.

INMOST::Sparse::Vector::End
const_iterator End() const
Iterator pointing behind the last constant value of the vector.
Definition: inmost_sparse.h:119

INMOST::Sparse::Vector::const_iterator
Entries::const_iterator const_iterator
Type for the iterator over vector of the constant values.
Definition: inmost_sparse.h:79

INMOST::Sparse::Vector::~Vector
~Vector()
Delete data of the vector.

INMOST::Sparse::Vector::isParallel
bool & isParallel()
Test whether the vector was assigned an extended range of values via OrderInfo class.
Definition: inmost_sparse.h:149

INMOST::Sparse::Vector::iterator
Entries::iterator iterator
Type for the iterator over vector of the values.
Definition: inmost_sparse.h:78

INMOST::Sparse::Vector::End
iterator End()
Iterator pointing behind the last value of the vector.
Definition: inmost_sparse.h:117

INMOST::Sparse::Vector::GetName
std::string GetName()
Get the vector name specified in the main constructor.
Definition: inmost_sparse.h:151

INMOST::Sparse::Vector::Load
void Load(std::string file, INMOST_DATA_ENUM_TYPE mbeg=ENUMUNDEF, INMOST_DATA_ENUM_TYPE mend=ENUMUNDEF, std::string file_ord="")
Load the vector from a single data file using the specified interval.

INMOST::Sparse::Vector::GetCommunicator
INMOST_MPI_Comm GetCommunicator() const
Get the communicator which the vector is associated with.
Definition: inmost_sparse.h:138

INMOST::Sparse::Vector::Vector
Vector(const Vector &other)
Copy constructor.

INMOST::Sparse::Vector::Swap
void Swap(Vector &other)
Exchange all the data with another vector.
Definition: inmost_sparse.h:141

INMOST::Sparse::Vector::Entries
interval< INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE > Entries
Type for representation of the local array of values.
Definition: inmost_sparse.h:77

INMOST::Sparse::Vector::GetInterval
void GetInterval(INMOST_DATA_ENUM_TYPE &start, INMOST_DATA_ENUM_TYPE &end) const
Get the start and the end of the distributed vector interval.
Definition: inmost_sparse.h:129

INMOST::Sparse::Vector::GetFirstIndex
INMOST_DATA_ENUM_TYPE GetFirstIndex() const
Get the first index of the distributed vector interval.
Definition: inmost_sparse.h:134

INMOST::Sparse::Vector::operator[]
INMOST_DATA_REAL_TYPE & operator[](INMOST_DATA_ENUM_TYPE i)
Return reference to i-th element of the vector.
Definition: inmost_sparse.h:101

INMOST::interval< INMOST_DATA_ENUM_TYPE, std::string >

INMOST::Sparse::HessianRow::hessian_entry_s
Definition: inmost_sparse.h:352

INMOST::Sparse::HessianRow::hessian_entry_s::first
index first
the column number of the row element.
Definition: inmost_sparse.h:353

INMOST::Sparse::HessianRow::hessian_entry_s::second
INMOST_DATA_REAL_TYPE second
the real value of the row element.
Definition: inmost_sparse.h:354

INMOST::Sparse::HessianRow::hessian_index_s
Entry of the sparse matrix row.
Definition: inmost_sparse.h:338

INMOST::Sparse::Row::entry_s
Entry of the sparse matrix row.
Definition: inmost_sparse.h:167

INMOST::Sparse::Row::entry_s::second
INMOST_DATA_REAL_TYPE second
the real value of the row element.
Definition: inmost_sparse.h:169

INMOST::Sparse::Row::entry_s::first
INMOST_DATA_ENUM_TYPE first
the column number of the row element.
Definition: inmost_sparse.h:168

INMOST::Sparse::Row::entry_s::operator<
bool operator<(const entry_s &other) const
Comparison operator that helps sorting entries.
Definition: inmost_sparse.h:171