Deklaracja
int fpclassify(floating-type x); int isfinite (floating-type x); int isinf (floating-type x); int isnan (floating-type x); int isnormal (floating-type x); int signbit (floating-type x);
#define FP_INFINITE wartość #define FP_NAN wartość #define FP_NORMAL wartość #define FP_SUBNORMAL wartość #define FP_ZERO wartość
// from /usr/include/math.h /* ISO C99 defines some generic macros which work on any data type. */ #ifdef __USE_ISOC99
/* All floating-point numbers can be put in one of these categories. */ enum
FP_NAN = # define FP_NAN 0 FP_NAN, FP_INFINITE = # define FP_INFINITE 1 FP_INFINITE, FP_ZERO = # define FP_ZERO 2 FP_ZERO, FP_SUBNORMAL = # define FP_SUBNORMAL 3 FP_SUBNORMAL, FP_NORMAL = # define FP_NORMAL 4 FP_NORMAL
Plik nagłówkowy math.h
Argumenty x wartość do sprawdzenia
Opis Funkcje (w zasadzie makra) klasyfikują wartość podaną jako argument. Są to makra, które przyjmują jako argumenty zmienne dowolnych typów zmiennoprzecinkowych.
Stałe FP_* określają wartości zwracane przez funkcję fpclassify. Konkretne implementacje mogą definiować własne stałe zaczynające się od FP_ i wielkiej litery określające inne klasyfikacje liczb.
Wartość zwracana fpclassify - klasyfikuje wartość argumentu i zwraca jedną z wartości określonych przez makra FP_INFINITE, FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO lub inne makra FP_* zależne od implementacji,| Rudimentary test program for floating-point classification isfinite - zwraca wartość niezerową jeżeli argument jest liczbą skończoną, isinf - zwraca wartość niezerową jeżeli argument jest liczbą nieskończoną,delftstack :infinity-in-c by Abdul Mateen Oct-26, 2022 isnan - zwraca wartośc niezerową jeżeli argument reprezentuje wartość NaN, isnormal - zwraca wartość niezerową jeżeli argument reprezentuje zwykłą liczbę rzeczywitą, signbit - zwraca wartość niezerową jeżeli znak argumentu jest ujemny.
Przykład użycia
isnan
Sprawdzanie zakresu : double x, r;
if (isnan(x) || islessequal(x, 0))
{ /* Deal with NaN / pole error / domain error */ }
r = log(x);
Klasyfikacja liczb Program klasyfikuje liczby zmiennoprzecinkowe podane w formie binarnej jako argumenty.
#include #include #include #include
void wyswietl_liczbe(char* s) { union { uint32_t bin; /* binarna reprezentacja */ float zmiennoprzecinkowa; /* liczby zmiennoprzecinkowej */ } liczba;
liczba.bin = 0; liczba.bin = strtoul(s, NULL, 0); /* tutaj bez sprawdzania błędów, domyślnie zero */
switch (fpclassify(liczba.zmiennoprzecinkowa)) { case FP_NAN: printf("0x%08x => NaN (nie liczba)\n", liczba.bin); break; case FP_INFINITE: printf("0x%08x => nieskończoność\n", liczba.bin); break; case FP_ZERO: printf("0x%08x => zero\n", liczba.bin); break; case FP_SUBNORMAL: printf("0x%08x => liczba zdenormalizowana\n", liczba.bin); break; case FP_NORMAL: printf("0x%08x => liczba o wartości %f\n", liczba.bin, liczba.zmiennoprzecinkowa ); break;
int main(int argc, char* argv[]) { int i;
if (argc < 2) { fprintf( stderr, "Podaj liczby szesnastkowe, które zostaną zainterpretowane jako " "liczba zmiennoprzecinkowa pojedynczej precyzji\n" ); return EXIT_FAILURE; } else for (i=1; i zero 0x7f800000 => nieskończoność 0x7fc00000 => NaN (nie liczba) 0xbadcafe0 => liczba o wartości -0.001684 0xdeedbeef => liczba o wartości -8565696407921491968.000000 0x00000001 => liczba zdenormalizowana
Sprawdzanie typu i znaku
/* http://homepages.cs.ncl.ac.uk/nick.cook/csc2025/minix/3.2.1/usr/src/test/test47.c by Nick Cook
gcc f.c -Wall -lm ./a.out >r.txt */
#include // fpclassify #include #include #include
/* Maximum normal double: (2 - 2^(-53)) * 2^1023 */ #define NORMAL_DOUBLE_MAX DBL_MAX // = 1.797693134862315708145274237317e+308
/* Minimum normal double: 2^(-1022) */ #define NORMAL_DOUBLE_MIN DBL_MIN // = 2.2250738585072013830902327173324e-308
/* Maximum subnormal double: (1 - 2^(-53)) * 2^(-1022) */ #define SUBNORMAL_DOUBLE_MAX 2.2250738585072008890245868760859e-308
/* Minimum subnormal double: 2^(-52) * 2^(-1023) */ #define SUBNORMAL_DOUBLE_MIN 4.9406564584124654417656879286822e-324
static int test_fpclassify(double value, int class) { /* test fpclassify */ if (fpclassify(value) != class) {printf("%.16e class bad,", value); } else printf("%.16e class good,", value);
if (fpclassify(-value) != class) {printf(" bad class of - value ");return 102;}
/* test signbit */ if (signbit(value)) {printf("sign neg \n"); return 103;} // return a non-zero value if and only if the sign of its argument value is negative. else {printf("sign pos \n"); return 104;} if (!signbit(-value)) return 105;
return 0; }
static void test_fpclassify_values(void) { double d;
printf(" test some corner cases for fpclassify and signbit \n\n"); test_fpclassify(NAN, FP_NAN); test_fpclassify(INFINITY, FP_INFINITE); test_fpclassify(NORMAL_DOUBLE_MAX, FP_NORMAL); test_fpclassify(1, FP_NORMAL); test_fpclassify(NORMAL_DOUBLE_MIN, FP_NORMAL); test_fpclassify(SUBNORMAL_DOUBLE_MAX, FP_SUBNORMAL); test_fpclassify(SUBNORMAL_DOUBLE_MIN, FP_SUBNORMAL); test_fpclassify(0, FP_ZERO);
printf("\n test other small numbers for fpclassify and signbit \n"); d = 1; while (d >= NORMAL_DOUBLE_MIN) { test_fpclassify(d, FP_NORMAL); d /= 10; } while (d >= SUBNORMAL_DOUBLE_MIN) { test_fpclassify(d, FP_SUBNORMAL); d /= 10; } test_fpclassify(d, FP_ZERO);
/* test other large numbers for fpclassify and signbit */ d = 1; while (d <= NORMAL_DOUBLE_MAX / 10) { test_fpclassify(d, FP_NORMAL); d *= 10;
int main()
/* test various floating point support functions */ test_fpclassify_values();
return 0; }
Wynik :
test some corner cases for fpclassify and signbit
nan class good,sign pos inf class good,sign pos 1.7976931348623157e+308 class good,sign pos 1.0000000000000000e+00 class good,sign pos 2.2250738585072014e-308 class good,sign pos 2.2250738585072009e-308 class good,sign pos 4.9406564584124654e-324 class good,sign pos 0.0000000000000000e+00 class good,sign pos
test other small numbers for fpclassify and signbit 1.0000000000000000e+00 class good,sign pos 1.0000000000000001e-01 class good,sign pos 1.0000000000000000e-02 class good,sign pos 1.0000000000000000e-03 class good,sign pos 1.0000000000000000e-04 class good,sign pos 1.0000000000000001e-05 class good,sign pos 1.0000000000000002e-06 class good,sign pos ... 9.9998886718268301e-321 class good,sign pos 9.9801260459931802e-322 class good,sign pos 9.8813129168249309e-323 class good,sign pos 9.8813129168249309e-324 class good,sign pos 0.0000000000000000e+00 class good,sign pos 1.0000000000000000e+00 class good,sign pos 1.0000000000000000e+01 class good,sign pos 1.0000000000000000e+02 class good,sign pos 1.0000000000000000e+03 class good,sign pos 1.0000000000000000e+04 class good,sign pos 1.0000000000000000e+05 class good,sign pos 1.0000000000000000e+06 class good,sign pos 1.0000000000000000e+07 class good,sign pos 1.0000000000000000e+08 class good,sign pos 1.0000000000000000e+09 class good,sign pos 1.0000000000000000e+10 class good,sign pos 1.0000000000000000e+11 class good,sign pos ... 1.0000000000000002e+301 class good,sign pos 1.0000000000000001e+302 class good,sign pos 1.0000000000000000e+303 class good,sign pos 9.9999999999999994e+303 class good,sign pos 9.9999999999999994e+304 class good,sign pos 9.9999999999999986e+305 class good,sign pos 9.9999999999999986e+306 class good,sign pos
Uwagi Funkcja została dodana do języka w standardzie C99.
W przypadku użycia funkcji matematycznych może zaistnieć konieczność podania odpowiedniego argumentu linkerowi, aby ten połączył program z biblioteką matematyczną. Np. na systemach GNU/Linux jest to -lm.
Wartości stałych są liczbami całkowitymi ( niekoniecznie zgodnymi z naszymi oczekiwaniami) : #include #include // fpclassify
int main(void) { printf(" p = %d \n",FP_ZERO); printf(" p = %f \n",(double)FP_ZERO); return 0; }
przykładowy wynik :
p = 2 p = 2.000000
Zobacz też matherr
Odnośniki