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

(

)

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 136 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 12 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 17 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 21 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 27 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 142 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 106 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 113 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 121 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 128 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 41 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 50 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 86 of file libminifloat.h.

References bits.

Referenced by nanoaod::flatTableHelper::MaybeMantissaReduce< float >::bulk(), and nanoaod::flatTableHelper::MaybeMantissaReduce< float >::one().

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

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

inlinestatic

Definition at line 94 of file libminifloat.h.

References f, and MiniFloatConverter::ReduceMantissaToNbitsRounding::ReduceMantissaToNbitsRounding().

        {
            return ReduceMantissaToNbitsRounding(bits)(f);
        }

template<typename InItr , typename OutItr >

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

inlinestatic

Definition at line 100 of file libminifloat.h.

References MiniFloatConverter::ReduceMantissaToNbitsRounding::ReduceMantissaToNbitsRounding(), and create_public_lumi_plots::transform.

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

Member Data Documentation

uint16_t MiniFloatConverter::basetable

staticprivate

Definition at line 151 of file libminifloat.h.

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

uint32_t MiniFloatConverter::exponenttable

staticprivate

Definition at line 149 of file libminifloat.h.

Referenced by filltables(), and float16to32().

uint32_t MiniFloatConverter::mantissatable

staticprivate

Definition at line 148 of file libminifloat.h.

Referenced by filltables(), and float16to32().

uint16_t MiniFloatConverter::offsettable

staticprivate

Definition at line 150 of file libminifloat.h.

Referenced by filltables(), and float16to32().

uint8_t MiniFloatConverter::shifttable

staticprivate

Definition at line 152 of file libminifloat.h.

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