std::fma, std::fmaf, std::fmal

float       fma ( float x, float y, float z );
double      fma ( double x, double y, double z );
long double fma ( long double x, long double y, long double z );

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

float       fmaf( float x, float y, float z );

long double fmal( long double x, long double y, long double z );

#define FP_FAST_FMA  /* implementation-defined */

#define FP_FAST_FMAF /* implementation-defined */

#define FP_FAST_FMAL /* implementation-defined */

template< class Arithmetic1, class Arithmetic2, class Arithmetic3 >
/* common-floating-point-type */
    fma( Arithmetic1 x, Arithmetic2 y, Arithmetic3 z );

Параметры

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

При успешном выполнении возвращает значение x * y + z как если бы вычислялось с бесконечной точностью и округлялось один раз до типа результата (или, альтернативно, вычислялось как единая троичная операция с плавающей точкой).

Если возникает ошибка диапазона из-за переполнения, возвращается ±HUGE_VAL, ±HUGE_VALF, или ±HUGE_VALL.

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

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

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

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

• Если x равно нулю, а y бесконечность, или если x бесконечность, а y равно нулю, и
  • если z не NaN, то возвращается NaN и генерируется FE_INVALID.
  • если z NaN, то возвращается NaN и может быть сгенерирован FE_INVALID.
• Если x * y точная бесконечность, а z бесконечность с противоположным знаком, возвращается NaN и генерируется FE_INVALID.
• Если x или y NaN, возвращается NaN.
• Если z NaN, и x * y не 0 * Бесконечность или Бесконечность * 0, то возвращается NaN (без FE_INVALID).

Примечания

Эта операция обычно реализуется в аппаратном обеспечении как инструкция ЦП умножения-сложения. Если поддерживается аппаратным обеспечением, ожидается определение соответствующих FP_FAST_FMA? макросов, но многие реализации используют инструкцию ЦП даже когда макросы не определены.

POSIX (fma, fmaf, fmal) дополнительно указывает, что ситуации, указанные для возврата FE_INVALID, являются ошибками области.

Благодаря своей бесконечной промежуточной точности, std::fma является общим строительным блоком других математических операций с правильным округлением, таких как std::sqrt или даже деление (если не предоставлено ЦП, например, Itanium).

Как и для всех выражений с плавающей точкой, выражение x * y + z может быть скомпилировано как умножение-сложение, если #pragma STDC FP_CONTRACT не выключен.

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

Пример

#include <cfenv>
#include <cmath>
#include <iomanip>
#include <iostream>
 
#ifndef __GNUC__
#pragma STDC FENV_ACCESS ON
#endif
 
int main()
{
    // demo the difference between fma and built-in operators
    const double in = 0.1;
    std::cout << "0.1 double is " << std::setprecision(23) << in
              << " (" << std::hexfloat << in << std::defaultfloat << ")\n"
              << "0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3), "
              << "or 1.0 if rounded to double\n";
 
    const double expr_result = 0.1 * 10 - 1;
    const double fma_result = std::fma(0.1, 10, -1);
    std::cout << "0.1 * 10 - 1 = " << expr_result
              << " : 1 subtracted after intermediate rounding\n"
              << "fma(0.1, 10, -1) = " << std::setprecision(6) << fma_result << " ("
              << std::hexfloat << fma_result << std::defaultfloat << ")\n\n";
 
    // fma is used in double-double arithmetic
    const double high = 0.1 * 10;
    const double low = std::fma(0.1, 10, -high);
    std::cout << "in double-double arithmetic, 0.1 * 10 is representable as "
              << high << " + " << low << "\n\n";
 
    // error handling 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fma(+Inf, 10, -Inf) = " << std::fma(INFINITY, 10, -INFINITY) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

0.1 double is 0.10000000000000000555112 (0x1.999999999999ap-4)
0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3), or 1.0 if rounded to double
0.1 * 10 - 1 = 0 : 1 subtracted after intermediate rounding
fma(0.1, 10, -1) = 5.55112e-17 (0x1p-54)
 
in double-double arithmetic, 0.1 * 10 is representable as 1 + 5.55112e-17
 
fma(+Inf, 10, -Inf) = -nan
    FE_INVALID raised

См. также