HalfFloatWord Class Reference

#include <HalfFloatWord.hh>

Collaboration diagram for HalfFloatWord:

Public Member Functions
	operator float () const
	HalfFloatWord (uint16_t binaryRep)
	HalfFloatWord (float value)
	HalfFloatWord (const HalfFloatWord &hw)
	HalfFloatWord ()
HalfFloatWord	operator+ (const HalfFloatWord &right) const
HalfFloatWord	operator- (const HalfFloatWord &right) const
HalfFloatWord	operator* (const HalfFloatWord &right) const
HalfFloatWord	operator/ (const HalfFloatWord &right) const
const HalfFloatWord &	operator= (float value)
const HalfFloatWord &	operator= (const HalfFloatWord &value)
uint16_t	getBinaryRep () const

Static Public Member Functions
static uint16_t	convertFloatToHalfWordRep (float value)
static float	convertToFloat (HalfFloatWord value)

Private Attributes
uint16_t	binaryRep_

Detailed Description

Half-precision, IEE-754-2008 16-bit floating point number.

Definition at line 41 of file HalfFloatWord.hh.

Constructor & Destructor Documentation

HalfFloatWord() [1/4]

HalfFloatWord::HalfFloatWord ( uint16_t  binaryRep )

explicit

Definition at line 50 of file HalfFloatWord.cc.

: binaryRep_(binaryRep) {}

HalfFloatWord() [2/4]

HalfFloatWord::HalfFloatWord ( float  value )

explicit

Definition at line 143 of file HalfFloatWord.cc.

                                        : 
    binaryRep_(convertFloatToHalfWordRep(value)) {}

HalfFloatWord() [3/4]

HalfFloatWord::HalfFloatWord

(

const HalfFloatWord &

hw

)

Definition at line 147 of file HalfFloatWord.cc.

                                                    : 
    binaryRep_(hw.binaryRep_) {}

HalfFloatWord() [4/4]

HalfFloatWord::HalfFloatWord

(

)

Definition at line 53 of file HalfFloatWord.cc.

: binaryRep_(0) {}

Referenced by operator*(), operator+(), operator-(), and operator/().

Member Function Documentation

convertFloatToHalfWordRep()

uint16_t HalfFloatWord::convertFloatToHalfWordRep ( float  value )

static

Definition at line 56 of file HalfFloatWord.cc.

                                                    {
    FloatConvUnion u;
    u.f = value;
    int binary16 = (u.i & 0x80000000) >> 16;
 
    int expon = (u.i & 0x7f800000) >> 23;
    if(expon == 255) {
        // Handle NAN
        return binary16 | 0x7e00;
    }
    expon += 15-127;
    if(expon <= 0) {
        // Underflow, return zero with correct sign
        // TODO: support denormals?
        return binary16;
    }
    if(expon >= 31) {
        // Overflow, return inf with correct sign
        binary16 |= 0x7c00;
        return binary16;
    }
    binary16 |= expon << 10;
    binary16 |= (u.i & 0x007FFFFF) >> 13;
 
    //Round to nearest even. Comment following code out
    //for Round to Zero behavior.
    int l, g, r, s;
    l = (u.i >> 13) & 1;
    g = (u.i >> 12) & 1;
    r = (u.i >> 11) & 1;
    s = (u.i & ((1<<11)-1)) ? 1 : 0;
    if(g && (l || (r||s)))
    binary16++;
 
    return binary16;
}

References FloatConvUnion::f, and FloatConvUnion::i.

Referenced by operator=().

convertToFloat()

float HalfFloatWord::convertToFloat ( HalfFloatWord  value )

static

Exact and slower version of operator float()-function.

Attempts to retain original presentation of the source half float.

