realTraits.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://www.scicomp.uni-kl.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://www.scicomp.uni-kl.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 <cmath>
#include <complex>
 
#include "../config.h"
#include "../misc/macros.hpp"
#include "expressionTraits.hpp"
 
namespace codi {
 
  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 const& 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> const& 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);
    };
 
    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 Type>
    typename DataExtraction<Type>::Real getValue(Type const& v) {
      return DataExtraction<Type>::getValue(v);
    }
 
    template<typename Type>
    typename DataExtraction<Type>::Identifier getIdentifier(Type const& v) {
      return DataExtraction<Type>::getIdentifier(v);
    }
 
    template<typename Type>
    void setValue(Type& v, typename DataExtraction<Type>::Real const& value) {
      return DataExtraction<Type>::setValue(v, value);
    }
 
    template<typename Type>
    void registerInput(Type& v) {
      return TapeRegistration<Type>::registerInput(v);
    }
 
    template<typename Type>
    void registerOutput(Type& v) {
      return TapeRegistration<Type>::registerOutput(v);
    }
 
    template<typename Type>
    typename DataExtraction<Type>::Identifier registerExternalFunctionOutput(Type& v) {
      return TapeRegistration<Type>::registerExternalFunctionOutput(v);
    }
 
#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;
        }
    };
 
    template<typename T_InnerType>
    struct DataExtraction<std::complex<T_InnerType>> {
      public:
 
        using InnerType = CODI_DD(T_InnerType, ActiveTypeProxy);
        using Type = std::complex<T_InnerType>;  
 
        using InnerExtraction = DataExtraction<InnerType>;
 
        using Real = std::complex<typename InnerExtraction::Real>;              
        using Identifier = std::complex<typename InnerExtraction::Identifier>;  
 
        CODI_INLINE static Real getValue(Type const& v) {
          InnerType const* vArray = reinterpret_cast<InnerType const*>(&v);
 
          return Real(InnerExtraction::getValue(vArray[0]), InnerExtraction::getValue(vArray[1]));
        }
 
        CODI_INLINE static Identifier getIdentifier(Type const& v) {
          InnerType const* vArray = reinterpret_cast<InnerType const*>(&v);
 
          return Identifier(InnerExtraction::getIdentifier(vArray[0]), InnerExtraction::getIdentifier(vArray[1]));
        }
 
        CODI_INLINE static void setValue(Type& v, Real const& value) {
          InnerType* vArray = reinterpret_cast<InnerType*>(&v);
 
          InnerExtraction::setValue(vArray[0], std::real(value));
          InnerExtraction::setValue(vArray[1], std::imag(value));
        }
    };
 
    template<typename T_InnerType>
    struct TapeRegistration<std::complex<T_InnerType>> {
      public:
 
        using InnerType = CODI_DD(T_InnerType, CODI_ANY);
        using Type = std::complex<T_InnerType>;  
 
        using InnerRegistration = TapeRegistration<InnerType>;
 
        using Real = typename DataExtraction<Type>::Real;  
 
        CODI_INLINE static void registerInput(Type& v) {
          InnerType* vArray = reinterpret_cast<InnerType*>(&v);
 
          InnerRegistration::registerInput(vArray[0]);
          InnerRegistration::registerInput(vArray[1]);
        }
 
        CODI_INLINE static void registerOutput(Type& v) {
          InnerType* vArray = reinterpret_cast<InnerType*>(&v);
 
          InnerRegistration::registerOutput(vArray[0]);
          InnerRegistration::registerOutput(vArray[1]);
        }
 
        CODI_INLINE static Real registerExternalFunctionOutput(Type& v) {
          InnerType* vArray = reinterpret_cast<InnerType*>(&v);
 
          return Real(InnerRegistration::registerExternalFunctionOutput(vArray[0]),
                      InnerRegistration::registerExternalFunctionOutput(vArray[1]));
        }
    };
#endif
 
    /*******************************************************************************/
 
    template<typename Type>
    using IsPassiveReal = std::is_same<Type, PassiveReal<Type>>;
 
#if CODI_IS_CPP14
    template<typename Expr>
    bool constexpr isPassiveReal = IsPassiveReal<Expr>::value;
#endif
 
    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;
 
 
  }
}