scalarproducts.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_SCALARPRODUCTS_HH
#define DUNE_ISTL_SCALARPRODUCTS_HH
 
#include <cmath>
#include <complex>
#include <iostream>
#include <iomanip>
#include <string>
 
#include "bvector.hh"
#include "solvercategory.hh"
 
 
namespace Dune {
  template<class X>
  class ScalarProduct {
  public:
    typedef X domain_type;
    typedef typename X::field_type field_type;
 
    virtual field_type dot (const X& x, const X& y) = 0;
 
    virtual double norm (const X& x) = 0;
 
 
    virtual ~ScalarProduct () {}
  };
 
  template<class X, class C, int c>
  struct ScalarProductChooser
  {
    typedef C communication_type;
 
    enum {
      solverCategory=c
    };
  };
 
 
 
  //=====================================================================
  // Implementation for ISTL-matrix based operator
  //=====================================================================
 
  template<class X>
  class SeqScalarProduct : public ScalarProduct<X>
  {
  public:
    typedef X domain_type;
    typedef typename X::field_type field_type;
 
    enum {category=SolverCategory::sequential};
 
    virtual field_type dot (const X& x, const X& y)
    {
      return x.dot(y);
    }
 
    virtual double norm (const X& x)
    {
      return static_cast<double>(x.two_norm());
    }
  };
 
  template<class X, class C>
  struct ScalarProductChooser<X,C,SolverCategory::sequential>
  {
    typedef SeqScalarProduct<X> ScalarProduct;
 
    enum {
      solverCategory=SolverCategory::sequential
    };
 
    static ScalarProduct* construct(const C&)
    {
      return new ScalarProduct();
    }
  };
 
 
} // end namespace
 
#endif