fma, fmaf, fmal

Parámetros

Valor de retorno

Si tiene éxito, devuelve el valor de ( x * y ) + z como si se calculara con precisión infinita y se redondeara una vez para ajustarse al tipo de resultado (o, alternativamente, calculado como una única operación ternaria de punto flotante).

Si ocurre un error de rango debido a desbordamiento, ±HUGE_VAL , ±HUGE_VALF , o ±HUGE_VALL es devuelto.

Si ocurre un error de rango debido a desbordamiento inferior, se devuelve el valor correcto (después del redondeo).

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),

• Si x es cero y y es infinito o si x es infinito y y es cero, y
  • si z no es un NaN, entonces se retorna NaN y se genera FE_INVALID ,
  • si z es un NaN, entonces se retorna NaN y puede generarse FE_INVALID .
• Si x * y es un infinito exacto y z es un infinito con el signo opuesto, se retorna NaN y se genera FE_INVALID .
• Si x o y son NaN, se retorna NaN.
• Si z es NaN, y x * y no es 0 * Inf o Inf * 0 , entonces se retorna NaN (sin FE_INVALID ).

Notas

Esta operación comúnmente se implementa en hardware como la instrucción de CPU fused multiply-add . Si es compatible con el hardware, se espera que las macros apropiadas FP_FAST_FMA * estén definidas, pero muchas implementaciones utilizan la instrucción de CPU incluso cuando las macros no están definidas.

POSIX especifica que la situación donde el valor x * y es inválido y z es un NaN es un error de dominio.

Debido a su precisión intermedia infinita, fma es un componente común de otras operaciones matemáticas correctamente redondeadas, como sqrt o incluso la división (cuando no está proporcionada por la CPU, por ejemplo Itanium ).

Como con todas las expresiones de punto flotante, la expresión ( x * y ) + z puede ser compilada como una operación fused multiply-add a menos que el #pragma STDC FP_CONTRACT esté desactivado.

Ejemplo

#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
// #pragma STDC FENV_ACCESS ON
int main(void)
{
    // demo the difference between fma and built-in operators
    double in = 0.1;
    printf("0.1 double is %.23f (%a)\n", in, in);
    printf("0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3),"
           " or 1.0 if rounded to double\n");
    double expr_result = 0.1 * 10 - 1;
    printf("0.1 * 10 - 1 = %g : 1 subtracted after "
           "intermediate rounding to 1.0\n", expr_result);
    double fma_result = fma(0.1, 10, -1);
    printf("fma(0.1, 10, -1) = %g (%a)\n", fma_result, fma_result);
    // fma use in double-double arithmetic
    printf("\nin double-double arithmetic, 0.1 * 10 is representable as ");
    double high = 0.1 * 10;
    double low = fma(0.1, 10, -high);
    printf("%g + %g\n\n", high, low);
    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf("fma(+Inf, 10, -Inf) = %f\n", fma(INFINITY, 10, -INFINITY));
    if (fetestexcept(FE_INVALID))
        puts("    FE_INVALID raised");
}

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 to 1.0
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

Referencias

Véase también