OperationsGridFunction.hpp

#pragma once

#include <amdis/Operations.hpp>
#include <amdis/gridfunctions/FunctorGridFunction.hpp>
#include <amdis/operations/Arithmetic.hpp>
#include <amdis/operations/FieldMatVec.hpp>

namespace AMDiS
{
  // scalar operations
  // @{

  template <class Lhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs>)>
  auto operator-(Lhs&& lhs)
  {
    return invokeAtQP(Operation::Negate{}, FWD(lhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto operator+(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Plus{}, FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto operator-(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Minus{}, FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto operator*(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Multiplies{}, FWD(lhs), FWD(rhs));
  }

  namespace Impl
  {
    template <class Lhs, class Value,
      REQUIRES(Concepts::ConstantToGridFunction<Value>)>
    auto divideAtQP(Lhs&& lhs, Value value)
    {
      return invokeAtQP(Operation::Multiplies{}, FWD(lhs), 1.0/value);
    }

    template <class Lhs, class Rhs,
      REQUIRES(not Concepts::ConstantToGridFunction<remove_cvref_t<Rhs>>)>
    auto divideAtQP(Lhs&& lhs, Rhs&& rhs)
    {
      return invokeAtQP(Operation::Divides{}, FWD(lhs), FWD(rhs));
    }
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto operator/(Lhs&& lhs, Rhs&& rhs)
  {
    return Impl::divideAtQP(FWD(lhs), FWD(rhs));
  }


  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto max(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Max{}, FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto min(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Min{}, FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto abs_max(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::AbsMax{}, FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto abs_min(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::AbsMin{}, FWD(lhs), FWD(rhs));
  }

  template <class V, class T,
    REQUIRES(Concepts::AnyGridFunction<V>)>
  auto clamp(V&& v, T const& lo, T const& hi)
  {
    return invokeAtQP(Operation::Clamp<T>{lo,hi}, FWD(v));
  }

  template <class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto abs(T&& value)
  {
    return invokeAtQP([](auto const& v) { using std::abs; return abs(v); }, FWD(value));
  }

  template <class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto sqr(T&& value)
  {
    return invokeAtQP(Operation::Sqr{}, FWD(value));
  }

  template <int p, class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto pow(T&& value)
  {
    return invokeAtQP(Operation::Pow<p>{}, FWD(value));
  }

  template <class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto pow(T&& value, int p)
  {
    return invokeAtQP(Operation::Pow_{p}, FWD(value));
  }

  template <std::size_t I, class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto get(T&& value)
  {
    return invokeAtQP(Operation::Get<I>{}, FWD(value));
  }

  template <class T,
    REQUIRES(Concepts::AnyGridFunction<T>)>
  auto get(T&& value, std::size_t i)
  {
    return invokeAtQP(Operation::Get_{i}, FWD(value));
  }

  // @}

  // unary vector operations
  // @{

  template <class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto sum(Vec&& vec)
  {
    return invokeAtQP([](auto const& v) { return sum(v); }, FWD(vec));
  }

  template <class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto unary_dot(Vec&& vec)
  {
    return invokeAtQP(Operation::UnaryDot{}, FWD(vec));
  }

  template <class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto one_norm(Vec&& vec)
  {
    return invokeAtQP([](auto const& v) { return one_norm(v); }, FWD(vec));
  }

  template <class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto two_norm(Vec&& vec)
  {
    return invokeAtQP(Operation::TwoNorm{}, FWD(vec));
  }

  template <int p, class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto p_norm(Vec&& vec)
  {
    return invokeAtQP([](auto const& v) { return p_norm<p>(v); }, FWD(vec));
  }

  template <class Vec,
    REQUIRES(Concepts::AnyGridFunction<Vec>)>
  auto infty_norm(Vec&& vec)
  {
    return invokeAtQP([](auto const& v) { return infty_norm(v); }, FWD(vec));
  }

  template <class Mat,
    REQUIRES(Concepts::AnyGridFunction<Mat>)>
  auto trans(Mat&& mat)
  {
    return invokeAtQP(Operation::Trans{}, FWD(mat));
  }

  // @}


  // binary vector operations
  // @{

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto dot(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP(Operation::Dot{},
      FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto distance(Lhs&& lhs, Rhs&& rhs)
  {
    using namespace Operation;
    return invokeAtQP(compose(TwoNorm{}, Minus{}),
      FWD(lhs), FWD(rhs));
  }

  template <class Lhs, class Rhs,
    REQUIRES(Concepts::AnyGridFunction<Lhs,Rhs>)>
  auto outer(Lhs&& lhs, Rhs&& rhs)
  {
    return invokeAtQP([](auto const& v, auto const& w) { return outer(v,w); },
      FWD(lhs), FWD(rhs));
  }

  // @}

} // end namespace AMDiS