types.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2026 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_BASE_TYPES_H
#define MI_BASE_TYPES_H
 
#include <mi/base/config.h>
#include <mi/base/assert.h>
#include <cstddef>             // define  size_t, ptrdiff_t
#include <cstdlib>             // declare abs
#include <cmath>               // declare abs overloads
 
#if defined(__has_include)
#if (!defined(_WIN32) || (defined(_HAS_CXX20) && _HAS_CXX20) || _MSVC_LANG >= 202002L)
#if __has_include(<bit>)
#include <bit>
#endif
#endif
#endif
 
#ifndef MI_BASE_NO_STL
#include <algorithm>           // define  min, max
#endif // MI_BASE_NO_STL
 
namespace mi {
 
// primitive types of known bit size
 
using Sint8   = signed char;        
using Sint16  = short;              
using Sint32  = int;                
using Uint8   = unsigned char;      
using Uint16  = unsigned short;     
using Uint32  = unsigned int;       
 
using Float32 = float;              
using Float64 = double;             
 
#if defined(MI_COMPILER_MSC)
 
using Sint64 = signed __int64;      
using Uint64 = unsigned __int64;    
 
#elif defined(MI_COMPILER_GCC) // defined(MI_COMPILER_MSC)
 
using Sint64 = long long;           
using Uint64 = unsigned long long;  
 
#else // defined(MI_COMPILER_GCC)
 
using Sint64 = signed   long long;  
using Uint64 = unsigned long long;  
 
#endif // defined(MI_COMPILER_GCC)
 
mi_static_assert( sizeof(  Sint8) == 1);
mi_static_assert( sizeof( Sint16) == 2);
mi_static_assert( sizeof( Sint32) == 4);
mi_static_assert( sizeof( Sint64) == 8);
mi_static_assert( sizeof(  Uint8) == 1);
mi_static_assert( sizeof( Uint16) == 2);
mi_static_assert( sizeof( Uint32) == 4);
mi_static_assert( sizeof( Uint64) == 8);
mi_static_assert( sizeof(Float32) == 4);
mi_static_assert( sizeof(Float64) == 8);
 
#define MI_BASE_FMT_MI_SINT64 "lld"
 
#define MI_BASE_FMT_MI_UINT64 "llu"
 
using Size = Uint64;
 
using Difference = Sint64;
 
mi_static_assert( sizeof(Size)       == 8);
mi_static_assert( sizeof(Difference) == 8);
 
static const Size       SIZE_MAX_VALUE       = 18446744073709551615ULL;
 
static const Difference DIFFERENCE_MIN_VALUE = -9223372036854775807LL - 1LL;
 
static const Difference DIFFERENCE_MAX_VALUE =  9223372036854775807LL;
 
#define MI_BASE_FMT_MI_SIZE "llu"
 
#define MI_BASE_FMT_MI_DIFFERENCE "lld"
 
// primitive types related constants
 
#define MI_PI    3.14159265358979323846
#define MI_PI_2  1.57079632679489661923
#define MI_PI_4  0.78539816339744830962
 
enum Comparison_result : Sint32
{
    NEGATIVE         = -1, 
    ZERO             =  0, 
    POSITIVE         =  1, 
 
