osg::Real16 Class Reference

#include <OSGReal16.h>

List of all members.

Public Member Functions
	Real16 ()
	Real16 (float f)
	operator float () const
Real16	operator- () const
Real16 &	operator= (Real16 h)
Real16 &	operator= (float f)
Real16 &	operator+= (Real16 h)
Real16 &	operator+= (float f)
Real16 &	operator-= (Real16 h)
Real16 &	operator-= (float f)
Real16 &	operator*= (Real16 h)
Real16 &	operator*= (float f)
Real16 &	operator/= (Real16 h)
Real16 &	operator/= (float f)
Real16	round (unsigned int n) const
bool	isFinite () const
bool	isNormalized () const
bool	isDenormalized () const
bool	isZero () const
bool	isNan () const
bool	isInfinity () const
bool	isNegative () const
unsigned short	bits () const
void	setBits (unsigned short bits)
Static Public Member Functions
static Real16	posInf ()
static Real16	negInf ()
static Real16	qNan ()
static Real16	sNan ()
Static Private Member Functions
static short	convert (int i)
static float	overflow ()
static bool	selftest ()
Private Attributes
unsigned short	_h
Static Private Attributes
static const uif	_toFloat [1<< 16]
static const unsigned short	_eLut [1<< 9]
static const bool	_itWorks
Classes
union	uif

---

Detailed Description

Definition at line 94 of file OSGReal16.h.

---

Constructor & Destructor Documentation

osg::Real16::Real16

(

)

[inline]

Definition at line 421 of file OSGReal16.h.

Referenced by operator*=(), operator+=(), operator-=(), operator/=(), operator=(), and osg::operator>>().

{
    // no initialization
}

osg::Real16::Real16

(

float

f

)

[inline]

Definition at line 432 of file OSGReal16.h.

References _eLut, _h, convert(), osg::Real16::uif::f, and osg::Real16::uif::i.

{
    if (f == 0)
    {
    //
    // Common special case - zero.
    // For speed, we don't preserve the zero's sign.
    //

    _h = 0;
    }
    else
    {
    //
    // We extract the combined sign and exponent, e, from our
    // floating-point number, f.  Then we convert e to the sign
    // and exponent of the half number via a table lookup.
    //
    // For the most common case, where a normalized half is produced,
    // the table lookup returns a non-zero value; in this case, all
    // we have to do, is round f's significand to 10 bits and combine
    // the result with e.
    //
    // For all other cases (overflow, zeroes, denormalized numbers
    // resulting from underflow, infinities and NANs), the table
    // lookup returns zero, and we call a longer, non-inline function
    // to do the float-to-half conversion.
    //

    uif x;

    x.f = f;

    register int e = (x.i >> 23) & 0x000001ff;

    e = _eLut[e];

    if (e)
    {
        //
        // Simple case - round the significand and
        // combine it with the sign and exponent.
        //

        _h = e + (((x.i & 0x007fffff) + 0x00001000) >> 13);
    }
    else
    {
        //
        // Difficult case - call a function.
        //

        _h = convert (x.i);
    }
    }
}

---

Member Function Documentation

osg::Real16::operator float

(

)

const [inline]

Definition at line 495 of file OSGReal16.h.

References _h, _toFloat, and osg::Real16::uif::f.

{
    return _toFloat[_h].f;
}

Real16 osg::Real16::operator-

(

)

const [inline]

Definition at line 565 of file OSGReal16.h.

References _h.

{
    Real16 h;
    h._h = _h ^ 0x8000;
    return h;
}

Real16 & osg::Real16::operator=

(

Real16

h

)

[inline]

Definition at line 574 of file OSGReal16.h.

References _h.

{
    _h = h._h;
    return *this;
}

Real16 & osg::Real16::operator=

(

float

f

)

[inline]

Definition at line 582 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (f);
    return *this;
}

Real16 & osg::Real16::operator+=

(

Real16

h

)

[inline]

Definition at line 590 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) + float (h));
    return *this;
}

Real16 & osg::Real16::operator+=

(

float

f

)

[inline]

Definition at line 598 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) + f);
    return *this;
}

Real16 & osg::Real16::operator-=

(

Real16

h

)

[inline]

Definition at line 606 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) - float (h));
    return *this;
}

Real16 & osg::Real16::operator-=

(

float

f

)

[inline]

Definition at line 614 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) - f);
    return *this;
}

Real16 & osg::Real16::operator*=

(

Real16

h

)

[inline]

Definition at line 622 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) * float (h));
    return *this;
}

Real16 & osg::Real16::operator*=

(

float

f

)

[inline]

Definition at line 630 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) * f);
    return *this;
}

