std::nearbyint, std::nearbyintf, std::nearbyintl

Определено в заголовочном файле `<cmath>`
float nearbyint ( float num ); double nearbyint ( double num ); long double nearbyint ( long double num );	(1)	(до C++23)
/floating-point-type/ nearbyint ( /floating-point-type/ num );	(1)		(начиная с C++23)
float nearbyintf( float num );	(2)	(начиная с C++11)
long double nearbyintl( long double num );	(3)	(начиная с C++11)
Перегрузка для SIMD (начиная с C++26)
Определено в заголовочном файле `<simd>`
template< /math-floating-point/ V > constexpr /deduced-simd-t/<V> nearbyint ( const V& v_num );	(S)	(начиная с C++26)
Дополнительные перегрузки (начиная с C++11)
Определено в заголовочном файле `<cmath>`
template< class Integer > double nearbyint ( Integer num );	(A)

1-3) Округляет аргумент с плавающей точкой num до целочисленного значения в формате с плавающей точкой, используя текущий режим округления. Библиотека предоставляет перегрузки std::nearbyint для всех типов с плавающей точкой, не являющихся cv-квалифицированными, в качестве типа параметра.(начиная с C++23)

S) Перегрузка для SIMD выполняет поэлементное std::nearbyint над v_num. (Определения см. в разделах math-floating-point и deduced-simd-t.) (начиная с C++26)

A) Для всех целочисленных типов предоставляются дополнительные перегрузки, в которых эти типы рассматриваются как double.

(начиная с C++11)

Параметры

num

значение с плавающей точкой или целочисленное значение

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

Возвращается ближайшее целочисленное значение к num в соответствии с текущим режимом округления.

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

Эта функция не подвержена ни одной из ошибок, указанных в math_errhandling.

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

FE_INEXACT никогда не возбуждается.
Если num равно ±∞, оно возвращается без изменений.
Если num равно ±0, оно возвращается без изменений.
Если num — NaN, возвращается NaN.

Примечания

Единственное различие между std::nearbyint и std::rint состоит в том, что std::nearbyint никогда не возбуждает FE_INEXACT.

Наибольшие представимые значения с плавающей точкой являются точными целыми числами во всех стандартных форматах с плавающей точкой, поэтому std::nearbyint никогда не вызывает переполнение самостоятельно; однако при сохранении результата в целочисленной переменной возможно переполнение любого целочисленного типа (включая std::intmax_t).

Если текущий режим округления — FE_TONEAREST, в случаях ровно посередине эта функция округляет до ближайшего чётного числа (как std::rint, но в отличие от std::round).

Дополнительные перегрузки не обязаны предоставляться именно в форме (A). Они должны лишь обеспечивать, чтобы для аргумента num целочисленного типа std::nearbyint(num) имела тот же эффект, что и std::nearbyint(static_cast<double>(num)).

Пример

#include <cfenv>
#include <cmath>
#include <iostream>
#pragma STDC FENV_ACCESS ON

int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "rounding to nearest: \n"
              << "nearbyint(+2.3) = " << std::nearbyint(2.3)
              << "  nearbyint(+2.5) = " << std::nearbyint(2.5)
              << "  nearbyint(+3.5) = " << std::nearbyint(3.5) << '\n'
              << "nearbyint(-2.3) = " << std::nearbyint(-2.3)
              << "  nearbyint(-2.5) = " << std::nearbyint(-2.5)
              << "  nearbyint(-3.5) = " << std::nearbyint(-3.5) << '\n';
    
    std::fesetround(FE_DOWNWARD);
    std::cout << "rounding down:\n"
              << "nearbyint(+2.3) = " << std::nearbyint(2.3)
              << "  nearbyint(+2.5) = " << std::nearbyint(2.5)
              << "  nearbyint(+3.5) = " << std::nearbyint(3.5) << '\n'
              << "nearbyint(-2.3) = " << std::nearbyint(-2.3)
              << "  nearbyint(-2.5) = " << std::nearbyint(-2.5)
              << "  nearbyint(-3.5) = " << std::nearbyint(-3.5) << '\n';
    
    std::cout << "nearbyint(-0.0) = " << std::nearbyint(-0.0)  << '\n'
              << "nearbyint(-Inf) = " << std::nearbyint(-INFINITY) << '\n';
}

Вывод:

rounding to nearest: 
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 4
nearbyint(-2.3) = -2  nearbyint(-2.5) = -2  nearbyint(-3.5) = -4
rounding down:
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 3
nearbyint(-2.3) = -3  nearbyint(-2.5) = -3  nearbyint(-3.5) = -4
nearbyint(-0.0) = -0
nearbyint(-Inf) = -inf

См. также

rintrintfrintllrintlrintflrintlllrintllrintfllrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	ближайшее целое число с использованием текущего режима округления; исключение возникает, если результат отличается (функция)
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	ближайшее целое число; в случаях ровно посередине округляет от нуля (функция)
fegetroundfesetround (C++11)(C++11)	получает или задаёт направление округления (функция)
Документация по C для `nearbyint`

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/numeric/math/nearbyint