std::fmod, std::fmodf, std::fmodl

float       fmod ( float x, float y );
double      fmod ( double x, double y );
long double fmod ( long double x, long double y );

constexpr /*floating-point-type*/
            fmod ( /*floating-point-type*/ x,
                   /*floating-point-type*/ y );

float       fmodf( float x, float y );

long double fmodl( long double x, long double y );

template< class V0, class V1 >
constexpr /*math-common-simd-t*/<V0, V1>
            fmod ( const V0& v_x, const V1& v_y );

template< class Integer >
double      fmod ( Integer x, Integer y );

Вычисленный этой функцией остаток от деления x / y с плавающей точкой в точности равен значению x - iquot * y, где iquot — это x / y с отброшенной дробной частью.

Возвращаемое значение имеет тот же знак, что и x, а его модуль меньше y.

Параметры

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

В случае успеха возвращает остаток от деления x / y с плавающей точкой, как определено выше.

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

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

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

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

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

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

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

Примечания

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

std::fmod, но не std::remainder, полезно для незаметного преобразования значений с плавающей точкой в беззнаковые целочисленные типы с циклическим переходом: (0.0 <= (y = std::fmod(std::rint(x), 65536.0)) ? y : 65536.0 + y) находится в диапазоне [-0.0, 65535.0], который соответствует unsignedshort, тогда как std::remainder(std::rint(x), 65536.0 находится в диапазоне [-32767.0, +32768.0], выходящем за пределы диапазона signedshort.

Версия std::fmod для типа double работает так, как если бы она была реализована следующим образом:

double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = std::remainder(std::fabs(x), y = std::fabs(y));
    if (std::signbit(result))
        result += y;
    return std::copysign(result, x);
}

Выражение x - std::trunc(x / y) * y может не совпадать с std::fmod(x, y), если при округлении x / y для инициализации аргумента std::trunc теряется слишком много точности (пример: x = 30.508474576271183309, y = 6.1016949152542370172).

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

Пример

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

int main()
{
    std::cout << "fmod(+5.1, +3.0) = " << std::fmod(5.1, 3) << '\n'
              << "fmod(-5.1, +3.0) = " << std::fmod(-5.1, 3) << '\n'
              << "fmod(+5.1, -3.0) = " << std::fmod(5.1, -3) << '\n'
              << "fmod(-5.1, -3.0) = " << std::fmod(-5.1, -3) << '\n';
    
    // special values
    std::cout << "fmod(+0.0, 1.0) = " << std::fmod(0, 1) << '\n'
              << "fmod(-0.0, 1.0) = " << std::fmod(-0.0, 1) << '\n'
              << "fmod(5.1, Inf) = " << std::fmod(5.1, INFINITY) << '\n';
    
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fmod(+5.1, 0) = " << std::fmod(5.1, 0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0
fmod(-0.0, 1.0) = -0
fmod(5.1, Inf) = 5.1
fmod(+5.1, 0) = -nan
    FE_INVALID raised

См. также