Definition at line 99 of file HalfFloatWord.cc.

                                                 {
    FloatConvUnion u;
 
    static const uint32_t half_inf_mask = 0x7C00;
    static const uint32_t half_mant_mask = 0x03FF;
    static const uint32_t float_inf_mask = 0x7F800000;
 
    uint32_t sign = (value.getBinaryRep() & 0x8000) << 16;
    uint32_t exp = (value.getBinaryRep() & half_inf_mask) >> 10; // Biased form
    uint32_t mant = (value.getBinaryRep() & half_mant_mask);
 
    if (exp == 0x1F) { // is +-inf or NaN?
        u.u = sign | float_inf_mask | mant << 13;
        return u.f;
    }
 
    if ((exp == 0 && mant != 0)) { // is denormal?
        // normalize
        exp = 127;
        while (!(mant & 0x400)) {
            exp--;
            mant <<= 1;
        }
        mant &= 0x400;
        u.u = sign | exp << 23 | mant << 13;
        return u.f;
    } else {
        u.u = sign | (exp-15+127) << 23 | mant << 13;
        return u.f;
    }
}

References FloatConvUnion::f, getBinaryRep(), and FloatConvUnion::u.

Here is the call graph for this function:

getBinaryRep()

uint16_t HalfFloatWord::getBinaryRep ( ) const

inline

Definition at line 60 of file HalfFloatWord.hh.

{ return binaryRep_; }

References binaryRep_.

Referenced by convertToFloat(), SimValue::operator=(), and SimValue::operator==().

operator float()

HalfFloatWord::operator float

(

)

const

Definition at line 152 of file HalfFloatWord.cc.

                                    {
    if (binaryRep_ == 0xFC00) {
        return -INFINITY;
    }
    if (binaryRep_ == 0x7C00) {
        return INFINITY;
    }
 
    bool sgn = ((binaryRep_ & 0x8000) >> 15);
    int exp = (binaryRep_ & 0x7C00) >> 10;
    int mant = binaryRep_ & 0x03FF;
 
    if (exp == 0x1F && mant != 0) {
        return NAN;
    }
 
    float value = (exp == 0) ? mant : mant | 0x0400; // 1.x if not denormal
    value /= 0x400;
    float mul = exp2(exp - 15);
    value *= mul;
    if (sgn) {
        value *= -1;
    }
    return value;
}

References INFINITY, and NAN.

operator*()

HalfFloatWord HalfFloatWord::operator*

(

const HalfFloatWord &

right

)

const

Definition at line 190 of file HalfFloatWord.cc.

                                                                        {
    return HalfFloatWord(float(*this) * float(right));
}

References HalfFloatWord().

Here is the call graph for this function:

operator+()

HalfFloatWord HalfFloatWord::operator+

(

const HalfFloatWord &

right

)

const

Definition at line 182 of file HalfFloatWord.cc.

                                                                        {
    return HalfFloatWord(float(*this) + float(right));
}

References HalfFloatWord().

Here is the call graph for this function:

operator-()

HalfFloatWord HalfFloatWord::operator-

(

const HalfFloatWord &

right

)

const

Definition at line 186 of file HalfFloatWord.cc.

                                                                        {
    return HalfFloatWord(float(*this) - float(right));
}

References HalfFloatWord().

Here is the call graph for this function:

operator/()

HalfFloatWord HalfFloatWord::operator/

(

const HalfFloatWord &

right

)

const

Definition at line 194 of file HalfFloatWord.cc.

                                                                        {
    return HalfFloatWord(float(*this) / float(right));
}

References HalfFloatWord().

Here is the call graph for this function:

operator=() [1/2]

const HalfFloatWord & HalfFloatWord::operator=

(

const HalfFloatWord &

value

)

Definition at line 138 of file HalfFloatWord.cc.

                                                                     {
    binaryRep_ = hf.binaryRep_;
    return *this;
}

References binaryRep_.

operator=() [2/2]

const HalfFloatWord & HalfFloatWord::operator=

(

float

value

)

Definition at line 133 of file HalfFloatWord.cc.

                                                         {
    binaryRep_ = convertFloatToHalfWordRep(value);
    return *this;
}

References binaryRep_, and convertFloatToHalfWordRep().

Here is the call graph for this function:

Member Data Documentation

binaryRep_

uint16_t HalfFloatWord::binaryRep_

private

Definition at line 66 of file HalfFloatWord.hh.

Referenced by getBinaryRep(), and operator=().

---

The documentation for this class was generated from the following files:

• HalfFloatWord.hh
• HalfFloatWord.cc