Diffpack Documentation

---

              Search  

---

Matrix_Type.h

Go to the documentation of this file.

class Matrix(Type) : public HandleId

{

protected:

  bool      symm_storage;    
  bool      pivot_allowed;   

  bool      is_factorized;   
  FactType  last_fact;
  PivotType last_pivtp;

  int prod_work;             
  int matvec_work;
  int fact_work;
  int forwback_work;
  int inv_work;
  int det_work;
  int jacobi_work;
  int sor_work;
  int ssor_work;

  virtual void copy_matrix_attributes (const Matrix(Type)& X);
  virtual void reset ();

public:

  

  Matrix(Type) ();

  virtual ~Matrix(Type) ();


  

  bool symmetricStorage () { return symm_storage; }
  bool pivotingAllowed  () { return pivot_allowed; }

  virtual int  getNoRows      () const = 0;
  virtual int  getNoColumns   () const = 0;
  virtual int  getNoNonzeroes () const = 0;
  virtual void size (int& m, int& n) const = 0;

  virtual int  getWork (const MatrixWork work_tp = MATVEC_WORK) const;
  virtual real getStorage() const = 0;


  

  virtual bool makeItSimilar (Handle(Matrix(Type))& M) const = 0;
  virtual bool redim (const Matrix(prm_Type)& pm) = 0;

  virtual void optimizeDataStructure () {}

  

  virtual bool redim         (const VecSimple(int)& ivec,
                              const VecSimple(int)& jvec,
                              int new_nrows,
                              int new_ncolumns)      = 0;
  virtual void getIndexSet   (VecSimple(int)& ivec,
                              VecSimple(int)& jvec) const = 0;
  virtual bool validIndexSet (const VecSimple(int)& ivec,
                              const VecSimple(int)& jvec,
                              const int new_nrows,
                              const int new_ncolumns) = 0;


  

  virtual Type& elm (int i, int j) = 0;  

  Matrix(Type)& operator = (const Matrix(Type)& X)
  { fill(X); return *this; }

  Matrix(Type)& operator = (Type a) { fill(a); return *this; }

  virtual void fill (const Matrix(Type)& X) = 0;
  virtual void fill (Type a) = 0;

  virtual void convertFrom (Matrix(Type)& X);

  virtual void assemble (const Mat(Type)& em,
                         const VecSimple(int)& idx_row_trans,
                         const VecSimple(int)& idx_col_trans,
                         int elm_no);


  

  virtual void add
    (Matrix(Type)& bm, Matrix(Type)& cm) = 0;

  virtual void add
    (Matrix(Type)& bm, char s, Matrix(Type)& cm) = 0;

  virtual void add
    (Matrix(Type)& bm, Type b, Matrix(Type)& cm) = 0;

  virtual void add
    (Type a, Matrix(Type)& bm, Type b, Matrix(Type)& cm) = 0;

  virtual void mult (Type value) = 0;

  virtual void prod     
    (
     const Vector(Type)& xb,
           Vector(Type)& yb,
           TransposeMode tpmode = NOT_TRANSPOSED,
           bool          add_to_yb = false
    ) const = 0;

  virtual void colManip
    (
     LinEqConstraint&     constraint_eq,
     Vec(Type)&           vc,
     VecSimple(bool)&     essential_dof
    );

  virtual void rowManip
    (
     LinEqConstraint&     constraint_eq,
     Vec(Type)&           vc,
     VecSimple(bool)&     essential_dof
    );


  

  void resetFact (bool is_factorized = false,
                  FactType last_fact = LU_FACT,
                  PivotType last_pivtp = NO_PIVOT);

  bool factorized () const { return is_factorized; }
  bool factorized (FactType& fact_tp, PivotType& pivot_tp) const;


  virtual bool factorize (const FactStrategy& fstrategy) = 0;
  virtual void forwBack  (Vector(Type)& bb, Vector(Type)& xb) = 0;


  

