cFloatEst.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFloatEst_H
#define _INC_cFloatEst_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#if _MSC_VER >= 1000
// #pragma warning(disable:4275)        // stupid linkage warning.
#endif // _MSC_VER >= 1000
 
#include "Calc.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cFloat.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cFloatEst);
 
#ifdef _MSC_VER
#pragma check_stack(off)
#if _MSC_VER >= 1300
#pragma runtime_checks( "", off )
#endif
#endif
 
        class cFloatEst : public cFloat32
        {
 
        public:
 
#ifdef USE_FLOAT_IEEE
                static inline float Sqrt(float n) noexcept
                {
                        UINT32 val = toBits(n);
                        val >>= 1;
                        val += (k_uOne >> 1);
                        return fromBits(val);
                }
                static inline float pow2(int iPow)  
                {
                        ASSERT((iPow >= -127) && (iPow <= FLT_MAX_EXP));        // FLT_MIN_EXP ??
                        UINT32 xd = (iPow + 127) << k_MANT_BITS;
                        return fromBits(xd);
                }
                static inline int ifloor_log2(float x)
                {
                        // Get the integer exponent.
                        // Same as (int)floorf(log2f(x)) its very precise and fast
                        UINT32 xd = toBits(x);
                        int nExp = (xd & k_EXP_MASK) >> k_MANT_BITS;
                        nExp -= 127;
                        return nExp;
                }
                static inline int iceil_log2(float x)
                {
                        // Get the integer exponent.
                        // Same as (int)ceilf(log2f(x)) its very precise and fast
                        UINT32 xd = toBits(x);
                        int nExp = (xd & k_EXP_MASK) >> k_MANT_BITS;
                        if (xd & k_MANT_MASK)
                                nExp -= 126;
                        else
                                nExp -= 127;
                        return nExp;
                }
 
#else // USE_FLOAT_IEEE
 
                static inline float Sqrt(float n)
                {
                        return ::sqrtf(n);
                }
                static inline float pow2(int iPow)
                {
                        return Calc::Pow<float>(2.0f, (float)iPow);
                }
                static inline int ifloor_log2(float x)
                {
                        return (int)::ceilf(Calc::Log(x) * cTypeF<float>::k_Log2e);
                }
                static inline int iceil_log2(float x)
                {
                        return (int)::floorf(Calc::Log(x) * cTypeF<float>::k_Log2e);
                }
#endif // USE_FLOAT_IEEE
 
                static inline int ifloor(float f)
                {
                        // Round down. just cast to int ???
                        return (int) ::floorf(f);       // FIX THIS ?
                }
                static inline int iceil(float f)
                {
                        // Round up
                        return (int) ::ceilf(f);
                }
                static inline bool IsInteger(float f)
                {
                        return f == (int)f;
                }
 
                UNITTEST_FRIEND(cFloatEst);
        };
 
#ifdef _MSC_VER
#pragma check_stack
#if _MSC_VER >= 1300
#pragma runtime_checks( "", restore )
#endif
#endif // _MSC_VER
 
        class cFloat32SinTable  // cSingletonStatic ? cValueCurve
        {
 
        public:
                cArrayVal<float> m_Values;      
 
        public:
                void CreateSinTable(int iTicks);
                float Sin(RADIANf_t fVal);
                // float Cos( RADIANf_t fVal );
                // float Tan( RADIANf_t fVal );
        };
 
};
 
#endif // _INC_cFloat_H