FieldMatVec.hpp

#pragma once
 
#include <amdis/common/FieldMatVec.hpp>
#include <amdis/operations/Arithmetic.hpp>
#include <amdis/operations/Basic.hpp>
#include <amdis/operations/CMath.hpp>
#include <amdis/operations/Composer.hpp>
 
namespace AMDiS
{
  namespace Operation
  {
    struct Dot
    {
      template <class T0, class T1, int N>
      constexpr auto operator()(Dune::FieldVector<T0,N> const& lhs, Dune::FieldVector<T1,N> const& rhs) const
      {
        return lhs.dot(rhs);
      }
 
      friend constexpr int order(Dot const&, int d1, int d2)
      {
        return d1 + d2;
      }
 
      friend constexpr auto partial(Dot const&, index_t<0>)
      {
        return Arg<1>{};
      }
 
      friend constexpr auto partial(Dot const&, index_t<1>)
      {
        return Arg<0>{};
      }
    };
 
    // -------------------------------------------------------------------------
 
    struct UnaryDot
    {
      template <class V>
      constexpr auto operator()(V const& vec) const
      {
        using Dune::unary_dot;
        return unary_dot(vec);
      }
 
      friend constexpr int order(UnaryDot const&, int d)
      {
        return 2*d;
      }
 
      friend auto partial(UnaryDot const&, index_t<0>)
      {
        return compose(Multiplies{}, StaticConstant<int,2>{}, Id{});
      }
    };
 
    // -------------------------------------------------------------------------
 
    struct TwoNorm
        : public Composer<Sqrt, UnaryDot>
    {
      constexpr TwoNorm()
        : Composer<Sqrt, UnaryDot>(Sqrt{}, UnaryDot{})
      {}
 
      template <class V>
      constexpr auto operator()(V const& vec) const
      {
        using Dune::two_norm;
        return two_norm(vec);
      }
    };
 
    // -------------------------------------------------------------------------
 
    struct Trans
    {
      template <class M>
      constexpr auto operator()(M const& mat) const
      {
        using Dune::trans;
        return trans(mat);
      }
 
      friend constexpr int order(Trans const&, int d)
      {
        return d;
      }
    };
 
    struct Mv
    {
      template <class T1, int M, int N, class T2>
      constexpr auto operator()(Dune::FieldMatrix<T1,M,N> const& lhs, Dune::FieldVector<T2,N> const& rhs) const
      {
        using T = typename Dune::PromotionTraits<T1,T2>::PromotedType;
        Dune::FieldVector<T,M> result;
        lhs.mv(rhs, result);
        return result;
      }
 
      friend constexpr int order(Mv const&, int d1, int d2)
      {
        return d1 + d2;
      }
 
      friend constexpr auto partial(Mv const&, index_t<0>)
      {
        return Arg<1>{};
      }
 
      friend constexpr auto partial(Mv const&, index_t<1>)
      {
        return Arg<0>{};
      }
    };
 
 
    struct Mtv
    {
      template <class T1, int M, int N, class T2>
      constexpr auto operator()(Dune::FieldMatrix<T1,M,N> const& lhs, Dune::FieldVector<T2,M> const& rhs) const
      {
        using T = typename Dune::PromotionTraits<T1,T2>::PromotedType;
        Dune::FieldVector<T,N> result;
        lhs.mtv(rhs, result);
        return result;
      }
 
      friend constexpr int order(Mtv const&, int d1, int d2)
      {
        return d1 + d2;
      }
 
      friend constexpr auto partial(Mtv const&, index_t<0>)
      {
        return Arg<1>{};
      }
 
      friend constexpr auto partial(Mtv const&, index_t<1>)
      {
        return Arg<0>{};
      }
    };
 
  } // end namespace Operation
} // end namespace AMDiS