subexpression.hh

#ifndef __DUNE_ACFEM_EXPRESSIONS_SUBEXPRESSION_HH__
#define __DUNE_ACFEM_EXPRESSIONS_SUBEXPRESSION_HH__
 
#include "expressionoperations.hh"
#include "interface.hh"
#include "densestorage.hh"
#include "transform.hh"
#include "../common/literals.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    namespace Expressions
    {
      using namespace Literals;
 
      template<class T, std::enable_if_t<IsSubExpressionExpression<T>::value, int> = 0>
      constexpr decltype(auto) subExpressionExpression(T&& t)
      {
        return std::forward<T>(t).template operand<1>();
      }
 
      template<
        class T,
        std::enable_if_t<(!IsSubExpressionExpression<T>::value
                          && !IsClosure<T>::value
        ), int> = 0>
      constexpr decltype(auto) subExpressionExpression(T&& t)
      {
        return std::forward<T>(t);
      }
 
      template<class T, std::enable_if_t<IsClosure<T>::value, int> = 0>
      constexpr decltype(auto) subExpressionExpression(T&& t)
      {
        return subExpressionExpression(asExpression(std::forward<T>(t)));
      }
 
      template<std::size_t... OperandPos, class T, std::enable_if_t<IsExpression<T>::value, int> = 0>
      auto subExpression(T&& t, IndexSequence<OperandPos...> = IndexSequence<OperandPos...>{})
      {
        using TreePos = IndexSequence<OperandPos...>;
        return subExpression(DenseStorageType<T>{}, std::forward<T>(t), TreePos{});
      }
 
      template<template<class...> class Storage, std::size_t... OperandPos, class T, std::enable_if_t<IsExpression<T>::value, int> = 0>
      auto subExpression(T&& t, IndexSequence<OperandPos...> = IndexSequence<OperandPos...>{})
      {
        using TreePos = IndexSequence<OperandPos...>;
        return subExpression(Storage<T>(), std::forward<T>(t), TreePos{});
      }
 
 
      namespace impl {
        template<class Functor>
        struct EvaluateSubExpression;
        template<class Optimize>
        struct ExpandSubExpression;
      }
 
      struct SExpForward
      {
        template<class Src>
        constexpr decltype(auto) operator()(Src&& src) const
        {
          return std::forward<Src>(src);
        }
      };
 
      struct SExpZero
      {
        template<class Dst>
        constexpr auto operator()(Dst&& dst) const
        {
          return zero(std::forward<Dst>(dst));
        }
      };
 
      template<
        class T,
        class Functor = SExpForward,
        std::enable_if_t<(IsSubExpressionExpression<T>::value
                          && std::is_assignable<decltype(std::declval<T>().operand(0_c)), Operand<1, T> >::value
          ), int> = 0>
      void evaluateSubExpression(T&& t, Functor&& f = Functor{})
      {
        if constexpr (!IsConstantExprArg<Operand<1, T> >::value) {
          // The sub-expression might again contain sub-expression which
          // should be evaluated first in order to finally yield the
          // correct result.
          traverse(std::forward<T>(t).operand(1_c), impl::EvaluateSubExpression<Functor>{f});
          std::forward<T>(t).operand(0_c) = asExpression(std::forward<Functor>(f)(std::forward<T>(t).operand(1_c)));
          //std::clog << "Evaluate " <<  asExpression(std::forward<Functor>(f)(std::forward<T>(t).operand(1_c))).name() << std::endl;
        }
      }
 
      template<
        class T,
        class Functor = SExpForward,
        std::enable_if_t<(IsSubExpressionExpression<T>::value
                          && !std::is_assignable<decltype(std::declval<T>().operand(0_c)), Operand<1, T> >::value
        ), int> = 0>
      void evaluateSubExpression(T&& t, Functor = Functor{})
      {}
 
      template<class T, class Functor = SExpForward, std::enable_if_t<IsClosure<T>::value, int> = 0>
      void evaluateSubExpression(T&& t, Functor&& f = Functor{})
      {
        evaluateSubExpression(asExpression(std::forward<T>(t)), std::forward<Functor>(f));
      }
 
      template<class T, class Optimize = OptimizeTop, class Functor = impl::ExpandSubExpression<Optimize> >
      constexpr decltype(auto) expandSubExpression(T&& t, Optimize = Optimize{}, Functor = Functor{})
      {
        static_assert(IsSubExpressionExpression<T>::value,
                      "Attempt to expand subexpression of non subexpression-expression.");
        // make sure we really get the contained type
        return transform(static_cast<Operand<1, T> >(std::forward<T>(t).operand(1_c)), Functor{}, Operate<Optimize>{});
      }
 
      namespace impl {
 
        template<class Functor>
        struct EvaluateSubExpression
        {
          template<class T, std::enable_if_t<IsSubExpressionExpression<T>::value, int> = 0>
          constexpr auto operator()(T&& t) const
          {
            evaluateSubExpression(std::forward<T>(t), f_);
            return 0;
          }
 
          Functor f_;
        };
 
        template<class Optimize>
        struct ExpandSubExpression
        {
          template<class T, std::enable_if_t<IsSubExpressionExpression<T>::value, int> = 0>
          constexpr decltype(auto) operator()(T&& t) const
          {
            return expandSubExpression(std::forward<T>(t), Optimize{});
          }
#if 0
          template<class T, std::enable_if_t<(IsPlaceholderExpression<T>::value
                                              || IsIndeterminateExpression<T>::value
            ), int> = 0>
          constexpr decltype(auto) operator()(T&& t) const
          {
            return std::forward<T>(t);
          }
#endif
        };
 
      } // NS impl
 
      template<class T, class Functor = SExpForward>
      void evaluateAllSubExpressions(T&& t, Functor&& f = Functor{})
      {
        static_assert(IsExpression<T>::value, "Called with something which is not an expression.");
 
        traverse(std::forward<T>(t), impl::EvaluateSubExpression<Functor>{f});
      }
 
      template<class T, class Optimize = OptimizeTop>
      constexpr auto expandAllSubExpressions(T&& t, Optimize = Optimize{})
      {
        return transform(std::forward<T>(t), impl::ExpandSubExpression<Optimize>{}, Operate<Optimize>{});
      }
 
 
 
    } // Expressions
 
    template<class T>
    struct ExpressionTraits<T, std::enable_if_t<IsSubExpressionExpression<T>::value> >
      : ExpressionTraits<Expressions::Operand<1, T> >
    {
      using BaseType = ExpressionTraits<Expressions::Operand<1, T> >;
      using ExpressionType = std::decay_t<T>;
      static constexpr bool isTypedValue = false;
      static constexpr bool isConstant = BaseType::isConstant || BaseType::isTypedValue;
    };
 
 
  } // ACFem
 
} // Dune
 
#endif // __DUNE_ACFEM_EXPRESSIONS_SUBEXPRESSION_HH__