Namespaces
Variants

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

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
nearbyint
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Определено в заголовке <cmath>
(1)
float nearbyint ( float num ) ;

double nearbyint ( double num ) ;

long double nearbyint ( long double num ) ;
(до C++23)
/*floating-point-type*/
nearbyint ( /*floating-point-type*/ num ) ;
(начиная с 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)
Определено в заголовке <cmath>
template < class Integer >
double nearbyint ( Integer num ) ;
(A)
1-3) Округляет аргумент с плавающей точкой num до целочисленного значения в формате с плавающей точкой, используя текущий режим округления . Библиотека предоставляет перегрузки std::nearbyint для всех неквалифицированных cv типов с плавающей точкой в качестве типа параметра. (since C++23)
S) Перегрузка SIMD выполняет поэлементное std::nearbyint на v_num .
(См. math-floating-point и deduced-simd-t для их определений.)
(since C++26)
A) Для всех целочисленных типов предоставлены дополнительные перегрузки, которые трактуются как double .
(since 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 << "округление к ближайшему: \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 << "округление вниз:\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';
}

Вывод: 

округление к ближайшему: 
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 4
nearbyint(-2.3) = -2  nearbyint(-2.5) = -2  nearbyint(-3.5) = -4
округление вниз:
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

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

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