scaledidmatrix.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_SCALEDIDMATRIX_HH
#define DUNE_ISTL_SCALEDIDMATRIX_HH
 
#include <cmath>
#include <cstddef>
#include <complex>
#include <iostream>
#include <dune/common/exceptions.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/diagonalmatrix.hh>
#include <dune/common/ftraits.hh>
 
namespace Dune {
 
  template<class K, int n>
  class ScaledIdentityMatrix
  {
    typedef DiagonalMatrixWrapper< ScaledIdentityMatrix<K,n> > WrapperType;
 
  public:
    //===== type definitions and constants
 
    typedef K field_type;
 
    typedef K block_type;
 
    typedef std::size_t size_type;
 
    typedef DiagonalRowVector<K,n> row_type;
    typedef row_type reference;
 
    typedef DiagonalRowVectorConst<K,n> const_row_type;
    typedef const_row_type const_reference;
 
    static constexpr std::integral_constant<size_type,n> rows = {};
 
    static constexpr std::integral_constant<size_type,n> cols = {};
 
    //===== constructors
    ScaledIdentityMatrix () {}
 
    ScaledIdentityMatrix (const K& k)
      : p_(k)
    {}
 
    ScaledIdentityMatrix& operator= (const K& k)
    {
      p_ = k;
      return *this;
    }
 
    bool identical(const ScaledIdentityMatrix<K,n>& other) const
    {
      return (this==&other);
    }
 
    //===== iterator interface to rows of the matrix
    typedef ContainerWrapperIterator<const WrapperType, reference, reference> Iterator;
    typedef Iterator iterator;
    typedef Iterator RowIterator;
    typedef typename row_type::Iterator ColIterator;
 
    Iterator begin ()
    {
      return Iterator(WrapperType(this),0);
    }
 
    Iterator end ()
    {
      return Iterator(WrapperType(this),n);
    }
 
    Iterator beforeEnd ()
    {
      return Iterator(WrapperType(this),n-1);
    }
 
    Iterator beforeBegin ()
    {
      return Iterator(WrapperType(this),-1);
    }
 
 
    typedef ContainerWrapperIterator<const WrapperType, const_reference, const_reference> ConstIterator;
    typedef ConstIterator const_iterator;
    typedef ConstIterator ConstRowIterator;
    typedef typename const_row_type::ConstIterator ConstColIterator;
 
    ConstIterator begin () const
    {
      return ConstIterator(WrapperType(this),0);
    }
 
    ConstIterator end () const
    {
      return ConstIterator(WrapperType(this),n);
    }
 
    ConstIterator beforeEnd() const
    {
      return ConstIterator(WrapperType(this),n-1);
    }
 
    ConstIterator beforeBegin () const
    {
      return ConstIterator(WrapperType(this),-1);
    }
 
 
    ScaledIdentityMatrix& operator+= (const ScaledIdentityMatrix& y)
    {
      p_ += y.p_;
      return *this;
    }
 
    ScaledIdentityMatrix& operator-= (const ScaledIdentityMatrix& y)
    {
      p_ -= y.p_;
      return *this;
    }
 
    ScaledIdentityMatrix& operator+= (const K& k)
    {
      p_ += k;
      return *this;
    }
 
    ScaledIdentityMatrix& operator-= (const K& k)
    {
      p_ -= k;
      return *this;
    }
 
    ScaledIdentityMatrix& operator*= (const K& k)
    {
      p_ *= k;
      return *this;
    }
 
    ScaledIdentityMatrix& operator/= (const K& k)
    {
      p_ /= k;
      return *this;
    }
 
    template <class Scalar,
              std::enable_if_t<IsNumber<Scalar>::value, int> = 0>
    friend auto operator* ( const ScaledIdentityMatrix& matrix, Scalar scalar)
    {
      return ScaledIdentityMatrix<typename PromotionTraits<K,Scalar>::PromotedType, n>{matrix.scalar()*scalar};
    }
 
    template <class Scalar,
              std::enable_if_t<IsNumber<Scalar>::value, int> = 0>
    friend auto operator* (Scalar scalar, const ScaledIdentityMatrix& matrix)
    {
      return ScaledIdentityMatrix<typename PromotionTraits<Scalar,K>::PromotedType, n>{scalar*matrix.scalar()};
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto& operator+= (FieldMatrix<OtherScalar,n,n>& fieldMatrix,
                             const ScaledIdentityMatrix& matrix)
    {
      for (int i=0; i<n; i++)
        fieldMatrix[i][i] += matrix.p_;
 
      return fieldMatrix;
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto operator+ (const FieldMatrix<OtherScalar,n,n>& fieldMatrix,
                           const ScaledIdentityMatrix& matrix)
    {
      using Result = FieldMatrix<typename PromotionTraits<K,OtherScalar>::PromotedType,n,n>;
      Result result = fieldMatrix;
      result += matrix;
      return result;
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto operator+ (const ScaledIdentityMatrix& matrix,
                           const FieldMatrix<OtherScalar,n,n>& fieldMatrix)
    {
      return fieldMatrix + matrix;
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto operator+= (DiagonalMatrix<OtherScalar,n>& diagonalMatrix,
                            const ScaledIdentityMatrix& matrix)
    {
      for (std::size_t i=0; i<n; i++)
        diagonalMatrix.diagonal(i) += matrix.p_;
 
      return diagonalMatrix;
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto operator+ (const DiagonalMatrix<OtherScalar,n>& diagonalMatrix,
                           const ScaledIdentityMatrix& matrix)
    {
      using Result = DiagonalMatrix<typename PromotionTraits<K,OtherScalar>::PromotedType,n>;
      Result result = diagonalMatrix;
      result += matrix;
      return result;
    }
 
    template <class OtherScalar>
      requires requires(K k, OtherScalar otherScalar) { k + otherScalar; }
    friend auto operator+ (const ScaledIdentityMatrix& matrix,
                           const DiagonalMatrix<OtherScalar,n>& diagonalMatrix)
    {
      return diagonalMatrix + matrix;
    }
 
    //===== comparison ops
 
    bool operator==(const ScaledIdentityMatrix& other) const
    {
      return p_==other.scalar();
    }
 
    bool operator!=(const ScaledIdentityMatrix& other) const
    {
      return p_!=other.scalar();
    }
 
 
    template<class X, class Y>
    void mv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; ++i)
        y[i] = p_ * x[i];
    }
 
    template<class X, class Y>
    void mtv (const X& x, Y& y) const
    {
      mv(x, y);
    }
 
    template<class X, class Y>
    void umv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; ++i)
        y[i] += p_ * x[i];
    }
 
    template<class X, class Y>
    void umtv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; ++i)
        y[i] += p_ * x[i];
    }
 
