operators.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_OPERATORS_HH
#define DUNE_ISTL_OPERATORS_HH
 
#include <cmath>
#include <complex>
#include <iostream>
#include <iomanip>
#include <string>
 
#include <dune/common/exceptions.hh>
 
#include "solvercategory.hh"
 
 
namespace Dune {
 
  //=====================================================================
  // Abstract operator interface
  //=====================================================================
 
 
  template<class X, class Y>
  class LinearOperator {
  public:
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;
 
    virtual void apply (const X& x, Y& y) const = 0;
 
    virtual void applyscaleadd (field_type alpha, const X& x, Y& y) const = 0;
 
    virtual ~LinearOperator () {}
 
    virtual SolverCategory::Category category() const
#if DUNE_ISTL_SUPPORT_OLD_CATEGORY_INTERFACE
    {
      DUNE_THROW(Dune::Exception,"It is necessary to implement the category method in a derived classes, in the future this method will pure virtual.");
    };
#else
    = 0;
#endif
  };
 
 
  template<class M, class X, class Y>
  class AssembledLinearOperator : public LinearOperator<X,Y> {
  public:
    typedef M matrix_type;
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;
 
    virtual const M& getmat () const = 0;
 
    virtual ~AssembledLinearOperator () {}
  };
 
 
 
  //=====================================================================
  // Implementation for ISTL-matrix based operator
  //=====================================================================
 
  template<class M, class X, class Y>
  class MatrixAdapter : public AssembledLinearOperator<M,X,Y>
  {
  public:
    typedef M matrix_type;
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;
 
    explicit MatrixAdapter (const M& A) : _A_(A) {}
 
    virtual void apply (const X& x, Y& y) const
    {
      _A_.mv(x,y);
    }
 
    virtual void applyscaleadd (field_type alpha, const X& x, Y& y) const
    {
      _A_.usmv(alpha,x,y);
    }
 
    virtual const M& getmat () const
    {
      return _A_;
    }
 
    virtual SolverCategory::Category category() const
    {
      return SolverCategory::sequential;
    }
 
  private:
    const M& _A_;
  };
 
} // end namespace
 
#endif