Sacado_Traits.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Sacado Package
//
// Copyright 2006 NTESS and the Sacado contributors.
// SPDX-License-Identifier: LGPL-2.1-or-later
//
// ***********************************************************************
//
// The forward-mode AD classes in Sacado are a derivative work of the
// expression template classes in the Fad package by Nicolas Di Cesare.
// The following banner is included in the original Fad source code:
//
// ************ DO NOT REMOVE THIS BANNER ****************
//
//  Nicolas Di Cesare <Nicolas.Dicesare@ann.jussieu.fr>
//  http://www.ann.jussieu.fr/~dicesare
//
//            CEMRACS 98 : C++ courses,
//         templates : new C++ techniques
//            for scientific computing
//
//********************************************************
//
//  NumericalTraits class to illustrate TRAITS
//
//********************************************************
// @HEADER

#ifndef SACADO_TRAITS_HPP
#define SACADO_TRAITS_HPP

#include <string>
#include <type_traits>

#include "Sacado_ConfigDefs.h"
#include "Sacado_dummy_arg.hpp"
#include "Sacado_mpl_enable_if.hpp"
#include "Sacado_mpl_disable_if.hpp"

#ifdef HAVE_SACADO_COMPLEX
#include <complex>
#endif

namespace Sacado {

  enum DerivInit {
    NoInitDerivArray = 0, 
    InitDerivArray        
  };

  template <typename T>
  struct IsExpr {
    static const bool value = false;
  };

  template <typename T>
  struct IsView {
    static const bool value = false;
  };

  template <typename T>
  struct BaseExprType {
    typedef T type;
  };

  template <typename T,unsigned,unsigned> struct ViewFadType {};

  template <typename T> struct OverrideDefaultPromote {
    static const bool value = false;
  };


  template <typename A, typename B, typename Enabled = void> struct Promote {};

