cFloat.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFloat_H
#define _INC_cFloat_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cTypes.h"
#include "cBits.h"
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
 
namespace Gray
{
        class GRAYCORE_LINK cFloat32
        {
        public:
                cUnion32 m_v; 
 
                static const UINT32 k_uOne = 0x3f800000;        
                static const UINT32 k_uTwo = 0x40000000;        
 
                static const UINT32 k_SIGN_MASK = 0x80000000;   
 
                static const UINT32 k_EXP_MASK = 0x7f800000;    
 
                static const UINT32 k_MANT_MASK = 0x007fffff;   
                static const UINT32 k_MANT_BITS = 23;                   
 
        public:
                cFloat32() noexcept
                {
                        // undefined.
                }
                cFloat32(float f) noexcept
                {
                        m_v.u_f = f;
                }
 
                void put_Bits(UINT32 dw) noexcept
                {
                        m_v.u_dw = dw;
                }
 
                static inline UINT32 toBits(float src) noexcept
                {
                        UINT32 dst = 0;
                        STATIC_ASSERT(sizeof(src) == sizeof(dst), toBits);
                        ::memcpy(&dst, &src, sizeof(dst));
                        return dst;
                }
                static inline float fromBits(UINT32 src) noexcept
                {
                        float dst = 0;
                        STATIC_ASSERT(sizeof(src) == sizeof(dst), fromBits);
                        ::memcpy(&dst, &src, sizeof(dst));
                        return dst;
                }
 
                // bool get_Negative() const
                // short get_Exponent() const
                UINT32 get_Mantissa() const noexcept
                {
                        return (m_v.u_dw & k_MANT_MASK);
                }
 
                UNITTEST_FRIEND(cFloat);
        };
 
        class GRAYCORE_LINK cFloat64
        {
 
        public:
                cUnion64 m_v;   
 
                static const UINT64 k_SIGN_MASK = CUINT64(80000000, 00000000);          
 
                static const UINT64 k_EXP_MASK = CUINT64(7FF00000, 00000000);           
 
                static const UINT64 k_MANT_MASK = CUINT64(000FFFFF, FFFFFFFF);          
                static const UINT32 k_MANT_BITS = 52;                                                           
 
        public:
                cFloat64() noexcept
                {
                        // undefined value.
                }
                cFloat64(double d) noexcept
                {
                        m_v.u_d = d;
                }
 
                void put_Bits(UINT64 qw) noexcept
                {
                        m_v.u_qw = qw;
                }
 
                static inline UINT64 toBits(double src) noexcept
                {
                        UINT64 dst;
                        STATIC_ASSERT(sizeof(src) == sizeof(dst), toBits);
                        ::memcpy(&dst, &src, sizeof(dst));
                        return dst;
                }
                static inline double fromBits(UINT64 src) noexcept
                {
                        double dst;
                        STATIC_ASSERT(sizeof(src) == sizeof(dst), fromBits);
                        ::memcpy(&dst, &src, sizeof(dst));
                        return dst;
                }
 
#if 0
                // bool get_Negative() const
                short get_Exponent() const noexcept
                {
                        // TODO FIX SIGN
                        return (short)((m_v.u_qw & k_EXP_MASK) >> sdf);
                }
#endif
                UINT64 get_Mantissa() const noexcept
                {
                        return (m_v.u_qw & k_MANT_MASK);
                }
        };
 
        // class cFloat80 // long double or "double double" NOT in M$?
};
 
#endif // _INC_cFloat_H