c语言定义小数无穷小,OC中常用的数学函数以及浮点处理函数
在編程中我們總要進行一些數學運算以及數字處理，尤其是浮點數的運算和處理，這篇文章主要介紹C語言下的數學庫。而其他語言中的數學庫函數的定義以及最終實現也是通過對C數學庫的調用來完成的，其內容大同小異，因此就不在這里介紹了。
C語言標準庫中的math.h定義了非常多的數學運算和數字處理函數。這些函數大部分都是在C89標準中定義的，而有些C99標準下的函數我會特殊的說明，同時因為不同的編譯器下的C標準庫中有些函數的定義有差別，我也會分別的說明。
數字的范圍
整型
整型用來存儲整數數值，它按存儲的字節長短分為：字符型，短整型，整型，長整型。 所有類型的存儲長度都是定長的。既然類型是定長的就有一個最大最小可表示的范圍，對于整型來說各種類型的最大最小的定義可以在limits.h中找到。下面表格列出了不同類型的存儲長度和最大最小值：
類型字節數最小值宏定義最大值宏定義備注char1-2^7SCHAR_MIN2^7-1SCHAR_MAX
unsigned char10UCHAR_MIN2^8-1UCHAR_MAX
short2-2^15SHRT_MIN2^15-1SHRT_MAX
unsigned short20USHRT_MIN2^16-1USHRT_MAX
int4?-2^31INT_MIN2^31-1INT_MAX
unsinged int4?0UINT_MIN2^32-1UINT_MAX
long4?-2^31LONG_MIN2^31-1LONG_MAX
unsigned long4?0ULONG_MIN2^32-1ULONG_MAX
long long8-2^63LLONG_MIN2^63-1LLONG_MAXC99
unsigned long long80ULLONG_MIN2^64-1ULLONG_MAXC99
對于int和long類型來說，二者的長度是依賴于操作系統的字長或者機器的字長。因此如果我們要編寫跨平臺或跨系統的程序就應該盡量減少對這兩個類型變量的直接定義。 下面表格列出了int和long兩種類型在不同操作系統字長下的長度。
類型16位系統/字節32位系統/字節64位系統/字節int244
long448
在很多系統中都對32位的整型以及64位的整型進行特殊的定義，比如Windows中的DWORD，UINT32，INT64等等。
浮點型
浮點型用來存儲浮點數值。它按精度分為：單精度浮點型，雙精度浮點型，擴展雙精度浮點型。 浮點數是連續并且無限的，但是計算機并不能表達出所有連續的值。因此對浮點數定義了最小規格化值和最大規格化值，這些定義可以在float.h中找到。下面表格列出了不同類型的存儲長度和最值：
類型字節數最小規格化值宏定義最大規格化值宏定義備注float41.175494351e-38FLT_MIN3.402823466e+38FLT_MAX
double82.2250738585072014e-308DBL_MIN1.7976931348623158e+308DBL_MAX
long double8?2.2250738585072014e-308LDBL_MIN1.7976931348623158e+308LDBL_MAXC99
這里的FLT_MIN,DBL_MIN,LDBL_MIN并不是指最小可表示的浮點數，而是最小規格化浮點值，具體我會在下面詳細介紹。
對 long double 的定義，取決于編譯器和機器字長，所以對于不同平臺可能有不同的實現，有的是8字節，有的是10字節，有的是12字節或16字節。
為了和數學中的無窮∞對應，標準庫中定義了一個宏：INFINITY來表示無窮大。比如1.0/0.0等于INFINITY，-1.0/0.0等于-INFINITY。無窮大可以進行加減乘除操作，比如1.0/INFINITY == 0。
為了和數學中的非法數字對應，標準庫中定義了一個宏：NAN來表示非法數字。比如負數開方、負數求對數、0.0/0.0、0.0* INFINITY、INFINITY/INFINITY、INFINITY-INFINITY這些操作都會得到NAN。注意：如果是整數0/0會產生操作異常
浮點數的存儲結構
浮點數不像整數那樣離散值，而是連續的值。但是用計算機來描述一個浮點數時就不可能完全實現其精度和連續性，現在的浮點型的存儲和描述普遍都是遵循IEEE754標準。如果您想詳細的了解關于浮點數的存儲格式那么您可以花費一點時間來閱讀：https://wenku.baidu.com/view/d02978d8d15abe23482f4dac.html?這篇文章。
簡單來說浮點數的存儲由：S(sign)符號位、E(exponent)指數位、M(mantissa 或significand)尾數位三個部分組成。我們以一個32位的float類型舉例來說，一個浮點數N的從高位到低位的存儲結構如下：
也就是一個32位的浮點數由1個符號位，8個指數位，23個尾數位組成。 而為了表示不同類型的浮點數，根據存儲格式對浮點數進行了如下分類：如果一個浮點數中指數位部分全為1，而尾數位部分全為0則這個浮點數表示為無窮大INFINITY，如果符號位為0表示正無窮大，否則就是負無窮大。
如果一個浮點數中指數位部分全為1，而尾數位部分不全為0則這個浮點數表示為非法數字NAN。因此可以看出非法數字并非一個數字而是一類數字。在下面介紹nan函數時我會更加深入的介紹NAN
如果一個浮點數中除符號位外全部都是0，那么這個浮點數就是0
如果一個浮點數中指數位部分全為0，而尾數位部分不全為0則這個浮點數稱為非規格化浮點數，英文稱為：subnormal number 或 denormal number 或 denormalized number。非規格化浮點數常用來表示一個非常接近于0的浮點數。
如果一個浮點數中的指數位部分即非全1又非全0。那么這個浮點數稱之為規格化浮點數，英文稱之為：normal number。我們上面定義的FLT_MIN, DBL_MIN?指的就是最小的規格化浮點數。
我們把規格化浮點數和非規格化浮點數合稱為可表示的浮點數，英文稱之為：machine representable number
一個規格化浮點數N的值可以用如下公式算出：
從上面的公式中可以看出對于一個32位浮點數來說，指數位占8位，最小值是1(全0為非常規浮點)，而最大值是254(全1為無窮或者非法浮點)，而減去127則表示指數部分的最小值為-126，最大值為127；同時我們發現除了23位尾數外，還有一個隱藏的1作為尾數的頭部。因此我們就很容易得出:FLT_MIN = 1.0 * 2^-126 = 1.175494351e-38FLT_MAX = (1.11111111111111111111111)b * 2^127 = 3.402823466e+38
一個非規格化浮點數N的值的可以用如下公式算出：
從上面的公式中可以看出對于一個32位的浮點數來說，我們發現雖然非規格化浮點的指數位部分全0，但是這里并不是0-127，而是1-127，同時發現尾數位部分并沒有使用隱藏的1作為尾數的頭部，而是將頭部的1移到了指數部分，這樣做的目的是為了保持浮點數字的連續性。我們可以看出當一個浮點數小于FLT_MIN時，他就變為了一個非規格化浮點。我們知道FLT_MIN的值是1.0 * 2^-126，而一個比FLT_MIN小的值就應該是：(0.11111111111111111111111)b * 2^-126，而一個比0大的值就是：(0.00000000000000000000001)b * 2^-126。如果非規格化浮點數以-127作為指數，而繼續使用1作為尾數的頭部時，那么這種數字連續性將會被打破。這也是為什么要定義規格化浮點數和非規格化浮點數的意義所在。可以看出浮點數的這種存儲設計的精妙之處！！。
從上面兩種類型的浮點數中可以總結出浮點數的計算公式可以表示為：N = 符號 * 尾數 * 2^指數
數學函數
數字判斷函數或宏//如果x是正無窮大返回1，負無窮大返回-1，否則返回0int?isinf(x)
//如果x是無窮大返回0int?isfinite(x)
//如果x是一個規格化浮點數則返回非0int??isnormal(x)
//如果x是一個非法的數字返回非0int?isnan(x)
//如果x是負數返回非0int?signbit(x)
/**
*返回浮點數的分類：
FP_INFINITE:??x是無窮大或者無窮小
FP_NAN：x是一個非法數字
FP_NORMAL：x是一個規格化浮點數
FP_SUBNORMAL：x是一個非規格化浮點數
FP_ZERO：x是0*/
int??fpclassify(x)
三角函數
1. 反余弦函數:?y = arccos(x)extern?float?acosf(float?x);
extern?double?acos(double?x);
extern?long?double?acosl(long?double?x);
2. 反正弦函數：y = arcsin(x)extern?float?asinf(float?x);
extern?double?asin(double?x);
extern?long?double?asinl(long?double?x);
3. 反正切函數：y = arctan(x)extern?float?atanf(float?x);
extern?double?atan(double?x);
extern?long?double?atanl(long?double?x);
4. 2個參數的反正切函數：z = arctan(y/x)extern?float?atan2f(float?y,?float?x);
extern?double?atan2(double?y,?double?x);
extern?long?double?atan2l(long?double?y,?long?double?x);
因為arctan的定義域是在(-∞, +∞)，而值域是在(-????/2, ????/2)之間。因此 ：atan2f(-1.0, 0.0) == -????/2; ?atan2f(1.0, 0.0) == ????/2;這個函數提供的另外一個意義在于tan函數的值其實就是對邊除以鄰邊的結果，因此當知道對邊和鄰邊時就可以直接用這個逆三角函數來求得對應的弧度值。假如特殊情況下對邊和鄰邊的值都是0.0，那么如果你調用atan(0.0/0.0)得到的值將是NAN而不是0。因為0.0/0.0的值是NAN,而對NAN調用atan函數返回的也是NAN，但是對atan2(0.0,0.0)調用返回的結果就是正確值0。
5. 余弦函數:?y = cos(x)extern?float?cosf(float?x);
extern?double?cos(double?x);
extern?long?double?cosl(long?double?x);
6. 正弦函數：y = sin(x)extern?float?sinf(float?x);
extern?double?sin(double?x);
extern?long?double?sinl(long?double?x);
7. 正切函數：y = tan(x)extern?float?tanf(float?x);
extern?double?tan(double?x);
extern?long?double?tanl(long?double?x);
雙曲函數
1. 反雙曲余弦函數：y = arccosh(x)extern?float?acoshf(float?x);
extern?double?acosh(double?x);
extern?long?double?acoshl(long?double?x);
2. 反雙曲正弦函數：y = arcsinh(x)extern?float?asinhf(float?x);
extern?double?asinh(double?x);
extern?long?double?asinhl(long?double?x);
3. 反雙曲正切函數：y = arctanh(x)extern?float?atanhf(float?x);
extern?double?atanh(double?x);
extern?long?double?atanhl(long?double?x);
4. 雙曲余弦函數：y = cosh(x)extern?float?coshf(float?x);
extern?double?cosh(double?x);
extern?long?double?coshl(long?double?x);
5. 雙曲正弦函數：y = sinh(x)extern?float?sinhf(float?x);
extern?double?sinh(double?x);
extern?long?double?sinhl(long?double?x);
6. 雙曲正切函數：?y = tanh(x)extern?float?tanhf(float?x);
extern?double?tanh(double?x);
extern?long?double?tanhl(long?double?x);
指數函數
1. 自然常數e為基數的指數函數：y = e^xextern?float?expf(float?x);
extern?double?exp(double?x);
extern?long?double?expl(long?double?x);
2. 自然常數e為基數的指數減1：y = e^x - 1extern?float?expm1f(float?x);
extern?double?expm1(double?x);
extern?long?double?expm1l(long?double?x);
我們既然定義了exp函數，那么按理說要實現e^x-1就很簡單，為什么要單獨定義這個函數呢？先看下面兩個輸出：double?o1?=?exp(1.0e-13)?-?1.0;
double?o2?=?expm1(1.0e-13);
printf("o1?=?%e,?o2?=?%e",?o1,?o2);
//output:???o1?=?9.992007e-14,?o2?=?1.000000e-13
從上面的例子中發現當用exp函數時出現了有效數字損失而expm1則沒有。出現這種問題的原因就是浮點加減運算本身機制的問題，在浮點運算中下面兩種類型的運算都有可能出現損失有效數字的情況：兩個相近的數相減
兩個數量級相差很大的數字相加減
我們可以做一個實驗，分別在調試器中查看a1,a2和b1,b2的結果：double?a1?=?5.37-5.36;
double?a2?=?(5.37*100?-?5.36*100)/100;
double?b1?=?100.0-0.01;
double?b2?=?(100.0/0.01?-?0.01/0.01)*0.01;//我們發現a1的值是0.0099999999999997868，而a2的值就是0.01//我們發現b1的值是99.989999999999994而b2的值是99.990000000000009
從上面的例子中可以看出當浮點數相近或者差異很大時加減運算出現了有效數字損失的情況，同時上面的例子也給出了一個減少這種損失的簡易解決方案。再回到上面exp函數的場景中，因為exp(1.0e-13)的值和1.0是非常接近，因此當對這兩個數做減法時就會出現有效數字損失的情況。我們再來考察expm1函數，這個函數主要用于當x接近于0時的場景。我們知道函數?y = e^x - 1?當x趨近于0時的極限是0，因此我們可以用泰勒級數來展開他：
可以看出這個級數收斂的很快，因此可以肯定的是expm1函數的內部實現就是通過上面的泰勒級數的方法來實現求值的。下面這段函數使用手冊的文檔也給出了用expm1代替exp函數的例子和說明：Note?that?computations?numerically?equivalent?to?exp(x)?-?1.0?are?often
hidden?in?more?complicated?expressions;?some?amount?of?algebraic?manipu-
lation?may?be?necessary?to?take?advantage?of?the?expm1()?function.??Con-
sider?the?following?example,?abstracted?from?a?developer's?actual?produc-
tion?code?in?a?bug?report:???????????double?z?=?exp(-x/y)*(x*x/y/y?+?2*x/y?+?2)?-?2
When?x?is?small?relative?to?y,?this?expression?is?approximately?equal?to:???????????double?z?=?2*(exp(-x/y)?-?1)?????and?all?precision?of?the?result?is?lost?in?the?computation?due?to?cata-
strophic?cancellation.??The?developer?was?aware?that?they?were?losing
precision,?but?didn't?know?what?to?do?about?it.??To?remedy?the?situation,
we?do?a?little?algebra?and?re-write?the?expression?to?take?advantage?of
the?expm1()?function:
exp(-x/y)*(x*x/y/y?+?2*x/y?+?2)?-?2
=?(2*exp(-x/y)?-?2)?+?exp(-x/y)*((x*x)/(y*y)?+?2*x/y)
This?transformation?allows?the?result?to?be?computed?to?a?high?degree?of
accuracy?as?follows:???????????const?double?r?=?x/y;???????????const?double?emrm1?=?expm1(-r);???????????double?z?=?2.0*emrm1?+?(1.0?+?emrm1)*(2.0?+?r)*r;
It?is?not?always?easy?to?spot?such?opportunities?for?improvement;?if?an
expression?involving?exp()?seems?to?be?suffering?from?an?undue?loss?of
accuracy,?try?a?few?simple?algebraic?operations?to?see?if?you?can?iden-
tify?a?factor?with?the?form?exp(x)?-?1.0,?and?substitute?expm1(x)?in?its
place.
3. 2為基數的指數函數：y = 2^xextern?float?exp2f(float?x);
extern?double?exp2(double?x);
extern?long?double?exp2l(long?double?x);
4. 浮點數構造函數：y = x * 2^nextern?float?ldexpf(float?x,?int?n);
extern?double?ldexp(double?x,?int?n);
extern?long?double?ldexpl(long?double?x,?int?n);
既然上面已經存在了一個exp函數，如果我們要實現相同的功能按理來只要:x*exp(n)就好了,為什么還要單獨提供一個新的ldexp函數呢？原因就是ldexp函數其實是一個用來構造浮點數的函數，我們知道浮點數的格式定義在符號*尾數*2^指數，剛好和ldexp所實現的功能是一致的，這里的x用來指定符號*尾數，而n則指定為指數。因此我們就可以借助這個函數來實現浮點數的構造。
5. 以FLT_RADIX基數的浮點數構造函數：y = x* FLT_RADIX^nextern?float?scalbnf(float?x,?int?n);
extern?double?scalbn(double?x,?int?n);
extern?long?double?scalbnl(long?double?x,?int?n);
extern?float?scalblnf(float?x,?long?int?n);
extern?double?scalbln(double?x,?long?int?n);
extern?long?double?scalblnl(long?double?x,?long?int?n);
這里的FLT_RADIX是浮點數存儲里面的基數(在float.h中有定義這個宏)，一般情況下是2，這時候這個函數就和ldexp函數是一致的。但是有些系統的浮點數存儲并不是以2為基數(比如IBM 360的機器)。因此如果你要構造一個和機器相關的浮點數時就用這個函數。
對數函數
1. 自然常數e為基數的對數函數：y = ln(x)extern?float?logf(float?x);
extern?double?log(double?x);
extern?long?double?logl(long?double?x);
2. 自然常數e為基數的對數函數：?y = ln(x + 1)extern?float?log1pf(float?x);
extern?double?log1p(double?x);
extern?long?double?log1pl(long?double?x);
這個函數的使用場景主要用于當x趨近于0的情況，上面曾經描述過當兩個浮點數之間的數量值相差很大時數字的加減會存在有效位丟失的情況。因此如果我們用log函數來計算時當x趨近于0的ln(x+1)時就會存在有效位的損失情況。比如下面的例子：double?o1?=?log(1.0e-13?+?1);
double?o2?=?log1p(1.0e-13);
printf("o1?=?%e,?o2?=?%e",?o1,?o2);
//output:?o1?=?9.992007e-14,?o2?=?1.000000e-13
可以看出函數log1p主要用于當x接近于0時的場景。我們知道函數 y = ln(x+1) 當x趨近于0時的極限是0，因此我們可以用泰勒級數來展開他：
可以看出這個級數收斂的很快，因此可以肯定的是log1p函數的內部實現就是通過上面的泰勒級數的方法來實現求值的。
3. 10為基數的對數函數：y = log10(x)extern?float?log10f(float?x);
extern?double?log10(double?x);
extern?long?double?log10l(long?double?x);
4. 2為基數的對數函數1：y = log2(x)extern?float?log2f(float?x);
extern?double?log2(double?x);
extern?long?double?log2l(long?double?x);
5. FLT_RADIX為基數的對數函數并取整：y = floor(log2(x))extern?float?logbf(float?x);
extern?double?logb(double?x);
extern?long?double?logbl(long?double?x);
函數返回的是一個小于等于真實指數的最大整數，也就是對返回的值進行了floor操作，具體floor函數的定義見下面。這里的FLT_RADIX是浮點數的基數，大部分系統定義為2。下面是這個函數的一些例子：logb(2.5)?==?floor(log2(2.5))?==?1;
logb(4.0)?==?floor(log2(4.0))?==?2;
logb(4.1)?==?floor(log2(4.1))?==?2;
logb(7)?==?floor(log2(7))?==?2;
logb(7.9999)?==?floor(log2(7.9999))?==?2;
logb(8.0)?==?floor(log2(8.0))?==?3;
6. FLT_RADIX為基數的對數函數并取整：y = floor(log2(x))extern?int?ilogbf(float?x);
extern?int?ilogb(double?x);
extern?int?ilogbl(long?double?x);
函數返回的是一個小于等于真實指數的最大整數，也就是對返回的值進行了floor操作，具體floor函數的定義見下面。需要注意的是這里返回的類型是整型，因此不可能存在返回NAN或者INFINITY的情況。下面是當x是0或者負數時返回的特殊值：FP_ILOGB0:??當x是0時返回這個特殊值。
FP_ILOGBNAN：當x是負數時返回這個特殊值。
這里區分一下log2,logb,ilogb?這三個函數的差異：logb,ilogb是以FLT_RADIX為基數的對數，而log2則是以2為基數的對數，雖然大部分系統中FLT_RADIX默認是定義為2。
log2,logb返回的都是浮點型，因此有可能返回INFINITY和NAN這兩個特殊值；而ilogb則返回的是整型，因此如果x是特殊的話那么將會返回FP_ILOGB0和FP_ILOGBNAN兩個值。
log2返回的是有可能帶小數的指數，而logb和ilogb則返回的是一個不大于實際指數的整數。
絕對值函數
1. 取絕對值函數：y = |x|extern?float?fabsf(float);
extern?double?fabs(double);
extern?long?double?fabsl(long?double);
冪函數
1. 平方根函數：y = √xextern?float?sqrtf(float?x);
extern?double?sqrt(double?x);
extern?long?double?sqrtl(long?double?x);
2. 立方根函數：?y = ?xextern?float?cbrtf(float?x);
extern?double?cbrt(double?x);
extern?long?double?cbrtl(long?double?x);
3. 冪函數：z = x ^ yextern?float?powf(float?x,?float?y);
extern?double?pow(double?x,?double?y);
extern?long?double?powl(long?double?x,?long?double?y);
4. 歐幾里得距離函數：?d =√x^2+y^2extern?float?hypotf(float?x,?float?y);
extern?double?hypot(double?x,?double?y);
extern?long?double?hypotl(long?double?x,?long?double?y);
這個函數可以用來求直角三角形的斜邊長度。
誤差函數
誤差函數主要用于概率論和偏微分方程中使用，具體參考誤差函數
1. 誤差函數extern?float?erff(float?x);
extern?double?erf(double?x);
extern?long?double?erfl(long?double?x);
2. 互補誤差函數extern?float?erfcf(float?x);
extern?double?erfc(double?x);
extern?long?double?erfcl(long?double?x);
伽瑪函數
1. 伽瑪函數 ：y = ????(x)extern?float?lgammaf(float?x);
extern?double?lgamma(double?x);
extern?long?double?lgammal(long?double?x);
2. 階乘函數：y = (x-1)!extern?float?tgammaf(float?x);
extern?double?tgamma(double?x);
extern?long?double?tgammal(long?double?x);
伽瑪函數其實就是階乘在實數上的擴展，一般我們知道3! = 3*2*1 = 8。那么我們要求2.5!怎么辦，這時候就可以用這個函數來實現。這個函數也可以用來進行階乘計算。 注意這里是x-1后再計算的。
取整函數
1. 返回一個大于等于x的最小整數extern?float?ceilf(float?x);
extern?double?ceil(double?x);
extern?long?double?ceill(long?double?x);
舉例來說我們要對于一個負浮點數按0.5進行四舍五入處理：即當某個負數的小數部分大于等于0并且小于0.5時則舍棄掉小數部分，而當小數部分大于等于0.5并且小于1時則等于0.5。我們就可以用ceil函數來實現如下：double?y?=?ceil(x*0.5)/0.5;
2. 返回一個小于等于x的最大整數extern?float?floorf(float?x);
extern?double?floor(double?x);
extern?long?double?floorl(long?double?x);
舉例來說我們要對于一個正浮點數按0.5進行四舍五入處理：即當某個正數的小數部分大于等于0并且小于0.5時則舍棄掉小數部分，而當小數部分大于等于0.5并且小于1時則等于0.5。我們就可以用floor函數來實現如下：double?y?=?floor(x*0.5)/0.5;
3. 返回一個最接近x的整數extern?float?nearbyintf(float?x);
extern?double?nearbyint(double?x);
extern?long?double?nearbyintl(long?double?x);
extern?float?rintf(float?x);extern?double?rint(double?x);
extern?long?double?rintl(long?double?x);
//下面三個函數返回的是整數。
extern?long?int?lrintf(float?x);
extern?long?int?lrint(double?x);
extern?long?int?lrintl(long?double?x);
//下面三個函數是C99或者gnu99中的函數。
extern?long?long?int?llrintf(float?x);
extern?long?long?int?llrint(double?x);
extern?long?long?int?llrintl(long?double?x);
4. 對x進行四舍五入取整extern?float?roundf(float?x);
extern?double?round(double?x);
extern?long?double?roundl(long?double?x);
extern?long?int?lroundf(float?x);
extern?long?int?lround(double?x);
extern?long?int?lroundl(long?double?x);
//下面三個函數是C99或者gnu99中的函數。
extern?long?long?int?llroundf(float?x);
extern?long?long?int?llround(double?x);
extern?long?long?int?llroundl(long?double?x);
如果x是正數，那么當小數部分小于0.5則返回的整數小于浮點數，如果小數部分大于等于0.5則返回的整數大于浮點數；如果x是負數，那么當小數部分小于0.5則返回的整數大于浮點數，如果小數部分大于等于0.5則返回的整數小于浮點數。
如果我們要實現保留N位小數的四舍五入時。我們可以用如下的方法實現：double?y?=?round(x?*?pow(10,?N))?/?pow(10,?N)
數字拆分
1. 返回浮點數x的整數部分extern?float?truncf(float?x);
extern?double?trunc(double?x);
extern?long?double?truncl(long?double?x);
這個函數和floor函數的區別主要體現在負數上，對一個負數求floor則會返回一個小于等于負數的負整數，而對一個負數求trunc則會返回一個大于等于負數的負整數。
如果我們要實現保留N位小數的截取時。我們可以用如下的方法實現：double?y?=?trunc(x?*?pow(10,?N))?/?pow(10,?N)
2. 返回x/y的余數1：?z = mod(x, y)extern?float?fmodf(float?x,?float?y);
extern?double?fmod(double?x,?double?y);
extern?long?double?fmodl(long?double?x,?long?double?y);
函數返回值r = x - n*y， 其中n等于x/y的值截取的整數。
3. 返回x/y的余數2：?z = mod(x, y)extern?float?remainderf(float?x,?float?y);
extern?double?remainder(double?x,?double?y);
extern?long?double?remainderl(long?double?x,?long?double?y);
函數返回值r = x - n*y， 其中n等于x/y的值取最接近的整數，如果有兩個數都接近x/y，那么n就取偶數。比如我們要求remainder(7,2)。因為7/2是3.5，按上面規則n就取4，因此最后的結果是r = 7 - 4*2 = -1。同樣我們可以得出remainder(7,3) == 7-2*3 == 1。從上面的描述可以看出fmod和remainder的區別主要在于x/y的整數部分的處理不一樣：前者是取x/y的整數來算余數，而后者則取最接近x/y的整數來算余數。
4. 返回x/y的余數和整數商extern?float?remquof(float?x,?float?y?,?int?*quo);
extern?double?remquo(double?x,?double?y,?int?*quo);
extern?long?double?remquol(long?double?x,?long?double?y,?int?*?quo);
這個函數和remainder函數一樣，只不過會將整數商也返回給quo，也就是說r = x - n *y這個等式中，r作為函數的返回，而n則返回給quo。
5. 分解出x的整數和小數部分extern?float?modff(float?x,?float?p*);
extern?double?modf(double?x,?double?p*);
extern?long?double?modfl(long?double?x,?long?double?p*);
函數返回小數部分，整數部分存儲在p中。這里面返回值和p都和x具有相同的符號。
6. 分解出x的指數和尾數部分extern?float?frexpf(float?x,?int?*?p);
extern?double?frexp(double?x,?int?*?p);
extern?long?double?frexpl(long?double?x,?int?*?p);
函數返回尾數*符號部分，指數部分存儲在p中。需要明確的是如果浮點數x為0或者非規格化浮點數時按浮點數的定義格式返回尾數和指數，而當x為規格化浮點數那么返回的值的區間是[0.5, 1)。這里的返回值和指數值p和上面介紹的規格化浮點數格式：符號 * (1.尾數) * 2^指數有差異。因為按照定義返回的尾數部分應該是1.xxx，但是這里的返回值卻是[0.5, 1)。其實這并不矛盾，只是函數對返回的值做了特殊處理：因為一個正浮點數可以表示為:1.m * 2^e ==> (2^0 + 0.m) * 2^e ==> (2^0 / 2 + 0.m / 2) *2^(e+1) =>(0.5 + 0.m/2) *2^(e+1)。因此frexp函數返回的真實值是： 尾數除以2，而p存儲的是：指數+1
下面函數使用的一些例子：int?p1?=?0;???double?y1?=?frexp(16.0,?&p);?//y1=0.5,?p=?5
int?p2?=?0;??double?y2?=?frexp(1.0,?&p);?//y2=0.5,?p?=?1
int?p3?=?0;??double?y3?=?frexp(0.0,?&p);?//y3=0,?p?=?0
這個函數和上面的ldexp函數為互逆函數。要詳細的了解浮點數存儲格式請參考
符號改變
1. 將y的符號賦值給x并返回具有和y相同符號的x值extern?float?copysignf(float?x,?float?y);
extern?double?copysign(double?x,?double?y);
extern?long?double?copysignl(long?double?x,?long?double?y);
舉例如下：copysign(10.0,?9.0)??==?10;
copysign(-10.0,?-9.0)?==?-10;
copysign(-10.0,?9.0)?==?10;
copysign(10.0,?-9.0)?==?-10;
這個函數的作用是實現符號的賦值，有就是將y的符號賦值給x。
無效數字定義
1.生成一個quient NAN浮點數extern?float?nanf(const?char?*tagp);
extern?double?nan(const?char?*tagp);
extern?long?double?nanl(const?char?*tagp);
前面我有介紹了浮點數里面有兩個特殊的值：無窮INFINITY和非法NAN，既然這兩個數字都可以用浮點數來描述，那么他就肯定也有對應的存儲格式。我們知道浮點數的格式為：符號*尾數*2^指數。在IEEE754標準中就對無窮和非法這兩種特殊的數進行了定義：當浮點數中的指數部分的二進制位全為1。而尾數部分的二進制位全為0時則表示的浮點數是無窮INFINITY，如果符號位為0則表示正無窮大，而符號位為1則表示負無窮大。
當浮點數中的指數部分的二進制位全為1。而尾數部分的二進制位不全為0時則表示的浮點數是非法數字NAN，或者表示為未定義的數字。
從上面的對NAN的定義可以得出非法數字并不是一個具體的數字而是一類數字，因此對兩個為NAN的浮點數字并不能用等號來比較。以32位IEEE單精度浮點數的NAN為例，按位表示即：S111 1111 1AXX XXXX XXXX XXXX XXXX XXXX，其中的S是符號位，而符號位后面的指數位為8個1表示這個數字是一個特殊的浮點數，剩余的A和X則組成為了尾數部分，因為是NAN?所以我們要求A和X這些位中至少有一個是1。在IEEE 754-2008標準中，又對NAN的類型進行了細分：如果A = 1，則該數是quiet NAN。也就是quiet NAN中尾數的最高位為1。
如果A為零、其余X部分非零，則是signaling NAN。
區分兩種NAN的目的是為了更好的對浮點數進行處理。一般我們將signaling NAN來表示為某個數字未初始化，而將quiet NAN則用來表示浮點運算的結果出現了某類異常，比如0除異常，比如負數開根異常等等。既然quiet NAN可以用來對無效數字進行分類，也就是說我們可以構建出一個有類別標志的quiet NAN。因此nan函數就是一個專門構建具有無效類別的NAN函數(繞了這么多終于說到點子上了)。nan函數中的tagp參數就是用來指定非法數字中的類別，雖然參數類型是字符串，但是要求里面的值必須是整數或者空字符串，而且系統在構造一個quiet NAN時會將tagp所表示的整數放在除A外的其他尾數位上。下面是使用nan函數的例子：float?f1?=?NAN;???????????//0b01111111110000000000000000000000
float?f2?=?nanf("");??????//0b01111111110000000000000000000000
float?f3?=?nanf("123");???//0b01111111110000000000000001111011
float?f4?=?nanf("456");???//0b01111111110000000000000111001000
float?f5?=?nanf("abc");???//0b01111111110000000000000000000000
具體操作時我們可以用如下來方法來處理各種異常情況：//定義部分：float??testfn(){
//有異常時根據不同的情況返回不同的nan。
if?(異常1)
return?nan("100");
else?if?(異常2)
return?nan("200");
else
return?正常數字;
}
//調用部分：
float?ret?=?testfn();
if?(isnan(ret))
{??????//取非法數字的錯誤標志部分
int?exceptionType?=?ret?&?0x3FFFFF;
if?(exceptionType?==?100)
{
}
else?if?(exceptionType?==?200)
{
}
}
else
{
//正常處理。
}
有一個地方疑惑的是為什么NAN定義默認值是一個quiet NAN而不是signaling NAN
遞增函數
1. 返回x在y方向上的下一個可表示的浮點數。extern?float?nextafterf(float?x,?float?y);
extern?double?nextafter(double?x,?double?y);
extern?long?double?nextafterl(long?double?x,?long?double?y);
extern?double?nexttoward(double?x,?long?double?y);
extern?float?nexttowardf(float?x,?long?double?y);
extern?long?double?nexttowardl(long?double?x,?long?double?y);
如果x等于y則返回x。這個函數主要用來實現那些需要高精度增量循環的處理邏輯。也就是說如果對浮點數進行for循環處理時，這個函數可以用來實現最小的浮點數可表示的數字的增量。比如下面的代碼：for?(double?x?=?0.1;?x?
{?????????//...
}
注意這里是下一個可表示的浮點數，也就是說當x為0而y為1時，那么返回的值將是最小的非常規浮點數；而如果x為1而y為2時，那么返回的值將是1+DBL_MIN(or FLT_MIN). 下面是具體的示例代碼：//?0.0f?==?0b00000000000000000000000000000000
float?a?=?nextafterf(0.0f,?1.0f);???//a?==?0b00000000000000000000000000000001
//?FLT_MIN?==???0b00000000100000000000000000000000
float?b?=?nextafterf(FLT_MIN,?1.0f);?//?b?=?0b00000000100000000000000000000001
//?1.0f?==?0b00111111100000000000000000000001
float?c?=?nextafterf(1.0f,?1.1f);?//?c?=?0b00111111100000000000000000000001
比較函數
1. 返回x減去y的差如果x>y，否則返回0extern?float?fdimf(float?x,?float?y);
extern?double?fdim(double?x,?double?y);
extern?long?double?fdiml(long?double?x,?long?double?y);
這個函數可以用來求兩個數的差，并且保證不會出現負數。下面是使用的例子：double?a?=?fdim(5.0,?3.0);???//2.0
double?b?=?fdim(5.0,?5.0);???//0.0
double?c?=?fdim(5.0,?6.0);???//0.0
2. 返回x和y中大的數字：?z = max(x,y)extern?float?fmaxf(float?x,?float?x);
extern?double?fmax(double?x,?double?x);
extern?long?double?fmaxl(long?double?x,?long?double?x);
3. 返回x和y中小的數字：?z = min(x,y)extern?float?fminf(float?x,?float?y);
extern?double?fmin(double?x,?double?y);
extern?long?double?fminl(long?double?x,?long?double?y);
浮點乘加運算
1. 浮點乘加運算：w = x*y + zextern?float?fmaf(float?x,?float?y,?float?z);
extern?double?fma(double?x,?double?y,?double?z);
extern?long?double?fmal(long?double?x,?long?double?y,?long?double?z);
這個函數返回x*y+z的結果，而且會保證中間計算不會丟失精度。這個函數會比直接用x*y+z要快，因為CPU中專門提供了一個用于浮點數乘加的指令FMA。具體情況請參考關于浮點乘加器方面的資料和應用。
結語
最后歡迎大家訪問我的github站點?多多點贊，多多支持！
參考文章：
總結
以上是生活随笔為你收集整理的c语言定义小数无穷小,OC中常用的数学函数以及浮点处理函数的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： c语言使用求余方式的转化为二进制程序,C
- 下一篇： c语言结构体易错点,C语言结构体注意点