pzskylnsymmat.h

Go to the documentation of this file.

//---------------------------------------------------------------------------

#ifndef pzskylnsymmatH
#define pzskylnsymmatH

//
// Author: Nathan Shauer.
//
// File:   pzskylnsymmat
//
// Class:  TPZSkylMatrix
//
// Obs.: This class manages non symmetric skylyne type matrix
//
//
// Versao: 12 / 2011.
//


#include "pzmatrix.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include "pzmanvector.h"


template<class TVar=REAL>
class TPZSkylNSymMatrix : public TPZMatrix<TVar>
{
 public:
  TPZSkylNSymMatrix() : TPZRegisterClassId(&TPZSkylNSymMatrix::ClassId),
    TPZMatrix<TVar>(0,0),fElem(0), fElemb(0), fStorage(0), fStorageb(0) { }
    
  TPZSkylNSymMatrix(const int64_t nrow, const int64_t ncol);
  TPZSkylNSymMatrix(const int64_t dim ,const TPZVec<int64_t> &skyline);
  
  TPZSkylNSymMatrix(const TPZSkylNSymMatrix &A ) : 
    TPZRegisterClassId(&TPZSkylNSymMatrix::ClassId),TPZMatrix<TVar>(A), fElem(0), fElemb(0), fStorage(0), fStorageb(0)  
    { 
        Copy(A); 
    }

  CLONEDEF(TPZSkylNSymMatrix)
  void SetSkyline(const TPZVec<int64_t> &skyline);

  int SkyHeight(int64_t col) { return fElem[col+1]-fElem[col] - 1; }

  //void AddSameStruct(TPZSkylNSymMatrix &B, double k = 1.);

  virtual int IsSimetric() const  override {return 0;}

  virtual ~TPZSkylNSymMatrix() { Clear(); }

  int PutVal(const int64_t row,const int64_t col,const TVar &element ) override;

  const TVar &GetVal(const int64_t row,const int64_t col ) const override;


  const TVar &GetValSup(const int64_t row,const int64_t col ) const;

  const TVar &GetValB(const int64_t row,const int64_t col ) const;


  TVar &operator()(const int64_t row, const int64_t col);
  virtual TVar &s(const int64_t row, const int64_t col) override;


  TVar &operator()(const int64_t row);

  virtual void MultAdd(const TPZFMatrix<TVar> &x,const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z,
                                       const TVar               alpha,const TVar beta ,const int opt = 0) const  override;
    
    
    virtual void UpdateFrom(TPZAutoPointer<TPZMatrix<TVar> > mat) override;

  // Operadores com matrizes SKY LINE.
  //TPZSkylNSymMatrix &operator= (const TPZSkylNSymMatrix &A );
  //TPZSkylMatrix &operator= (TTempMat<TPZSkylMatrix> A);

  //TPZSkylNSymMatrix operator+  (const TPZSkylNSymMatrix &A ) const;
  //TPZSkylNSymMatrix operator-  (const TPZSkylNSymMatrix &A ) const;

  //TPZSkylNSymMatrix &operator+=(const TPZSkylNSymMatrix &A );
  //TPZSkylNSymMatrix &operator-=(const TPZSkylNSymMatrix &A );

  // Operadores com valores NUMERICOS.
  //TPZSkylNSymMatrix operator*  (const REAL v ) const;
  //TPZSkylNSymMatrix &operator*=( REAL v );

  //TPZSkylNSymMatrix operator-() const;// { return operator*(-1.0); }

  // Redimensiona a matriz, mas mantem seus elementos.
  // o segundo parametro � o tamanho das colunas
  //int Resize(const int newDim ,const int );

  // Redimensiona a matriz e ZERA seus elementos.
  // o segundo parametro � o tamanho das colunas
  //int Redim(const int newDim ,const int );
  //int Redim(const int newDim) {return Redim(newDim,newDim);}

  // Zera os Elementos da matriz
  //int Zero();


  /*** Resolucao de sistemas ***/

  int Decompose_LU() override;  // Faz A = LU.

  //virtual void SolveSOR(int &numiterations,const TPZFMatrix &F, TPZFMatrix &result,
                //                              TPZFMatrix *residual,TPZFMatrix &scratch,const REAL overrelax, REAL &tol,
                //                              const int FromCurrent = 0,const int direction = 1) ;


  //int Subst_Forward  ( TPZFMatrix *b ) const override;
  int Subst_Backward ( TPZFMatrix<TVar> *b ) const override;
  int Subst_LForward ( TPZFMatrix<TVar> *b ) const override;
  //int Subst_LBackward( TPZFMatrix *b ) const override;
  //int Subst_Diag     ( TPZFMatrix *b ) const override;

  //void TestSpeed(int col, int prevcol);
                
                public:
int ClassId() const override;

                void Read(TPZStream &buf, void *context) override;
                void Write(TPZStream &buf, int withclassid) const override;
    
                void AutoFill(int64_t nrow, int64_t ncol, int symmetric);


 protected:

  TVar *Diag(int64_t col) { return fElem[col];}

  //void DecomposeColumn(int col, int prevcol);
                //void DecomposeColumn(int col, int prevcol, std::list<int64_t> &singular);

  //void DecomposeColumn2(int col, int prevcol);
 private:

  // Aloca uma nova coluna. 'fDiag[col].pElem' deve ser NULL.

//static int  Error(const char *msg1,const char* msg2="" );
  int  Clear() override;
  void Copy (const TPZSkylNSymMatrix & );
  int Size(const int64_t column) const {return fElem[column+1]-fElem[column];}
  static int64_t NumElements(const TPZVec<int64_t> &skyline);
  static void InitializeElem(const TPZVec<int64_t> &skyline, TPZManVector<TVar> &storage, TPZVec<TVar *> &elem);
  static void ComputeMaxSkyline(const TPZSkylNSymMatrix &first, const TPZSkylNSymMatrix &second, TPZVec<int> &res);
                
                virtual int Zero() override {
                                fStorage.Fill(0.);
        fStorageb.Fill(0.);
                                return 1;
    }


protected:
  TPZVec<TVar *> fElem;

  TPZVec<TVar *> fElemb;

private:
  TPZManVector<TVar> fStorage;

  TPZManVector<TVar> fStorageb;
};

/*
template<int N>
inline REAL TemplateSum(const REAL *p1, const REAL *p2){
  return *p1* *p2 + TemplateSum<N-1>(p1+1,p2+1);

}


template<>
inline REAL TemplateSum<1>(const REAL *p1, const REAL *p2){
  return *p1 * *p2;
}

*/

//---------------------------------------------------------------------------

template<class TVar>
int TPZSkylNSymMatrix<TVar>::ClassId() const{
    return Hash("TPZSkylNSymMatrix") ^ TPZMatrix<TVar>::ClassId() << 1;
}
#endif