Matrix.h

// =======================================================================
// @(#)Matrix.h        1.2 11/20/98
// 
// Class:       TMatrix
//
// Purpose:     store a  matrix (ansatz != test space)
//
// Author:      Gunar Matthies
//
// History:     26.08.1998 start implementation
//
// =======================================================================

#ifndef __MATRIX__
#define __MATRIX__

#include <Structure.h>
#include <string>
#include <map>

class TMatrix
{
  protected:
    TStructure *structure;
    
    double *Entries;
    
  public:
    TMatrix(TStructure *structure);
    
    TMatrix(TStructure *structure, double* Entries);
    
    void SetStructure(TStructure *structure);
    
    TMatrix(int nRows, int nCols);

    ~TMatrix();

    void Reset();

    int GetN_Rows() const
    { return structure->GetN_Rows(); }

    int GetN_Columns() const
    { return structure->GetN_Columns(); }
    
    int GetN_Entries() const
    { return structure->GetN_Entries(); }

    int GetHangingN_Entries() const
    { return structure->GetHangingN_Entries(); }

    int *GetKCol() const
    { return structure->GetKCol(); }

    int *GetHangingKCol() const
    { return structure->GetHangingKCol(); }

    int *GetHangingRowPtr() const
    { return structure->GetHangingRowPtr(); }

    int *GetRowPtr() const
    { return structure->GetRowPtr(); }

    TStructure* GetStructure() const
    { return structure; }
    
    double *GetEntries() const
    { return Entries; }

    double GetNorm(int p=-1) const;

    int Write(const char *filename) const;
    
    void Print(const char *name = "a") const;
    
    void PrintFull(std::string name="", int fieldWidth=4) const;

    // add a value at selected entry
    void add(int i,int j, double val);
    // add values in row 'i' given by the map 'vals', multiplied by 'factor'
    // this should be faster than adding all values in 'vals' individually
    void add(int i, std::map<int,double> vals, double factor = 1.0);
    // add values 'vals[i][j]' to this matrix at the positions (i,j) for all
    // i,j defined in the map 'vals'
    void add(std::map<int, std::map<int,double> > vals, double factor = 1.0);
    // set a value at selected entry
    void set(int i, int j, double val);
    // get a value at selected entry
    const double& get(int i,int j) const;
    // get a value at selected entry (you may change that value (similar to set)
    double& get(int i,int j);
    
    // set the whole elements array
    void setEntries(double* entries) {
      this->Entries = entries;
    }
    
    TMatrix* GetTransposed() const;
    
    void changeRows(std::map<int,std::map<int,double> > entries,
                    bool deleteOldArrays=false);
    
    
    friend double* operator*(const TMatrix & A, const double* x);

    virtual TMatrix & operator+=(const TMatrix * A);
    virtual TMatrix & operator-=(const TMatrix * A);
    virtual TMatrix & operator+=(const TMatrix & A) 
    { *this += &A; return *this; }
    virtual TMatrix & operator*=(const double a);
    TMatrix & operator=(const TMatrix& A);
    
    void multiply(const double * const x, double *y, double a = 1.0) const;
    
    TMatrix* multiply(const TMatrix * const B, double a = 1.0) const;
    
    void scale(const double * const factor, bool from_left = true);
    
    void remove_zeros(double tol = 0.0);
    
    double & operator()(const int i, const int j);
    const double & operator()(const int i, const int j) const;
};

#endif