#include <libminifloat.h>

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 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 7 of file libminifloat.h.

Constructor & Destructor Documentation

MiniFloatConverter::MiniFloatConverter ( )

Definition at line 13 of file libminifloat.cc.

References filltables().

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

Member Function Documentation

static float MiniFloatConverter::denorm_min ( )

inlinestatic

Definition at line 109 of file libminifloat.h.

References conv.

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

void MiniFloatConverter::filltables ( )

staticprivate

Definition at line 18 of file libminifloat.cc.

References basetable, MillePedeFileConverter_cfg::e, exponenttable, mps_fire::i, createfilelist::int, funct::m, mantissatable, offsettable, and shifttable.

Referenced by MiniFloatConverter().

                                     {
     // ==== 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;
         }
     }
 }

static float MiniFloatConverter::float16to32 ( uint16_t h )

inlinestatic

Definition at line 10 of file libminifloat.h.

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().

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

static uint16_t MiniFloatConverter::float32to16 ( float x )

inlinestatic

Definition at line 15 of file libminifloat.h.

References float32to16round().

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

                                                     {
             return float32to16round(x);
         }

static uint16_t MiniFloatConverter::float32to16crop ( float x )

inlinestatic

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

Definition at line 19 of file libminifloat.h.

References basetable, conv, shifttable, and x.

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

static uint16_t MiniFloatConverter::float32to16round ( float x )

inlinestatic

Slower implementation, but it rounds to avoid biases.

Definition at line 25 of file libminifloat.h.

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

Referenced by float32to16().

                                                          {
             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]);
             }
         }

static bool MiniFloatConverter::isdenorm ( uint16_t h )

inlinestatic

Definition at line 115 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;
         }

static float MiniFloatConverter::max ( )

inlinestatic

Definition at line 79 of file libminifloat.h.

References conv.

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

static float MiniFloatConverter::max32RoundedToMax16 ( )

inlinestatic

Definition at line 86 of file libminifloat.h.

References conv.

                                                   {
             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;
         }

static float MiniFloatConverter::min ( )

inlinestatic

Definition at line 94 of file libminifloat.h.

References conv.

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

static float MiniFloatConverter::min32RoundedToMin16 ( )

inlinestatic

Definition at line 101 of file libminifloat.h.

References conv.

                                                   {
             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;
         }

template<int bits>

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

inlinestatic

Definition at line 39 of file libminifloat.h.

References bits, constexpr, conv, f, and RecoTauDiscriminantConfiguration::mask.

Referenced by CompressionElement::pack().

         {
             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;
         }

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

inlinestatic

Definition at line 48 of file libminifloat.h.

References bits, conv, f, and RecoTauDiscriminantConfiguration::mask.

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

template<int bits>

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

inlinestatic

Definition at line 58 of file libminifloat.h.

References bits, constexpr, conv, f, RecoTauDiscriminantConfiguration::mask, and edm::shift.

         {
             static_assert(bits <= 23,"max mantissa size is 23 bits");
             constexpr int      shift = (23-bits);    // bits I throw away
             constexpr uint32_t mask  = (0xFFFFFFFF >> (shift)) << (shift); // mask for truncation
             constexpr uint32_t test  = 1 << (shift-1); // most significant bit I throw away
             constexpr uint32_t low23 = (0x007FFFFF); // mask to keep lowest 23 bits = mantissa
             constexpr uint32_t  hi9  = (0xFF800000); // mask to keep highest 9 bits = the rest
             constexpr uint32_t maxn  = (1<<bits)-2; // max number I can increase before overflowing
             union { float flt; uint32_t i32; } conv;
             conv.flt=f;
             if (conv.i32 & test) { // need to round
                 uint32_t mantissa = (conv.i32 & low23) >> shift;
                 if (mantissa < maxn) mantissa++;
                 conv.i32 = (conv.i32 & hi9) | (mantissa << shift);
             } else {
                 conv.i32 &= mask;
             }
             return conv.flt;
         }