types.H

// ===========================================================================
//
// some basic types used for SIMD programming
//
// This source code file is part of the following software:
//
//    - the low-level C++ template SIMD library
//    - the SIMD implementation of the MinWarping and the 2D-Warping methods
//      for local visual homing.
//
// The software is provided based on the accompanying license agreement in the
// file LICENSE.md.
// The software is provided "as is" without any warranty by the licensor and
// without any liability of the licensor, and the software may not be
// distributed by the licensee; see the license agreement for details.
//
// (C) Ralf Möller
//     Computer Engineering
//     Faculty of Technology
//     Bielefeld University
//     www.ti.uni-bielefeld.de
//
// ===========================================================================
 
// 02. Mar 23 (Jonas Keller): added doxygen documentation
// 13. May 23 (Jonas Keller): added Double support
 
#pragma once
#ifndef SIMD_TYPES_H_
#define SIMD_TYPES_H_
 
#include "defs.H"
 
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <limits>
#include <type_traits>
 
namespace simd {
 
// ===========================================================================
// data types
// ===========================================================================
 
using Byte       = uint8_t;  
using SignedByte = int8_t;   
using Word       = uint16_t; 
using Short      = int16_t;  
using Int        = int32_t;  
using Long       = int64_t;  
using Float      = float;  
using Double     = double; 
// exclude from doxygen (until endcond)
 
// 30. Mar 23 (Jonas Keller): replaced the magic numbers in these macros with
// std::numeric_limits<T>::max() and std::numeric_limits<T>::lowest()
// and also added SIMDFLOAT_TRUE using an immediately invoked lambda and
// std::memcpy
 
// 23. Nov 23 (Jonas Keller): use simd::internal::bit_cast instead of using
// memcpy directly in SIMDFLOAT_TRUE and SIMDDOUBLE_TRUE
 
#define SIMDBYTE_TRUE       (::simd::Byte(~0))
#define SIMDSIGNEDBYTE_TRUE (::simd::SignedByte(~0))
#define SIMDWORD_TRUE       (::simd::Word(~0))
#define SIMDSHORT_TRUE      (::simd::Short(~0))
#define SIMDINT_TRUE        (::simd::Int(~0))
#define SIMDLONG_TRUE       (::simd::Long(~0))
#define SIMDFLOAT_TRUE      (::simd::internal::bit_cast<::simd::Float>(SIMDINT_TRUE))
#define SIMDDOUBLE_TRUE                                                        \
  (::simd::internal::bit_cast<::simd::Double>(SIMDLONG_TRUE))
 
#define SIMDBYTE_MIN       (::std::numeric_limits<Byte>::lowest())
#define SIMDSIGNEDBYTE_MIN (::std::numeric_limits<SignedByte>::lowest())
#define SIMDWORD_MIN       (::std::numeric_limits<Word>::lowest())
#define SIMDSHORT_MIN      (::std::numeric_limits<Short>::lowest())
#define SIMDINT_MIN        (::std::numeric_limits<Int>::lowest())
#define SIMDLONG_MIN       (::std::numeric_limits<Long>::lowest())
#define SIMDFLOAT_MIN      (::std::numeric_limits<Float>::lowest())
#define SIMDDOUBLE_MIN     (::std::numeric_limits<Double>::lowest())
 
#define SIMDBYTE_MAX       (::std::numeric_limits<Byte>::max())
#define SIMDSIGNEDBYTE_MAX (::std::numeric_limits<SignedByte>::max())
#define SIMDWORD_MAX       (::std::numeric_limits<Word>::max())
#define SIMDSHORT_MAX      (::std::numeric_limits<Short>::max())
#define SIMDINT_MAX        (::std::numeric_limits<Int>::max())
#define SIMDLONG_MAX       (::std::numeric_limits<Long>::max())
#define SIMDFLOAT_MAX      (::std::numeric_limits<Float>::max())
#define SIMDDOUBLE_MAX     (::std::numeric_limits<Double>::max())
 
// 0x7fffff80
#define MAX_POS_FLOAT_CONVERTIBLE_TO_INT32 2147483520.0f
// 0x7fffff8000000000
#define MAX_POS_FLOAT_CONVERTIBLE_TO_INT64 9223371487098961920.0f
// 0x7fffffff
#define MAX_POS_DOUBLE_CONVERTIBLE_TO_INT32 2147483647.0
// 0x7ffffffffffffc00
#define MAX_POS_DOUBLE_CONVERTIBLE_TO_INT64 9223372036854774784.0
 
// 28. Feb 23 (Jonas Keller): added SortSlope enum
 
enum class SortSlope { ASCENDING = 0, DESCENDING = 1 };
 
// ===========================================================================
// TypeInfo
// ===========================================================================
 
// NOTE: min() and max() are functions since "floating-point literals are not
// allowed in constant expressions according to -pedantic
 
// defaultFormat() returns a full format specifier with % and space, can be
// used for tests
 
// 27. Jan 23 (Jonas Keller): added wrapper class for TypeInfo for doxygen
// documentation
// 30. Mar 23 (Jonas Keller): deprecated isSigned, isInteger, isFloatingPoint,
// min() and max() in TypeInfo in favor of the corresponding functions in
// the std library and used those functions in the implementation of
// TypeInfo
 
namespace internal {
namespace types {
template <typename T>
struct TypeInfo;
 
template <>
struct TypeInfo<Byte>
{
  static constexpr SIMD_INLINE const char *name() { return "Byte"; }
  static constexpr SIMD_INLINE const char *format() { return "u"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%u "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%02x "; }
  static constexpr SIMD_INLINE Byte trueval() { return SIMDBYTE_TRUE; }
  using NextLargerType = Word;
  using UnsignedType   = Byte;
  using SignedType     = SignedByte;
  using IntegerType    = SignedByte;
};
 
template <>
struct TypeInfo<SignedByte>
{
  static constexpr SIMD_INLINE const char *name() { return "SignedByte"; }
  static constexpr SIMD_INLINE const char *format() { return "d"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%d "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%02x "; }
  static constexpr SIMD_INLINE SignedByte trueval()
  {
    return SIMDSIGNEDBYTE_TRUE;
  }
  using NextLargerType = Short;
  using UnsignedType   = Byte;
  using SignedType     = SignedByte;
  using IntegerType    = SignedByte;
};
 
template <>
struct TypeInfo<Word>
{
  static constexpr SIMD_INLINE const char *name() { return "Word"; }
  static constexpr SIMD_INLINE const char *format() { return "u"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%u "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%04x "; }
  static constexpr SIMD_INLINE Word trueval() { return SIMDWORD_TRUE; }
  using NextLargerType = Int; // no larger unsigned type, use Int
  using UnsignedType   = Word;
  using SignedType     = Short;
  using IntegerType    = Short;
};
 
template <>
struct TypeInfo<Short>
{
  static constexpr SIMD_INLINE const char *name() { return "Short"; }
  static constexpr SIMD_INLINE const char *format() { return "d"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%d "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%04x "; }
  static constexpr SIMD_INLINE Short trueval() { return SIMDSHORT_TRUE; }
  using NextLargerType = Int;
  using UnsignedType   = Word;
  using SignedType     = Short;
  using IntegerType    = Short;
};
 
template <>
struct TypeInfo<Int>
{
  static constexpr SIMD_INLINE const char *name() { return "Int"; }
  static constexpr SIMD_INLINE const char *format() { return "d"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%d "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%08x "; }
  static constexpr SIMD_INLINE Int trueval() { return SIMDINT_TRUE; }
  using NextLargerType = Long;
  using UnsignedType   = uint32_t; // not a SIMD type
  using SignedType     = Int;
  using IntegerType    = Int;
};
 
template <>
struct TypeInfo<Long>
{
  static constexpr SIMD_INLINE const char *name() { return "Long"; }
  static constexpr SIMD_INLINE const char *format() { return "ld"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%ld "; }
  static constexpr SIMD_INLINE const char *hexFormat() { return "%016lx "; }
  static constexpr SIMD_INLINE Long trueval() { return SIMDLONG_TRUE; }
  using NextLargerType = Long;     // no larger integer type than Long
  using UnsignedType   = uint64_t; // not a SIMD type
  using SignedType     = Long;
  using IntegerType    = Long;
};
 
template <>
struct TypeInfo<Float>
{
  static constexpr SIMD_INLINE const char *name() { return "Float"; }
  static constexpr SIMD_INLINE const char *format() { return ".9g"; }
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%.9g "; }
  static SIMD_INLINE Float trueval() { return SIMDFLOAT_TRUE; }
  using NextLargerType = Double;
  using UnsignedType   = Float; // no unsigned float type
  using SignedType     = Float;
  using IntegerType    = Int;
};
 
template <>
struct TypeInfo<Double>
{
  static constexpr SIMD_INLINE const char *name() { return "Double"; };
  static constexpr SIMD_INLINE const char *format() { return ".17g"; };
  static constexpr SIMD_INLINE const char *defaultFormat() { return "%.17g "; };
  static SIMD_INLINE Double trueval() { return SIMDDOUBLE_TRUE; }
  using NextLargerType = Double; // no larger double type than Double
  using UnsignedType   = Double; // no unsigned double type
  using SignedType     = Double;
  using IntegerType    = Long;
};
 
} // namespace types
} // namespace internal
 
template <typename T>
struct TypeInfo
{
  static constexpr SIMD_INLINE const char *name()
  {
    return internal::types::TypeInfo<T>::name();
  };
  static constexpr SIMD_INLINE const char *format()
  {
    return internal::types::TypeInfo<T>::format();
  };
  static constexpr SIMD_INLINE const char *defaultFormat()
  {
    return internal::types::TypeInfo<T>::defaultFormat();
  };
  static constexpr SIMD_INLINE const char *hexFormat()
  {
    return internal::types::TypeInfo<T>::hexFormat();
  }
  static constexpr bool isSigned = std::is_signed<T>::value;
  static constexpr bool isInteger = std::is_integral<T>::value;
  static constexpr bool isFloatingPoint = std::is_floating_point<T>::value;
  static constexpr SIMD_INLINE T min()
  {
    return std::numeric_limits<T>::lowest();
  }
  static constexpr SIMD_INLINE T max() { return std::numeric_limits<T>::max(); }
  static constexpr SIMD_INLINE T trueval()
  {
    return internal::types::TypeInfo<T>::trueval();
  }
  using NextLargerType = typename internal::types::TypeInfo<T>::NextLargerType;
  using UnsignedType = typename internal::types::TypeInfo<T>::UnsignedType;
  using SignedType = typename internal::types::TypeInfo<T>::SignedType;
  using IntegerType = typename internal::types::TypeInfo<T>::IntegerType;
};
 
// ===========================================================================
// formatting
// ===========================================================================
 
// note that for T=Float, TypeInfo<T>::format() returns "g",
// for which precision encodes the number of significant digits,
// not the number of fractional digits
template <typename T>
struct Format
{
  char format[256]; 
 
