J:/Tecgraf/prj/femoop/trunk/mlib/sysmat.h

// -------------------------------------------------------------------------
// SysMat.h - Definition of classes to handle square sparse matrices of
//            large linear systems.
// -------------------------------------------------------------------------
// Remarks:
// -------------------------------------------------------------------------
// cSysMatrix => classe para matrizes de grandes sistemas lineares 
//   cSymSkylMatrix => matriz simetrica em perfil (triangular inferior)
//   cSprsMatrix => matrix esparsa
//     cSymSprsMatrix => matrix simetrica esparsa (triangular inferior)
// -------------------------------------------------------------------------

#ifndef _SYSMAT_H
#define _SYSMAT_H

// -------------------------------------------------------------------------
// Forward declarations:
//
class cVector;

// -------------------------------------------------------------------------
// Abstract base class to handle sparse matrices:
//
class cSysMatrix
{
 friend class cVector;  // Allow cVector access the private data

 protected:
  int dim;        // Matrix dimension (rows/columns)
  int nelm;       // Number of stored elements
  int maxit;      // Max iterations for linear solver
  double tol;     // Solver tolerance

 protected:
  int IsSup(int i, int j) { return(i < j); }
  int IsInf(int i, int j) { return(i > j); }

 public:
                   cSysMatrix(int n = 1) { dim = n; nelm = 0; 
                                           maxit = n; tol = 1.0e-05; }
  virtual         ~cSysMatrix(void) { }
          int      GetNumElm (void) { return nelm; }
          int      Dim       (void) { return dim; }
          void     SetParam  (int k, double t) { maxit = k; tol = t; }
  virtual double **Val       (void) { return 0; }
  virtual void     Zero      (void) { }
  virtual int      Solve     (cVector &, cVector &) { return 0; }
  virtual int      GetSmlPvt (void) { return 0; }
  virtual int      GetLgtPvt (void) { return 0; }
  virtual int      GetNgtPvt (void) { return 0; }
  virtual double   Get       (int, int) = 0;
  virtual void     Add       (int, int, double) = 0;
  virtual void     Print     (void) = 0;
  virtual void     MultVect  (double *, double *) = 0;
};

// -------------------------------------------------------------------------
// Symmetric skeyline matrices:
//
class cSymSkylMatrix : public cSysMatrix
{
 protected:
  int    dec;     // Decomposition flag 
  int    *skl;    // Matrix skyline
  double **val;   // Stored values

 public:
           cSymSkylMatrix(int, int *);
          ~cSymSkylMatrix(void);
  double&  operator()    (int i, int j) { return val[i][j]; }
  double **Val           (void) { return val; }
  void     Zero          (void);
  int      Solve         (cVector &, cVector &);
  int      GetSmlPvt     (void);
  int      GetLgtPvt     (void);
  int      GetNgtPvt     (void);
  double   Get           (int, int);
  void     Add           (int, int, double);
  void     Print         (void);
  void     MultVect      (double *, double *);
};

// -------------------------------------------------------------------------
// Sparse matrix element:
//
typedef struct _spelm SpElm;

struct _spelm
{
  int    col;
  double val;
  SpElm *nxt;
};
  
// -------------------------------------------------------------------------
// Class to handle nonsymentric sparse matrices:
//
class cSprsMatrix : public cSysMatrix
{
 protected:
  SpElm **row;   // Array of rows (list of nonzero elements)

 public:
                  cSprsMatrix(int n = 1);
  virtual        ~cSprsMatrix(void);
  virtual double  Get        (int, int);
  virtual void    Add        (int, int, double);
  virtual void    Print      (void);
  virtual void    MultVect   (double *, double *);
};

// -------------------------------------------------------------------------
// Class to handle symmetric sparse matrices:
//
class cSymSprsMatrix : public cSprsMatrix
{
 public:
          cSymSprsMatrix(int n = 1);
         ~cSymSprsMatrix(void) { }
  int     Solve         (cVector &, cVector &);
  double  Get           (int, int);
  void    Add           (int, int, double);
  void    Print         (void);
  void    MultVect      (double *, double *);
};

// -------------------------------------------------------------------------
// Generic Solvers:
//
int PCGSolver(int maxit, double tol, cSysMatrix *K, cVector &f,
              cVector &u);

int FstEigPair(int maxit, double tol, cSysMatrix *K, double *, cVector &v);

#endif

---