tpzverysparsematrix.h

Go to the documentation of this file.

#ifndef TPZVERYSPARSEMATRIX_H
#define TPZVERYSPARSEMATRIX_H

#include <iostream>
#include <map>

#include "pzmatrix.h"

#define TPZVERYSPARSEMATRIX_ID 28291001;

template <class TVar>
class TPZFMatrix;

template <class TVar>
class TPZFYsmpMatrix;

template<class TVar>
class TPZVerySparseMatrix: public TPZMatrix<TVar>
{
public:
                
                friend class TPZFYsmpMatrix<TVar>;
                
                TPZVerySparseMatrix();
                
                TPZVerySparseMatrix(int64_t rows, int64_t cols) :
    TPZRegisterClassId(&TPZVerySparseMatrix::ClassId),
    TPZMatrix<TVar>(rows, cols)
                {
                }
                TPZVerySparseMatrix(int64_t rows, int64_t cols, TVar val) :
    TPZRegisterClassId(&TPZVerySparseMatrix::ClassId),
    TPZMatrix<TVar>(rows, cols)
                {
                }
                
                virtual ~TPZVerySparseMatrix();
                
                TPZVerySparseMatrix(const TPZVerySparseMatrix<TVar> &copy) :
    TPZRegisterClassId(&TPZVerySparseMatrix::ClassId),
    TPZMatrix<TVar>(copy), fExtraSparseData(copy.fExtraSparseData)
                {
                }
                
                TPZVerySparseMatrix(const TPZFMatrix<TVar> &cp);
                
                void Simetrize() override;
    
                int PutVal(const int64_t row, const int64_t col, const TVar &val) override;
                
                virtual const TVar &GetVal(const int64_t row, const int64_t col) const override;
                
                virtual TVar &s(const int64_t row, const int64_t col) override
                {
#ifdef PZDEBUG
                                if(row >= this->Rows() || row<0 || col >= this->Cols() || col<0)
                                {
                                                this->Error("TPZFMatrix::operator() "," Index out of bounds");
                                                DebugStop();
                                }
#endif
                                return fExtraSparseData[std::pair<int64_t, int64_t>(row, col)];
                }
                
                CLONEDEF(TPZVerySparseMatrix)
                
                
                virtual void MultAdd(const TPZFMatrix<TVar> & x, const TPZFMatrix<TVar> & y,
                                                                                                 TPZFMatrix<TVar> & z, const TVar alpha = 1, const TVar beta = 0,
                                                                                                 const int opt = 0) const override;
                
                virtual void Transpose(TPZVerySparseMatrix<TVar>* T) const;
                virtual void Transpose(TPZMatrix<TVar>*const T) const  override {
        TPZMatrix<TVar>::Transpose(T);
    }
    
                public:
int ClassId() const override;

                void Write(TPZStream &buf, int withclassid) const override;
                void Read(TPZStream &buf, void *context) override;

                typename std::map <std::pair<int64_t, int64_t>, TVar>::const_iterator MapBegin() const { return fExtraSparseData.begin(); }
                typename std::map <std::pair<int64_t, int64_t>, TVar>::const_iterator MapEnd() const { return fExtraSparseData.end(); }
                
private:
                void WriteMap(TPZStream &buf, int withclassid, const std::map<std::pair<int64_t, int64_t>, TVar> & TheMap) const;
                void ReadMap(TPZStream &buf, void *context, std::map<std::pair<int64_t, int64_t>, TVar> & TheMap);
                
protected:
    
                std::map<std::pair<int64_t, int64_t>, TVar> fExtraSparseData;
    
};

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

#endif