  virtual void SSOR1it     (Vector(Type)& xnew, const Vector(Type)& xold,
                            const Vector(Type)& b, real omega,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;
  virtual void SSORsolve   (Vector(Type)& y, const Vector(Type)& c,
                            real omega,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;

  virtual void SOR1it      (Vector(Type)& xnew, const Vector(Type)& xold,
                            const Vector(Type)& b, real omega,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;
  virtual void SORsolve    (Vector(Type)& y, const Vector(Type)& c,
                            real omega,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;

  virtual void Jacobi1it   (Vector(Type)& xnew, const Vector(Type)& xold,
                            const Vector(Type)& b,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;
  virtual void Jacobisolve (Vector(Type)& y, const Vector(Type)& c,
                            TransposeMode tpmode = NOT_TRANSPOSED) const = 0;


  

  virtual void print (Os os, const char* header = NULL,
                      int nentries_per_line = 3) const = 0;
  virtual void printAscii (Os os, const char* header = NULL) const =0;

  virtual void scan  (Is is) = 0;

  virtual void save  (const char* filename, const char* name = "X") const;
  virtual void load  (const char* filename, const char* name = "X");

  CLASS_INFO

  
  DEF_VIRTUAL_CAST(MatBand(Type))
  DEF_VIRTUAL_CAST(Mat(Type))

  DEF_VIRTUAL_CAST(MatStructSparse(Type))
  DEF_VIRTUAL_CAST(MatSparse(Type))
  DEF_VIRTUAL_CAST(MatDiag(Type))
  DEF_VIRTUAL_CAST(MatTri(Type))
  DEF_VIRTUAL_CAST(MatLapack(Type))
  DEF_VIRTUAL_CAST(MatBandLapack(Type))
  DEF_VIRTUAL_CAST(MatEBE(Type))
};




inline void add
  (
   Matrix(Type)& A,
   Matrix(Type)& B,
   Matrix(Type)& C
  )

{
  A.add(B,C);
}




inline void add
  (
   Matrix(Type)& A,
   Matrix(Type)& B,
   char       s,
   Matrix(Type)& C
  )

{
  A.add(B,s,C);
}




inline void add
  (
   Matrix(Type)& A,
   Matrix(Type)& B,
   Type       b,
   Matrix(Type)& C
  )

{
  A.add(B,b,C);
}




inline void add
  (
   Matrix(Type)& A,
   Type       a,
   Matrix(Type)& B,
   Type       b,
   Matrix(Type)& C
  )

{
  A.add(a,B,b,C);
}




inline void prod     
  (
         Vector(Type)& y,
   const Matrix(Type)& A,
   const Vector(Type)& x,
         TransposeMode tpmode = NOT_TRANSPOSED,
         bool          add_to_yb = false
  )

{
  if (&y == &x) {
    errorFP("prod (y,A,x)","y is identical to x (same adress) - illegal!");
  }

  A.prod (x, y, tpmode, add_to_yb);
}


#define  ClassType Matrix(Type)
#include <Handle.h>
#undef   ClassType



inline void add
  (
   Handle(Matrix(Type)) am,
   Handle(Matrix(Type)) bm,
   Handle(Matrix(Type)) cm
  )

{
  am->add (*bm, *cm);
}





inline void add
  (
   Handle(Matrix(Type)) am,
   Handle(Matrix(Type)) bm,
   char       s,
   Handle(Matrix(Type)) cm

  )

{
  am->add(*bm,s,*cm);
}




inline void add
  (
   Handle(Matrix(Type)) am,
   Handle(Matrix(Type)) bm,
   Type  b,
   Handle(Matrix(Type)) cm
  )

{
  am->add(*bm,b,*cm);
}




inline void add
  (
   Handle(Matrix(Type)) am,
   Type       a,
   Handle(Matrix(Type)) bm,
   Type  b,
   Handle(Matrix(Type)) cm
  )

{
  am->add(a,*bm,b,*cm);
}

---