std:: nextafter, std:: nextafterf, std:: nextafterl, std:: nexttoward, std:: nexttowardf, std:: nexttowardl

from 의 다음 표현 가능한 값을 to 방향으로 반환합니다.

매개변수

반환값

오류가 발생하지 않으면, from 의 다음 표현 가능한 값이 to 방향으로 반환됩니다. 만약 from 이 to 와 같다면, to 가 반환됩니다.

오버플로로 인한 범위 오류가 발생하면, ±HUGE_VAL , ±HUGE_VALF , 또는 ±HUGE_VALL 가 반환됩니다 ( from 과 동일한 부호로).

언더플로로 인해 범위 오류가 발생하면 올바른 결과가 반환됩니다.

오류 처리

오류는 math_errhandling 에 명시된 대로 보고됩니다.

구현이 IEEE 부동 소수점 연산(IEC 60559)을 지원하는 경우,

• from 이 유한하지만 예상 결과가 무한대인 경우, FE_INEXACT 와 FE_OVERFLOW 를 발생시킵니다.
• from 이 to 와 같지 않고 결과가 서브노멀 또는 0인 경우, FE_INEXACT 와 FE_UNDERFLOW 를 발생시킵니다.
• 어떤 경우든 반환되는 값은 현재 반올림 모드와 무관합니다.
• from 또는 to 중 하나가 NaN인 경우 NaN이 반환됩니다.

참고 사항

POSIX는 오버플로우 및 언더플로우 조건이 범위 오류( errno 가 설정될 수 있음)라고 명시합니다.

IEC 60559는 from 이 from == to 일 때마다 from 을 반환할 것을 권장합니다. 하지만 이 함수들은 대신 to 를 반환하여, 0 주변의 동작을 일관성 있게 만듭니다: std :: nextafter ( - 0.0 , + 0.0 ) 는 + 0.0 을 반환하고, std :: nextafter ( + 0.0 , - 0.0 ) 는 - 0.0 을 반환합니다.

std::nextafter 는 일반적으로 IEEE 표현 방식을 조작하여 구현됩니다 ( glibc , musl ).

추가적인 std::nextafter 오버로드는 반드시 (A) 와 동일하게 제공될 필요가 없습니다. 이들은 단지 첫 번째 인수 num1 와 두 번째 인수 num2 에 대해 다음을 보장하기에 충분하기만 하면 됩니다:

추가적인 std::nexttoward 오버로드는 반드시 (B) 와 동일하게 제공될 필요가 없습니다. 이들은 정수 타입의 인자 num 에 대해, std :: nexttoward ( num ) 가 std :: nexttoward ( static_cast < double > ( num ) ) 와 동일한 효과를 가지도록 보장하기에 충분하기만 하면 됩니다.

예제

#include <cfenv>
#include <cfloat>
#include <cmath>
#include <concepts>
#include <iomanip>
#include <iostream>
int main()
{
    float from1 = 0, to1 = std::nextafter(from1, 1.f);
    std::cout << "다음으로 표현 가능한 float 값은 " << std::setprecision(20) << from1
              << "는 " << to1
              << std::hexfloat << " (" << to1 << ")\n" << std::defaultfloat;
    float from2 = 1, to2 = std::nextafter(from2, 2.f);
    std::cout << "다음으로 표현 가능한 float 값은 " << from2 << "는 " << to2
              << std::hexfloat << " (" << to2 << ")\n" << std::defaultfloat;
    double from3 = std::nextafter(0.1, 0), to3 = 0.1;
    std::cout << "숫자 0.1은 두 개의 유효한 double 값 사이에 있습니다:\n"
              << std::setprecision(56) << "    " << from3
              << std::hexfloat << " (" << from3 << ')' << std::defaultfloat
**번역 결과:**
std::defaultfloat
**번역 설명:**
- HTML 태그와 속성은 그대로 유지
- ``, `` 태그 내부의 텍스트는 C++ 관련 용어이므로 번역하지 않음
- `std::defaultfloat`은 C++ 표준 라이브러리 매니퓰레이터로 전문 용어이므로 원문 유지
- 링크 구조와 클래스 속성 모두 원본 형식 그대로 보존
              << "\n및 " << to3 << std::hexfloat << "  (" << to3 << ")\n"
              << std::defaultfloat
**번역 결과:**
std::defaultfloat
**번역 설명:**
- HTML 태그와 속성은 그대로 유지
- `` 태그 내의 텍스트는 C++ 관련 용어이므로 번역하지 않음
- `std::defaultfloat`은 C++ 표준 라이브러리 매니퓰레이터로 원문 유지
- 전체 구조와 포맷팅 완벽하게 보존 << std::setprecision(20);
    std::cout << "\nnextafter와 nexttoward의 차이점:\n";
    long double dir = std::nextafter(from1, 1.0L); // 첫 번째 서브노멀 long double
    float x = std::nextafter(from1, dir); // 먼저 dir을 float로 변환하여 0을 제공합니다
    std::cout << "With nextafter, 다음 float 값은 " << from1 << "는 " << x << '\n';
    x = std::nexttoward(from1, dir);
    std::cout << "With nexttoward, 다음 float 값은 " << from1 << "는 " << x << '\n';
    std::cout << "\n특수 값:\n";
    {
        // #pragma STDC FENV_ACCESS ON
        std::feclearexcept(FE_ALL_EXCEPT);
        double from4 = DBL_MAX, to4 = std::nextafter(from4, INFINITY);
        std::cout << "다음으로 표현 가능한 double 값은 " << std::setprecision(6)
                  << from4 << std::hexfloat << " (" << from4 << ')'
                  << std::defaultfloat
**번역 결과:**
std::defaultfloat
**번역 설명:**
- HTML 태그와 속성은 그대로 유지
- C++ 특정 용어(std::defaultfloat)는 번역하지 않음
- 태그 내부의 텍스트도 C++ 용어이므로 번역하지 않음
- 링크 구조와 클래스 속성은 완전히 보존 << "는 " << to4
                  << std::hexfloat << " (" << to4 << ")\n" << std::defaultfloat
**번역 결과:**
std::defaultfloat
**번역 설명:**
- HTML 태그와 속성은 그대로 유지
- `` 태그 내의 텍스트는 C++ 관련 용어이므로 번역하지 않음
- `std::defaultfloat`은 C++ 표준 라이브러리 매니퓰레이터로 원문 그대로 보존;
        if (std::fetestexcept(FE_OVERFLOW))
            std::cout << "   FE_OVERFLOW가 발생했습니다\n";
        if (std::fetestexcept(FE_INEXACT))
            std::cout << "   FE_INEXACT가 발생했습니다\n";
    } // FENV_ACCESS 블록 종료
    float from5 = 0.0, to5 = std::nextafter(from5, -0.0);
    std::cout << "std::nextafter(+0.0, -0.0) gives " << std::fixed
**번역 결과:**
HTML 태그와 속성은 번역하지 않고 원본 형식을 유지합니다. ``, `
`, `$`\; 태그\; 내의\; 텍스트는\; 번역하지\; 않습니다.\; C++\; 관련\; 용어는\; 번역하지\; 않습니다.\; 정확성과\; 전문성을\; 요구합니다.\; 주어진\; 텍스트는\; HTML\; 태그와\; C++\; 네임스페이스(`std::fixed`)로\; 구성되어\; 있어\; 번역\; 대상이\; 아닙니다.\; 따라서\; 원본을\; 그대로\; 유지합니다.$ << to5 << '\n';
    auto precision_loss_demo = []<std::floating_point Fp>(const auto rem, const Fp start)
    {
        std::cout << rem;
        for (Fp from = start, to, Δ;
            (Δ = (to = std::nextafter(from, +INFINITY)) - from) < Fp(10.0);
            from *= Fp(10.0))
            std::cout << "nextafter(" << std::scientific << std::setprecision(0) << from 
                      << ", INF) gives " << std::fixed << std::setprecision(6) << to
                      << "; Δ = " << Δ << '\n';
    };
    precision_loss_demo("\nfloat의 정밀도 손실 데모:\n", 10.0f);
    precision_loss_demo("\ndouble에 대한 정밀도 손실 데모:\n", 10.0e9);
    precision_loss_demo("\nlong double에 대한 정밀도 손실 데모:\n", 10.0e17L);
}

