#include <libminifloat.h>

Public Member Functions
	MiniFloatConverter ()

Static Public Member Functions
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 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 6 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

void MiniFloatConverter::filltables ( )

staticprivate

Definition at line 18 of file libminifloat.cc.

References basetable, alignCSCRings::e, exponenttable, i, 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 9 of file libminifloat.h.

References conv, exponenttable, mantissatable, and offsettable.

Referenced by pat::PackedGenParticle::unpack(), pat::PackedCandidate::unpack(), 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 14 of file libminifloat.h.

References float32to16round().

Referenced by pat::PackedGenParticle::pack(), pat::PackedCandidate::pack(), 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 18 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 24 of file libminifloat.h.

References newFWLiteAna::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]);
             }
         }