C++/C++11中头文件<cmath>的使用

<math.h>是C标准函数库中的头文件。在C++中一般用<cmath>。此头文件中声明了一系列函数来计算常见的数学运算和变换：

std::abs: 计算绝对值，包括整数类型；

std::fabs: 计算绝对值，不包括整数类型；

std::fma(x,y,z):x*y+z;

std::sin: 正弦；

std::asin: 反正弦；

std::sinh: 双曲正弦；

std::asinh: 双曲反正弦；

std::cos: 余弦；

std::acos: 反正弦；

std::cosh: 双曲余弦；

std::acosh: 双曲反余弦；

std::tan：正切；

std::atan：反正切；

std::atan2: 反正切；

std::tanh: 双曲正切；

std::atanh: 双曲反正切；

std::sqrt: 计算平方根；

std::cbrt: 计算立方根；

std::hypot: 计算两个数平方的和的平方根；

std::pow：幂运算；

std::ceil: 不小于给定值的最近整数；

std::floor: 不大于给定值的最近整数；

std::fmod: 两数除法操作的余数(rounded towards zero)；

std::trunc: 不大于给定值的最近整数；

std::round: 舍入取整；

std::lround: 舍入取整, 返回long int；

std::llround: 舍入取整, 返回long long int；

std::nearbyint: 使用当前的舍入模式取整(fegetround())；

std::remainder: 两数除法操作的余数(rounded to nearest)；

std::remquo: 两数除法操作的余数；

std::rint: 使用当前的舍入模式取整(fegetround())；

std::lrint: 使用当前的舍入模式取整(fegetround()),返回long int；

std::llrint: 使用当前的舍入模式取整(fegetround())，返回long longint；

std::exp: e^x;

std::frexp: 将一个浮点数分解为有效数(significand)及以2为底的幂(x = significand* 2^exp);

std::ldexp: x *2^exp;

std::exp2: 2^x;

std::expm1: e^x-1;

std::scalbn: x *FLT_RADIXⁿ;

std::scalbln: x* FLT_RADIXⁿ;

std::log: ln(x);

std::log10: log₁₀(x);

std::modf: 将一个浮点数分解为整数及小数部分；

std::ilogb: 返回以FLT_RADIX为底，|x|的对数值，返回值为整数；

std::log1p: ln(1+x);

std::log2: log₂(x);

std::logb: 返回以FLT_RADIX为底，|x|的对数值，返回值为浮点数；

std::erf: 误差函数；

std::erfc: 互补(complementary)误差函数；

std::tgamma: 伽玛函数；

std::lgamma: log-伽玛函数；

std::copysign(x,y):返回x的值及y的正负符号组成的浮点数；

std::nan: Generatequiet NaN;

std::nextafter(x,y): 返回x之后y方向上的下一个可表示值；

std::nexttoward(x,y): 返回x之后y方向上的下一个可表示值；

std::fdim(x,y): Thefunction returns x-y if x>y, and zero otherwise;

std::fmax: 返回较大的值;

std::fmin: 返回较小的值;

std::fpclassify:为浮点值归类，返回一个类型为int的值；

std::isfinite: 检测是否是有限值；

std::isinf: 检测是否是无穷大值；

std::isnan: 检测是否是非数型；

std::isnormal: 检测是否是normal值，neitherinfinity, NaN, zero or subnormal；

std::signbit: 检测是否是负数；

std::isgreater: 检测第一个数是否大于第二个数；

std::isgreaterequal:检测第一个数是否大于或等于第二个数；

std::isless: 检测第一个数是否小于第二个数；

std::islessequal:检测第一个数是否小于或等于第二个数；

std::islessgreater:检测第一个数是否不等于第二个数；

std::isunordered:检测两个浮点数是否是无序的.

下面是从其它文章中copy的<cmath>测试代码，详细内容介绍可以参考对应的reference：

