MathDynSparseArrayBase Entity Reference

Inherits Eigen::DynamicSparseMatrix< Scalar >.

List of all members.

Libraries
MathDynSparseArrayBase
Swap
	swaps the data pointers of both objects (fastest way to transfer data)

---

Detailed Description

template<typename Scalar>
class tngmath::MathDynSparseArrayBase< Scalar >

A class that represents storage for sparse linalg objects with random write access.

The storage scheme is column_major (FORTRAN). It basically provides basic features of the Eigen::DynamicSparseMatrix class, i.e. basic operators and assembly methods.

The storage scheme is described in the Eigen doc in detail. It should be noted that one can view any column_major sparse matrix as a set of 'ncols' sparse vectors. The sparse vectors are labeled by the index i ("outer iterator"), the access of the elements within these vectors is labeled by the Eigen::InnerIterator object it ("inner iterator"/ "inner loop").

In comparison to MathSparseArrayBase, MathDynSparseArrayBase requires more storage since the sparse vectors are directly used as storage containers, not only as mappers onto a single data array. As a result, DynMatrix ("dynamic matrix storage") provides more flexible assembly methods. A few math operations are slower, see the Eigen doc for details.

The following methods can be used for storage:

(1) Sorted fill

                                SparseMatrix\<double,ColMajor> m(rows,cols);
                                m.startFill(rows*cols*percent_of_non_zero); // estimate of the number of nonzeros (optional)
                                for (int j=0; j\<cols; ++j)
                                        for (int i=0; i\<rows; ++i)
                                                if (rand()\<percent_of_non_zero)
                                                        m.fill(i,j) = rand();
                                m.endFill();

One has to fill the elements according to their internal index sort order (2) Fill by random inner access Herein one has to fill each outer index in its given sort order, but may fill the items into the currently active sparse vector in random order:

                                SparseMatrix\<double,ColMajor> m(rows,cols);
                                m.startFill(rows*cols*percent_of_non_zero); // estimate of the number of nonzeros (optional)
                                for (int k=0; k\<cols; ++k)
                                for (int i=0; i\<rows*percent_of_non_zero; ++i)
                                        m.fillrand(i,rand(0,cols)) = rand();
                                m.endFill();

(3) Complete random access Using the 'coeff' and 'coeffRef' methods a dynamic matrix can be filled and read like a dense matrix.

                                DynamicSparseMatrix\<float> aux(1000,1000);
                                for (...)
                                for each i
                                        for each j interacting with i
                                        aux.coeffRef(i,j) += foo(o1,o2);
                                SparseMatrix\<float> mat(aux); // convert the DynamicSparseMatrix to a SparseMatrix

---

Constructor & Destructor Documentation

[Library]

destructor constructs a nrow*ncol matrix

---

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

• modules/tngmath/tngmath/dynamicsparsematrixbase.hpp