MiniFloatConverter Class Reference

#include <libminifloat.h>

Classes
class	ReduceMantissaToNbitsRounding

Public Member Functions
	MiniFloatConverter ()

Static Public Member Functions
static float	denorm_min ()
static float	float16to32 (uint16_t h)
static uint16_t	float32to16 (float x)
static uint16_t	float32to16crop (float x)
	Fast implementation, but it crops the number so it biases low. More...
static uint16_t	float32to16round (float x)
	Slower implementation, but it rounds to avoid biases. More...
static bool	isdenorm (uint16_t h)
static float	max ()
static float	max32RoundedToMax16 ()
static float	min ()
static float	min32RoundedToMin16 ()
template<int bits>
static float	reduceMantissaToNbits (const float &f)
static float	reduceMantissaToNbits (const float &f, int bits)
template<int bits>
static float	reduceMantissaToNbitsRounding (const float &f)
static float	reduceMantissaToNbitsRounding (float f, int bits)
template<typename InItr , typename OutItr >
static void	reduceMantissaToNbitsRounding (int bits, InItr begin, InItr end, OutItr out)

Static Private Member Functions
static void	filltables ()

Static Private Attributes
static uint16_t	basetable [512]
static uint32_t	exponenttable [64]
static uint32_t	mantissatable [2048]
static uint16_t	offsettable [64]
static uint8_t	shifttable [512]

Detailed Description

Definition at line 9 of file libminifloat.h.

Constructor & Destructor Documentation

MiniFloatConverter()

MiniFloatConverter::MiniFloatConverter

(

)

Definition at line 12 of file libminifloat.cc.

                                       {
  static bool once = false;
  if (!once) {
    filltables();
    once = true;
  }
}

References filltables().

Member Function Documentation

denorm_min()

static float MiniFloatConverter::denorm_min ( )

inlinestatic

Definition at line 158 of file libminifloat.h.

                                   {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.i32 = 0x33800000;  // mantissatable[offsettable[0]+1]+exponenttable[0]
    return conv.flt;
  }

References conv.

filltables()

void MiniFloatConverter::filltables ( )

staticprivate

Definition at line 20 of file libminifloat.cc.

                                    {
  // ==== mantissatable ===
  // -- zero --
  mantissatable[0] = 0;
  // -- denorm --
  for (unsigned int i = 1; i <= 1023; ++i) {
    unsigned int m = (i << 13), e = 0;
    while (!(m & 0x00800000)) {  // While not normalized
      e -= 0x00800000;           // Decrement exponent (1<<23)
      m <<= 1;                   // Shift mantissa
    }
    m &= ~0x00800000;  // Clear leading 1 bit
    e += 0x38800000;   // Adjust bias ((127-14)<<23)
    mantissatable[i] = m | e;
  }
  // -- norm --
  for (unsigned int i = 1024; i <= 2047; ++i) {
    mantissatable[i] = 0x38000000 + ((i - 1024) << 13);
  }
  // ==== exponenttable ===
  exponenttable[0] = 0;
  for (unsigned int i = 1; i <= 30; ++i)
    exponenttable[i] = i << 23;
  exponenttable[31] = 0x47800000;
  exponenttable[32] = 0x80000000u;
  for (unsigned int i = 33; i <= 62; ++i)
    exponenttable[i] = 0x80000000u | ((i - 32) << 23);
  exponenttable[63] = 0xC7800000;
 
  // ==== offsettable ====
  for (unsigned int i = 0; i <= 63; ++i)
    offsettable[i] = ((i == 0 || i == 32) ? 0 : 1024);
 
  // ==== basetable, shifttable ===
  for (unsigned i = 0; i < 256; ++i) {
    int e = int(i) - 127;
    if (e < -24) {  // Very small numbers map to zero
      basetable[i | 0x000] = 0x0000;
      basetable[i | 0x100] = 0x8000;
      shifttable[i | 0x000] = 24;
      shifttable[i | 0x100] = 24;
    } else if (e < -14) {  // Small numbers map to denorms
      basetable[i | 0x000] = (0x0400 >> (-e - 14));
      basetable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
      shifttable[i | 0x000] = -e - 1;
      shifttable[i | 0x100] = -e - 1;
    } else if (e <= 15) {  // Normal numbers just lose precision
      basetable[i | 0x000] = ((e + 15) << 10);
      basetable[i | 0x100] = ((e + 15) << 10) | 0x8000;
      shifttable[i | 0x000] = 13;
      shifttable[i | 0x100] = 13;
    } else if (e < 128) {  // Large numbers map to Infinity
      basetable[i | 0x000] = 0x7C00;
      basetable[i | 0x100] = 0xFC00;
      shifttable[i | 0x000] = 24;
      shifttable[i | 0x100] = 24;
    } else {  // Infinity and NaN's stay Infinity and NaN's
      basetable[i | 0x000] = 0x7C00;
      basetable[i | 0x100] = 0xFC00;
      shifttable[i | 0x000] = 13;
      shifttable[i | 0x100] = 13;
    }
  }
}

