sparse_block_matrix.h

#pragma once
#include "DLLInfo.h"
#include "Base/Headers/Buffer.hpp"
#include "Base/Headers/Dictionary.h"
#include <Eigen/Core>
 
#include "sparse_block_matrix_ccs.h"
#include "matrix_structure.h"
#include "matrix_operations.h"
#include <map>
namespace NDEVR
{
    using namespace Eigen;
    template <class MatrixType = MatrixX<g_type>>
    class SparseBlockMatrix {
 
    public:
        typedef MatrixType SparseMatrixBlock;

        inline int cols() const { return _colBlockIndices.size() ? _colBlockIndices.last() : 0; }
        inline int rows() const { return _rowBlockIndices.size() ? _rowBlockIndices.last() : 0; }
 
        typedef std::map<int, SparseMatrixBlock> IntBlockMap;

        SparseBlockMatrix(const int* rbi, const int* cbi, int rb, int cb, bool hasStorage = true);
 
        SparseBlockMatrix();
 
        ~SparseBlockMatrix();
 

        void clear(bool dealloc = false);

        SparseMatrixBlock* block(int r, int c, bool alloc = false);
        const SparseMatrixBlock* block(int r, int c) const;

        inline int rowsOfBlock(int r) const { return r ? _rowBlockIndices[r] - _rowBlockIndices[r - 1] : _rowBlockIndices[0]; }

        inline int colsOfBlock(int c) const { return c ? _colBlockIndices[c] - _colBlockIndices[c - 1] : _colBlockIndices[0]; }

        inline int rowBaseOfBlock(int r) const { return r ? _rowBlockIndices[r - 1] : 0; }

        inline int colBaseOfBlock(int c) const { return c ? _colBlockIndices[c - 1] : 0; }

        uint04 nonZeros() const;
        uint04 nonZeroBlocks() const;
 

        SparseBlockMatrix* slice(int rmin, int rmax, int cmin, int cmax, bool alloc = true) const;

        template <class MatrixTransposedType>
        bool transpose(SparseBlockMatrix<MatrixTransposedType>*& dest) const;

        bool add(SparseBlockMatrix<MatrixType>& dest) const;

        template <class MatrixResultType, class MatrixFactorType>
        bool multiply(SparseBlockMatrix<MatrixResultType>*& dest, const SparseBlockMatrix<MatrixFactorType>* M) const;

        void multiply(g_type*& dest, const g_type* src) const;

        void multiplySymmetricUpperTriangle(g_type*& dest, const g_type* src) const;

        void rightMultiply(g_type*& dest, const g_type* src) const;

        void scale(g_type a);

        bool symmPermutation(SparseBlockMatrix<MatrixType>*& dest, const int* pinv, bool onlyUpper = false) const;

        int fillCCS(int* Cp, int* Ci, g_type* Cx, bool upperTriangle = false) const;

        int fillCCS(g_type* Cx, bool upperTriangle = false) const;

        void fillBlockStructure(MatrixStructure& ms) const;

        const Buffer<IntBlockMap>& blockCols() const { return _blockCols; }
        Buffer<IntBlockMap>& blockCols() { return _blockCols; }

        const Buffer<int>& rowBlockIndices() const { return _rowBlockIndices; }
        Buffer<int>& rowBlockIndices() { return _rowBlockIndices; }

        const Buffer<int>& colBlockIndices() const { return _colBlockIndices; }
        Buffer<int>& colBlockIndices() { return _colBlockIndices; }

        int fillSparseBlockMatrixCCS(SparseBlockMatrixCCS<MatrixType>& blockCCS) const;

        int fillSparseBlockMatrixCCSTransposed(SparseBlockMatrixCCS<MatrixType>& blockCCS) const;

        void takePatternFromHash(SparseBlockMatrixHashMap<MatrixType>& hashMatrix);
 
    protected:
        Buffer<int> _rowBlockIndices; 
        Buffer<int> _colBlockIndices; 
        Buffer <IntBlockMap> _blockCols;
        bool _hasStorage;   
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    };
}
#include "sparse_block_matrix.hpp"