C语言库函数

c语言函数库
第五章（数学函数）


1. abs、labs、fabs：求绝对值函数
2. acos： 反余弦函数
3. asin： 反正弦函数
4. atan：反正切函数
5. atan2：反正切函数
6. ceil：向上舍入函数
7. cos ：余弦函数
8. cosh： 双曲余弦函数
9. div、ldiv：除法函数
10. exp：求e的x次幂函数
11. floor：向下舍入函数
12. fmod：求模函数
13. frexp：分解浮点数函数
14. hypot：求直角三角形斜边长函数
15. ldexp：装载浮点数函数
16. log、log10：对数函数
17. modf：分解双精度数函数
18. pow、pow10：指数函数
19. rand：产生随机整数函数
20. sin：正弦函数
21. sinh： 双曲正弦函数
22. sqrt：开平方函数
23. srand：设置随机时间的种子函数
24. tan： 正切函数
25. tanh：双曲正切函数
1. abs、labs、fabs：求绝对值函数
　　函数原型：int abs(int x);
　　  long labs(long x);
　　  double fabs(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：函数int abs(int x);是求整数x的绝对值；函数long labs(long n);是求长整型数x的绝对值；函数double fabs(double x); 是求浮点数x的绝对值。
　　返回值：返回计算结果。
　　例程如下： 计算整数的绝对值。
#include <math.h>
int main(void)
{
  int x = -56;
  printf("number: %d  absolute value: %d\n",x, abs(x));
  return 0; 
}
　　例程说明：
　　本例程通过abs函数计算出整型数-56的绝对值56，并在屏幕上显示结果。本例程的运行结果为：
number: -56  absolute value: 56
　　例程如下：计算长整数的绝对值。
#include <math.h> 
int main(void) 
{ 
   long x = -12345678L; 
   printf("number: %ld absolute value: %ld\n", x,labs(x));
   return 0; 
}
　　例程说明：
　　本例程通过labs函数计算出长整型数-12345678的绝对值12345678，并在屏幕上显示结果。本例程的运行结果为：
number: -12345678 absolute value: 12345678
　　例程如下：计算浮点数的绝对值。
#include <math.h> 
int main(void) 
{ 
   float  x = -128.0;
   printf("number: %f  absolute value: %f\n", x, fabs(x));
   return 0; 
}
　　例程说明：
　　本例程通过fabs函数计算出浮点数-128.0的绝对值128.0，并在屏幕上显示结果。本例程的运行结果为：
number: -128.000000  absolute value: 128.000000


2. acos： 反余弦函数
　　函数原型：double acos(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的反余弦值，这里，x为弧度，x的定义域为[-1.0，1.0]，arccosx的值域为[0，π]。
　　返回值：计算结果的双精度值。
　　例程如下： 求arccosx。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
  double result; 
  double x = 1.0;
  result = acos(x); 
  printf("arccos %lf=%lf\n", x, result);
  return 0; 
}
　　例程说明：
本例程应用函数acos计算1.0的反余弦值，即：arccos1。返回计算结果的双精度值。本例程的运行结果是：
arccos 1.000000=0.000000


3. asin： 反正弦函数
　　函数原型：double asin(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的反正弦值，这里，x为弧度，x的定义域为[-1.0，1.0]，arcsinx值域为[-π/2，+π/2]。
　　返回值：计算结果的双精度值。
　　例程如下：求arcsinx。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = 1.0;
   result = asin(x); 
   printf("arcsin %lf is %lf\n", x, result);
   return(0); 
}
　　例程说明：
本例程应用函数asin计算1.0的反正弦值，即：arcsin1。返回计算结果的双精度值。本例程的运行结果是：
arcsin 1.000000 is 1.570796


4. atan：反正切函数
　　函数原型：double atan(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的反正切值，这里，x为弧度，x的定义域为(-∞,+∞)，arctanx的值域为(-π/2，+π/2)。
　　返回值：计算结果的双精度值。
　　例程如下： 求arctanx。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = 1.0;
   result = atan(x); 
   printf("arctan %lf = %lf\n", x, result);
   return(0); 
}
　　例程说明：
本例程应用函数atan计算1.0的反正切值，即：arctan1。并返回计算结果的双精度值。本例程的运行结果是：
arctan 1.000000 = 0.785398


5. atan2：反正切函数2
　　函数原型：double atan2(double y, double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求y/x的反正切值。
　　返回值：计算结果的双精度值。
　　例程如下： 求arctan(x/y)。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = 10.0, y = 5.0;
   result = atan2(y, x); 
   printf("arctan%lf = %lf\n", (y / x), result);
   return 0; 
}
　　例程说明：
本例程应用函数atan2计算10.0/5.0的反正切值，即：arctan0.5。并返回计算结果的双精度值。本例程的运行结果是：
arctan0.500000 = 0.463648


6. ceil：向上舍入函数
　　函数原型：double ceil(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：将双精度数x向上舍入，即：取它的最大整数。例如：ceil(123.400000)=124.000000。
　　返回值：返回计算结果。
　　例程如下： 数值的向上舍入。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double num = 123.400000;
   double up;
   up = ceil(num);
   printf("The original number   %lf\n", num);
   printf("The num rounded up    %lf\n", up);
   return 0; 
}
　　例程说明：
　　本例程通过函数ceil将双精度数123.400000向上舍入，得到的结果为124.000000，并在屏幕上显示运算结果。本例程的运行结果为：
The original number   123.400000
The num rounded up    124.000000


7. cos ：余弦函数
　　函数原型：double cos(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的余弦值，这里，x为弧度。
　　返回值：计算结果的双精度值。
　　例程如下： 求cosx。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = M_PI;
   result = cos(x); 
   printf("cos(PI) is %lf\n", result);
   return 0; 
}
　　例程说明：
本例程应用cos函数计算π的余弦值，即：cosπ，再返回计算结果的双精度值。本例程的运行结果是：
cos(PI) is -1.000000


8. cosh： 双曲余弦函数
　　函数原型：dluble cosh(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：计算x的双曲余弦值。其中ch(x)=(ex+e-x)/2。
　　返回值：计算结果的双精度值。
　　例程如下： 求x的双曲余弦值ch(x)。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = 0.5; 
   result = cosh(x); 
   printf("ch(%lf) = %lf\n", x, result);
   return 0; 
}
　　例程说明：
本例程应用函数cosh计算0.5的双曲余弦值，即：ch(0.5)，并返回计算结果的双精度值。本例程的运行结果是：
ch(0.500000) = 1.127626


9. div、ldiv：除法函数
　　函数原型：div_t div(int number, int denom);
　　      ldiv_t ldiv(long lnumer, long ldenom);
　　头文件：#include<stdlib.h>
　　是否是标准函数：是
　　函数功能：函数div是将两个整数numbe和denom相除, 返回商和余数。函数ldiv是将两个长整数lnumbe和ldenom相除, 返回商和余数。
　　返回值：函数div返回div_t类型的值；函数ldiv返回ldiv_t类型的值。
　　例程如下：两整数相除，求其商和余数。
#include <stdlib.h> 
#include <stdio.h> 
div_t x; 
int main(void) 
{ 
   x = div(11,5);
   printf("11 div 5 = %d remainder %d\n", x.quot, x.rem);
   return 0; 
}
　　例程说明：
　　本例程通过div函数将11和5相除，返回其商和余数。
　　注意：div函数并不是<math.h>中的函数，而是<stdlib.h>中的函数。<stdlib.h>中包含存储分配函数和一些杂项函数。但由于div函数具有数学计算的功能，因此将其归类到数学函数中。
　　div_t是<stdlib.h>中定义的数据类型，它是一个结构体，定义如下：
typedef struct 
{
　int quot;          /*商*/
　int rem;          /*余数*/
}div_t;
　　其中包含两个域：商和余数。div函数将两个整数相除, 返回一个div_t类型的值。
　　该函数的运行结果是：
　11 div 2 = 5 remainder 1
　　例程如下：两长整数相除，求其商和余数。
#include <stdlib.h> 
#include <stdio.h> 
ldiv_t lx; 
int main(void) 
{ 


   lx = ldiv(200000L, 70000L);
   printf("200000 div 70000 = %ld remainder %ld\n", lx.quot, lx.rem);
   return 0; 
}
　　例程说明：
　　本例程通过ldiv函数将长整数200000与70000相除，并返回其商和余数。
　　注意：同函数div一样，函数ldiv是<stdlib.h>中的函数。
　　ldiv_t是<stdlib.h>中定义的数据类型，它是一个结构体，定义如下：
typedef struct {
        long    quot;
        long    rem;
} ldiv_t;
　　其中包含两个域：商和余数。ldiv函数将两个长整数相除, 返回一个ldiv_t类型的值。
　　该函数的运行结果是：
200000 div 70000 = 2 remainder 60000


10. exp：求e的x次幂函数
　　函数原型：double exp(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：计算自然常数e的x幂。
　　返回值：返回计算结果的双精度值。
　　例程如下： 计算ex（说明：e=2.718281828...）。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result; 
   double x = 3.0;
   result = exp(x); 
   printf("'e' raised to the power of %lf (e ^ %lf) = %lf\n", x, x, result);
   return 0; 
}
　　例程说明：
　　本例程应用函数exp计算e3，该函数返回计算结果的双精度值。本例程的运行结果为：
'e' raised to the power of 3.000000 (e ^ 3.000000) = 20.085537


11. floor：向下舍入函数
　　函数原型：double floor(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：将双精度数x向下舍入，即：取它的最小整数。例如：floor(123.400000)=123.000000。
　　返回值：返回计算结果。
　　例程如下：数值的向下舍入。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double num = 123.400000;
   double up;
   up = floor(num);
   printf("The original number   %lf\n", num);
   printf("The num rounded down    %lf\n", up);
   return 0; 
}
　　例程说明：
　　本例程通过函数floor将双精度数123.400000向下舍入，得到的结果为123.000000，并在屏幕上显示运算结果。本例程的运行结果为：
The original number   123.400000
The num rounded down    123.000000


12. fmod：求模函数
　　函数原型：double fmod(double x, double y);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：计算x对y的模, 即x/y的余数。
　　返回值：返回计算结果，即余数的双精度。
　　例程如下： 计算两数的余数。
#include <stdio.h>
#include <math.h>
int main(void)
{
    float x,y;
    x=12.580000;
    y=2.600000;
    printf("12.580000/2.600000: %f\n",fmod(x,y));
    getchar();
    return 0;
}
　　例程说明：
　　本例程通过函数fmod求双精度数12.580000和2.600000的模，其结果为：2.180000。
本例程的运行结果为：
12.580000/2.600000: 2.180000


13. frexp：分解浮点数函数
　　函数原型：double frexp(double val, int *exp);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：把浮点数或双精度数val分解为数字部分（尾数部分）x和以2为底的指数部分n。即val=x*2n，其中n存放在exp指向的变量中。
　　返回值：返回尾数部分x的双精度值，且0.5≤x<1。
　　例程如下： 应用函数frexp分解浮点数。
#include <stdio.h>
#include <math.h>
int main(void)
{
    float x;
    int exp;
    x=frexp(64.0,&exp);
    printf("64.0=%.2f*2^%d",x,exp);
    getchar();
    return 0;
}
　　例程说明：
　　本例程通过函数frexp将浮点数64.0分解为尾数0.5和以2为底的指数7。该函数将指数7存放在变量exp 中，并返回一个双精度的尾数0.500000。本例程的运行结果为：
64.0=0.50*2^7


14. hypot：求直角三角形斜边长函数
　　函数原型：double hypot(double x, double y);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：x,y为给定的直角三角形两直角边，求该直角三角形的斜边。
　　返回值：返回计算结果的双精度值。
　　例程如下： 根据两直角边求斜边的长。
#include <stdio.h> 
#include <math.h>
int main(void) 
{ 
   double result; 
   double x = 3.0; 
   double y = 4.0; 
   result = hypot(x, y); 
   printf("The hypotenuse is: %lf\n", result); 
   return 0; 
}
　　例程说明：
　　本例程中，已知两直角边长度：x = 3.0; y = 4.0，应用函数hypot求出其斜边长度。本例程的运行结果为：
The hypotenuse is: 5.000000


15. ldexp：装载浮点数函数
　　函数原型：double ldexp(double val, int exp);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：功能与函数frexp相反，将给定的尾数，指数装载成相应的双精度数或浮点数。即计算val*2n，其中n为参数exp 的值。
　　返回值：返回val*2n的计算结果。
　　例程如下：应用函数frexp装载浮点数。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double value; 
   double x = 3.000000;
   value = ldexp(x,3); 
   printf("The ldexp value is: %lf\n", value);
   getchar();
   return 0;
}
　　例程说明：
　　本例程通过函数ldexp将尾数3.000000与指数3装载成相应的双精度数。即：3.000000*23= 24.000000。该函数返回一个双精度数。本例程的运行结果为：
The ldexp value is: 24.000000