References basetable, MillePedeFileConverter_cfg::e, exponenttable, mps_fire::i, createfilelist::int, visualization-live-secondInstance_cfg::m, mantissatable, offsettable, and shifttable.

Referenced by MiniFloatConverter().

float16to32()

static float MiniFloatConverter::float16to32 ( uint16_t  h )

inlinestatic

Definition at line 12 of file libminifloat.h.

                                              {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.i32 = mantissatable[offsettable[h >> 10] + (h & 0x3ff)] + exponenttable[h >> 10];
    return conv.flt;
  }

References conv, exponenttable, mantissatable, and offsettable.

Referenced by convertPackedEtaToPackedY(), CompressionElement::unpack(), pat::MET::PackedMETUncertainty::unpack(), pat::PackedGenParticle::unpack(), pat::PackedCandidate::unpack(), BeamCurrentInfo::unpackData(), and pat::PackedCandidate::unpackVtx().

float32to16()

static uint16_t MiniFloatConverter::float32to16 ( float  x )

inlinestatic

Definition at line 20 of file libminifloat.h.

{ return float32to16round(x); }

References float32to16round(), and x.

Referenced by CompressionElement::pack(), pat::MET::PackedMETUncertainty::pack(), pat::PackedGenParticle::pack(), pat::PackedCandidate::pack(), BeamCurrentInfo::packData(), and pat::PackedCandidate::packVtx().

float32to16crop()

static uint16_t MiniFloatConverter::float32to16crop ( float  x )

inlinestatic

Fast implementation, but it crops the number so it biases low.

Definition at line 22 of file libminifloat.h.

                                                  {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.flt = x;
    return basetable[(conv.i32 >> 23) & 0x1ff] + ((conv.i32 & 0x007fffff) >> shifttable[(conv.i32 >> 23) & 0x1ff]);
  }

References basetable, conv, shifttable, and x.

float32to16round()

static uint16_t MiniFloatConverter::float32to16round ( float  x )

inlinestatic

Slower implementation, but it rounds to avoid biases.

Definition at line 31 of file libminifloat.h.

                                                   {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.flt = x;
    uint8_t shift = shifttable[(conv.i32 >> 23) & 0x1ff];
    if (shift == 13) {
      uint16_t base2 = (conv.i32 & 0x007fffff) >> 12;
      uint16_t base = base2 >> 1;
      if (((base2 & 1) != 0) && (base < 1023))
        base++;
      return basetable[(conv.i32 >> 23) & 0x1ff] + base;
    } else {
      return basetable[(conv.i32 >> 23) & 0x1ff] + ((conv.i32 & 0x007fffff) >> shifttable[(conv.i32 >> 23) & 0x1ff]);
    }
  }

References newFWLiteAna::base, compare_using_db::base2, basetable, conv, edm::shift, shifttable, and x.

Referenced by float32to16().

isdenorm()

static bool MiniFloatConverter::isdenorm ( uint16_t  h )

inlinestatic

Definition at line 167 of file libminifloat.h.

                                          {
    // if exponent is zero (sign-bit excluded of course) and mantissa is not zero
    return ((h >> 10) & 0x1f) == 0 && (h & 0x3ff) != 0;
  }

max()

static float MiniFloatConverter::max ( )

inlinestatic

Definition at line 116 of file libminifloat.h.

                            {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.i32 = 0x477fe000;  // = mantissatable[offsettable[0x1e]+0x3ff]+exponenttable[0x1e]
    return conv.flt;
  }

References conv.

Referenced by pat::PackedCandidate::pack().

max32RoundedToMax16()

static float MiniFloatConverter::max32RoundedToMax16 ( )

inlinestatic

Definition at line 126 of file libminifloat.h.

                                            {
    union {
      float flt;
      uint32_t i32;
    } conv;
    // 2^16 in float32 is the first to result inf in float16, so
    // 2^16-1 is the last float32 to result max() in float16
    conv.i32 = (0x8f << 23) - 1;
    return conv.flt;
  }

