DenseMatrix.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _DENSE_MATRIX_H
#define _DENSE_MATRIX_H
 
#include "SystemMatrix.h"
 
class SparseMatrix;
 
 
class DenseMatrix : public SystemMatrix
{
public:
  DenseMatrix(size_t m = 0, size_t n = 0, bool s = false);
  DenseMatrix(const DenseMatrix& A);
  explicit DenseMatrix(const RealArray& data, size_t nrows = 0);
  explicit DenseMatrix(const Matrix& A, bool s = false);
  virtual ~DenseMatrix() { delete[] ipiv; }
 
  virtual LinAlg::MatrixType getType() const { return LinAlg::DENSE; }
 
  virtual SystemMatrix* copy() const { return new DenseMatrix(*this); }
 
  bool redim(size_t r, size_t c);
 
  void setSymmetric(bool s = true) { symm = s && myMat.rows() == myMat.cols(); }
 
  virtual size_t dim(int idim) const
  {
    return idim > 0 && idim < 3 ? myMat.dim(idim) : myMat.size();
  }
 
  Matrix& getMat() { return myMat; }
  Real& operator()(size_t r, size_t c) { return myMat(r,c); }
  const Real& operator()(size_t r, size_t c) const { return myMat(r,c); }
 
  virtual void dump(std::ostream& os, LinAlg::StorageFormat format,
                    const char* label);
 
  virtual void initAssembly(const SAM& sam, char);
 
  virtual void init();
 
  virtual bool assemble(const Matrix& eM, const SAM& sam, int e);
  virtual bool assemble(const Matrix& eM, const SAM& sam,
                        SystemVector& B, int e);
  virtual bool assemble(const Matrix& eM, const SAM& sam,
                        SystemVector& B, const std::vector<int>& meq);
 
  virtual bool assemble(const Matrix& eM, const IntVec& meq);
 
  virtual bool augment(const SystemMatrix& B, size_t r0, size_t c0);
 
  virtual void mult(Real alpha) { myMat.multiply(alpha); }
 
  virtual bool add(const SystemMatrix& B, Real alpha);
 
  virtual bool add(Real sigma, int ieq);
 
  virtual bool multiply(const SystemVector& B, SystemVector& C) const;
 
  using SystemMatrix::solve;
  virtual bool solve(SystemVector& B, Real* rc = nullptr);
  bool solve(Matrix& B);
 
  bool solveEig(RealArray& eigVal, Matrix& eigVec, int nev);
 
  bool solveEigNon(RealArray& r_val, RealArray& c_val);
 
  bool solveEig(DenseMatrix& B, RealArray& eigVal, Matrix& eigVec, int nev,
                Real shift = Real(0));
 
  virtual Real Linfnorm() const { return myMat.normInf(); }
 
  virtual bool load(const char* fileName, bool binary);
 
protected:
  bool augment(const Matrix& B, size_t r0, size_t c0);
 
  bool augment(const SparseMatrix& B, size_t r0, size_t c0);
 
  bool solve(Real* B, size_t nrhs, Real* rcond = nullptr);
 
  virtual std::ostream& write(std::ostream& os) const { return os << myMat; }
 
private:
  Matrix myMat; 
  int*   ipiv;  
  bool   symm;  
};
 
DenseMatrix operator*(Real alpha, const DenseMatrix& A);
 
DenseMatrix operator*(const DenseMatrix& A, Real alpha);
 
#endif