Matrix.h

Go to the documentation of this file.

// Copyright (C) 2002 Johan Hoffman and Anders Logg.
// Licensed under the GNU GPL Version 2.
//
// Modified by Erik Svensson, 2003, 2004.

#ifndef __MATRIX_H
#define __MATRIX_H

#include <dolfin/dolfin_log.h>
#include <dolfin/constants.h>
#include <dolfin/Variable.h>
#include <dolfin/General.h>

namespace dolfin {

  class Vector;
  class GenericMatrix;


  class Matrix : public Variable {
  public:

    enum Type {sparse, dense, generic};

    Matrix(Type type = sparse);

    Matrix(unsigned int m, unsigned int n, Type type = sparse);

    Matrix(const Matrix& A);

    virtual ~Matrix();

    // Forward declaration of nested classes
    class Element;
    class Row;
    class Column;


    virtual void init(unsigned int m, unsigned int n, Type type = sparse);

    virtual void clear();

    
    virtual Type type() const;

    virtual unsigned int size(unsigned int dim) const;

    virtual unsigned int size() const;

    virtual unsigned int rowsize(unsigned int i) const;

    virtual unsigned int bytes() const;


    virtual real operator()(unsigned int i, unsigned int j) const;

    virtual Element operator()(unsigned int i, unsigned int j);

    virtual Row operator()(unsigned int i, Range j);

    virtual Row operator()(Index i, Range j);
    
    virtual Column operator()(Range i, unsigned int j);

    virtual Column operator()(Range i, Index j);

    virtual real* operator[](unsigned int i) const;

    virtual real operator()(unsigned int i, unsigned int& j, unsigned int pos) const;

    virtual void operator=(real a);

    virtual void operator=(const Matrix& A);

    virtual void operator+=(const Matrix& A);

    virtual void operator-=(const Matrix& A);

    virtual void operator*=(real a);    
    

    virtual real norm() const;

    virtual real mult(const Vector& x, unsigned int i) const;

    virtual void mult(const Vector& x, Vector& Ax) const;
    
    virtual void multt(const Vector& x, Vector &Ax) const;

    virtual void mult(const Matrix& B, Matrix& AB) const;

    virtual real multrow(const Vector& x, unsigned int i) const;

    virtual real multcol(const Vector& x, unsigned int j) const;

    virtual void transp(Matrix& At) const;

    virtual void solve(Vector& x, const Vector& b);

    virtual void inverse(Matrix& Ainv);

    virtual void hpsolve(Vector& x, const Vector& b) const;

    virtual void lu();

    virtual void solveLU(Vector& x, const Vector& b) const;

    virtual void inverseLU(Matrix& Ainv) const;

    virtual void hpsolveLU(const Matrix& LU, Vector& x, const Vector& b) const;
    

    virtual void resize();
    
    virtual void ident(unsigned int i);

    virtual void lump(Vector& a) const;

    virtual void addrow();
    
    virtual void addrow(const Vector& x);

    virtual void initrow(unsigned int i, unsigned int rowsize);

    virtual bool endrow(unsigned int i, unsigned int pos) const;
    
    virtual void settransp(const Matrix& A);

    virtual real rowmax(unsigned int i) const;

    virtual real colmax(unsigned int i) const;    
    
    virtual real rowmin(unsigned int i) const;

    virtual real colmin(unsigned int i) const;

    virtual real rowsum(unsigned int i) const;

    virtual real colsum(unsigned int i) const;

    virtual real rownorm(unsigned int i,unsigned int type) const;

    virtual real colnorm(unsigned int i,unsigned int type) const;


    virtual void show() const;

    friend LogStream& operator<< (LogStream& stream, const Matrix& A);


    class Element {
    public:
    
      Element(Matrix& matrix, unsigned int i, unsigned int j);
      
      operator real() const;
      
      void operator=  (real a);
      void operator=  (const Element& e);
      void operator+= (real a);
      void operator-= (real a);
      void operator*= (real a);
      void operator/= (real a);
      

    protected:
    
      Matrix& A;
      unsigned int i;
      unsigned int j;

    };

    class Row {
    public:
    
      Row(Matrix& matrix, unsigned int i, Range j);
      Row(Matrix& matrix, Index i, Range j);

      unsigned int size() const;

      real max() const;
      real min() const;
      real sum() const;
      real norm(unsigned int type) const;

      real operator() (unsigned int j) const;
      Element operator()(unsigned int j);

      void operator= (const Row& row);
      void operator= (const Column& col);
      void operator= (const Vector& x);

      real operator* (const Vector& x) const;

      friend class Column;

    private:
    
      Matrix& A;
      unsigned int i;
      Range j;

    };

    class Column {
    public:
    
      Column(Matrix& matrix, Range i, unsigned int j);
      Column(Matrix& matrix, Range i, Index j);

      unsigned int size() const;

      real max() const;
      real min() const;
      real sum() const;
      real norm(unsigned int type) const;

      real operator() (unsigned int i) const;
      Element operator()(unsigned int i);

      void operator= (const Column& col);
      void operator= (const Row& row);
      void operator= (const Vector& x);

      real operator* (const Vector& x) const;

      friend class Row;

    private:
    
      Matrix& A;
      Range i;
      unsigned int j;

    };

    friend class DirectSolver;
    friend class Element;

  private:
    
    real** values();

    real** const values() const;
    
    void initperm();

    void clearperm();

    unsigned int* permutation();
    
    unsigned int* const permutation() const;
    
    GenericMatrix* A;
    Type _type;

  };
  
}

#endif

Documentation automatically generated with Doxygen on 10 Sep 2004.