References conv.

min()

static float MiniFloatConverter::min ( )

inlinestatic

Definition at line 137 of file libminifloat.h.

                            {
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.i32 = 0x38800000;  // = mantissatable[offsettable[1]+0]+exponenttable[1]
    return conv.flt;
  }

References conv.

min32RoundedToMin16()

static float MiniFloatConverter::min32RoundedToMin16 ( )

inlinestatic

Definition at line 147 of file libminifloat.h.

                                            {
    union {
      float flt;
      uint32_t i32;
    } conv;
    // 2^-14-1 in float32 is the first to result denormalized in float16, so
    // 2^-14 is the first float32 to result min() in float16
    conv.i32 = (0x71 << 23);
    return conv.flt;
  }

References conv.

reduceMantissaToNbits() [1/2]

template<int bits>

static float MiniFloatConverter::reduceMantissaToNbits ( const float &  f )

inlinestatic

Definition at line 49 of file libminifloat.h.

                                                            {
    static_assert(bits <= 23, "max mantissa size is 23 bits");
    constexpr uint32_t mask = (0xFFFFFFFF >> (23 - bits)) << (23 - bits);
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.flt = f;
    conv.i32 &= mask;
    return conv.flt;
  }

References conv, and f.

Referenced by CompressionElement::pack().

reduceMantissaToNbits() [2/2]

static float MiniFloatConverter::reduceMantissaToNbits ( const float &  f, int  bits  )

inlinestatic

Definition at line 60 of file libminifloat.h.

                                                                      {
    uint32_t mask = (0xFFFFFFFF >> (23 - bits)) << (23 - bits);
    union {
      float flt;
      uint32_t i32;
    } conv;
    conv.flt = f;
    conv.i32 &= mask;
    return conv.flt;
  }

References conv, and f.

reduceMantissaToNbitsRounding() [1/3]

template<int bits>

static float MiniFloatConverter::reduceMantissaToNbitsRounding ( const float &  f )

inlinestatic

Definition at line 102 of file libminifloat.h.

                                                                    {
    static const ReduceMantissaToNbitsRounding reducer(bits);
    return reducer(f);
  }

References f.

Referenced by nanoaod::flatTableHelper::MaybeMantissaReduce< float >::bulk(), SimpleFlatTableProducerBase< T, TProd >::FuncVariable< StringFunctor, ValType >::fill(), nanoaod::flatTableHelper::MaybeMantissaReduce< float >::one(), HLTScoutingTrackProducer::produce(), HLTScoutingPFProducer::produce(), and HLTScoutingEgammaProducer::produce().

reduceMantissaToNbitsRounding() [2/3]

static float MiniFloatConverter::reduceMantissaToNbitsRounding ( float  f, int  bits  )

inlinestatic

Definition at line 107 of file libminifloat.h.

                                                                       {
    return ReduceMantissaToNbitsRounding(bits)(f);
  }

References f.

reduceMantissaToNbitsRounding() [3/3]

template<typename InItr , typename OutItr >

static void MiniFloatConverter::reduceMantissaToNbitsRounding ( int  bits, InItr  begin, InItr  end, OutItr  out  )

inlinestatic

Definition at line 112 of file libminifloat.h.

                                                                                          {
    std::transform(begin, end, out, ReduceMantissaToNbitsRounding(bits));
  }

References mps_fire::end, MillePedeFileConverter_cfg::out, and HcalDetIdTransform::transform().

Member Data Documentation

basetable

uint16_t MiniFloatConverter::basetable

staticprivate

Definition at line 176 of file libminifloat.h.

Referenced by filltables(), float32to16crop(), and float32to16round().

exponenttable

uint32_t MiniFloatConverter::exponenttable

staticprivate

Definition at line 174 of file libminifloat.h.

Referenced by filltables(), and float16to32().

mantissatable

uint32_t MiniFloatConverter::mantissatable

staticprivate

Definition at line 173 of file libminifloat.h.

Referenced by filltables(), and float16to32().

offsettable

uint16_t MiniFloatConverter::offsettable

staticprivate

Definition at line 175 of file libminifloat.h.

Referenced by filltables(), and float16to32().

shifttable

uint8_t MiniFloatConverter::shifttable

staticprivate

Definition at line 177 of file libminifloat.h.

Referenced by filltables(), float32to16crop(), and float32to16round().