constantoperations.hh

#ifndef __DUNE_ACFEM_EXPRESSIONS_INTCONSTOPERATIONS_HH__
#define __DUNE_ACFEM_EXPRESSIONS_INTCONSTOPERATIONS_HH__
 
#include "../common/types.hh"
#include "../common/fractionconstant.hh"
#include "../common/namedconstant.hh"
#include "expressiontraits.hh"
#include "fieldpromotion.hh"
#include "storage.hh"
#include "weight.hh"
 
namespace Dune
{
  template<class I, I N, I D>
  struct FieldTraits<ACFem::TypedValue::FractionConstant<I, N, D> >
    : FieldTraits<ACFem::ConditionalType<D == 1, I, ACFem::FloatingPointClosure<I> > >
  {};
 
  template<class T, char... Name>
  struct FieldTraits<ACFem::TypedValue::NamedConstant<T, Name...> >
    : FieldTraits<T>
  {};
 
  namespace ACFem
  {
 
    using TypedValue::toString;
    using TypedValue::FractionConstant;
    using TypedValue::Fraction;
    using TypedValue::IntFraction;
    using TypedValue::intFraction;
    using TypedValue::numerator;
    using TypedValue::denominator;
    using TypedValue::Sign;
    using TypedValue::sign;
    using TypedValue::IsSign;
 
    template<class I, I N, I D>
    struct IsScalar<TypedValue::FractionConstant<I, N, D> >
      : TrueType
    {};
 
    template<class T, char... Name>
    struct IsScalar<TypedValue::NamedConstant<T, Name...> >
      : IsScalar<T>
    {};
 
    template<class I, I N>
    struct IsIntegral<TypedValue::FractionConstant<I, N, 1> >
      : TrueType
    {};
 
    template<class T, bool Exclusive = true>
    using IsFractionOperand =
      BoolConstant<(IsScalar<T>::value
                    && !(Exclusive && IsFractionConstant<T>::value)
                    && !IsIntegralConstant<T>::value // leave integral constants alone
                    && !IsExpression<T>::value // don't interfere with expression optimizations
      )>;
 
    template<class T, std::enable_if_t<IsFractionOperand<T, false>::value, int> = 0>
    constexpr auto zero(T&& t)
    {
      return IntFraction<0, 1>{};
    }
 
    template<class T, std::enable_if_t<IsFractionOperand<T, false>::value, int> = 0>
    constexpr auto one(T&& t)
    {
      return IntFraction<1, 1>{};
    }
 
    template<class Int, Int N, Int D>
    struct ExpressionTraits<FractionConstant<Int, N, D> >
    {
     protected:
      static constexpr ssize_t nSign = (N == 0 ? 0 : (N > 0 ? 1 : -1));
      static constexpr ssize_t dSign = (D == 0 ? 0 : (D > 0 ? 1 : -1));
     public:
      static constexpr bool isSemiPositive = nSign * dSign >= 0;
      static constexpr bool isSemiNegative = nSign * dSign <= 0;
      static constexpr bool isZero = N == 0;
      static constexpr bool isOne = N*D == 1;
      static constexpr bool isMinusOne = N*D == -1;
      static constexpr bool isNonZero = !isZero;
      static constexpr bool isNonSingular = !isZero && D != 0;
      static constexpr bool isPositive = nSign * dSign > 0;
      static constexpr bool isNegaive = nSign * dSign < 0;
 
      static constexpr bool isVolatile = false;
      static constexpr bool isIndependent = true;
      static constexpr bool isConstant = true;
      static constexpr bool isTypedValue = true;
 
      using Sign = ExpressionSign<isNonSingular, isSemiPositive, isSemiNegative, 0>;
    };
 
    template<class T, char... Name>
    struct ExpressionTraits<TypedValue::NamedConstant<T, Name...> >
      : ExpressionTraits<T>
    {
      static constexpr bool isVolatile = false;
      static constexpr bool isIndependent = true;
      static constexpr bool isConstant = true;
      static constexpr bool isTypedValue = true;
 
      static_assert(IsScalar<T>::value, "NamedConstant only supported for scalars.");
 
      using Sign = PositiveExpressionSign;
    };
 
    namespace Expressions {
 
      template<class T, char... Name>
      constexpr inline std::size_t WeightV<TypedValue::NamedConstant<T, Name...> > = (0 + ... + ((std::size_t)Name));
 
