algebra/block_matrix.h

// -*- c++ -*-

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

#ifndef _MATHTL_BLOCK_MATRIX_H
#define _MATHTL_BLOCK_MATRIX_H

#include <iostream>
#include <utils/array1d.h>
#include <algebra/vector.h>
#include <algebra/matrix_block.h>

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

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

    BlockMatrix(const size_type block_rows, const size_type block_columns);

    BlockMatrix(const BlockMatrix<C>&);

    ~BlockMatrix();
    
    MatrixBlock<C>* clone() const;

    MatrixBlock<C>* clone_transposed() const;

    const size_type row_dimension() const { return rowdim_; }
    
    const size_type column_dimension() const { return coldim_; }

    const size_type block_rows() const;

    const size_type block_columns() const;

    const size_type block_row_dimension(const size_type block_row) const;
    
    const size_type block_column_dimension(const size_type block_column) const;
    
    const MatrixBlock<C>* get_block(const size_type block_row, const size_type block_column) const;

    void set_block(const size_type row, const size_type column, MatrixBlock<C>* block);
    
    void resize_block_row(const size_type block_row, const size_type rows);

    void resize_block_column(const size_type block_row, const size_type columns);

    bool empty() const;

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

    void apply_transposed(const Vector<C>& x, Vector<C>& Mtx) const;
    
    void print(std::ostream& os,
               const unsigned int tabwidth = 10,
               const unsigned int precision = 3) const;

  protected:
    Array1D<MatrixBlock<C>*> blocks;

    Array1D<size_type> block_rows_rows;
    
    Array1D<size_type> block_columns_columns;

    size_type rowdim_;

    size_type coldim_;

    void calculate_size();
  };

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

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

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

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

#endif