type_traits.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/util/half.hpp>
#include <kernel/util/string.hpp>
 
#include <typeindex>
 
#if defined(FEAT_HAVE_FLOATX) && !defined(__CUDACC__)
FEAT_DISABLE_WARNINGS
#include <floatx.hpp>
FEAT_RESTORE_WARNINGS
#endif // FEAT_HAVE_FLOATX && !defined(__CUDACC__)
 
namespace FEAT
{
  namespace Type
  {
    struct Helper
    {
      static inline size_t extract_type_size(uint64_t feature_hash)
      {
        return (size_t) feature_hash&0xFFFFFFFF; //take only the lower 32 bits
      }
 
      static inline bool extract_intness(uint64_t feature_hash)
      {
        return (feature_hash&(uint64_t(1)<<32)) != uint64_t(0);
      }
 
      static inline bool extract_floatness(uint64_t feature_hash)
      {
        return (feature_hash&(uint64_t(1)<<33)) != uint64_t(0);
      }
 
      static inline bool extract_signedness(uint64_t feature_hash)
      {
        return (feature_hash&(uint64_t(1)<<34)) != uint64_t(0);
      }
    };
 
    class AnotherClass {};
    class IntegralClass {};
    class FloatingClass {};
    class BooleanClass {};
 
    template<typename DT_>
    struct Traits
    {
      typedef AnotherClass TypeClass;
 
      static String name()
      {
        return DT_::name();
      }
    };
 
    template<>
    struct Traits<float>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return "float";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(float)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<double>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return "double";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(double)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<long double>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return "long double";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(long double)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<unsigned int>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = false;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "unsigned int";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(unsigned int)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<signed int>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "signed int";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(signed int)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<unsigned char>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = false;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "unsigned char";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(unsigned char)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<signed char>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "signed char";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(signed char)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<unsigned short>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = false;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "unsigned short";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(unsigned short)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<signed short>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "signed short";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(signed short)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<unsigned long>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = false;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "unsigned long";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(unsigned long)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<signed long>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "signed long";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(signed long)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<unsigned long long>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = false;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "unsigned long long";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(unsigned long long)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<signed long long>
    {
      static constexpr bool is_int = true;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef IntegralClass TypeClass;
 
      static String name()
      {
        return "signed long long";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(signed long long)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
    template<>
    struct Traits<bool>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = false;
      static constexpr bool is_bool = true;
      static constexpr bool is_signed = false;
 
      typedef BooleanClass TypeClass;
 
      static String name()
      {
        return "bool";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(bool)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
 
#if defined(FEAT_HAVE_QUADMATH) && !defined(__CUDACC__)
    template<>
    struct Traits<__float128>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return "__float128";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(__float128)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
#endif // FEAT_HAVE_QUADMATH && !__CUDACC__
 
#if defined(FEAT_HAVE_HALFMATH)
    template<>
    struct Traits<Half>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return "Half";
      }
 
      static uint64_t feature_hash()
      {
        return uint64_t(sizeof(Half)) | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
#endif // FEAT_HAVE_HALFMATH
 
#if defined(FEAT_HAVE_FLOATX) && !defined(__CUDACC__)
    template<int exp_bits_, int sig_bits_, typename Backend_>
    struct Traits<flx::floatx<exp_bits_, sig_bits_, Backend_>>
    {
      static constexpr bool is_int = false;
      static constexpr bool is_float = true;
      static constexpr bool is_bool = false;
      static constexpr bool is_signed = true;
 
      typedef FloatingClass TypeClass;
 
      static String name()
      {
        return String("floatx<") + stringify(exp_bits_) + "," + stringify(sig_bits_) + "," + Traits<Backend_>::name() + ">";
      }
 
      static uint64_t feature_hash()
      {
        // This one is more tricky, because we also have to encode
        // the chosen number of exponent and significant bits
        return uint64_t(sizeof(Backend_)) | uint64_t(exp_bits_) << 16 | uint64_t(sig_bits_) << 24
          | uint64_t(is_int) << 32 | uint64_t(is_float) << 33 | uint64_t(is_signed) << 34;
      }
    };
#endif // FEAT_HAVE_FLOATX && !__CUDACC__
  } // namespace Type
} // namespace FEAT