realTraits.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2025 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <array>
#include <cmath>
#include <complex>
 
#include "../config.h"
#include "../misc/compileTimeLoop.hpp"
#include "../misc/macros.hpp"
#include "computationTraits.hpp"
#include "expressionTraits.hpp"

namespace codi {
 
  template<typename T_Real, typename T_InnerActiveType, typename T_Impl, bool T_isStatic>
  struct AggregatedActiveTypeBase;

  namespace RealTraits {
 
    /*******************************************************************************/

    template<typename T_Type, typename = void>
    struct TraitsImplementation {
      public:
 
        using Type = CODI_DD(T_Type, double);  
 
        using Real = Type;         
        using PassiveReal = Type;  
 
        static int constexpr MaxDerivativeOrder = 0;  

        static CODI_INLINE PassiveReal getPassiveValue(Type const& v) {
          return v;
        }
    };

    template<typename T_Type, typename = void>
    struct IsTotalFinite {
      public:
 
        using Type = CODI_DD(T_Type, double);  

        static CODI_INLINE bool isTotalFinite(Type const& v) {
          using std::isfinite;
          return isfinite(v);
        }
    };

    template<typename T_Type, typename = void>
    struct IsTotalZero {
      public:
 
        using Type = CODI_DD(T_Type, double);  

        static CODI_INLINE bool isTotalZero(Type const& v) {
          return Type() == v;
        }
    };

    template<typename Type>
    using Real = typename TraitsImplementation<Type>::Real;

    template<typename Type>
    using PassiveReal = typename TraitsImplementation<Type>::PassiveReal;

    template<typename Type>
    CODI_INLINE size_t constexpr MaxDerivativeOrder() {
      return TraitsImplementation<Type>::MaxDerivativeOrder;
    }

    template<typename Type>
    CODI_INLINE PassiveReal<Type> getPassiveValue(Type const& v) {
      return TraitsImplementation<Type>::getPassiveValue(v);
    }

    template<typename Type>
    CODI_INLINE bool isTotalFinite(Type const& v) {
      return IsTotalFinite<Type>::isTotalFinite(v);
    }

    template<typename Type>
    CODI_INLINE bool isTotalZero(Type const& v) {
      return IsTotalZero<Type>::isTotalZero(v);
    }

    /*******************************************************************************/

    template<typename T_Type, typename = void>
    struct DataExtraction {
      public:
        CODI_STATIC_ASSERT(false && std::is_void<T_Type>::value,
                           "Instantiation of unspecialized RealTraits::DataExtraction.");
 
        using Type = CODI_DD(T_Type, ActiveTypeProxy);  
 
        using Real = typename Type::Real;              
        using Identifier = typename Type::Identifier;  

        CODI_INLINE static Real getValue(Type const& v);

        CODI_INLINE static Identifier getIdentifier(Type const& v);

        CODI_INLINE static void setValue(Type& v, Real const& value);

        CODI_INLINE static void setIdentifier(Type& v, Identifier const& identifier);
    };

    template<typename T_Type, typename = void>
    struct TapeRegistration {
      public:
        CODI_STATIC_ASSERT(false && std::is_void<T_Type>::value,
                           "Instantiation of unspecialized RealTraits::TapeRegistration.");
 
        using Type = CODI_DD(T_Type, CODI_ANY);  
 
        using Real = typename DataExtraction<Type>::Real;  

        CODI_INLINE static void registerInput(Type& v);

        CODI_INLINE static void registerOutput(Type& v);

        CODI_INLINE static Real registerExternalFunctionOutput(Type& v);
    };

    template<typename T_Type, typename = void>
    struct AggregatedTypeTraits {
      public:
        using Type = CODI_DD(T_Type, double);  
        using InnerType = CODI_ANY;            
        using Real = CODI_ANY;  
 
        static int constexpr Elements = 0;  

        static Type arrayConstructor(InnerType const* v) {
          CODI_UNUSED(v);
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          return Type{};
        }

        template<size_t element>
        static InnerType adjointOfConstructor(Type const& w, Type const& w_b) {
          CODI_UNUSED(w, w_b);
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          return InnerType{};
        }

        template<size_t element>
        static InnerType arrayAccess(Type const& w) {
          CODI_UNUSED(w);
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          return InnerType{};
        }

        template<size_t element>
        CODI_INLINE static InnerType& arrayAccess(Type& v) {
          CODI_UNUSED(v);
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          static InnerType temp = {};
          return temp;
        }

        template<size_t element>
        static Type adjointOfArrayAccess(Type const& w, InnerType const& v_b) {
          CODI_UNUSED(w, v_b);
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          return Type{};
        }

