SYS/SYS_Floor.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      PROGRAMMER
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        SYS_Floor (C++)
 *
 * COMMENTS:    Fast floating point floor function (faster than floorf)
 *              There are two versions, a fast inline and a slower (but
 *              still faster than floorf) out-lined function.
 *
 */

#ifndef __SYS_Floor_H__
#define __SYS_Floor_H__

#include "SYS_API.h"
#include <math.h>
#include "SYS_Types.h"

SYS_API extern fpreal32 SYSfloor(fpreal32 val);
SYS_API extern fpreal32 SYSceil(fpreal32 val);
SYS_API extern fpreal32 SYSfrac(fpreal32 val);
SYS_API extern fpreal64 SYSfrac(fpreal64 val);
SYS_API extern fpreal64 SYSniceNumber(fpreal64 num, int digits = 6);

static inline fpreal32 SYSniceNumber(fpreal32 num, int digits = 6)
                       { return (fpreal32)SYSniceNumber((fpreal64)num, digits);}

static inline fpreal64 SYSfloor(fpreal64 a)     { return floor(a); }
static inline fpreal64 SYSceil(fpreal64 a)      { return ceil(a); }

static inline int32
SYSfastFloor(fpreal32 a) { return a < 0 ? (int32)a - 1 : (int32)a; }

static inline int64
SYSfastFloor(fpreal64 a) { return a < 0 ? (int64)a - 1 : (int64)a; }

//
// The following function splits a floating point value into its fractional and
// integer components.  The integer returned is the floor() of the fractional
// value, while the fractional component is guaranteed to always be in the
// range [0, 1).  This is different from (val - floor(val)) which can cause
// problems if the value is very close to -0.
//
SYS_API extern void     SYSsplitFloat(fpreal32 &val, int &ival);
SYS_API extern void     SYSsplitFloat(fpreal32 &val, fpreal32 &ival);

// fastSplitFloat() is not as correct as the above code.  Using the fast
// version, you can get somewhat unexpected results.  However, in many cases,
// it's quite acceptable to get these results.
//   a) Denormalization of -ve values close to zero (i.e. -1e-10) will result
//      in the fractional value being 1.0 exactly and the integer value = -1
static inline void
SYSfastSplitFloat(fpreal32 &val, int32 &ival)
{
    ival = SYSfastFloor(val);
    val -= (fpreal32)ival;
}

static inline void
SYSfastSplitFloat(fpreal64 &val, int64 &ival)
{
    ival = SYSfastFloor(val);
    val -= (fpreal64)ival;
}

inline fpreal32
SYSfloorIL(fpreal32 val)
{
    SYS_FPReal32Union    tmp;
    register unsigned    shift;

    tmp.fval = val;
    shift = (tmp.uval >> 23) & 0xff;

    if (shift < 0x7f)
    {
        tmp.fval = (tmp.uval > 0x80000000) ? -1.0F : 0.0F;
    }
    else if (shift < 0x96)
    {
        register unsigned mask = 0xffffffff << (0x96 - shift);
        if (tmp.uval & 0x80000000)
        {
            if ((tmp.uval & ~mask) & 0x7fffff)
            {
                tmp.uval &= mask;
                tmp.fval--;
            }
        }
        else tmp.uval &= mask;
    }
    return tmp.fval;
}

inline fpreal64 SYSfloorIL(fpreal64 val) { return SYSfloor(val); }
inline fpreal32 SYSceilIL(fpreal32 val) { return SYSceil(val); }
inline fpreal64 SYSceilIL(fpreal64 val) { return SYSceil(val); }

inline fpreal32
SYSfracIL(fpreal32 val)
{
    // On Intel chips, val may be a double precision register value.  In this
    // case, a small value less than zero will cause the fractional result to
    // be outside the range [0-1), which is obviously invalid.  Thus, we have
    // to have special code to handle this case properly.  On non-intel chips,
    // which support floating point operations, we can simply de-normalize the
    // value and return the fractional component properly.
#if defined(WIN32) || defined(LINUX)
    val = val - SYSfloorIL(val);
    return (val < 0 || val >= 1) ? 0 : val;
#else
    val += 1;           // Normalize fpreal32 first
    return val - SYSfloorIL(val);
#endif
}

inline fpreal64
SYSfracIL(fpreal64 val)
{
    return SYSfrac(val);
}

inline fpreal32
SYSrint(fpreal32 val)
{
    return SYSfloorIL(val + 0.5F);
}

inline fpreal64
SYSrint(fpreal64 val)
{
    return SYSfloor(val + 0.5);
}


#endif

---