Real16 & osg::Real16::operator/=

(

Real16

h

)

[inline]

Definition at line 638 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) / float (h));
    return *this;
}

Real16 & osg::Real16::operator/=

(

float

f

)

[inline]

Definition at line 646 of file OSGReal16.h.

References Real16().

{
    *this = Real16 (float (*this) / f);
    return *this;
}

Real16 osg::Real16::round

(

unsigned int

n

)

const [inline]

Definition at line 506 of file OSGReal16.h.

References _h.

{
    //
    // Parameter check.
    //

    if (n >= 10)
    return *this;

    //
    // Disassemble h into the sign, s,
    // and the combined exponent and significand, e.
    //

    unsigned short s = _h & 0x8000;
    unsigned short e = _h & 0x7fff;

    //
    // Round the exponent and significand to the nearest value
    // where ones occur only in the (10-n) most significant bits.
    // Note that the exponent adjusts automatically if rounding
    // up causes the significand to overflow.
    //

    e >>= 9 - n;
    e  += e & 1;
    e <<= 9 - n;

    //
    // Check for exponent overflow.
    //

    if (e >= 0x7c00)
    {
    //
    // Overflow occurred -- truncate instead of rounding.
    //

    e = _h;
    e >>= 10 - n;
    e <<= 10 - n;
    }

    //
    // Put the original sign bit back.
    //

    Real16 h;
    h._h = s | e;

    return h;
}

bool osg::Real16::isFinite

(

)

const [inline]

Definition at line 654 of file OSGReal16.h.

References _h.

{
    unsigned short e = (_h >> 10) & 0x001f;
    return e < 31;
}

bool osg::Real16::isNormalized

(

)

const [inline]

Definition at line 662 of file OSGReal16.h.

References _h.

{
    unsigned short e = (_h >> 10) & 0x001f;
    return e > 0 && e < 31;
}

bool osg::Real16::isDenormalized

(

)

const [inline]

Definition at line 670 of file OSGReal16.h.

References _h.

{
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 0 && m != 0;
}

bool osg::Real16::isZero

(

)

const [inline]

Definition at line 679 of file OSGReal16.h.

References _h.

{
    return (_h & 0x7fff) == 0;
}

bool osg::Real16::isNan

(

)

const [inline]

Definition at line 686 of file OSGReal16.h.

References _h.

{
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 31 && m != 0;
}

bool osg::Real16::isInfinity

(

)

const [inline]

Definition at line 695 of file OSGReal16.h.

References _h.

{
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 31 && m == 0;
}

bool osg::Real16::isNegative

(

)

const [inline]

Definition at line 704 of file OSGReal16.h.

References _h.

{
    return (_h & 0x8000) != 0;
}

Real16 osg::Real16::posInf

(

)

[inline, static]

Definition at line 711 of file OSGReal16.h.

References _h.

{
    Real16 h;
    h._h = 0x7c00;
    return h;
}

Real16 osg::Real16::negInf

(

)

[inline, static]

Definition at line 720 of file OSGReal16.h.

References _h.

{
    Real16 h;
    h._h = 0xfc00;
    return h;
}

Real16 osg::Real16::qNan

(

)

[inline, static]

Definition at line 729 of file OSGReal16.h.

References _h.

{
    Real16 h;
    h._h = 0x7fff;
    return h;
}

Real16 osg::Real16::sNan

(

)

[inline, static]

Definition at line 738 of file OSGReal16.h.

References _h.

{
    Real16 h;
    h._h = 0x7dff;
    return h;
}

unsigned short osg::Real16::bits

(

)

const [inline]

Definition at line 747 of file OSGReal16.h.

References _h.

Referenced by osg::printBits(), and osg::BinaryDataHandler::putValue().

{
    return _h;
}

void osg::Real16::setBits

(

unsigned short

bits

)

[inline]

Definition at line 754 of file OSGReal16.h.

References _h.

Referenced by osg::BinaryDataHandler::getValue(), and osg::BinaryDataHandler::getValues().

{
    _h = bits;
}

short osg::Real16::convert

(

int

i

)

[static, private]

Definition at line 16555 of file OSGReal16.cpp.

References overflow().

Referenced by Real16().