16. log、log10：对数函数
　　函数原型：double log(double x);
　　  double log10(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求对数。函数log是求以e为底的x的对数（自然对数）即：lnx；函数log10是求以10为底的x的对数，即：log10x。
　　返回值：返回计算结果的双精度值。
　　例程如下： 计算lnx。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double result; 
   double x = M_E;
   result = log(x); 
   printf("The natural log of %lf is %lf\n", x, result); 
   return 0; 
}
　　例程说明：
　　本例程应用函数log计算双精度数M_E的自然对数，其中M_E为<math.h>中定义的常数#define M_E 2.71828182845904523536就等于e，因此，本例程的运行结果为：
The natural log of 2.718282 is 1.000000
　　例程如下： 计算log10x。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double result; 
   double x = 1000.0 ;
   result = log10(x); 
   printf("The common log of %lf is %lf\n", x, result); 
   return 0; 
}
　　例程说明：
　　本例程应用函数log10计算双精度数1000.0的以10为底的对数，该函数返回的结果仍是双精度数。本例程的运行结果为：
The common log of 1000.000000 is 3.000000


17. modf：分解双精度数函数
　　函数原型：double modf(double num, double *i);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：把双精度数num分解为整数部分和小数部分，并把整数部分存到i指向的单元中。
　　返回值：返回num的小数部分的双精度值。
　　例程如下： 应用函数modf分解双精度数。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double fraction, integer; 
   double number = 12345.6789;
   fraction = modf(number, &integer); 
   printf("The integer and the fraction of  %lf are %lf and %lf\n",
          number, integer, fraction); 
   return 0; 
}
　　例程说明：
　　本例程将双精度数12345.6789分解为整数部分和小数部分，并将整数部分存入变量integer中，返回小数部分。最后在屏幕上显示结果。本例程的运行结果为：
The integer and the fraction of  12345.678900 are 12345.000000 and 0.678900


