nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl

Параметры

Возвращаемое значение

Если ошибок не возникает, возвращается следующее представимое значение from в направлении to . Если from равно to , тогда возвращается to , преобразованное в тип функции.

Если происходит ошибка диапазона из-за переполнения, возвращается ± HUGE_VAL , ±HUGE_VALF , или ±HUGE_VALL (с тем же знаком, что и from ).

Если происходит ошибка диапазона из-за потери значимости (underflow), возвращается корректный результат.

Обработка ошибок

Ошибки сообщаются, как указано в math_errhandling .

Если реализация поддерживает арифметику с плавающей запятой IEEE (IEC 60559),

• если from конечно, но ожидаемый результат является бесконечностью, возбуждает FE_INEXACT и FE_OVERFLOW .
• если from не равно to и результат является субнормальным или нулевым, возбуждает FE_INEXACT и FE_UNDERFLOW .
• в любом случае возвращаемое значение не зависит от текущего режима округления
• если либо from либо to является NaN, возвращается NaN.

Примечания

POSIX определяет что условия переполнения и потери значимости являются ошибками диапазона ( errno может быть установлен).

IEC 60559 рекомендует, чтобы from возвращалось всякий раз, когда from == to . Эти функции вместо этого возвращают to , что делает поведение вокруг нуля последовательным: nextafter(-0.0, +0.0) возвращает + 0.0 , а nextafter(+0.0, -0.0) возвращает - 0.0 .

nextafter обычно реализуется через манипуляции с IEEE представлением ( glibc musl ).

Пример

#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
int main(void)
{
    float from1 = 0, to1 = nextafterf(from1, 1);
    printf("Следующее представимое число с плавающей запятой после %.2f это %.20g (%a)\n", from1, to1, to1);
    float from2 = 1, to2 = nextafterf(from2, 2);
    printf("Следующее представимое число с плавающей запятой после %.2f это %.20f (%a)\n", from2, to2, to2);
    double from3 = nextafter(0.1, 0), to3 = 0.1;
    printf("Число 0.1 находится между двумя допустимыми значениями double:\n"
           "    %.56f (%a)\nи %.55f  (%a)\n", from3, from3, to3, to3);
    // разница между nextafter и nexttoward:
    long double dir = nextafterl(from1, 1); // первое субнормальное long double
    float x = nextafterf(from1, dir); // сначала преобразует dir в float, получая 0
    printf("Используя nextafter, следующее число float после %.2f (%a) это %.20g (%a)\n",
           from1, from1, x, x);
    x = nexttowardf(from1, dir);
    printf("Используя nexttoward, следующее число float после %.2f (%a) это %.20g (%a)\n",
           from1, from1, x, x);
    // специальные значения
    {
        #pragma STDC FENV_ACCESS ON
        feclearexcept(FE_ALL_EXCEPT);
        double from4 = DBL_MAX, to4 = nextafter(from4, INFINITY);
        printf("Следующее представимое число double после %.2g (%a) это %.23f (%a)\n",
               from4, from4, to4, to4);
        if(fetestexcept(FE_OVERFLOW)) puts("   вызвано FE_OVERFLOW");
        if(fetestexcept(FE_INEXACT)) puts("   вызвано FE_INEXACT");
    } // конец блока FENV_ACCESS
    float from5 = 0.0, to5 = nextafter(from5, -0.0);
    printf("nextafter(+0.0, -0.0) дает %.2g (%a)\n", to5, to5);
}

Следующее представимое число с плавающей запятой после 0.00 это 1.4012984643248170709e-45 (0x1p-149)
Следующее представимое число с плавающей запятой после 1.00 это 1.00000011920928955078 (0x1.000002p+0)
Число 0.1 находится между двумя допустимыми значениями double:
    0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)
и 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)
Используя nextafter, следующее число float после 0.00 (0x0p+0) это 0 (0x0p+0)
Используя nexttoward, следующее число float после 0.00 (0x0p+0) это 1.4012984643248170709e-45 (0x1p-149)
Следующее представимое число double после 1.8e+308 (0x1.fffffffffffffp+1023) это inf (inf)
   вызвано FE_OVERFLOW
   вызвано FE_INEXACT
nextafter(+0.0, -0.0) дает -0 (-0x0p+0)

Ссылки

Смотрите также