{
    //
    // Our floating point number, f, is represented by the bit
    // pattern in integer i.  Disassemble that bit pattern into
    // the sign, s, the exponent, e, and the significand, m.
    // Shift s into the position where it will go in in the
    // resulting half number.
    // Adjust e, accounting for the different exponent bias
    // of float and half (127 versus 15).
    //

    register int s =  (i >> 16) & 0x00008000;
    register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
    register int m =   i        & 0x007fffff;

    //
    // Now reassemble s, e and m into a half:
    //

    if (e <= 0)
    {
    if (e < -10)
    {
        //
        // E is less than -10.  The absolute value of f is
        // less than REAL16_MIN (f may be a small normalized
        // float, a denormalized float or a zero).
        //
        // We convert f to a half zero.
        //

        return 0;
    }

    //
    // E is between -10 and 0.  F is a normalized float,
    // whose magnitude is less than REAL16_NRM_MIN.
    //
    // We convert f to a denormalized half.
    // 

    m = (m | 0x00800000) >> (1 - e);

    //
    // Round to nearest, round "0.5" up.
    //
    // Rounding may cause the significand to overflow and make
    // our number normalized.  Because of the way a half's bits
    // are laid out, we don't have to treat this case separately;
    // the code below will handle it correctly.
    // 

    if (m &  0x00001000)
        m += 0x00002000;

    //
    // Assemble the half from s, e (zero) and m.
    //

    return s | (m >> 13);
    }
    else if (e == 0xff - (127 - 15))
    {
    if (m == 0)
    {
        //
        // F is an infinity; convert f to a half
        // infinity with the same sign as f.
        //

        return s | 0x7c00;
    }
    else
    {
        //
        // F is a NAN; we produce a half NAN that preserves
        // the sign bit and the 10 leftmost bits of the
        // significand of f, with one exception: If the 10
        // leftmost bits are all zero, the NAN would turn 
        // into an infinity, so we have to set at least one
        // bit in the significand.
        //

        m >>= 13;
        return s | 0x7c00 | m | (m == 0);
    }
    }
    else
    {
    //
    // E is greater than zero.  F is a normalized float.
    // We try to convert f to a normalized half.
    //

    //
    // Round to nearest, round "0.5" up
    //

    if (m &  0x00001000)
    {
        m += 0x00002000;

        if (m & 0x00800000)
        {
        m =  0;        // overflow in significand,
        e += 1;        // adjust exponent
        }
    }

    //
    // Handle exponent overflow
    //

    if (e > 30)
    {
        overflow ();    // Cause a hardware floating point overflow;
        return s | 0x7c00;    // if this returns, the half becomes an
    }               // infinity with the same sign as f.

    //
    // Assemble the half from s, e and m.
    //

    return s | (e << 10) | (m >> 13);
    }
}

float osg::Real16::overflow

(

)

[static, private]

Definition at line 16538 of file OSGReal16.cpp.

Referenced by convert().

{
    volatile float f = 1e10;

    for (int i = 0; i < 10; i++)    
    f *= f;                // this will overflow before
                    // the for­loop terminates
    return f;
}

bool osg::Real16::selftest

(

)

[static, private]

Definition at line 16727 of file OSGReal16.cpp.

References REAL16_MAX, REAL16_MIN, REAL16_NRM_MIN, osg::testDenormalized(), and osg::testNormalized().

{
    testNormalized   ((float)  REAL16_MAX);
    testNormalized   ((float) -REAL16_MAX);
    testNormalized   ( 0.1f);
    testNormalized   (-0.1f);
    testNormalized   ( 0.5f);
    testNormalized   (-0.5f);
    testNormalized   ( 1.0f);
    testNormalized   (-1.0f);
    testNormalized   ( 2.0f);
    testNormalized   (-2.0f);
    testNormalized   ( 3.0f);
    testNormalized   (-3.0f);
    testNormalized   ( 17.0f);
    testNormalized   (-17.0f);
    testNormalized   ((float)  REAL16_NRM_MIN);
    testNormalized   ((float) -REAL16_NRM_MIN);
    testDenormalized ((float)  REAL16_MIN);
    testDenormalized ((float) -REAL16_MIN);
    testDenormalized ( 0.0f);
    testDenormalized (-0.0f);

    return true;
}

---

Member Data Documentation

unsigned short osg::Real16::_h [private]

Definition at line 221 of file OSGReal16.h.

Referenced by bits(), isDenormalized(), isFinite(), isInfinity(), isNan(), isNegative(), isNormalized(), isZero(), negInf(), operator float(), operator-(), operator=(), posInf(), qNan(), Real16(), round(), setBits(), and sNan().

const Real16::uif osg::Real16::_toFloat [static, private]

Definition at line 223 of file OSGReal16.h.

Referenced by operator float().

const unsigned short osg::Real16::_eLut [static, private]

Definition at line 224 of file OSGReal16.h.

Referenced by Real16().

const bool osg::Real16::_itWorks [static, private]

Initial value:

    selftest()

Definition at line 225 of file OSGReal16.h.

---

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

• OSGReal16.h
• OSGReal16.cpp