Edison.X. Blog

[回目錄]

IEEE754 特殊值保留

IEEE754 裡面，有幾個欄位之特別值是留給，要表達出特殊值用的，

多為使用的大概是下面幾項 (裡面提到 e，即代表 Exponment Field 所使用 bit 數)

(1) 零

Exponment 與 Mantissa 欄位均為 0 時才為零。注意，依 IEEE754 規格而言，有正負零之分。

(2) 無窮大

Exponment = (2^e) - 1，Mantissa = 0。依正負號而言，也有正無窮大與負無窮大。

(3) NAN (Not A Number)

Exponment = (2^e) - 1，Mantissa 不為 0。

(4) 判斷是否  正規化

Exponment = [1, (2^e) - 2 ]，Mantissa 不限定 (可為零，也可不為零)。

(5) 判斷是否  非正規化

Exponment = 0，Mantissa 不為零。

上述五個判別可發現，「正規化」與「非正規化」並非為補集關係，意指，

若寫出了一函式 int is_normalize(float x); 

要判斷「非正規化」，不可這麼調用

float x;
int is_non_normalize = ! (is_normalize(x));

C/C++ 浮點數出現 -1.#QNAN ?

C/C++ 在做浮點數運算後，有幾個較特別的符號可能會看到，如 NAN、INF、IND，

若是出現 SNAN、QNAN、SINF、QINF、SIND、QIND 發生原因一樣，

唯資料型態不一樣，這裡做個紀錄

-1.#INF 

infinite，無窮大；有幾個操作可能產生

INF +/ INF

0 * INF

x/0 , INF / INF

x % 0 , INF % x

x = DBL_MAX * 2 , overflow

1.#NAN

Not a number，不是一個數字；有幾個操作可能產生

x < 0 , sqrt(x) , log(x)

x = DBL_MAX * 2 , overflow

1.#IND : 

indefinite，未定值；有幾個操作可能產生

fmod(x, 0)

fmod(INF, 0)

INF / INF

NAN 在做比較時要注意，若一數 double x 為 NAN

x==x 傳回結果 為false，C++ 裡有提供一份 _fpclass 可測得這些特殊數值，

詳細可看這篇 blog - IEEE floating point exceptions in C++ ，

裡面也提了一份 demo code 供參考。

另上述有些操作有重覆之處，原因乃在於 compiler 對於這部份之定義留有權力，

但可確定的是，出現 INF、NAN、IND 的情況，在運算過程中必發生不正常之情形，

於此不再深入探討。

設定 / 判斷特殊值

這份 C code，主要是拿來設定、判斷其浮點數之特殊值。

其中主用都在調用之前寫過的四個函數

void   Get754Field32(float v, uint* sign, uint* exp, uint* mat);
void   Get754Field64(double v, uint* sign, uint* exp, ull* mat);
float  Set754Field32(uint sign, uint exp, uint mat);
double Set754Field64(uint sign, uint exp, ull  mat);

且由於這次使用之函式較多，也以分開編譯方式進行，

同時把之前寫過的都塞進來。

xFloating.h

/*******************************************************************/
/*                                                                 */
/*     filename : xFloating.h                                      */
/*     author   : edison.shih/edisonx                              */
/*     compiler : Visual C++ 2008                                  */
/*     date     : 2011.03.07                                       */
/*                                                                 */
/*         A.L.L.      R.I.G.H.T.S.     R.E.S.E.R.V.E.             */
/*                                                                 */
/*******************************************************************/

#ifndef FLOATING_SPECIAL_H__
#define FLOATING_SPECIAL_H__

///////////////////////////////////////////////////////////////////

typedef unsigned long long ull;
typedef unsigned uint;

//--------------------------------------------------
void bin32(void* v); // 2 進位方式顯示32 位元資料
void bin64(void* v); // 2 進位方式顯示64 位元資料
void hex32(void* v); //16 進位方式顯示32 位元資料
void hex64(void* v); //16 進位方式顯示64 位元資料
//--------------------------------------------------
void   Get754Value32(float  v, int* sign, int* exp, float*  mat);
void   Get754Value64(double v, int* sign, int* exp, double* mat);
int  Set754Value32(float*  v,  int sign, int exp, float  mat);
int  Set754Value64(double* v,  int sign, int exp, double mat);

