identitymatrix.hh

Go to the documentation of this file.

#ifndef DUNE_COMMON_IDENTITYMATRIX_HH
#define DUNE_COMMON_IDENTITYMATRIX_HH
 
#warning Deprecated since dune-common 2.5: If you really do need an identity matrix, use DiagonalMatrix or ScalarIdentityMatrix (from dune-istl) instead!
 
#include <dune/common/boundschecking.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/ftraits.hh>
#include <dune/common/math.hh>
 
namespace Dune
{
 
  // IdentityMatrix
  // --------------
 
  template< class K, int N >
  struct IdentityMatrix
  {
    typedef K field_type;
    typedef std::size_t size_type;
 
    constexpr size_type rows () const { return N; }
    constexpr size_type cols () const { return N; }
 
    template< class X, class Y >
    void mv ( const X &x, Y &y ) const
    {
      y = x;
    }
 
    template< class X, class Y >
    void mtv ( const X &x, Y &y ) const
    {
      y = x;
    }
 
    template< class X, class Y >
    void umv ( const X &x, Y &y ) const
    {
      y += x;
    }
 
    template< class X, class Y >
    void umtv ( const X &x, Y &y ) const
    {
      y += x;
    }
 
    template< class X, class Y >
    void umhv ( const X &x, Y &y ) const
    {
      y += x;
    }
 
    template< class X, class Y >
    void mmv ( const X &x, Y &y ) const
    {
      y -= x;
    }
 
    template< class X, class Y >
    void mmtv ( const X &x, Y &y ) const
    {
      y -= x;
    }
 
    template< class X, class Y >
    void mmhv ( const X &x, Y &y ) const
    {
      y -= x;
    }
 
    template< class X, class Y >
    void usmv (const typename FieldTraits<Y>::field_type & alpha,
      const X& x, Y& y) const
    {
      y.axpy( alpha, x );
    }
 
    template< class X, class Y >
    void usmtv (const typename FieldTraits<Y>::field_type & alpha,
      const X& x, Y& y) const
    {
      y.axpy( alpha, x );
    }
 
    template< class X, class Y >
    void usmhv (const typename FieldTraits<Y>::field_type & alpha,
      const X& x, Y& y) const
    {
      y.axpy( alpha, x );
    }
 
    typename FieldTraits< field_type >::real_type frobenius_norm () const
    {
      return std::sqrt( frobenius_norm2() );
    }
 
    typename FieldTraits< field_type >::real_type frobenius_norm2 () const
    {
      return FieldTraits< field_type >::real_type( N );
    }
 
    typename FieldTraits< field_type >::real_type infinity_norm () const
    {
      return FieldTraits< field_type >::real_type( 1 );
    }
 
    typename FieldTraits< field_type >::real_type infinity_norm_real () const
    {
      return FieldTraits< field_type >::real_type( 1 );
    }
  };
 
  template <class DenseMatrix, class field, int N>
  struct DenseMatrixAssigner<DenseMatrix, IdentityMatrix<field, N>> {
    static void apply(DenseMatrix &denseMatrix, IdentityMatrix<field, N> const &rhs) {
      DUNE_ASSERT_BOUNDS(denseMatrix.M() == N);
      DUNE_ASSERT_BOUNDS(denseMatrix.N() == N);
      denseMatrix = field(0);
      for (int i = 0; i < N; ++i)
        denseMatrix[i][i] = field(1);
    }
  };
} // namespace Dune
 
#endif // #ifndef DUNE_COMMON_IDENTITYMATRIX_HH