#include "cmath.hpp"#include <cmath>#include <iostream>#include <fenv.h> // fegetround, FE_*#include <float.h> // FLT_RADIX// reference: http://www.cplusplus.com/reference/cmath/#define PI 3.14159265namespace cmath_ {int test_cmath_abs(){{ // std::abs: double/float/long double/Tstd::cout << "abs (3.141611111) = " << std::abs(3.141611111) << '\n'; // 3.14161std::cout << "abs (-10.6)  = " << std::abs(-10.6f) << '\n'; // 10.6std::cout << "abs ((int)-10)  = " << std::abs((int)-10) << '\n'; // 10}{ // std::fabs: double/float/long double/Tstd::cout << "fabs (3.141611111) = " << std::fabs(3.141611111) << '\n'; // 3.14161std::cout << "fabs (-10.6)  = " << std::fabs(-10.6f) << '\n'; // 10.6}{ // std::fma: Returns x*y+zdouble x, y, z, result;x = 10.0, y = 20.0, z = 30.0;result = std::fma(x, y, z);printf("10.0 * 20.0 + 30.0 = %f\n", result); // 230.0}return 0;}int test_cmath_triangle(){{ // std::sin: double/float/long double/Tdouble param, result;param = 30.0;result = std::sin(param*PI / 180);fprintf(stdout, "The sine of %f degrees is %f.\n", param, result); // 0.5}{ // std::asin: double/float/long double/Tdouble param, result;param = 0.5;result = std::asin(param) * 180.0 / PI;fprintf(stdout, "The arc sine of %f is %f degrees\n", param, result); // 30.0}{ // std::sinh: double/float/long double/Tdouble param, result;param = log(2.0);result = std::sinh(param);printf("The hyperbolic sine of %f is %f.\n", param, result); // 0.75}{ // std::asinh double/float/long double/Tdouble param, result;param = std::exp(2) - std::cosh(2);result = std::asinh(param);fprintf(stdout, "The area hyperbolic sine of %f is %f.\n", param, result); // 2.0}{ // std::cos double/float/long double/Tdouble param, result;param = 60.0;result = std::cos(param * PI / 180.0);fprintf(stdout, "The cosine of %f degrees is %f.\n", param, result); // 0.5}{// std::acos: double/float/long double/Tdouble param, result;param = 0.5;result = std::acos(param) * 180.0 / PI;fprintf(stdout, "The arc cosine of %f is %f degrees.\n", param, result); // 60.0}{ // std::cosh double/float/long double/Tdouble param, result;param = std::log(2.0);result = std::cosh(param);fprintf(stdout, "The hyperbolic cosine of %f is %f.\n", param, result); // 1.25}{ // std::acosh: double/float/long double/Tdouble param, result;param = std::exp(2) - std::sinh(2);result = std::acosh(param);fprintf(stdout, "The area hyperbolic cosine of %f is %f radians.\n", param, result); // 2.0}{ // std::tan: double/float/long double/Tdouble param, result;param = 45.0;result = std::tan(param * PI / 180.0);fprintf(stdout, "The tangent of %f degrees is %f.\n", param, result); // 1.0}{ // std::atan: double/float/long double/Tdouble param, result;param = 1.0;result = std::atan(param) * 180 / PI;fprintf(stdout, "The arc tangent of %f is %f degrees\n", param, result); // 45.0}{ // std::atan2: double/float/long double/Tdouble x, y, result;x = -10.0;y = 10.0;result = std::atan2(y, x) * 180 / PI;fprintf(stdout, "The arc tangent for (x=%f, y=%f) is %f degrees\n", x, y, result); // 135.0}{ // std::tanh: double/float/long double/Tdouble param, result;param = std::log(2.0);result = std::tanh(param);fprintf(stdout, "The hyperbolic tangent of %f is %f.\n", param, result); // 0.6}{ // std::atanh: double/float/long double/Tdouble param, result;param = std::tanh(1);result = std::atanh(param);fprintf(stdout, "The area hyperbolic tangent of %f is %f.\n", param, result); // 1}return 0;}int test_cmath_pow(){{ // std::sqrt(x): Returns the square root of xdouble param, result;param = 1024.0;result = std::sqrt(param);printf("sqrt(%f) = %f\n", param, result); // 32.0}{ // std::cbrt: Compute cubic rootdouble param, result;param = 27.0;result = std::cbrt(param);fprintf(stdout, "cbrt (%f) = %f\n", param, result); // 3.0}{ // std::hypot(x, y): sqrt(x^2+y^2)double leg_x, leg_y, result;leg_x = 3;leg_y = 4;result = std::hypot(leg_x, leg_y);fprintf(stdout, "%f, %f and %f form a right-angled triangle.\n", leg_x, leg_y, result); // 5.0}{ // std::pow(x, y): x^yfprintf(stdout, "7 ^ 3 = %f\n", std::pow(7.0, 3.0)); // 343.0fprintf(stdout, "4.73 ^ 12 = %f\n", std::pow(4.73, 12.0)); // 125410439.217423fprintf(stdout, "32.01 ^ 1.54 = %f\n", std::pow(32.01, 1.54)); // 208.036691fprintf(stdout, "4 ^ 3 = %f\n", std::pow((int)4, (int)3)); // 64.0}return 0;}int test_cmath_integer(){{ // std::ceil(x): returning the smallest integral value that is not less than xfprintf(stdout, "ceil of 2.3 is %.1f\n", std::ceil(2.3)); // 3.0fprintf(stdout, "ceil of 3.8 is %.1f\n", std::ceil(3.8)); // 4.0fprintf(stdout, "ceil of -2.3 is %.1f\n", std::ceil(-2.3)); // -2.0fprintf(stdout, "ceil of -3.8 is %.1f\n", std::ceil(-3.8)); // -3.0}{ // std::floor returning the largest integral value that is not greater than xfprintf(stdout, "floor of 2.3 is %.1lf\n", std::floor(2.3)); // 2.0fprintf(stdout, "floor of 3.8 is %.1lf\n", std::floor(3.8)); // 3.0fprintf(stdout, "floor of -2.3 is %.1lf\n", std::floor(-2.3)); // -2.0fprintf(stdout, "floor of -3.8 is %.1lf\n", std::floor(-3.8)); // -3.0}{ // std::fmod: Returns the floating-point remainder of numer/denom(rounded towards zero)printf("fmod of 5.3 / 2 is %f\n", std::fmod(5.3, 2)); // fmod of 5.3 / 2 is 1.3printf("fmod of 18.5 / 4.2 is %f\n", std::fmod(18.5, 4.2)); // fmod of 18.5 / 4.2 is 1.7}{ // std::trunc(x): Rounds x toward zero, returning the nearest integral value that is not larger in magnitude than x.  // std::round(x): Returns the integral value that is nearest to xconst char * format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";printf("value\tround\tfloor\tceil\ttrunc\n");printf("-----\t-----\t-----\t----\t-----\n"); // round  floor  ceil  truncprintf(format, 2.3, std::round(2.3), std::floor(2.3), std::ceil(2.3), std::trunc(2.3)); // 2.0     2.0    3.0   2.0printf(format, 3.8, std::round(3.8), std::floor(3.8), std::ceil(3.8), std::trunc(3.8)); // 4.0     3.0    4.0   3.0printf(format, 5.5, std::round(5.5), std::floor(5.5), std::ceil(5.5), std::trunc(5.5)); // 6.0     5.0    6.0   5.0printf(format, -2.3, std::round(-2.3), std::floor(-2.3), std::ceil(-2.3), std::trunc(-2.3)); // -2.0    -3.0   -2.0  -2.0printf(format, -3.8, std::round(-3.8), std::floor(-3.8), std::ceil(-3.8), std::trunc(-3.8)); // -4.0    -4.0   -3.0  -3.0printf(format, -5.5, std::round(-5.5), std::floor(-5.5), std::ceil(-5.5), std::trunc(-5.5)); // -6.0    -6.0   -5.0  -5.0}{ // std::lround: Returns the integer value that is nearest in value to xprintf("lround (2.3) = %ld\n", std::lround(2.3)); // 2printf("lround (3.8) = %ld\n", std::lround(3.8)); // 4printf("lround (-2.3) = %ld\n", std::lround(-2.3)); // -2printf("lround (-3.8) = %ld\n", std::lround(-3.8)); // -4}{ // std::llround(x): Returns the integer value that is nearest in value to xprintf("llround (2.3) = %lld\n", std::llround(2.3)); // 2printf("llround (3.8) = %lld\n", std::llround(3.8)); // 4printf("llround (-2.3) = %lld\n", std::llround(-2.3)); // -2printf("llround (-3.8) = %lld\n", std::llround(-3.8)); // -4}{ // std::nearbyint: Round to nearby integral valueprintf("rounding using ");switch (fegetround()) {case FE_DOWNWARD: printf("downward"); break;case FE_TONEAREST: printf("to-nearest"); break; // to-nearestcase FE_TOWARDZERO: printf("toward-zero"); break;case FE_UPWARD: printf("upward"); break;default: printf("unknown");}printf(" rounding:\n");printf("nearbyint (2.3) = %.1f\n", std::nearbyint(2.3)); // 2.0printf("nearbyint (3.8) = %.1f\n", std::nearbyint(3.8)); // 4.0printf("nearbyint (-2.3) = %.1f\n", std::nearbyint(-2.3)); // -2.0printf("nearbyint (-3.8) = %.1f\n", std::nearbyint(-3.8)); // -4.0}{ // std::remainder: Returns the floating-point remainder of numer/denom(rounded to nearest)printf("remainder of 5.3 / 2 is %f\n", std::remainder(5.3, 2)); // remainder of 5.3 / 2 is -0.7printf("remainder of 18.5 / 4.2 is %f\n", std::remainder(18.5, 4.2)); // remainder of 18.5 / 4.2 is 1.7}{ // std::remquo: Returns the same as remainder, but it additionally stores the quotient  // internally used to determine its result in the object pointed by quotdouble numer = 10.3;double denom = 4.5;int quot;double result = std::remquo(numer, denom, ");printf("numerator: %f\n", numer); // 10.3printf("denominator: %f\n", denom); // 4.5printf("remainder: %f\n", result); // 1.3printf("quotient: %d\n", quot); // 2}{ // std::rint: Round to integral valueprintf("rounding using ");switch (fegetround()) {case FE_DOWNWARD: printf("downward"); break;case FE_TONEAREST: printf("to-nearest"); break; // to-nearestcase FE_TOWARDZERO: printf("toward-zero"); break;case FE_UPWARD: printf("upward"); break;default: printf("unknown");}printf(" rounding:\n");printf("rint (2.3) = %.1f\n", std::rint(2.3)); // 2.0printf("rint (3.8) = %.1f\n", std::rint(3.8)); // 4.0printf("rint (-2.3) = %.1f\n", std::rint(-2.3)); // -2.0printf("rint (-3.8) = %.1f\n", std::rint(-3.8)); // -4.0}{ // std::lrint: Rounds x to an integral value, and returns it as a value of type long int.printf("rounding using ");switch (fegetround()) {case FE_DOWNWARD: printf("downward"); break;case FE_TONEAREST: printf("to-nearest"); break; // to-nearestcase FE_TOWARDZERO: printf("toward-zero"); break;case FE_UPWARD: printf("upward"); break;default: printf("unknown");}printf(" rounding:\n");printf("lrint (2.3) = %ld\n", std::lrint(2.3)); // 2printf("lrint (3.8) = %ld\n", std::lrint(3.8)); // 4printf("lrint (-2.3) = %ld\n", std::lrint(-2.3)); // -2printf("lrint (-3.8) = %ld\n", std::lrint(-3.8)); // -4}{ // std::llrint: Rounds x to an integral value,returns it as a value of type long long intprintf("rounding using ");switch (fegetround()) {case FE_DOWNWARD: printf("downward"); break;case FE_TONEAREST: printf("to-nearest"); break; // to-nearestcase FE_TOWARDZERO: printf("toward-zero"); break;case FE_UPWARD: printf("upward"); break;default: printf("unknown");}printf(" rounding:\n");printf("llrint (2.3) = %lld\n", std::llrint(2.3)); // 2printf("llrint (3.8) = %lld\n", std::llrint(3.8)); // 4printf("llrint (-2.3) = %lld\n", std::llrint(-2.3)); // -2printf("llrint (-3.8) = %lld\n", std::llrint(-3.8)); // -4}return 0;}int test_cmath_exp(){{ // std::exp: Returns the base-e exponential function of x, e^xdouble param, result;param = 1.0;result = std::exp(param);printf("The exponential value of %f is %f.\n", param, result); // 1.0 2.718282}{ // std::frexp(x, int* exp):Breaks the floating point number x into its binary significand  // (a floating point with an absolute value between 0.5(included) and 1.0(excluded)) and an integral exponent for 2  // x = significand * (2 ^ exponent)double param, result;int n;param = 8.0;result = std::frexp(param, &n);printf("%f = %f * 2^%d\n", param, result, n); // 8.0 = 0.5 * 2^4}{ // std::ldexp: Returns the result of multiplying x (the significand) by 2 raised to the power of exp (the exponent)double param, result;int n;param = 0.95;n = 4;result = std::ldexp(param, n);printf("%f * 2^%d = %f\n", param, n, result); // 0.95 * 2^4 = 15.2}{ // std::exp2: Returns the base-2 exponential function of xdouble param, result;param = 8.0;result = std::exp2(param);printf("2 ^ %f = %f.\n", param, result); // 2^8 = 256}{ // std::expm1: Compute exponential minus onedouble param, result;param = 1.0;result = std::expm1(param);printf("expm1 (%f) = %f.\n", param, result); // expm1(1.0) = 1.718282}{ // std::scalbn: Scales x by FLT_RADIX raised to the power of ndouble param, result;int n;param = 1.50;n = 4;result = std::scalbn(param, n);printf("%f * %d^%d = %f\n", param, FLT_RADIX, n, result); // 1.5 * 2^4 = 24.0}{ // std::scalbln: Scales x by FLT_RADIX raised to the power of ndouble param, result;long n;param = 1.50;n = 4L;result = std::scalbln(param, n);printf("%f * %d^%d = %f\n", param, FLT_RADIX, n, result); // 1.5 * 2^4 = 24.0}return 0;}int test_cmath_log(){{ // std::log: Returns the natural logarithm of x  // The natural logarithm is the base-e logarithm: the inverse of the natural exponential function (exp)double param, result;param = 5.5;result = std::log(param);printf("log(%f) = %f\n", param, result); // ln(5.5) = 1.704748}{ // std::log10: Returns the common (base-10) logarithm of xdouble param, result;param = 1000.0;result = std::log10(param);printf("log10(%f) = %f\n", param, result); // log10(1000.0) = 3.0}{ // std::modf: Breaks x into an integral and a fractional partdouble param, fractpart, intpart;param = 3.14159265;fractpart = std::modf(param, &intpart);printf("%f = %f + %f \n", param, intpart, fractpart); // 3.14159265 = 3.0 + 0.141593}{ // std::ilogb: Returns the integral part of the logarithm of |x|, using FLT_RADIX as base for the logarithm.double param;int result;param = 10.0;result = std::ilogb(param);printf("ilogb(%f) = %d\n", param, result); // ilogb(10.0) = 3}{ // std::log1p: Returns the natural logarithm of one plus xdouble param, result;param = 1.0;result = std::log1p(param);printf("log1p (%f) = %f.\n", param, result); // log1p(1.0) = 0.693147}{ // std::log2: Returns the binary (base-2) logarithm of x.double param, result;param = 1024.0;result = std::log2(param);printf("log2 (%f) = %f.\n", param, result); // log2(1024.0) = 10.0}{ // std::logb: Returns the logarithm of |x|, using FLT_RADIX as base for the logarithmdouble param, result;param = 1024.0;result = std::logb(param);printf("logb (%f) = %f.\n", param, result); // logb(1024.0) = 10.0}return 0;}int test_cmath_error(){{ // std::erf: Returns the error function value for x.double param, result;param = 1.0;result = std::erf(param);printf("erf (%f) = %f\n", param, result); // erf(1.0) = 0.842701}{ // std::erfc: Returns the complementary error function value for xdouble param, result;param = 1.0;result = std::erfc(param);printf("erfc(%f) = %f\n", param, result); // erfc(1.0) = 0.157299}{ // std::tgamma: Compute gamma functiondouble param, result;param = 0.5;result = std::tgamma(param);printf("tgamma(%f) = %f\n", param, result); // tgamma(0.5) = 1.772454}{ // std::lgamma: Compute log-gamma functiondouble param, result;param = 0.5;result = std::lgamma(param);printf("lgamma(%f) = %f\n", param, result); // lgamma(0.5) = 0.572365}return 0;}int test_cmath_1(){{ // std::copysign: Returns a value with the magnitude of x and the sign of yprintf("copysign ( 10.0,-1.0) = %f\n", std::copysign(10.0, -1.0)); // -10.0printf("copysign (-10.0,-1.0) = %f\n", std::copysign(-10.0, -1.0)); // -10.0printf("copysign (-10.0, 1.0) = %f\n", std::copysign(-10.0, 1.0)); // 10.0}{ // std::nan: Returns a quiet NaN (Not-A-Number) value of type double.}{ // std::nextafter: Returns the next representable value after x in the direction of yprintf("first representable value greater than zero: %e\n", std::nextafter(0.0, 1.0)); // 4.940656e-324printf("first representable value less than zero: %e\n", std::nextafter(0.0, -1.0)); // -4.940656e-324}{ // std::nexttoward: Returns the next representable value after x in the direction of yprintf("first representable value greater than zero: %e\n", std::nexttoward(0.0, 1.0L)); // 4.940656e-324printf("first representable value less than zero: %e\n", std::nexttoward(0.0, -1.0L)); // -4.940656e-324}return 0;}int test_cmath_2(){{ // std::fdim: The function returns x-y if x>y, and zero otherwise.printf("fdim (2.0, 1.0) = %f\n", std::fdim(2.0, 1.0)); // 1.0printf("fdim (1.0, 2.0) = %f\n", std::fdim(1.0, 2.0)); // 0.0printf("fdim (-2.0, -1.0) = %f\n", std::fdim(-2.0, -1.0)); // 0.0printf("fdim (-1.0, -2.0) = %f\n", std::fdim(-1.0, -2.0)); // 1.0}{ // std::fmax: Returns the larger of its arguments: either x or yprintf("fmax (100.0, 1.0) = %f\n", std::fmax(100.0, 1.0)); // 100.0printf("fmax (-100.0, 1.0) = %f\n", std::fmax(-100.0, 1.0)); // 1.0printf("fmax (-100.0, -1.0) = %f\n", std::fmax(-100.0, -1.0)); // -1.0}{ // std::fmin: Returns the smaller of its arguments: either x or yprintf("fmin (100.0, 1.0) = %f\n", std::fmin(100.0, 1.0)); // 1.0printf("fmin (-100.0, 1.0) = %f\n", std::fmin(-100.0, 1.0)); // -100.0printf("fmin (-100.0, -1.0) = %f\n", std::fmin(-100.0, -1.0)); // -100.0}return 0;}int test_cmath_classify(){{ // std::fpclassify: Returns a value of type int that matches one of the classification  // macro constants, depending on the value of xdouble d = std::sqrt(-1.0); // 1.0 / 0.0;switch (std::fpclassify(d)) {case FP_INFINITE:  printf("infinite");  break;case FP_NAN:       printf("NaN");       break; // NaNcase FP_ZERO:      printf("zero");      break;case FP_SUBNORMAL: printf("subnormal"); break;case FP_NORMAL:    printf("normal");    break;}if (std::signbit(d)) printf(" negative\n"); // negativeelse printf(" positive or unsigned\n");}{ // std::isfinite: Returns whether x is a finite valueprintf("isfinite(0.0)       : %d\n", std::isfinite(0.0)); // 1//printf("isfinite(1.0/0.0)   : %d\n", std::isfinite(1.0 / 0.0));//printf("isfinite(-1.0/0.0)  : %d\n", std::isfinite(-1.0 / 0.0));printf("isfinite(sqrt(-1.0)): %d\n", std::isfinite(std::sqrt(-1.0))); // 0}{ // std::isinf: Returns whether x is an infinity value printf("isinf(0.0)       : %d\n", std::isinf(0.0)); // 0//printf("isinf(1.0/0.0)   : %d\n", std::isinf(1.0 / 0.0));//printf("isinf(-1.0/0.0)  : %d\n", std::isinf(-1.0 / 0.0));printf("isinf(sqrt(-1.0)): %d\n", std::isinf(std::sqrt(-1.0))); // 0}{ // std::isnan: Returns whether x is a NaN (Not-A-Number) value.printf("isnan(0.0)       : %d\n", std::isnan(0.0)); // 0//printf("isnan(1.0/0.0)   : %d\n", std::isnan(1.0 / 0.0));//printf("isnan(-1.0/0.0)  : %d\n", std::isnan(-1.0 / 0.0));printf("isnan(sqrt(-1.0)): %d\n", std::isnan(std::sqrt(-1.0))); // 1}{ // std::isnormal: Returns whether x is a normal value  // i.e., whether it is neither infinity, NaN, zero or subnormalprintf("isnormal(1.0)    : %d\n", std::isnormal(1.0)); // 1printf("isnormal(0.0)    : %d\n", std::isnormal(0.0)); // 0//printf("isnormal(1.0/0.0): %d\n", std::isnormal(1.0 / 0.0));}{ // std::signbit: Returns whether the sign of x is negativeprintf("signbit(0.0)       : %d\n", std::signbit(0.0)); // 0//printf("signbit(1.0/0.0)   : %d\n", std::signbit(1.0 / 0.0));//printf("signbit(-1.0/0.0)  : %d\n", std::signbit(-1.0 / 0.0));printf("signbit(sqrt(-1.0)): %d\n", std::signbit(std::sqrt(-1.0))); // 1}return 0;}int test_cmath_compare(){double result;result = std::log(10.0);{ // std::isgreater: Returns whether x is greater than yif (std::isgreater(result, 0.0))printf("log(10.0) is positive\n"); // log(10.0) is positiveelseprintf("log(10.0) is not positive\n");}{ // std::isgreaterequal: Returns whether x is greater than or equal to yif (std::isgreaterequal(result, 0.0))printf("log(10.0) is not negative\n"); // log(10.0) is not negativeelseprintf("log(10.0) is negative\n");}{ // std::isless: Returns whether x is less than yif (std::isless(result, 0.0))printf("log(10.0) is negative\n");elseprintf("log(10.0) is not negative\n"); // log(10.0) is not negative}{ // std::islessequal: Returns whether x is less than or equal to yif (std::islessequal(result, 0.0))printf("log(10.0) is not positive\n");elseprintf("log(10.0) is positive\n"); // log(10.0) is positive}{ // std::islessgreater: Returns whether x is less than or greater than yif (islessgreater(result, 0.0))printf("log(10.0) is not zero\n"); // log(10.0) is not zeroelseprintf("log(10.0) is zero\n");}{ // std::isunordered: Returns whether x or y are unordered valuesdouble result;result = std::sqrt(-1.0);if (std::isunordered(result, 0.0))printf("sqrt(-1.0) and 0.0 cannot be ordered\n"); // sqrt(-1.0) and 0.0 cannot be orderedelseprintf("sqrt(-1.0) and 0.0 can be ordered\n");}return 0;}} // namespace cmath_

GitHub： https://github.com/fengbingchun/Messy_Test