FloatingPointHelpers::ConversionHelper< FLarge, FSmall > Struct Template Reference

#include <FPHelpers.h>

Collaboration diagram for FloatingPointHelpers::ConversionHelper< FLarge, FSmall >:

Static Public Member Functions
template<class T>
static constexpr T	down_convert (const T pattern, const RoundingModes rt=RoundingModes::Default)
template<class T>
static constexpr T	up_convert (const T pattern, const RoundingModes rt=RoundingModes::Default)

Detailed Description

template<class FLarge, class FSmall>
struct FloatingPointHelpers::ConversionHelper< FLarge, FSmall >

Definition at line 707 of file FPHelpers.h.

Member Function Documentation

down_convert()

template<class FLarge, class FSmall>

template<class T>

constexpr T FloatingPointHelpers::ConversionHelper< FLarge, FSmall >::down_convert ( const T pattern, const RoundingModes rt = RoundingModes::Default )

inlinestaticconstexpr

Definition at line 714 of file FPHelpers.h.

    {
      using FDest = FSmall;
      using FSource = FLarge;
      using namespace OperatorsHelper;
 
      const bool sign_bit = pattern & FSource::template sign_mask<T>();
 
      const T exponent = (pattern & FSource::template exponent_mask<T>()) >> FSource::mantissa_size_bits();
      const T mantissa = pattern & FSource::template mantissa_mask<T>();
 
      constexpr T delta_exponents = FSource::template exponent_bias<T>() - FDest::template exponent_bias<T>();
 
      const bool exponent_full = (exponent > delta_exponents + FDest::template max_exponent_with_bias<T>());
      const bool delete_mantissa = exponent_full && exponent <= FSource::template max_exponent_with_bias<T>();
      //If the number is clamped to infinity, we must delete the mantissa
      //so we don't get a NaN!
      const bool denormal = exponent <= delta_exponents;
      const bool zero = exponent + FDest::mantissa_size_bits() <= delta_exponents;
 
      const T final_exponent = min(clamped_sub(exponent, delta_exponents), FDest::template max_exponent_with_bias<T>() + 1);
 
      const T extra_mantissa_shift = clamped_sub(delta_exponents + 1, exponent) * denormal;
      const T total_mantissa_shift = (FSource::mantissa_size_bits() - FDest::mantissa_size_bits()) + extra_mantissa_shift;
 
      const T mantissa_keep_mask = safe_lshift(FDest::template mantissa_mask<T>(), total_mantissa_shift) & FSource::template mantissa_mask<T>();
      const T check_for_rounding_mask = FSource::template mantissa_mask<T>() & (~mantissa_keep_mask);
      const T last_mantissa_bit = safe_lshift(FDest::template mantissa_mask<T>(), total_mantissa_shift) & FSource::template mantissa_mask<T>();
      const T first_discarded_bit_mask = last_mantissa_bit >> 1;
      //In case total_mantissa_shift == 0, this is 0 too.
 
      const T extra_denormal_bit = safe_rshift(T(denormal) << FDest::mantissa_size_bits(), extra_mantissa_shift);
 
      const bool round_up = (mantissa & check_for_rounding_mask) > first_discarded_bit_mask;
      const bool tie_break = ((mantissa & check_for_rounding_mask) == first_discarded_bit_mask);
 
      const bool round_bit = FDest::template round_results<T>(sign_bit, mantissa & last_mantissa_bit, round_up, tie_break, rt) && !(exponent_full && !delete_mantissa && !denormal);
      //The last part is so that NaN get truncated instead of rounded.
 
      T final_mantissa = (safe_rshift(mantissa, total_mantissa_shift) | extra_denormal_bit) + round_bit;
 
      final_mantissa *= !delete_mantissa;
 
      return sign_bit * FDest::template sign_mask<T>() | ((final_exponent << FDest::mantissa_size_bits()) | final_mantissa) * !zero;
 
    }

up_convert()

template<class FLarge, class FSmall>

template<class T>

constexpr T FloatingPointHelpers::ConversionHelper< FLarge, FSmall >::up_convert ( const T pattern, const RoundingModes rt = RoundingModes::Default )

inlinestaticconstexpr

Definition at line 762 of file FPHelpers.h.

    {
      using FDest = FLarge;
      using FSource = FSmall;
      using namespace OperatorsHelper;
 
      const bool sign_bit = pattern & FSource::template sign_mask<T>();
      T exponent = (pattern & FSource::template exponent_mask<T>()) >> FSource::mantissa_size_bits();
      T mantissa = pattern & FSource::template mantissa_mask<T>();
 
      constexpr T delta_exponents = (FDest::template exponent_bias<T>() - FSource::template exponent_bias<T>());
 
      if (exponent == 0 && FDest::exponent_size_bits() > FSource::exponent_size_bits())
        {
          const unsigned int leading_zeros = LeadingZerosPortability::count_leading_zeros<T>(mantissa);
          const unsigned int shift_amount = leading_zeros - (sizeof(T) * CHAR_BIT - FSource::mantissa_size_bits()) + 1;
          const unsigned int exponent_offset = (mantissa != 0) * (shift_amount - 1);
          mantissa = (mantissa << shift_amount) & FSource::template mantissa_mask<T>();
 
          exponent = delta_exponents - exponent_offset;
        }
      else if (exponent > FSource::template max_exponent_with_bias<T>())
        //Infinity or NaN
        {
          exponent = FDest::template max_exponent_with_bias<T>() + 1;
        }
      else
        {
          exponent = exponent + delta_exponents;
        }
 
 
      return sign_bit * FDest::template sign_mask<T>() | (exponent << FDest::mantissa_size_bits()) | (mantissa << (FDest::mantissa_size_bits() - FSource::mantissa_size_bits()));
 
    }

---

The documentation for this struct was generated from the following file:

• FPHelpers.h