  template <typename A>
  struct Promote< A, A,
                  typename mpl::enable_if_c< !OverrideDefaultPromote<A>::value >::type > {
    typedef typename BaseExprType<A>::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< std::is_convertible<A,B>::value &&
                                            !std::is_convertible<B,A>::value &&
                                            !OverrideDefaultPromote<A>::value &&
                                            !OverrideDefaultPromote<B>::value
                                           >::type > {
    typedef typename BaseExprType<B>::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< std::is_convertible<B,A>::value &&
                                            !std::is_convertible<A,B>::value &&
                                            !OverrideDefaultPromote<A>::value &&
                                            !OverrideDefaultPromote<B>::value
                                           >::type > {
    typedef typename BaseExprType<A>::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< std::is_convertible<A,B>::value &&
                                             std::is_convertible<B,A>::value &&
                                             !std::is_same<A,B>::value &&
                                             ( IsExpr<A>::value ||
                                               IsExpr<B>::value ) >::type >
  {
    typedef typename BaseExprType<A>::type A_base_fad_type;
    typedef typename BaseExprType<B>::type B_base_fad_type;
    typedef typename Promote< A_base_fad_type, B_base_fad_type >::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< !std::is_convertible<A,B>::value &&
                                             !std::is_convertible<B,A>::value &&
                                             IsExpr<A>::value &&
                                             std::is_convertible< B, typename BaseExprType< typename A::value_type >::type >::value
                                             >::type >
  {
    typedef typename BaseExprType<A>::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< !std::is_convertible<A,B>::value &&
                                             !std::is_convertible<B,A>::value &&
                                             IsExpr<B>::value &&
                                              std::is_convertible< A, typename BaseExprType< typename B::value_type >::type >::value
                                             >::type >
  {
    typedef typename BaseExprType<B>::type type;
  };

  template <typename A, typename B>
  struct Promote< A, B,
                  typename mpl::enable_if_c< !std::is_convertible<A,B>::value &&
                                             !std::is_convertible<B,A>::value &&
                                             IsExpr<A>::value &&
                                             IsExpr<B>::value &&
                                             std::is_same< typename BaseExprType< typename A::value_type >::type,
                                                           typename BaseExprType< typename B::value_type >::type >::value
                                             >::type >
  {
    typedef typename BaseExprType<A>::type A_base_expr_type;
    typedef typename BaseExprType<B>::type B_base_expr_type;
    typedef typename Promote< A_base_expr_type, B_base_expr_type >::type type;
  };

#define SACADO_PROMOTE_SPECIALIZATION(type1,type2,type3)   \
  template <> struct Promote< type1, type2, void > {       \
    typedef type3 type;                                    \
  };                                                       \
  template <> struct Promote< type2, type1, void > {       \
    typedef type3 type;                                    \
  };

  SACADO_PROMOTE_SPECIALIZATION(double,float,double)
  SACADO_PROMOTE_SPECIALIZATION(double,long,double)
  SACADO_PROMOTE_SPECIALIZATION(double,int,double)
  SACADO_PROMOTE_SPECIALIZATION(float,long,float)
  SACADO_PROMOTE_SPECIALIZATION(float,int,float)
#ifdef HAVE_SACADO_COMPLEX
  SACADO_PROMOTE_SPECIALIZATION(std::complex<double>,std::complex<float>,std::complex<double>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<double>,double,std::complex<double>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<double>,float,std::complex<double>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<double>,long,std::complex<double>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<double>,int,std::complex<double>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<float>,float,std::complex<float>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<float>,long,std::complex<float>)
  SACADO_PROMOTE_SPECIALIZATION(std::complex<float>,int,std::complex<float>)
#endif // HAVE_SACADO_COMPLEX

#undef SACADO_PROMOTE_SPECIALIZATION

   // Macros for building proper Promote specialization for AD types

#define SACADO_AD_PROMOTE_SPEC(NS, AD) /* */

#define SACADO_AD_PROMOTE_SPEC2(NS, AD) /* */

#define SACADO_FAD_PROMOTE_SPEC(NS, FAD) /* */

#define SACADO_SFAD_PROMOTE_SPEC(NS, FAD) /* */

#define SACADO_EXPR_PROMOTE_SPEC(NS) /* */

#define SACADO_VFAD_PROMOTE_SPEC(NS) /* */

#define SACADO_RAD_PROMOTE_SPEC(NS)                                     \
  namespace NS {                                                        \
    template <typename> class ADvar;                                    \
    template <typename> class ADvari;                                   \
  }                                                                     \
  template <typename T>                                                 \
  struct OverrideDefaultPromote< NS :: ADvari <T>& > {                  \
    static const bool value = true;                                     \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< NS :: ADvar <T>,                                      \
                  NS :: ADvari <T>& > {                                 \
    typedef NS :: ADvar <T> type;                                       \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< NS :: ADvari <T>&,                                    \
                  NS :: ADvar <T> > {                                   \
    typedef NS :: ADvar <T> type;                                       \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< NS :: ADvari <T>&,                                    \
                  typename NS :: ADvari <T>::value_type > {             \
    typedef NS :: ADvar <T> type;                                       \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< typename NS :: ADvari <T>::value_type,                \
                  NS :: ADvari <T>& > {                                 \
    typedef NS :: ADvar <T> type;                                       \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< NS :: ADvari <T>&,                                    \
                  typename dummy< typename NS :: ADvari <T>::value_type, \
                                  typename NS :: ADvari <T>::scalar_type \
                                  >::type > {                           \
    typedef NS :: ADvar <T> type;                                       \
  };                                                                    \
  template <typename T>                                                 \
  struct Promote< typename dummy< typename NS :: ADvari <T>::value_type, \
                                  typename NS :: ADvari <T>::scalar_type \
                                  >::type,                              \
                  NS :: ADvari <T>& > {                                 \
    typedef NS :: ADvar <T> type;                                       \
  };

  //
  // We define defaults for all of the traits to make Sacado easier to use.
  // The default choices are based on what appears to be the "safest" choice
  // for any scalar type.  They may not work in all cases, in which case a
  // specialization should be provided.
  //


  template <typename T> struct ScalarType {
    typedef T type;
  };


  template <typename T> struct ScalarType<const T> {
    typedef const typename ScalarType<T>::type type;
  };


  template <typename T> struct ValueType {
    typedef T type;
  };


  template <typename T> struct ValueType<const T> {
    typedef const typename ValueType<T>::type type;
  };


  template <typename T> struct IsADType {
    static const bool value = false;
  };


  template <typename T> struct IsScalarType {
    static const bool value = false;
  };


  template <typename T> struct IsSimdType {
    static const bool value = false;
  };


  template <typename T> struct Value {
    SACADO_INLINE_FUNCTION
    static const T& eval(const T& x) { return x; }
  };

  template <typename T> struct Value<const T> {
    typedef typename ValueType<T>::type value_type;
    SACADO_INLINE_FUNCTION
    static const value_type& eval(const T& x) {
      return Value<T>::eval(x);
    }
  };


  template <typename T> struct ScalarValue {
    SACADO_INLINE_FUNCTION
    static const T& eval(const T& x) { return x; }
  };

  template <typename T> struct ScalarValue<const T> {
    typedef typename ScalarType<T>::type scalar_type;
    SACADO_INLINE_FUNCTION
    static const scalar_type& eval(const T& x) {
      return ScalarValue<T>::eval(x);
    }
  };

  template <typename T>
  SACADO_INLINE_FUNCTION
  typename ScalarType<T>::type scalarValue(const T& x) {
    return ScalarValue<T>::eval(x);
  }

  template <typename T> struct MarkConstant {
    SACADO_INLINE_FUNCTION
    static void eval(T& x) {}
  };

  template <typename T> struct StringName {
    static std::string eval() { return ""; }
  };

  template <typename T> struct IsEqual {
    SACADO_INLINE_FUNCTION
    static bool eval(const T& x, const T& y) { return x == y; }
  };

  template <typename T> struct IsStaticallySized {
    static const bool value = false;
  };


  template <typename T> struct IsStaticallySized<const T> {
    static const bool value = IsStaticallySized<T>::value;
  };

  template <typename T> struct StaticSize {
    static const unsigned value = 0;
  };

  template <typename T> struct IsFad {
    static const bool value = false;
  };

  template <typename T> struct IsFad< const T >
  {
    static const bool value = IsFad<T>::value;
  };

  template <typename T>
  struct RemoveConst {
    typedef T type;
  };

  template <typename T>
  struct RemoveConst< const T > {
    typedef T type;
  };

#define SACADO_BUILTIN_SPECIALIZATION(t,NAME)             \
  template <> struct ScalarType< t > {                    \
    typedef t type;                                       \
  };                                                      \
  template <> struct ValueType< t > {                     \
    typedef t type;                                       \
  };                                                      \
  template <> struct IsADType< t > {                      \
    static const bool value = false;                      \
  };                                                      \
  template <> struct IsScalarType< t > {                  \
    static const bool value = true;                       \
  };                                                      \
  template <> struct Value< t > {                         \
    SACADO_INLINE_FUNCTION                                \
    static const t& eval(const t& x) { return x; }        \
  };                                                      \
  template <> struct ScalarValue< t > {                   \
    SACADO_INLINE_FUNCTION                                \
    static const t& eval(const t& x) { return x; }        \
  };                                                      \
  template <> struct StringName< t > {                    \
    static std::string eval() { return NAME; }            \
  };                                                      \
  template <> struct IsEqual< t > {                       \
    SACADO_INLINE_FUNCTION                                \
    static bool eval(const t& x, const t& y) {            \
      return x == y; }                                    \
  };                                                      \
  template <> struct IsStaticallySized< t > {             \
    static const bool value = true;                       \
  };

#define SACADO_BUILTIN_SPECIALIZATION_COMPLEX(t,NAME)     \
  template <> struct ScalarType< t > {                    \
    typedef t type;                                       \
  };                                                      \
  template <> struct ValueType< t > {                     \
    typedef t type;                                       \
  };                                                      \
  template <> struct IsADType< t > {                      \
    static const bool value = false;                      \
  };                                                      \
  template <> struct IsScalarType< t > {                  \
    static const bool value = true;                       \
  };                                                      \
  template <> struct Value< t > {                         \
    static const t& eval(const t& x) { return x; }        \
  };                                                      \
  template <> struct ScalarValue< t > {                   \
    static const t& eval(const t& x) { return x; }        \
  };                                                      \
  template <> struct StringName< t > {                    \
    static std::string eval() { return NAME; }            \
  };                                                      \
  template <> struct IsEqual< t > {                       \
    static bool eval(const t& x, const t& y) {            \
      return x == y; }                                    \
  };                                                      \
  template <> struct IsStaticallySized< t > {             \
    static const bool value = true;                       \
  };

  SACADO_BUILTIN_SPECIALIZATION(char,"char")
  SACADO_BUILTIN_SPECIALIZATION(float,"float")
  SACADO_BUILTIN_SPECIALIZATION(double,"double")
  SACADO_BUILTIN_SPECIALIZATION(int,"int")
  SACADO_BUILTIN_SPECIALIZATION(unsigned int,"unsigned int")
  SACADO_BUILTIN_SPECIALIZATION(long,"long")
  SACADO_BUILTIN_SPECIALIZATION(unsigned long,"unsigned long")
  SACADO_BUILTIN_SPECIALIZATION(bool,"bool")
#ifdef HAVE_SACADO_COMPLEX
  SACADO_BUILTIN_SPECIALIZATION_COMPLEX(std::complex<double>,"std::complex<double>")
  SACADO_BUILTIN_SPECIALIZATION_COMPLEX(std::complex<float>,"std::complex<float>")
#endif

#undef SACADO_BUILTIN_SPECIALIZATION
#undef SACADO_BUILTIN_SPECIALIZATION_COMPLEX

template< typename T , T v , bool NonZero = ( v != T(0) ) >
struct integral_nonzero
{
  // Declaration of 'static const' causes an unresolved linker symbol in debug
  // static const T value = v ;
  enum { value = T(v) };
  typedef T value_type ;
  typedef integral_nonzero<T,v> type ;
  SACADO_INLINE_FUNCTION integral_nonzero() {}
  SACADO_INLINE_FUNCTION integral_nonzero( const T & ) {}
  SACADO_INLINE_FUNCTION integral_nonzero( const integral_nonzero & ) {}
  SACADO_INLINE_FUNCTION integral_nonzero& operator=(const integral_nonzero &) {return *this;}
  SACADO_INLINE_FUNCTION integral_nonzero& operator=(const T &) {return *this;}
};

template< typename T , T zero >
struct integral_nonzero<T,zero,false>
{
  T value ;
  typedef T value_type ;
  typedef integral_nonzero<T,0> type ;
  SACADO_INLINE_FUNCTION integral_nonzero() : value() {}
  SACADO_INLINE_FUNCTION integral_nonzero( const T & v ) : value(v) {}
  SACADO_INLINE_FUNCTION integral_nonzero( const integral_nonzero & v) : value(v.value) {}
  SACADO_INLINE_FUNCTION integral_nonzero& operator=(const integral_nonzero & v) { value = v.value; return *this; }
  SACADO_INLINE_FUNCTION integral_nonzero& operator=(const T & v) { value = v; return *this; }
};

} // namespace Sacado

#endif // SACADO_TRAITS_HPP