///////////////////////////////////////////////////////////////////

//--------------------------------------------------
void   Get754Field32(float v, uint* sign, uint* exp, uint* mat);
void   Get754Field64(double v, uint* sign, uint* exp, ull* mat);
float  Set754Field32(uint sign, uint exp, uint mat);
double Set754Field64(uint sign, uint exp, ull  mat);
//--------------------------------------------------
// 特殊值判斷
int   IsNan32(float   v);
int   IsNan64(double  v);
int   IsInf32(float   v);
int   IsInf64(double  v);
int   IsZero32(float  v);
int   IsZero64(double v);

int   IsNormalize32(float  v);
int   IsNormalize64(double v);
int   IsNoNormalize32(float v);
int   IsNoNormalize64(float v);

int   IsNormalizeMin32(float  v); // 正規化最小32 bits (正數)
int   IsNormalizeMin64(double v); // 正規化最小64 bits (正數)
int   IsNormalizeMax32(float v);  // 正規化最大32 bits (正數)
int   IsNormalizeMax64(double v); // 正規化最大64 bits (正數)

int   IsNoNormalizeMin32(float  v); // 非正規化最小32 bits (正數)
int   IsNoNormalizeMin64(double v); // 非正規化最小64 bits (正數)
int   IsNoNormalizeMax32(float v);  // 非正規化最大32 bits (正數)
int   IsNoNormalizeMax64(double v); // 非正規化最大64 bits (正數)

///////////////////////////////////////////////////////////////////

//--------------------------------------------------
// 特殊值設定
float  SetNan32();
double SetNan64();
float  SetInf32();
double SetInf64();
float  SetZero32();
double SetZero64();

float  SetNormalizeMin32();
double SetNormalizeMin64();
float  SetNormalizeMax32();
double SetNormalizeMax64();

float  SetNoNormalizeMin32();
double SetNoNormalizeMin64();
float  SetNoNormalizeMax32();
double SetNoNormalizeMax64();

///////////////////////////////////////////////////////////////////
#endif

xFloating.c

/*******************************************************************/
/*                                                                 */
/*     filename : xFloating.c                                      */
/*     author   : edison.shih/edisonx                              */
/*     compiler : Visual C++ 2008                                  */
/*     date     : 2011.03.07                                       */
/*                                                                 */
/*         A.L.L.      R.I.G.H.T.S.     R.E.S.E.R.V.E.             */
/*                                                                 */
/*******************************************************************/

#include <stdio.h>
#include "xFloating.h"

///////////////////////////////////////////////////////////////////
// macro define

//--------------------------------------------------
#define FLT_SIGN_BITS 1           // float signed     field using bit
#define FLT_EXP_BITS  8           // float exponment  field using bits
#define FLT_MAT_BITS  23          // float mantissa   field using bits

#define FLT_SIGN_MASK 0x80000000U // float signed bit
#define FLT_EXP_MASK  0x7f800000U // float exponment bits
#define FLT_MAT_MASK  0x007fffffU // float mantissa bits

#define DBL_SIGN_BITS 1           // double signed    field using bit
#define DBL_EXP_BITS  11          // double exponment field using bits
#define DBL_MAT_BITS  52          // double mantissa  field using bits

#define DBL_SIGN_MASK 0x8000000000000000ULL
#define DBL_EXP_MASK  0x7ff0000000000000ULL
#define DBL_MAT_MASK  0x000fffffffffffffULL

#define FLT_BASE_VAL  ((1U  <<(FLT_EXP_BITS-1))-1U  ) // float  base value
#define DBL_BASE_VAL  ((1ULL<<(DBL_EXP_BITS-1))-1ULL) // double base value

///////////////////////////////////////////////////////////////////
// 資料顯示相關函式

//--------------------------------------------------
//2 進位方式顯示32 位元資料
void bin32(void* v)
{
     unsigned mask=0x80000000U;
     unsigned value = *(unsigned*)v;
     while(mask){
           printf("%d", (mask&value)!=0U);
           mask>>=1;
     }
}
//--------------------------------------------------
//2 進位方式顯示64 位元資料
void bin64(void* v)
{
     unsigned long long mask=0x8000000000000000ULL;
     unsigned long long value = *(unsigned long long*)v;
     while(mask){
           printf("%d", (mask&value)!=0ULL);
           mask>>=1;
     }
}
//--------------------------------------------------
//16 進位方式顯示32 位元資料
void hex32(void* v)
{
     printf("%08x", *(unsigned*)v);
}
//--------------------------------------------------
//16 進位方式顯示64 位元資料
void hex64(void* v)
{
     unsigned a[2];
     *(unsigned long long*)a=*(unsigned long long*)v;
     printf("%08x%08x", a[1], a[0]);
}