    LESS             = -1, 
    EQUAL            =  0, 
    GREATER          =  1  
};
 
inline Comparison_result operator-( Comparison_result sign)
{
    return Comparison_result( -static_cast<int>( sign));
}
 
template <typename T>
inline Comparison_result three_valued_sign( T t)
{
    if      (t < 0)     return NEGATIVE;
    else if (t > 0)     return POSITIVE;
    else                return ZERO;
}
 
template <typename T>
inline Comparison_result three_valued_compare( T lhs, T rhs)
{
    if      (lhs < rhs) return LESS;
    else if (rhs < lhs) return GREATER;
    else                return EQUAL;
}
 
namespace base {
 
// Define min/max within mi::base if and only if no STL usage is selected by defining the
// MI_BASE_NO_STL macro. Use std definitions otherwise.
#ifdef MI_BASE_NO_STL
 
template <class T>
inline const T& min MI_PREVENT_MACRO_EXPAND (const T& a, const T& b)
{ return a < b ? a : b; }
 
template <class T>
inline const T& max MI_PREVENT_MACRO_EXPAND (const T& a, const T& b)
{ return a > b ? a : b; }
 
#else // MI_BASE_NO_STL
 
using std::min;
using std::max;
 
#endif // MI_BASE_NO_STL
 
// For simple types, we add variants that pass the arguments by value. This can result in better
// performance on some compilers.
inline Sint8 min MI_PREVENT_MACRO_EXPAND (const Sint8 a, const Sint8 b)
{ return a < b ? a : b; }
inline Sint16 min MI_PREVENT_MACRO_EXPAND (const Sint16 a, const Sint16 b)
{ return a < b ? a : b; }
inline Sint32 min MI_PREVENT_MACRO_EXPAND (const Sint32 a, const Sint32 b)
{ return a < b ? a : b; }
inline Sint64 min MI_PREVENT_MACRO_EXPAND (const Sint64 a, const Sint64 b)
{ return a < b ? a : b; }
inline Uint8 min MI_PREVENT_MACRO_EXPAND (const Uint8 a, const Uint8 b)
{ return a < b ? a : b; }
inline Uint16 min MI_PREVENT_MACRO_EXPAND (const Uint16 a, const Uint16 b)
{ return a < b ? a : b; }
inline Uint32 min MI_PREVENT_MACRO_EXPAND (const Uint32 a, const Uint32 b)
{ return a < b ? a : b; }
inline Uint64 min MI_PREVENT_MACRO_EXPAND (const Uint64 a, const Uint64 b)
{ return a < b ? a : b; }
inline Float32 min MI_PREVENT_MACRO_EXPAND (const Float32 a, const Float32 b)
{ return a < b ? a : b; }
inline Float64 min MI_PREVENT_MACRO_EXPAND (const Float64 a, const Float64 b)
{ return a < b ? a : b; }
 
inline Sint8 max MI_PREVENT_MACRO_EXPAND (const Sint8 a, const Sint8 b)
{ return a > b ? a : b; }
inline Sint16 max MI_PREVENT_MACRO_EXPAND (const Sint16 a, const Sint16 b)
{ return a > b ? a : b; }
inline Sint32 max MI_PREVENT_MACRO_EXPAND (const Sint32 a, const Sint32 b)
{ return a > b ? a : b; }
inline Sint64 max MI_PREVENT_MACRO_EXPAND (const Sint64 a, const Sint64 b)
{ return a > b ? a : b; }
inline Uint8 max MI_PREVENT_MACRO_EXPAND (const Uint8 a, const Uint8 b)
{ return a > b ? a : b; }
inline Uint16 max MI_PREVENT_MACRO_EXPAND (const Uint16 a, const Uint16 b)
{ return a > b ? a : b; }
inline Uint32 max MI_PREVENT_MACRO_EXPAND (const Uint32 a, const Uint32 b)
{ return a > b ? a : b; }
inline Uint64 max MI_PREVENT_MACRO_EXPAND (const Uint64 a, const Uint64 b)
{ return a > b ? a : b; }
inline Float32 max MI_PREVENT_MACRO_EXPAND (const Float32 a, const Float32 b)
{ return a > b ? a : b; }
inline Float64 max MI_PREVENT_MACRO_EXPAND (const Float64 a, const Float64 b)
{ return a > b ? a : b; }
 
// Take the abs function overloads from the Standard Library header cmath.
 
using std::abs;
 
namespace {
    // helper class for the \c binary_cast function defined below
    template <class Target, class Source>
    union Binary_cast
    {
        Source  source;
        Target  target;
    };
}
 
#ifdef  __cpp_lib_bit_cast
template<class T, class S>
constexpr T binary_cast(const S& src) noexcept { return std::bit_cast<T,S>(src); }
#else
template <class Target, class Source>
inline Target binary_cast(Source const & val)
{
    mi_static_assert( sizeof(Source) == sizeof(Target));
    Binary_cast<Target, Source> val_;
    val_.source = val;
    return val_.target;
}
#endif
 
template <typename T>
struct numeric_traits_base
{
    static const bool is_specialized = false;
 
    static const bool has_infinity = false;
 
    static const bool has_quiet_NaN = false;
 
    static const bool has_signaling_NaN = false;
 
 
    static T (min)() noexcept { return T(); }
 
    static T (max)() noexcept { return T(); }
 
    static T negative_max() noexcept { return T(); }
 
    static T infinity() noexcept { return T(); }
 
    static T quiet_NaN() noexcept { return T(); }
 