  Format(int fieldWidth = -1, int precision = -1)
  {
    char fieldWidthStr[16], precisionStr[16];
    if (fieldWidth >= 0)
      sprintf(fieldWidthStr, "%d", fieldWidth);
    else
      strcpy(fieldWidthStr, "");
    if (precision >= 0)
      sprintf(precisionStr, ".%d", precision);
    else
      strcpy(precisionStr, "");
    if (TypeInfo<T>::isInteger)
      // integer format, precision is ignored
      sprintf(format, "%%%s%s", fieldWidthStr, TypeInfo<T>::format());
    else
      // float format, precision is used
      sprintf(format, "%%%s%s%s", fieldWidthStr, precisionStr,
              TypeInfo<T>::format());
  }
};
 
// a crude way to format SIMD* types as decimal number, can be used in
// fprintf (use %s format specification)
template <typename T>
struct Decimal
{
  char str[256]; 
 
  Decimal(T value, int fieldWidth = -1, int precision = -1)
  {
    sprintf(str, Format<T>(fieldWidth, precision).format, value);
  }
};
 
// 07. Oct 23 (Jonas Keller): added dont_deduce
 
namespace internal {
template <typename T>
struct dont_deduce
{
  using type = T;
};
} // namespace internal
 
template <typename T>
using dont_deduce = typename internal::dont_deduce<T>::type;
 
// 22. Jan 23 (Jonas Keller): moved tag dispatching classes into internal
// namespace
 
namespace internal {
// ===========================================================================
// tag dispatching
// ===========================================================================
 
// int2type trick from
// Andrei Alexandrescu: Modern C++ Design (Addison Wesley)
 
// 08. Apr 23 (Jonas Keller): removed IsIntSize; it is no longer used
// 24. Nov 23 (Jonas Keller): removed some more unused tag dispatching classes
 
template <size_t N>
struct Integer
{};
 
template <size_t N>
struct Part
{};
 
template <size_t N>
struct Elements
{};
 
template <size_t N>
struct Bytes
{};
 
template <bool AT_LOWER_LIMIT, size_t LOWER_LIMIT_INCLUSIVE,
          size_t UPPER_LIMIT_EXCLUSIVE>
struct Range
{};
 
template <size_t IMM, size_t SIZE>
struct SizeRange
  : public Range<(IMM & (SIZE - 1)) == 0,    // is IMM a multiple of SIZE?
                 IMM & ~(SIZE - 1),          // previous multiple of SIZE
                 (IMM & ~(SIZE - 1)) + SIZE> // next multiple of SIZE
{};
 
template <size_t N>
struct Compression
{};
 
template <typename T>
struct OutputType
{};
} // namespace internal
 
} // namespace simd
 
#endif