18. pow、pow10：指数函数
　　函数原型：double pow(double x, double y);
　　          double pow10(int x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：指数函数。函数pow是求x的y次方；函数pow10相当于pow(10.0,x)，是求10的x次方。
　　返回值：返回计算结果的双精度值。
　　例程如下： 计算xy 。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double x = 2.0, y = 10.0;
   printf("The result of %lf raised to %lf is %lf\n", x, y, pow(x, y));
   return 0; 
}
　　例程说明：
　　本例程中，应用函数pow计算210，并将结果的双精度值返回。本例程的运行结果为：
The result of 2.000000 raised to 10.000000 is 1024.000000
　　例程如下： 计算10x。
#include <math.h> 
#include <stdio.h> 
int main(void) 
{ 
   double x = 2.0;
   printf("The result of 10 raised to %lf is %lf\n", x, pow10(x));
   return 0; 
}
　　本例程中，应用函数pow10计算102，并将结果的双精度值返回。本例程的运行结果为：
The result of 10 raised to 2.000000 is 100.000000


19. rand：产生随机整数函数
　　函数原型：int rand(void);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：产生-90到32767之间的随机整数。
　　返回值：产生的随机整数。
　　例程如下： 利用函数rand产生处于0~99之间的5个随机整数。
#include <stdlib.h> 
#include <stdio.h> 
int main(void) 
{ 
   int i; 
   printf("Random numbers from 0 to 99\n");
   for(i=0; i<5; i++)
      printf("%d ", rand() % 100);
   return 0; 
}
　　例程说明：
　　循环地应用函数rand产生随机整数，并利用rand() % 100将范围控制在0~99之间。共产生5个0~99之间的随机整数。本例程的运行结果为：
Random numbers from 0 to 99
46 30 82 90 56
　　注意：rand不是<math.h>中定义的函数，而是<stdlib.h>中定义的函数。因此要在源程序中包含<stdlib.h>头文件。


