std::remquo, std::remquof, std::remquol

float       remquo ( float x, float y, int* quo );
double      remquo ( double x, double y, int* quo );
long double remquo ( long double x, long double y, int* quo );

constexpr /* floating-point-type */
            remquo ( /* floating-point-type */ x,
                     /* floating-point-type */ y, int* quo );

float       remquof( float x, float y, int* quo );

long double remquol( long double x, long double y, int* quo );

template< class Arithmetic1, class Arithmetic2 >
/* common-floating-point-type */
    remquo( Arithmetic1 x, Arithmetic2 y, int* quo );

Параметры

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

При успешном выполнении возвращает остаток от деления с плавающей точкой x / y согласно определению в std::remainder, и сохраняет в *quo знак и по крайней мере три младших бита x / y (формально, сохраняет значение, чей знак такой же как у x / y, а модуль конгруэнтен по модулю 2ⁿ к модулю целой части частного x / y, где n — определённое реализацией целое число, большее или равное 3).

Если y равно нулю, значение, сохранённое в *quo, не определено.

Если произошла ошибка области значений, возвращается определённое реализацией значение (NaN при поддержке).

Если произошла ошибка диапазона из-за подпотока, корректный результат возвращается, если поддерживаются субнормали.

Если y равно нулю, но ошибка области значений не произошла, возвращается ноль.

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

Ошибки сообщаются согласно math_errhandling.

Ошибка области значений может произойти, если y равно нулю.

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

• Текущий режим округления не оказывает влияния.
• FE_INEXACT никогда не поднимается.
• Если x равно ±∞, а y не NaN, возвращается NaN, и FE_INVALID поднимается.
• Если y равно ±0, а x не NaN, возвращается NaN, и FE_INVALID поднимается.
• Если x или y равно NaN, возвращается NaN.

Примечания

POSIX требует, чтобы произошла ошибка области значений, если x бесконечно или y равно нулю.

Эта функция полезна при реализации периодических функций с периодом, точно представимым в виде значения с плавающей точкой: при вычислении sin(πx) для очень большого x, вызов std::sin напрямую может привести к большой ошибке, но если аргумент функции сначала уменьшить с помощью std::remquo, младшие биты частного могут быть использованы для определения знака и октанта результата внутри периода, а остаток может быть использован для вычисления значения с высокой точностью.

На некоторых платформах эта операция поддерживается аппаратным обеспечением (например, на процессорах Intel, FPREM1 оставляет ровно 3 бита точности в частном при завершении).

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

Пример

#include <cfenv>
#include <cmath>
#include <iostream>
 
#ifndef __GNUC__
#pragma STDC FENV_ACCESS ON
#endif
 
const double pi = std::acos(-1); // or std::numbers::pi since C++20
 
double cos_pi_x_naive(double x)
{
    return std::cos(pi * x);
}
 
// the period is 2, values are (0;0.5) positive, (0.5;1.5) negative, (1.5,2) positive
double cos_pi_x_smart(double x)
{
    int quadrant;
    double rem = std::remquo(x, 1, &quadrant);
    quadrant = static_cast<unsigned>(quadrant) % 2; // The period is 2.
    return quadrant == 0 ?  std::cos(pi * rem)
                         : -std::cos(pi * rem);
}
 
int main()
{
    std::cout << std::showpos
              << "naive:\n"
              << "  cos(pi * 0.25) = " << cos_pi_x_naive(0.25) << '\n'
              << "  cos(pi * 1.25) = " << cos_pi_x_naive(1.25) << '\n'
              << "  cos(pi * 2.25) = " << cos_pi_x_naive(2.25) << '\n'
              << "smart:\n"
              << "  cos(pi * 0.25) = " << cos_pi_x_smart(0.25) << '\n'
              << "  cos(pi * 1.25) = " << cos_pi_x_smart(1.25) << '\n'
              << "  cos(pi * 2.25) = " << cos_pi_x_smart(2.25) << '\n'
              << "naive:\n"
              << "  cos(pi * 1000000000000.25) = "
              << cos_pi_x_naive(1000000000000.25) << '\n'
              << "  cos(pi * 1000000000001.25) = "
              << cos_pi_x_naive(1000000000001.25) << '\n'
              << "smart:\n"
              << "  cos(pi * 1000000000000.25) = "
              << cos_pi_x_smart(1000000000000.25) << '\n'
              << "  cos(pi * 1000000000001.25) = "
              << cos_pi_x_smart(1000000000001.25) << '\n';
 
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
 
    int quo;
    std::cout << "remquo(+Inf, 1) = " << std::remquo(INFINITY, 1, &quo) << '\n';
    if (fetestexcept(FE_INVALID))
        std::cout << "  FE_INVALID raised\n";
}

naive:
  cos(pi * 0.25) = +0.707107
  cos(pi * 1.25) = -0.707107
  cos(pi * 2.25) = +0.707107
smart:
  cos(pi * 0.25) = +0.707107
  cos(pi * 1.25) = -0.707107
  cos(pi * 2.25) = +0.707107
naive:
  cos(pi * 1000000000000.25) = +0.707123
  cos(pi * 1000000000001.25) = -0.707117
smart:
  cos(pi * 1000000000000.25) = +0.707107
  cos(pi * 1000000000001.25) = -0.707107
remquo(+Inf, 1) = -nan
  FE_INVALID raised

См. также