std:: rint, std:: rintf, std:: rintl, std:: lrint, std:: lrintf, std:: lrintl, std:: llrint, std:: llrintf

Параметры

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

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

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

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

Если результат std::lrint или std::llrint выходит за пределы диапазона, представимого типом возвращаемого значения, может возникнуть ошибка домена или ошибка диапазона.

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

Для функции std::rint :

• Если num равен ±∞, он возвращается без изменений.
• Если num равен ±0, он возвращается без изменений.
• Если num является NaN, возвращается NaN.

Для функций std::lrint и std::llrint :

• Если num равен ±∞, FE_INVALID устанавливается и возвращается определяемое реализацией значение.
• Если результат округления выходит за пределы диапазона возвращаемого типа, FE_INVALID устанавливается и возвращается определяемое реализацией значение.
• Если num является NaN, FE_INVALID устанавливается и возвращается определяемое реализацией значение.

Примечания

POSIX определяет что все случаи, когда std::lrint или std::llrint вызывают FE_INEXACT являются ошибками домена.

Как указано в math_errhandling , FE_INEXACT может быть (но не обязательно на платформах с не-IEEE представлением чисел с плавающей точкой) возбужден функцией std::rint при округлении конечного нецелочисленного значения.

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

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

Если текущий режим округления:

• FE_DOWNWARD , тогда std::rint эквивалентен std::floor .
• FE_UPWARD , тогда std::rint эквивалентен std::ceil .
• FE_TOWARDZERO , тогда std::rint эквивалентен std::trunc .
• FE_TONEAREST , тогда std::rint отличается от std::round тем, что значения посередине округляются к ближайшему чётному, а не от нуля.

Дополнительные перегрузки не обязаны быть предоставлены в точности как (A-C) . Они должны быть лишь достаточными для обеспечения того, чтобы для их аргумента num целочисленного типа:

• std :: rint ( num ) имеет тот же эффект, что и std :: rint ( static_cast < double > ( num ) ) .
• std :: lrint ( num ) имеет тот же эффект, что и std :: lrint ( static_cast < double > ( num ) ) .
• std :: llrint ( num ) имеет тот же эффект, что и std :: llrint ( static_cast < double > ( num ) ) .

Пример

#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Округление к ближайшему (половинные случаи к чётному):\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n';
    std::fesetround(FE_DOWNWARD);
    std::cout << "Округление в меньшую сторону:\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n'
              << "Округление вниз с помощью lrint:\n"
              << "  lrint(+2.3) = " << std::lrint(2.3) << '\n'
              << "  lrint(+2.5) = " << std::lrint(2.5) << '\n'
              << "  lrint(+3.5) = " << std::lrint(3.5) << '\n'
              << "  lrint(-2.3) = " << std::lrint(-2.3) << '\n'
              << "  lrint(-2.5) = " << std::lrint(-2.5) << '\n'
              << "  lrint(-3.5) = " << std::lrint(-3.5) << '\n'
              << "Специальные значения:\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
    // обработка ошибок
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  Было поднято исключение FE_INEXACT\n";
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::lrint(LONG_MIN-2048.0) = "
              << std::lrint(LONG_MIN - 2048.0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "  FE_INVALID был поднят\n";
}

Округление к ближайшему (половинные случаи к четному):
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Округление вниз:
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Округление вниз с lrint:
  lrint(+2.3) = 2
  lrint(+2.5) = 2
  lrint(+3.5) = 3
  lrint(-2.3) = -3
  lrint(-2.5) = -3
  lrint(-3.5) = -4
Специальные значения:
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  FE_INVALID был поднят

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