        static CODI_INLINE std::string getMathRep() {
          CODI_STATIC_ASSERT(false && std::is_void<Type>::value,
                             "Instantiation of unspecialized AggregatedTypeTraits.");
 
          return "";
        }
    };

    template<typename T_Type, typename T_InnerType, typename T_Real, int T_Elements>
    struct ArrayAggregatedTypeTraitsBase {
      public:
        static_assert(
            sizeof(T_Type) == T_Elements * sizeof(T_InnerType),
            "ArrayAggregatedTypeTraitsBase is designed for aggregated types that resemble arrays of their inner type."
            " The sizes in the given instantiation do not match this use case.");
 
        using Type = CODI_DD(T_Type, CODI_ANY);            
        using InnerType = CODI_DD(T_InnerType, CODI_ANY);  
        using Real = CODI_DD(T_Real, CODI_ANY);            
 
        static int constexpr Elements = CODI_DD(T_Elements, 1);  

        CODI_INLINE static Type arrayConstructor(InnerType const* v) {
          Type w{};
 
          InnerType* wArray = reinterpret_cast<InnerType*>(&w);
 
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            wArray[i.value] = v[i.value];
          });
 
          return w;
        }

        template<size_t element>
        CODI_INLINE static InnerType adjointOfConstructor(Type const& w, Type const& w_b) {
          CODI_UNUSED(w);
 
          // We assume that dT/dv is the identity and is not holomorphic. That means no one is changed to a minus one on
          // a transpose.
          InnerType const* w_bArray = reinterpret_cast<InnerType const*>(&w_b);
          return ComputationTraits::transpose(w_bArray[element]);
        }

        template<size_t element>
        CODI_INLINE static InnerType& arrayAccess(Type& w) {
          InnerType* wArray = reinterpret_cast<InnerType*>(&w);
 
          return wArray[element];
        }

        template<size_t element>
        CODI_INLINE static InnerType const& arrayAccess(Type const& w) {
          InnerType const* wArray = reinterpret_cast<InnerType const*>(&w);
 
          return wArray[element];
        }

        template<size_t element>
        CODI_INLINE static Type adjointOfArrayAccess(Type const& w, InnerType const& v_b) {
          CODI_UNUSED(w);
 
          // We assume that dw[element]/w is the identity and is not holomorphic. That means no one is changed to a
          // minus one on a transpose.
          Type w_b{};
          InnerType* w_bArray = reinterpret_cast<InnerType*>(&w_b);
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            w_bArray[i.value] = InnerType();
          });
          w_bArray[element] = v_b;
 
          return w_b;
        }
    };

    template<typename Type>
    CODI_INLINE typename DataExtraction<Type>::Real getValue(Type const& v) {
      return DataExtraction<Type>::getValue(v);
    }

    template<typename Type>
    CODI_INLINE typename DataExtraction<Type>::Identifier getIdentifier(Type const& v) {
      return DataExtraction<Type>::getIdentifier(v);
    }

    template<typename Type>
    CODI_INLINE void setValue(Type& v, typename DataExtraction<Type>::Real const& value) {
      return DataExtraction<Type>::setValue(v, value);
    }

    template<typename Type>
    CODI_INLINE void registerInput(Type& v) {
      return TapeRegistration<Type>::registerInput(v);
    }

    template<typename Type>
    CODI_INLINE void registerOutput(Type& v) {
      return TapeRegistration<Type>::registerOutput(v);
    }

    template<typename Type>
    CODI_INLINE typename DataExtraction<Type>::Real registerExternalFunctionOutput(Type& v) {
      return TapeRegistration<Type>::registerExternalFunctionOutput(v);
    }

    /*******************************************************************************/

    template<typename Type>
    using EnableIfAggregatedTypeTraitsIsSpecialized =
        typename std::enable_if<(AggregatedTypeTraits<Type>::Elements != 0) &
                                (!ExpressionTraits::IsLhsExpression<Type>::value)>::type;

    template<typename Expr>
    using EnableIfAggregatedActiveType =
        typename enable_if_base_of<AggregatedActiveTypeBase<typename Expr::Real, typename Expr::InnerActiveType,
                                                            typename Expr::Impl, Expr::isStatic>,
                                   Expr>::type;

    template<typename Type>
    using IsPassiveReal = std::is_same<Type, PassiveReal<Type>>;

    template<typename Expr>
    bool constexpr isPassiveReal = IsPassiveReal<Expr>::value;

    template<typename Type>
    using EnableIfNotPassiveReal = typename std::enable_if<!IsPassiveReal<Type>::value>::type;

    template<typename Type>
    using EnableIfPassiveReal = typename std::enable_if<IsPassiveReal<Type>::value>::type;
 