///////////////////////////////////////////////////////////////////
// 以16 進位方式取得/設定ieee754 欄位數值

//--------------------------------------------------
// 將32 位浮點數v , 拆成signed, exp, mat
void Get754Field32(float v, uint* sign, uint* exp, uint* mat)
{
     uint value = *(uint*)&v; // dump 到unsigned
     *sign = (value & FLT_SIGN_MASK) >> (FLT_MAT_BITS + FLT_EXP_BITS);
     *exp  = (value & FLT_EXP_MASK) >> (FLT_MAT_BITS);
     *mat  = (value & FLT_MAT_MASK);
}
//--------------------------------------------------
// 將64 位浮點數v , 拆成signed, exp, mat
void Get754Field64(double v, uint* sign, uint* exp, ull* mat)
{
     ull value = *(ull*)&v;
     *sign = (uint)((value & DBL_SIGN_MASK) >> (DBL_MAT_BITS + DBL_EXP_BITS));
     *exp  = (uint)((value & DBL_EXP_MASK ) >> (DBL_MAT_BITS));
     *mat  =       ( value & DBL_MAT_MASK );
}
//--------------------------------------------------
// 依sign, exp , mat 設32 位元浮點數
float  Set754Field32(uint sign, uint exp, uint mat)
{
     unsigned x;
     x = (sign << (FLT_MAT_BITS + FLT_EXP_BITS) ) |
           (exp  << FLT_MAT_BITS) |
           (mat);
     return *(float*)&x;
}
//--------------------------------------------------
// 依sign, exp , mat 設64 位元浮點數
double Set754Field64(uint sign, uint exp, ull mat)
{
     ull x;
     x = ((ull)sign << (DBL_MAT_BITS + DBL_EXP_BITS) ) |
           ((ull)exp  << DBL_MAT_BITS) |
           (mat);
     return *(double*)&x;
}

///////////////////////////////////////////////////////////////////
// 以正規化格式設定/取得ieee754 欄位數值

//--------------------------------------------------
// 單精度取得正規化之欄位
void   Get754Value32(float  v, int* sign, int* exp, float*  mat)
{
     float pwr=0.5f;
     uint value   = *(uint*)&v;

     *sign = (int)((value & FLT_SIGN_MASK) >> (FLT_MAT_BITS + FLT_EXP_BITS));
     *exp  = (int)((value & FLT_EXP_MASK) >> FLT_MAT_BITS  ) - FLT_BASE_VAL;

     // calculate mantissa field

     *mat=1.0f, value<<=(FLT_SIGN_BITS + FLT_EXP_BITS);
     while(value){
           if(value & FLT_SIGN_MASK) *mat+=pwr;
           pwr*=0.5f;
           value<<=1;
     }
}
//--------------------------------------------------
// 倍精度取得正規化之欄位
void   Get754Value64(double v, int* sign, int* exp, double* mat)
{
     double pwr=0.5;
     ull value   = *(ull*)&v;

     *sign = (int)((value & DBL_SIGN_MASK) >> (DBL_MAT_BITS + DBL_EXP_BITS));
     *exp  = (int)((value & DBL_EXP_MASK) >> DBL_MAT_BITS  ) - DBL_BASE_VAL;

     // calculate mantissa field
     *mat=1.0, value<<=(DBL_SIGN_BITS + DBL_EXP_BITS);
     while(value){
           if(value & DBL_SIGN_MASK) *mat+=pwr;
           pwr*=0.5;
           value<<=1;
     }
}
//--------------------------------------------------
// 單精度正規化數值寫入欄位, 成功傳回,失敗傳
int Set754Value32(float* f, int sign, int exp, float  mat)
{
     uint  *pv =  (uint*)f;
     uint    m = *(uint*)&mat;
     uint mask =  (1U<<(FLT_MAT_BITS-1));

     // error defect
     exp+=FLT_BASE_VAL;
     if(exp<0 || exp>= (1U << FLT_EXP_BITS))return 0;
     if(mat>=2.0f || mat<1.0f) return 0;
     *pv=0U;

     // set sign and exp
     if(sign) *pv|=FLT_SIGN_MASK;
     *pv|=(exp << FLT_MAT_BITS);

     // cal and set mantissa
     mat-=1.0f;
     while(mask && mat!=0.0f) {
           if(mask & m) *pv|=mask;
           mat*=2.0f;
           if(mat>1.0f) mat-=1.0f;        
           mask>>=1;
     }
     return 1;
}
//--------------------------------------------------
// 倍精度正規化數值寫入欄位, 成功傳回,失敗傳
int Set754Value64(double* d,int sign, int exp, double mat)
{
     ull  *pv =  (ull*)d;
     ull    m = *(ull*)&mat;
     ull mask =  (1ULL<<(DBL_MAT_BITS-1));

     // error defect
     exp+=DBL_BASE_VAL;
     if(exp<0 || exp>= (1ULL << DBL_EXP_BITS))return 0;
     if(mat>=2.0 || mat<1.0) return 0;
     *pv=0ULL;

     // set sign and exp
     if(sign) *pv|=DBL_SIGN_MASK;
     *pv|=((ull)exp << DBL_MAT_BITS);

     // cal and set mantissa
     mat-=1.0; 
     while(mask && mat!=0.0) {
           if(mask & m) *pv|=mask;
           mat*=2.0;
           if(mat>1.0) mat-=1.0;     
           mask>>=1;
     }
     return 1;
}