      template<class Int, Int N, Int D>
      constexpr inline std::size_t WeightV<FractionConstant<Int, N, D> > = 1UL;
 
    }
 
 
    namespace TypedValue {
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator*(FractionConstant<I, 0, 1>, T&& t)
      {
        return zero(std::forward<T>(t));
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator*=(T& t, FractionConstant<I, 0, 1>)
      {
        return (t = zero(t));
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator*(FractionConstant<I, 1, 1>, T&& t)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator*=(T& t, FractionConstant<I, 1, 1>)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator*(FractionConstant<I, -1, 1>, T&& t)
      {
        return -t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator*=(T& t, FractionConstant<I, -1, 1>)
      {
        return -t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator+(FractionConstant<I, 0, 1>, T&& t)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator+=(T& t, FractionConstant<I, 0, 1>)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator-(FractionConstant<I, 0, 1>, T&& t)
      {
        return -t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator-=(T& t, FractionConstant<I, 0, 1>)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator/(FractionConstant<I, 0, 1>, T&& t)
      {
        return zero(std::forward<T>(t));
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator/(T&& t, FractionConstant<I, 1, 1>)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator/(T& t, FractionConstant<I, 1, 1>)
      {
        return t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator/(T&&t, FractionConstant<I, -1, 1>)
      {
        return -t;
      }
 
      template<class I, class T, std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto& operator/(T& t, FractionConstant<I, -1, 1>)
      {
        return -t;
      }
 
 
      template<
        class I, I N, class T,
        std::enable_if_t<(N*N > 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator*(FractionConstant<I, N, 1>, T&& t)
      {
        return N*t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N*N > 1
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator*=(T& t, FractionConstant<I, N, D>)
      {
        return t *= N;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator+(FractionConstant<I, N, D>, T&& t)
      {
        return N+t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator+=(T& t, FractionConstant<I, N, D>)
      {
        return t += N;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator-(FractionConstant<I, N, D>, T&& t)
      {
        return N-t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator/(FractionConstant<I, N, D>, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return (FType)N / (FType)t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator/=(T& t, FractionConstant<I, N, D>)
      {
        return t /= N;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator==(FractionConstant<I, N, D>, T&& t)
      {
        return N == t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator!=(FractionConstant<I, N, D>, T&& t)
      {
        return N != t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator<=(FractionConstant<I, N, D>, T&& t)
      {
        return N <= t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator<(FractionConstant<I, N, D>, T&& t)
      {
        return N < t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator>=(FractionConstant<I, N, D>, T&& t)
      {
        return N >= t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D == 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator>(FractionConstant<I, N, D>, T&& t)
      {
        return N > t;
      }
 
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator*(FractionConstant<I, N, D>, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return (FType)N/(FType)D*t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator*=(T& t, FractionConstant<I, N, D>)
      {
        using FType = FieldPromotionType<T, I>;
        return t *= (FType)N/(FType)D;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator+(FractionConstant<I, N, D>, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return (FType)N/(FType)D+t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator+=(T& t, FractionConstant<I, N, D>)
      {
        using FType = FieldPromotionType<T, I>;
        return t += (FType)N/(FType)D;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator-(FractionConstant<I, N, D>, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return (FType)N/(FType)D-t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator-(T& t, FractionConstant<I, N, D>)
      {
        using FType = FieldPromotionType<T, I>;
        return t -= (FType)N/(FType)D;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto operator/(FractionConstant<I, N, D>, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return (FType)N / (FType)D / (FType)t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(N != 0
                          && D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr auto& operator/(T& t, FractionConstant<I, N, D>)
      {
        using FType = FieldPromotionType<T, I>;
        return t /= (FType)N / (FType)D;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator==(FractionConstant<I, N, D>, T&& t)
      {
        return N == D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator!=(FractionConstant<I, N, D>, T&& t)
      {
        return N != D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator<=(FractionConstant<I, N, D>, T&& t)
      {
        return N <= D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator<(FractionConstant<I, N, D>, T&& t)
      {
        return N < D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator>=(FractionConstant<I, N, D>, T&& t)
      {
        return N >= D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<(D != 1
                          && IsFractionOperand<T>::value), int> = 0>
      constexpr bool operator>(FractionConstant<I, N, D>, T&& t)
      {
        return N > D * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto min(FractionConstant<I, N, D> f, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return f <= t ? (FType)f : (FType)t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto max(FractionConstant<I, N, D> f, T&& t)
      {
        using FType = FieldPromotionType<T, I>;
        return f >= t ? (FType)f : (FType)t;
      }
 
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator*(T&& t, FractionConstant<I, N, D> f)
      {
        return f * t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator/(T&& t, FractionConstant<I, N, D> f)
      {
        return Fraction<I, D, N>{} * t;
      }
 
      template<
      class I, I N, I D, class T,
      std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator+(T&& t, FractionConstant<I, N, D> f)
      {
        return f + t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto operator-(T&& t, FractionConstant<I, N, D> f)
      {
        return -f + t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator==(T&& t, FractionConstant<I, N, D> f)
      {
        return f == t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator!=(T&& t, FractionConstant<I, N, D> f)
      {
        return f != t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator<=(T&& t, FractionConstant<I, N, D> f)
      {
        return f >= t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator<(T&& t, FractionConstant<I, N, D> f)
      {
        return f > t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator>=(T&& t, FractionConstant<I, N, D> f)
      {
        return f <= t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr bool operator>(T&& t, FractionConstant<I, N, D> f)
      {
        return f < t;
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto min(T&& t, FractionConstant<I, N, D> f)
      {
        return min(f, t);
      }
 
      template<
        class I, I N, I D, class T,
        std::enable_if_t<IsFractionOperand<T>::value, int> = 0>
      constexpr auto max(T&& t, FractionConstant<I, N, D> f)
      {
        return max(f, t);
      }
 
 
 
 
    } // NS TypedValue
 
  } // NS ACFem
 
} // NS Dune
 
#endif // __DUNE_ACFEM_EXPRESSIONS_INTCONSTOPERATIONS_HH__