#ifndef DOXYGEN_DISABLE

    /*******************************************************************************/

    template<typename T_Type>
    struct DataExtraction<T_Type, typename std::enable_if<std::is_floating_point<T_Type>::value>::type> {
      public:
        using Type = CODI_DD(T_Type, double);  
 
        using Real = double;     
        using Identifier = int;  

        CODI_INLINE static Real getValue(Type const& v) {
          return v;
        }

        CODI_INLINE static Identifier getIdentifier(Type const& v) {
          CODI_UNUSED(v);
 
          return 0;
        }

        CODI_INLINE static void setValue(Type& v, Real const& value) {
          v = value;
        }

        CODI_INLINE static void setIdentifier(Type& v, Identifier const& identifier) {
          CODI_UNUSED(v, identifier);
        }
    };

    template<typename T_Type>
    struct DataExtraction<T_Type, EnableIfAggregatedTypeTraitsIsSpecialized<T_Type>> {
      public:
 
        using Type = CODI_DD(T_Type, double);
 
        using TypeTraits = AggregatedTypeTraits<Type>;
        using InnerType = typename TypeTraits::InnerType;
        static int constexpr Elements = TypeTraits::Elements;
 
        using InnerDataExtraction = DataExtraction<InnerType>;
 
        using Real = typename TypeTraits::Real;
        using Identifier = std::array<CODI_DD(typename InnerType::Identifier, int), Elements>;
 
        using RealTypeTraits = AggregatedTypeTraits<Real>;

        CODI_INLINE static Real getValue(Type const& v) {
          Real real{};
 
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            RealTypeTraits::template arrayAccess<i.value>(real) =
                InnerDataExtraction::getValue(TypeTraits::template arrayAccess<i.value>(v));
          });
 
          return real;
        }

        CODI_INLINE static Identifier getIdentifier(Type const& v) {
          Identifier res;
 
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            res[i.value] = InnerDataExtraction::getIdentifier(TypeTraits::template arrayAccess<i.value>(v));
          });
 
          return res;
        }

        CODI_INLINE static void setValue(Type& v, Real const& value) {
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            InnerDataExtraction::setValue(TypeTraits::template arrayAccess<i.value>(v),
                                          RealTypeTraits::template arrayAccess<i.value>(value));
          });
        }

        CODI_INLINE static void setIdentifier(Type& v, Identifier const& identifier) {
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            InnerDataExtraction::setIdentifier(TypeTraits::template arrayAccess<i.value>(v), identifier[i.value]);
          });
        }
    };

    template<typename T_Type>
    struct TapeRegistration<T_Type, EnableIfAggregatedTypeTraitsIsSpecialized<T_Type>> {
      public:
 
        using Type = CODI_DD(T_Type, CODI_ANY);
 
        using TypeTraits = AggregatedTypeTraits<Type>;
        using InnerType = typename TypeTraits::InnerType;
        static int constexpr Elements = TypeTraits::Elements;
 
        using Real = typename TypeTraits::Real;
 
        using RealTypeTraits = RealTraits::AggregatedTypeTraits<Real>;
        using InnerTraits = TapeRegistration<InnerType>;

        CODI_INLINE static void registerInput(Type& v) {
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            InnerTraits::registerInput(TypeTraits::template arrayAccess<i.value>(v));
          });
        }

        CODI_INLINE static void registerOutput(Type& v) {
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            InnerTraits::registerOutput(TypeTraits::template arrayAccess<i.value>(v));
          });
        }

        CODI_INLINE static Real registerExternalFunctionOutput(Type& v) {
          Real res{};
 
          static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
            RealTypeTraits::template arrayAccess<i.value>(res) =
                InnerTraits::registerExternalFunctionOutput(TypeTraits::template arrayAccess<i.value>(v));
          });
 
          return res;
        }
    };
    template<typename T_Type>
    struct AggregatedTypeTraits<T_Type, typename std::enable_if<std::is_floating_point<T_Type>::value>::type>
        : ArrayAggregatedTypeTraitsBase<T_Type, T_Type, T_Type, 1> {};
 
    template<typename T_Type>
    struct AggregatedTypeTraits<T_Type, typename std::enable_if<std::is_integral<T_Type>::value>::type>
        : ArrayAggregatedTypeTraitsBase<T_Type, T_Type, T_Type, 1> {};
 
    template<>
    struct AggregatedTypeTraits<int*> : ArrayAggregatedTypeTraitsBase<int*, int*, int*, 1> {};
 
#endif

 
  }
}