20. sin：正弦函数
　　函数原型：double sin(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的正弦值，这里，x为弧度。
　　返回值：计算结果的双精度值。
　　例程如下： 求sinx。
#include <stdio.h>
#include <math.h>
int main(void)
{
    float x;
    x=M_PI/2;
    printf("sin(PI/2)=%f",sin(x));
    getchar();
    return 0;
}
　　例程说明：
　　本例程应用sin函数计算π/2的正弦值，即：sin(π/2)。返回计算结果的双精度值。
　　注意：M_PI是<math.h>中定义的π值常量。本例程的运行结果为：
sin(PI/2)=1.00000


21. sinh： 双曲正弦函数
　　函数原型：double sinh(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：计算x的双曲正弦值。其中sh(x)=(ex-e-x)/2。
　　返回值：计算结果的双精度值。
　　例程如下： 求x的双曲正弦值sh(x)。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result, x = 0.5; 
   result = sinh(x); 
   printf("sh( %lf )=%lf\n", x, result);
   return 0; 
}
　　例程说明：
本例程应用函数sinh计算0.5的双曲正弦值，即：sh(0.5)，并返回计算结果的双精度值。本例程的运行结果是：
sh( 0.500000 )=0.521095


22. sqrt：开平方函数
　　函数原型：double sqrt(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求双精度数x的算术平方根，这里，x≥0。
　　返回值：返回计算结果的双精度值。
　　例程如下： 计算双精度数的平方根。
#include <math.h> 
#include <stdio.h>
 int main(void) 
 { 
    double  result,x = 4.0;
    result = sqrt(x); 
    printf("The square root of %lf is %lf\n", x, result); 
    return 0; 
}
　　例程说明：
　　本例程中，应用函数sqrt计算出4.0的平方根，并将结果的双精度值返回。本例程的运行结果为：
The square root of 4.000000 is 2.000000


23. srand：设置随机时间的种子函数
　　函数原型：int srand (unsigned int seed);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：设置随机时间的种子，常与rand()结合使用。否则如果直接用rand函数产生随机数，每次运行程序的结果都相同。
　　返回值：
　　例程如下： 产生不同的随机整数序列。
#include <stdlib.h> 
#include <stdio.h> 
#include <time.h> 
int main(void) 
{ 
   int i; 
   time_t t; 
   srand((unsigned) time(&t)); 
   printf("Random numbers from 0 to 99\n");
   for(i=0; i<5; i++)
       printf("%d ", rand() % 100);
   return 0; 
}
　　例程说明：
　　（1）首先，程序应用函数time获取系统时间作为种子，并强制转换为unsigned型变量，作为函数srand的参数。
　　（2）再利用rand函数产生5个0~99之间的随机整数。这样，每次运行该程序，都以当时的系统时间作为随机时间的种子，产生的随机数就不会重复了。
　　注意：time_t是<time.h >中定义的数据类型，用以描述时间。而函数time可以获取当前的系统时间。运行两次本例程，可得到两组不同的随机数序列：
Random numbers from 0 to 99
23 16 92 26 99
Random numbers from 0 to 99
60 72 77 40 45


24. tan： 正切函数
　　函数原型：double tan(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的正切值，这里，x为弧度，其中x≠k(π/2)，k为整数。
　　返回值：计算结果的双精度值。
　　例程如下： 求tanx。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result, x; 
   x = M_PI/4;
   result = tan(x); 
   printf("tan (PI/4)=%lf\n",  result);
   return 0; 
}
　　例程说明：
本例程应用tan函数计算π/4的正切值，即：tan(π/4)。并返回计算结果的双精度值。本例程的运行结果是：
tan (PI/4)=1.00000


25. tanh：双曲正切函数
　　函数原型：double tanh(double x);
　　头文件：#include<math.h>
　　是否是标准函数：是
　　函数功能：求x的双曲正切值。其中th(x)=sh(x)/ch(x)= (ex-e-x)/ (ex+e-x)。
　　返回值：计算结果的双精度值。
　　例程如下： 求x的双曲正切值th(x)。
#include <stdio.h> 
#include <math.h> 
int main(void) 
{ 
   double result, x; 
   x = 0.5; 
   result = tanh(x); 
   printf("th(%lf) = %lf\n", x, result);
   return 0; 
}
　　例程说明：
本例程应用函数tanh计算0.5的双曲正切值，即：th(0.5)，并返回计算结果的双精度值。本例程的运行结果是：
th(0.500000) = 0.462117