    template<class X, class Y>
    void umhv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; i++)
        y[i] += conjugateComplex(p_)*x[i];
    }
 
    template<class X, class Y>
    void mmv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; ++i)
        y[i] -= p_ * x[i];
    }
 
    template<class X, class Y>
    void mmtv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; ++i)
        y[i] -= p_ * x[i];
    }
 
    template<class X, class Y>
    void mmhv (const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; i++)
        y[i] -= conjugateComplex(p_)*x[i];
    }
 
    template<class X, class Y>
    void usmv (const K& alpha, const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; i++)
        y[i] += alpha * p_ * x[i];
    }
 
    template<class X, class Y>
    void usmtv (const K& alpha, const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; i++)
        y[i] += alpha * p_ * x[i];
    }
 
    template<class X, class Y>
    void usmhv (const K& alpha, const X& x, Y& y) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (x.N()!=N()) DUNE_THROW(FMatrixError,"index out of range");
      if (y.N()!=M()) DUNE_THROW(FMatrixError,"index out of range");
#endif
      for (size_type i=0; i<n; i++)
        y[i] += alpha * conjugateComplex(p_) * x[i];
    }
 
 
 
 
    typename FieldTraits<field_type>::real_type frobenius_norm () const
    {
      return fvmeta::sqrt(n*p_*p_);
    }
 
    typename FieldTraits<field_type>::real_type frobenius_norm2 () const
    {
      return n*p_*p_;
    }
 
    typename FieldTraits<field_type>::real_type infinity_norm () const
    {
      return std::abs(p_);
    }
 
    typename FieldTraits<field_type>::real_type infinity_norm_real () const
    {
      return fvmeta::absreal(p_);
    }
 
 
    template<class V>
    void solve (V& x, const V& b) const
    {
      for (int i=0; i<n; i++)
        x[i] = b[i]/p_;
    }
 
    void invert()
    {
      p_ = 1/p_;
    }
 
    K determinant () const {
      return std::pow(p_,n);
    }
 
    //===== sizes
 
    size_type N () const
    {
      return n;
    }
 
    size_type M () const
    {
      return n;
    }
 
    //===== query
 
    bool exists (size_type i, size_type j) const
    {
#ifdef DUNE_FMatrix_WITH_CHECKING
      if (i<0 || i>=n) DUNE_THROW(FMatrixError,"row index out of range");
      if (j<0 || j>=n) DUNE_THROW(FMatrixError,"column index out of range");
#endif
      return i==j;
    }
 
    //===== conversion operator
 
    friend std::ostream& operator<< (std::ostream& s, const ScaledIdentityMatrix<K,n>& a)
    {
      for (size_type i=0; i<n; i++) {
        for (size_type j=0; j<n; j++)
          s << ((i==j) ? a.p_ : 0) << " ";
        s << std::endl;
      }
      return s;
    }
 
    reference operator[](size_type i)
    {
      return reference(const_cast<K*>(&p_), i);
    }
 
    const_reference operator[](size_type i) const
    {
      return const_reference(const_cast<K*>(&p_), i);
    }
 
    const K& diagonal(size_type /*i*/) const
    {
      return p_;
    }
 
    K& diagonal(size_type /*i*/)
    {
      return p_;
    }
 
    const K& scalar() const
    {
      return p_;
    }
 
    K& scalar()
    {
      return p_;
    }
 
  private:
    // the data, very simply a single number
    K p_;
 
  };
 
  template <class DenseMatrix, class field, int N>
  struct DenseMatrixAssigner<DenseMatrix, ScaledIdentityMatrix<field, N>> {
    static void apply(DenseMatrix& denseMatrix,
                      ScaledIdentityMatrix<field, N> const& rhs) {
      assert(denseMatrix.M() == N);
      assert(denseMatrix.N() == N);
      denseMatrix = field(0);
      for (int i = 0; i < N; ++i)
        denseMatrix[i][i] = rhs.scalar();
    }
  };
 
  template<class K, int n>
  struct FieldTraits< ScaledIdentityMatrix<K, n> >
  {
    using field_type = typename ScaledIdentityMatrix<K, n>::field_type;
    using real_type = typename FieldTraits<field_type>::real_type;
  };
 
} // end namespace
 
#endif