algebra/matrix.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_MATRIX_H
#define _MATHTL_MATRIX_H

#include <iostream>
#include <algebra/vector.h>
#include <algebra/matrix_block.h>
#include <algebra/symmetric_matrix.h>
#include <algebra/triangular_matrix.h>
#include <algebra/kronecker_matrix.h>

// matrix norms, for convenience
#include <algebra/matrix_norms.h>

namespace MathTL
{
  template <class C>
  class Matrix
    : public MatrixBlock<C>
  {
  public:
    typedef typename Vector<C>::size_type size_type;
    
    explicit Matrix(const size_type n = 0);

    Matrix(const Matrix<C>& M);

    Matrix(const SymmetricMatrix<C>& M);
    
    Matrix(const LowerTriangularMatrix<C>& M);
    
    Matrix(const UpperTriangularMatrix<C>& M);
    
    template <class MATRIX1, class MATRIX2>
    Matrix(const KroneckerMatrix<C,MATRIX1,MATRIX2>& M);
    
    Matrix(const Vector<C>& v);

    Matrix(const size_type row_dimension, const size_type column_dimension);

    Matrix(const size_type row_dimension,
           const size_type column_dimension,
           const char* str,
           const bool byrow = true);

    MatrixBlock<C>* clone() const;

    MatrixBlock<C>* clone_transposed() const;

    const size_type row_dimension() const;

    const size_type column_dimension() const;

    const size_type size() const;
    
    void resize(const size_type rows, const size_type columns);

    void reshape(const size_type rows);

    void reshape(Vector<C>& v) const;
    
    void col(Vector<C>& v) const;

    void decol(const Vector<C>& v, const size_type rows);
    
    void diagonal(const size_type n, const C diag);

    const size_type memory_consumption() const;

    bool empty() const;

    const C operator () (const size_type row, const size_type column) const;

    const C get_entry(const size_type row, const size_type column) const;

    template <class MATRIX>
    void get_block(const size_type firstrow, const size_type firstcolumn,
                   const size_type rows, const size_type columns,
                   MATRIX& M, const bool resizeM = false) const;
    
    C& operator () (const size_type row, const size_type column);
    
    void set_entry(const size_type row, const size_type column, const C value);

    template <class MATRIX>
    void set_block(const size_type firstrow, const size_type firstcolumn,
                   const MATRIX& M,
                   const bool reflect = false);

    template <class C2>
    bool operator == (const Matrix<C2>& M) const;

    template <class C2>
    bool operator != (const Matrix<C2>& M) const;

    Matrix<C>& operator = (const Matrix<C>& M);

    void swap(Matrix<C>& M);

    void reflect(Matrix<C>& M) const;
    
    void scale(const C s);

    template <class VECTOR>
    void apply(const VECTOR& x, VECTOR& Mx) const;

    void apply(const Vector<C>& x, Vector<C>& Mx) const;

    template <class VECTOR>
    void apply_transposed(const VECTOR& x, VECTOR& Mtx) const;

    void apply_transposed(const Vector<C>& x, Vector<C>& Mtx) const;
    
    void compress(const double eta = 1e-16);

    void print(std::ostream& os,
               const unsigned int tabwidth = 10,
               const unsigned int precision = 3) const;

    void matlab_output(const char *file, const char *Matrixname, const int binary) const;

  protected:
    Vector<C> entries_;

    size_type rowdim_;

    size_type coldim_;
  };

  template <class C>
  void swap(Matrix<C>& M1, Matrix<C>& M2);

  template <class C>
  Matrix<C> operator + (const Matrix<C>& M, const Matrix<C>& N);

  template <class C>
  Matrix<C> operator - (const Matrix<C>& M, const Matrix<C>& N);

  template <class C>
  Matrix<C> operator * (const Matrix<C>& M, const Matrix<C>& N);

  template <class C>
  Matrix<C> transpose(const Matrix<C>& M);

  template <class C>
  std::ostream& operator << (std::ostream& os, const Matrix<C>& M);
}

// include implementation of inline functions
#include <algebra/matrix.cpp>

#endif