0 다음의 표현 가능한 다음 float 값은 1.4012984643248170709e-45 (0x1p-149)입니다.
1 다음의 표현 가능한 다음 float 값은 1.0000001192092895508 (0x1.000002p+0)입니다.
숫자 0.1은 두 개의 유효한 double 값 사이에 있습니다:
    0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)
및 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)
nextafter와 nexttoward의 차이:
nextafter를 사용하면 0 다음의 다음 float 값은 0입니다
nexttoward를 사용하면 0 다음의 다음 float 값은 1.4012984643248170709e-45입니다
특수 값:
1.79769e+308 (0x1.fffffffffffffp+1023) 다음의 표현 가능한 다음 double 값은 inf (inf)입니다
   FE_OVERFLOW 발생
   FE_INEXACT 발생
std::nextafter(+0.0, -0.0)는 -0.000000을 제공합니다
float에 대한 정밀도 손실 데모:
nextafter(1e+01, INF)는 10.000001을 제공합니다; Δ = 0.000001
nextafter(1e+02, INF)는 100.000008을 제공합니다; Δ = 0.000008
nextafter(1e+03, INF)는 1000.000061을 제공합니다; Δ = 0.000061
nextafter(1e+04, INF)는 10000.000977을 제공합니다; Δ = 0.000977
nextafter(1e+05, INF)는 100000.007812을 제공합니다; Δ = 0.007812
nextafter(1e+06, INF)는 1000000.062500을 제공합니다; Δ = 0.062500
nextafter(1e+07, INF)는 10000001.000000을 제공합니다; Δ = 1.000000
nextafter(1e+08, INF)는 100000008.000000을 제공합니다; Δ = 8.000000
double에 대한 정밀도 손실 데모:
nextafter(1e+10, INF)는 10000000000.000002을 제공합니다; Δ = 0.000002
nextafter(1e+11, INF)는 100000000000.000015을 제공합니다; Δ = 0.000015
nextafter(1e+12, INF)는 1000000000000.000122을 제공합니다; Δ = 0.000122
nextafter(1e+13, INF)는 10000000000000.001953을 제공합니다; Δ = 0.001953
nextafter(1e+14, INF)는 100000000000000.015625을 제공합니다; Δ = 0.015625
nextafter(1e+15, INF)는 1000000000000000.125000을 제공합니다; Δ = 0.125000
nextafter(1e+16, INF)는 10000000000000002.000000을 제공합니다; Δ = 2.000000
long double에 대한 정밀도 손실 데모:
nextafter(1e+18, INF)는 1000000000000000000.062500을 제공합니다; Δ = 0.062500
nextafter(1e+19, INF)는 10000000000000000001.000000을 제공합니다; Δ = 1.000000
nextafter(1e+20, INF)는 100000000000000000008.000000을 제공합니다; Δ = 8.000000

참고 항목