///////////////////////////////////////////////////////////////////
// 特殊值之判斷

//--------------------------------------------------
// 判斷32 位浮點數是否為NAN
int IsNan32(float   v)
{
     uint sign, exponment, mantissa;
     uint e = (1U << ( FLT_EXP_BITS )) - 1U;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (e==exponment && mantissa!=0U);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為NAN
int   IsNan64(double  v)
{
     uint sign, exponment;
     ull  mantissa;
     uint e = (1U << ( DBL_EXP_BITS )) - 1U;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (e==exponment && mantissa!=0ULL);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為infinte
int IsInf32(float   v)
{
     uint sign, exponment, mantissa;
     uint e = (1U << ( FLT_EXP_BITS )) - 1U;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (e==exponment && mantissa==0U);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為infinte
int IsInf64(double  v)
{
     uint sign, exponment;
     ull  mantissa;
     uint e = (1U << ( DBL_EXP_BITS )) - 1U;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (e==exponment && mantissa==0ULL);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為+-0
int IsZero32(float  v)
{
     uint x = *(uint*)&v;
     return (x==0U || x==FLT_SIGN_MASK);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為+-0
int   IsZero64(double v)
{
     ull x = *(ull*)&v;
     return (x==0U || x==DBL_SIGN_MASK);
}
//--------------------------------------------------
// 判斷32 位浮點數是否normalize
int   IsNormalize32(float  v)
{
     uint sign, exponment, mantissa;
     uint e = (1U << ( FLT_EXP_BITS )) - 2U;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment>=1U && exponment<=e);
}
//--------------------------------------------------
// 判斷64 位浮點數是否normalize
int   IsNormalize64(double v)
{
     uint sign, exponment;
     ull  mantissa;
     uint e = (1U << ( DBL_EXP_BITS )) - 2U;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment>=1U && exponment<=e);
}
//--------------------------------------------------
// 判斷32 位浮點數是否non-normalize
int   IsNoNormalize32(float v)
{
     uint sign, exponment, mantissa;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa!=0U);
}
//--------------------------------------------------
// 判斷64 位浮點數是否non-normalize
int   IsNoNormalize64(float v)
{
     uint sign, exponment;
     ull  mantissa;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa!=0ULL);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為正規化之最小數(可正可負)
int   IsNormalizeMin32(float  v)
{
     uint sign, exponment, mantissa;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment==1U && mantissa==0U);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為正規化之最小數(可正可負)
int   IsNormalizeMin64(double v)
{
     uint sign, exponment;
     ull  mantissa;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment==1U && mantissa==0ULL);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為正規化之最大數(可正可負)
int   IsNormalizeMax32(float v)
{
     uint sign, exponment, mantissa;
     uint e = (1U << FLT_EXP_BITS) - 2U;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment==e && mantissa==FLT_MAT_MASK);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為正規化之最大數(可正可負)
int   IsNormalizeMax64(double v)
{
     uint sign, exponment;
     ull  mantissa;
     uint e = (1U << DBL_EXP_BITS) - 2U;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment==e && mantissa==DBL_MAT_MASK);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為非正規化之最小數(可正可負)
int   IsNoNormalizeMin32(float  v)
{
     uint sign, exponment, mantissa;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa==1U);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為非正規化之最小數(可正可負)
int   IsNoNormalizeMin64(double v)
{
     uint sign, exponment;
     ull  mantissa;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa==1ULL);
}
//--------------------------------------------------
// 判斷32 位浮點數是否為非正規化之最大數(可正可負)
int   IsNoNormalizeMax32(float v)
{
     uint sign, exponment, mantissa;
     Get754Field32(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa==FLT_MAT_MASK);
}
//--------------------------------------------------
// 判斷64 位浮點數是否為非正規化之最大數(可正可負)
int   IsNoNormalizeMax64(double v)
{
     uint sign, exponment;
     ull mantissa;
     Get754Field64(v, &sign, &exponment, &mantissa);
     return (exponment==0U && mantissa==DBL_MAT_MASK);
}

///////////////////////////////////////////////////////////////////
// 特殊值之設定

//--------------------------------------------------
// 傳回32 位元NAN
float  SetNan32()
{
     uint e = (1U << FLT_EXP_BITS)-1U;
     return Set754Field32(0U, e, 1U);
}
//--------------------------------------------------
// 傳回64 位元NAN
double SetNan64()
{
     uint e = (1U << DBL_EXP_BITS)-1U;
     return Set754Field32(0U, e, 1ULL);
}
//--------------------------------------------------
// 傳回32 位元+INF
float  SetInf32()
{
     uint e = (1U << FLT_EXP_BITS)-1U;
     return Set754Field32(0U, e, 0U);
}
//--------------------------------------------------
// 傳回64 位元+INF
double SetInf64()
{
     uint e = (1U << DBL_EXP_BITS)-1U;
     return Set754Field32(0U, e, 0ULL);
}
//--------------------------------------------------
// 傳回32 位元+0
float  SetZero32()
{
     uint zero = 0U;
     return *(float*)&zero;
}
//--------------------------------------------------
// 傳回64 位元+0
double SetZero64()
{
     ull zero = 0ULL;
     return *(ull*)&zero;
}
//--------------------------------------------------
// 傳回32 位元正規化最小值(正數)
float  SetNormalizeMin32()
{
     return Set754Field32(0U, 1U, 0U);
}
//--------------------------------------------------
// 傳回64 位元正規化最小值(正數)
double SetNormalizeMin64()
{
     return Set754Field64(0U, 1U, 0ULL);
}
//--------------------------------------------------
// 傳回32 位元正規化最大值(正數)
float  SetNormalizeMax32()
{
     uint e = (1U << FLT_EXP_BITS) - 2U;
     return Set754Field32(0U, e, FLT_MAT_MASK);
}
//--------------------------------------------------
// 傳回64 位元正規化最大值(正數)
double SetNormalizeMax64()
{
     uint e = (1U << DBL_EXP_BITS) - 2U;
     return Set754Field64(0U, e, DBL_MAT_MASK);
}
//--------------------------------------------------
// 傳回32 位元非正規化最小值(正數)
float  SetNoNormalizeMin32()
{
     return Set754Field32(0U, 0U, 1U);
}
//--------------------------------------------------
// 傳回64 位元非正規化最小值(正數)
double SetNoNormalizeMin64()
{
     return Set754Field64(0U, 0U, 1ULL);
}
//--------------------------------------------------
// 傳回64 位元非正規化最大值(正數)
float  SetNoNormalizeMax32()
{
     return Set754Field32(0U, 0U, FLT_MAT_MASK);
}
//--------------------------------------------------
// 傳回64 位元非正規化最大值(正數)
double SetNoNormalizeMax64()
{
     return Set754Field64(0U, 0U, DBL_MAT_MASK);
}

///////////////////////////////////////////////////////////////////

xFloatingMain.c

/*******************************************************************/
/*                                                                 */
/*     filename : xFloatingMain.c                                  */
/*     author   : edison.shih/edisonx                              */
/*     compiler : Visual C++ 2008                                  */
/*     date     : 2011.03.07                                       */
/*                                                                 */
/*         A.L.L.      R.I.G.H.T.S.     R.E.S.E.R.V.E.             */
/*                                                                 */
/*******************************************************************/

#include <stdio.h>
#include <float.h>
#include "xFloating.h"

int main()
{
     double dnan, dinf;
     double dmax, dmin;
     double dnmax, dnmin;
     double dzero;

     float fnan, finf;
     float fmax, fmin;
     float fnmax, fnmin;
     float fzero;

     // --------------------------------------------------------------------
     dnan = SetNan64();
     dinf = SetInf64();
     dmax = SetNormalizeMax64();
     dmin = SetNormalizeMin64();
     dnmax = SetNoNormalizeMax64();
     dnmin = SetNoNormalizeMin64();
     dzero = SetZero64();
    
     printf("nan               : %+.15e(check : %d)\n", dnan,   IsNan64(dnan));
     printf("inf               : %+.15e(check : %d)\n", dinf,   IsInf64(dinf));
     printf("max               : %+.15e(check : %d)\n", dmax,  IsNormalizeMax64(dmax));
     printf("DBL_MAX           : %+.15e\n", DBL_MAX);
     printf("min               : %+.15e(check : %d)\n", dmin,  IsNormalizeMin64(dmin));
     printf("DBL_MIN           : %+.15e\n", DBL_MIN);
     printf("non-normalize max : %+.15e(check : %d)\n", dnmax, IsNoNormalizeMax64(dnmax));
     printf("non-normalize nmin: %+.15e(check : %d)\n", dnmin, IsNoNormalizeMin64(dnmin));
     printf("zero              : %+.15e(check : %d)\n", dzero, IsZero64(dzero));
     puts("\n------------------\n");

     // --------------------------------------------------------------------
     fnan = SetNan32();
     finf = SetInf32();
     fmax = SetNormalizeMax32();
     fmin = SetNormalizeMin32();
     fnmax = SetNoNormalizeMax32();
     fnmin = SetNoNormalizeMin32();
     fzero = SetZero32();


     printf("nan               : %+.15e(check : %d)\n", fnan,   IsNan32(fnan));
     printf("inf               : %+.15e(check : %d)\n", finf,   IsInf32(finf));
     printf("max               : %+.15e(check : %d)\n", fmax,  IsNormalizeMax32(fmax));
     printf("FLT_MAX           : %+.15e\n", FLT_MAX);
     printf("min               : %+.15e(check : %d)\n", fmin,  IsNormalizeMin32(fmin));
     printf("DBL_MIN           : %+.15e\n", FLT_MIN);
     printf("non-normalize max : %+.15e(check : %d)\n", fnmax, IsNoNormalizeMax32(fnmax));
     printf("non-normalize nmin: %+.15e(check : %d)\n", fnmin, IsNoNormalizeMin32(fnmin));
     printf("zero              : %+.15e(check : %d)\n", fzero, IsZero32(fzero));
     return 0;
}

執行結果 (恕縮排全跑掉)

nan               : -1.#QNAN0000000000e+000(check : 1)
inf               : -1.#INF00000000000e+000(check : 1)
max               : +1.797693134862316e+308(check : 1)
DBL_MAX           : +1.797693134862316e+308
min               : +2.225073858507201e-308(check : 1)
DBL_MIN           : +2.225073858507201e-308
non-normalize max : +2.225073858507201e-308(check : 1)
non-normalize nmin: +4.940656458412465e-324(check : 1)
zero              : +0.000000000000000e+000(check : 1)

------------------

nan               : +1.#QNAN0000000000e+000(check : 1)
inf               : +1.#INF00000000000e+000(check : 1)
max               : +3.402823466385289e+038(check : 1)
FLT_MAX           : +3.402823466385289e+038
min               : +1.175494350822288e-038(check : 1)
DBL_MIN           : +1.175494350822288e-038
non-normalize max : +1.175494210692441e-038(check : 1)
non-normalize nmin: +1.401298464324817e-045(check : 1)
zero              : +0.000000000000000e+000(check : 1)

[回目錄]