    static T signaling_NaN() noexcept { return T(); }
};
 
template <typename T>
struct numeric_traits : public numeric_traits_base<T>
{};
 
template <> struct numeric_traits<Sint8> : public numeric_traits_base<Sint8>
{
    static const bool is_specialized = true;  
    static Sint8   (min)()         noexcept { return -128; } 
    static Sint8   (max)()         noexcept { return  127; } 
    static Sint8   negative_max()  noexcept { return -128; } 
};
 
template <> struct numeric_traits<Sint16> : public numeric_traits_base<Sint16>
{
    static const bool is_specialized = true;  
    static Sint16  (min)()         noexcept { return -32768; } 
    static Sint16  (max)()         noexcept { return  32767; } 
    static Sint16  negative_max()  noexcept { return -32768; } 
};
 
template <> struct numeric_traits<Sint32> : public numeric_traits_base<Sint32>
{
    static const bool is_specialized = true;  
    static Sint32  (min)()         noexcept { return -2147483647 - 1; } 
    static Sint32  (max)()         noexcept { return  2147483647;     } 
    static Sint32  negative_max()  noexcept { return -2147483647 - 1; } 
};
 
template <> struct numeric_traits<Sint64> : public numeric_traits_base<Sint64>
{
    static const bool is_specialized = true;  
    static Sint64  (min)()         noexcept { return -9223372036854775807LL - 1LL; } 
    static Sint64  (max)()         noexcept { return  9223372036854775807LL; }       
    static Sint64  negative_max()  noexcept { return -9223372036854775807LL - 1LL; } 
};
 
template <> struct numeric_traits<Uint8> : public numeric_traits_base<Uint8>
{
    static const bool is_specialized = true;  
    static Uint8   (max)()         noexcept { return 255; } 
};
 
template <> struct numeric_traits<Uint16> : public numeric_traits_base<Uint16>
{
    static const bool is_specialized = true;  
    static Uint16   (max)()        noexcept { return 65535; } 
};
 
template <> struct numeric_traits<Uint32> : public numeric_traits_base<Uint32>
{
    static const bool is_specialized = true;  
    static Uint32   (max)()        noexcept { return 4294967295U; } 
};
 
template <> struct numeric_traits<Uint64> : public numeric_traits_base<Uint64>
{
    static const bool is_specialized = true;  
    static Uint64   (max)()        noexcept { return 18446744073709551615ULL; } 
};
 
// Architecture dependent definition of quiet NaN
#ifdef MI_ARCH_BIG_ENDIAN
#   define MI__FLOAT32_INF_REP  { 0x7f80, 0 }
#   define MI__FLOAT32_QNAN_REP { 0x7fc1, 0 }
#   define MI__FLOAT32_SNAN_REP { 0x7f81, 0 }
#   define MI__FLOAT64_INF_REP  { 0x7ff0, 0, 0, 0 }
#   define MI__FLOAT64_QNAN_REP { 0x7ff9, 0, 0, 0 }
#   define MI__FLOAT64_SNAN_REP { 0x7ff1, 0, 0, 0 }
#endif // MI_ARCH_BIG_ENDIAN
#ifdef MI_ARCH_LITTLE_ENDIAN
#   define MI__FLOAT32_INF_REP  {       0, 0x7f80 }
#   define MI__FLOAT32_QNAN_REP {       0, 0x7fc0 }
#   define MI__FLOAT32_SNAN_REP {       0, 0x7fa0 }
#   define MI__FLOAT64_INF_REP  { 0, 0, 0, 0x7ff0 }
#   define MI__FLOAT64_QNAN_REP { 0, 0, 0, 0x7ff8 }
#   define MI__FLOAT64_SNAN_REP { 0, 0, 0, 0x7ff4 }
#endif // MI_ARCH_LITTLE_ENDIAN
 
namespace {
    // Float number type representation for bitwise inits with NaNs
    union Float32_rep { Uint16 rep[2]; Float32 val; };
    union Float64_rep { Uint16 rep[4]; Float64 val; };
}
 
template <> struct numeric_traits<Float32> : public numeric_traits_base<Float32>
{
    static const bool is_specialized    = true; 
    static const bool has_infinity      = true; 
    static const bool has_quiet_NaN     = true; 
    static const bool has_signaling_NaN = true; 
    static Float32 (min)()         noexcept { return  1.17549435e-38F; }  
    static Float32 (max)()         noexcept { return  3.402823466e+38F; } 
    static Float32 negative_max()  noexcept { return -3.402823466e+38F; } 
    static Float32 infinity()      noexcept { 
        Float32_rep rep = { MI__FLOAT32_INF_REP };
        return rep.val;
    }
    static Float32 quiet_NaN()     noexcept { 
        Float32_rep rep = { MI__FLOAT32_QNAN_REP };
        return rep.val;
    }
    static Float32 signaling_NaN() noexcept { 
        Float32_rep rep = { MI__FLOAT32_SNAN_REP };
        return rep.val;
    }
};
 
template <> struct numeric_traits<Float64> : public numeric_traits_base<Float64>
{
    static const bool is_specialized    = true; 
    static const bool has_infinity      = true; 
    static const bool has_quiet_NaN     = true; 
    static const bool has_signaling_NaN = true; 
    static Float64 (min)()         noexcept { return  2.2250738585072014e-308; } 
    static Float64 (max)()         noexcept { return  1.7976931348623158e+308; } 
    static Float64 negative_max()  noexcept { return -1.7976931348623158e+308; } 
    static Float64 infinity()      noexcept { 
        Float64_rep rep = { MI__FLOAT64_INF_REP };
        return rep.val;
    }
    static Float64 quiet_NaN()     noexcept { 
        Float64_rep rep = { MI__FLOAT64_QNAN_REP };
        return rep.val;
    }
    static Float64 signaling_NaN() noexcept { 
        Float64_rep rep = { MI__FLOAT64_SNAN_REP };
        return rep.val;
    }
};
 // end group mi_base_number_traits_specialization
 
} // namespace base
 // end group mi_base_types
 
} // namespace mi
 
#endif // MI_BASE_TYPES_H