SparseBlockMatrix.h

#ifndef SparseBlockMatrix_h
#define SparseBlockMatrix_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
// std library
#include <iostream>
 
// Qt library
#include <QMap>
#include <QList>
 
// boost library
#include <boost/numeric/ublas/fwd.hpp>
 
// Isis library
#include "LinearAlgebra.h"
 
// Qt library
class QDebug;
 
namespace Isis {
 
  class SparseBlockColumnMatrix :
      public QMap< int, LinearAlgebra::Matrix * > {
 
  public:
    SparseBlockColumnMatrix();  // default constructor
    ~SparseBlockColumnMatrix(); // destructor
 
    // copy constructor
    SparseBlockColumnMatrix(const SparseBlockColumnMatrix& src);
 
    SparseBlockColumnMatrix& operator=(const SparseBlockColumnMatrix& src);
 
    void wipe();
    void copy(const SparseBlockColumnMatrix& src);
 
    void zeroBlocks();
    bool insertMatrixBlock(int nColumnBlock, int nRows, int nCols);
 
    void setStartColumn(int nStartColumn);
    int startColumn() const;
    int numberOfElements();
    int numberOfRows();
    int numberOfColumns();
    void print(std::ostream& outstream);
    void printClean(std::ostream& outstream);
 
  protected:
    int m_startColumn; 
  };
 
  // operators to read/write SparseBlockColumnMatrix to/from binary disk file
  QDataStream &operator<<(QDataStream &, const SparseBlockColumnMatrix &);
  QDataStream &operator>>(QDataStream &, SparseBlockColumnMatrix &);
 
  // operator to write SparseBlockColumnMatrix to QDebug stream
  QDebug operator<<(QDebug dbg, const SparseBlockColumnMatrix &sbcm);
 
 
  class SparseBlockRowMatrix :
      public QMap< int, LinearAlgebra::Matrix  * > {
 
  public:
    SparseBlockRowMatrix(){} // default constructor
    ~SparseBlockRowMatrix();
 
    // copy constructor
    SparseBlockRowMatrix(const SparseBlockRowMatrix& src);
 
    SparseBlockRowMatrix& operator=(const SparseBlockRowMatrix& src);
 
 
    void wipe();
    void copy(const SparseBlockRowMatrix& src);
 
    void zeroBlocks();
    bool insertMatrixBlock(int nRowBlock, int nRows, int nCols);
    void copyToBoost(boost::numeric::ublas::compressed_matrix<double>& B);
    int getLeadingColumnsForBlock(int nblockColumn);
    int numberOfElements();
    void print(std::ostream& outstream);
    void printClean(std::ostream& outstream);
  };
 
  // operators to read/write SparseBlockRowMatrix to/from binary disk file
  QDataStream &operator<<(QDataStream &, const SparseBlockRowMatrix &);
  QDataStream &operator>>(QDataStream &, SparseBlockRowMatrix &);
 
  // operator to write SparseBlockRowMatrix to QDebug stream
  QDebug operator<<(QDebug dbg, const SparseBlockRowMatrix &sbcm);
 
  class SparseBlockMatrix : public QList< SparseBlockColumnMatrix* > {
 
  public:
    SparseBlockMatrix() {} // default constructor
    ~SparseBlockMatrix();
 
    // copy constructor
    SparseBlockMatrix(const SparseBlockMatrix& src);
 
    SparseBlockMatrix& operator=(const SparseBlockMatrix& src);
 
    void wipe();
    void copy(const SparseBlockMatrix& src);
 
    bool setNumberOfColumns( int n );
    void zeroBlocks();
    bool insertMatrixBlock(int nColumnBlock, int nRowBlock, int nRows, int nCols);
    LinearAlgebra::Matrix *getBlock(int column, int row);
    int numberOfBlocks();
    int numberOfDiagonalBlocks();
    int numberOfOffDiagonalBlocks();
    int numberOfElements();
    void print(std::ostream& outstream);
    void printClean(std::ostream& outstream);
    bool write(std::ofstream &fp_out, bool binary=true);
    int getLeadingColumnsForBlock(int nblockColumn);
    int getLeadingRowsForBlock(int nblockRow);
  };
 
  // operators to read/write SparseBlockMatrix to/from binary disk file
  QDataStream &operator<<(QDataStream &, const SparseBlockMatrix &);
  QDataStream &operator>>(QDataStream &, SparseBlockMatrix &);
 
  // operator to write SparseBlockMatrix to QDebug stream
  QDebug operator<<(QDebug dbg, const SparseBlockMatrix &m);
}
 
#endif