Operações com ponto flutuante parecem simples, mas pequenas diferenças de arredondamento podem crescer em cálculos científicos, financeiros, gráficos e estatísticos. O Python oferece math.fma(), uma função que executa uma multiplicação seguida de uma soma usando uma única etapa de arredondamento. A sigla vem de fused multiply-add, ou multiplicação e adição fundidas.
Em vez de calcular x * y, arredondar o resultado e depois somar z com um novo arredondamento, math.fma(x, y, z) calcula conceitualmente x * y + z com precisão intermediária maior e arredonda apenas uma vez ao final. Essa diferença pode melhorar estabilidade numérica, reprodutibilidade e qualidade de algoritmos que acumulam muitos termos.
Como usar math.fma
import math
resultado = math.fma(2.5, 4.0, 1.5)
print(resultado) # 11.5
A chamada recebe três números reais. Os dois primeiros são multiplicados e o terceiro é adicionado. Para valores comuns, o resultado é igual ao de x * y + z. A vantagem aparece em situações nas quais o produto intermediário não pode ser representado exatamente em ponto flutuante.
Por que uma única etapa de arredondamento importa
Números float seguem, em geral, o padrão IEEE 754. Muitos valores decimais não têm representação binária exata, então cada operação pode introduzir uma pequena aproximação. Em uma expressão comum, a multiplicação produz um valor arredondado e a soma trabalha sobre esse valor já aproximado. A operação fundida evita o primeiro arredondamento observável.
import math
x = 1.0000000000000002
y = 1.0000000000000002
z = -1.0000000000000004
comum = x * y + z
fundido = math.fma(x, y, z)
print(comum)
print(fundido)
Dependendo dos valores e da plataforma, os resultados podem diferir por alguns bits. Essa diferença pequena é importante quando o cálculo participa de milhares de iterações ou quando um teste numérico exige resultados previsíveis.
Acumulação de produtos
Produtos escalares, filtros digitais, regressões e transformações geométricas calculam repetidamente uma soma de produtos. math.fma() permite atualizar um acumulador com uma única operação numericamente mais estável.
import math
def produto_escalar(a, b):
if len(a) != len(b):
raise ValueError("vetores com tamanhos diferentes")
total = 0.0
for x, y in zip(a, b):
total = math.fma(x, y, total)
return total
Isso não transforma o algoritmo em precisão arbitrária e não elimina todo erro. Porém, reduz uma fonte de arredondamento em cada iteração. Para somas particularmente sensíveis, compare também com math.fsum(), que foi projetado para somar sequências com maior precisão.
math.fma versus math.fsum
As duas funções resolvem problemas diferentes. math.fma() combina uma multiplicação e uma soma. math.fsum() recebe uma sequência de valores e calcula uma soma mais precisa, controlando perdas por cancelamento e diferenças de magnitude.
import math
valores = [1e16, 1.0, -1e16]
print(sum(valores))
print(math.fsum(valores))
Em um produto escalar, você pode gerar os produtos e usar math.fsum(), ou acumular com math.fma(). A melhor escolha depende do tamanho dos dados, do custo aceitável e do nível de precisão necessário. Sempre meça com dados representativos.
Polinômios com o método de Horner
O método de Horner avalia polinômios usando uma sequência de multiplicações e somas. Ele combina naturalmente com FMA.
import math
def avaliar_polinomio(coeficientes, x):
resultado = 0.0
for coeficiente in coeficientes:
resultado = math.fma(resultado, x, coeficiente)
return resultado
Além de reduzir operações, essa forma pode diminuir erros intermediários. A ordem esperada dos coeficientes deve ser documentada. No exemplo, eles são fornecidos do termo de maior grau para o termo constante.
Interpolação linear
Uma interpolação pode ser escrita como a + t * (b - a). A versão fundida reduz um arredondamento na etapa principal.
import math
def lerp(a, b, t):
return math.fma(t, b - a, a)
Em animações, áudio e simulações, pequenas diferenças podem se acumular. Ainda assim, valide o intervalo de t quando a aplicação não aceitar extrapolação.
Valores especiais
Assim como outras operações de ponto flutuante, math.fma() pode produzir infinito ou NaN quando recebe valores extremos ou especiais. Não assuma que todo resultado será finito.
import math
resultado = math.fma(float("inf"), 2.0, 1.0)
if not math.isfinite(resultado):
print("resultado não finito")
Dados vindos de arquivos, sensores ou APIs devem ser validados antes do cálculo. Em sistemas críticos, registre entradas não finitas e defina uma política clara para rejeição, substituição ou propagação.
Compatibilidade entre versões
Antes de usar a função em uma biblioteca distribuída para vários ambientes, confirme a versão mínima de Python suportada. Uma alternativa segura é testar a presença do atributo.
import math
def multiplicar_somar(x, y, z):
fma = getattr(math, "fma", None)
if fma is None:
return x * y + z
return fma(x, y, z)
O fallback mantém compatibilidade funcional, mas não oferece a mesma garantia de arredondamento único. Documente essa diferença caso os resultados exatos sejam relevantes.
Desempenho
Processadores modernos frequentemente possuem instruções FMA em hardware, mas o desempenho real depende da implementação do Python, da plataforma e do custo de chamadas de função em loops. Não presuma que substituir toda expressão por math.fma() tornará o programa mais rápido. O principal benefício é numérico.
Para grandes vetores, bibliotecas como NumPy podem explorar operações vetorizadas e instruções do processador com mais eficiência. Use timeit para comparar versões e mantenha os testes separados das medições de precisão.
Testando resultados numéricos
Evite comparar floats com igualdade exata quando pequenas diferenças são aceitáveis. Use math.isclose() com tolerâncias adequadas ao domínio.
import math
obtido = math.fma(0.1, 0.2, 0.3)
esperado = 0.32
assert math.isclose(obtido, esperado, rel_tol=1e-12, abs_tol=1e-15)
A tolerância não deve ser escolhida apenas para fazer o teste passar. Relacione-a à escala dos dados, ao número de operações e ao erro permitido pela aplicação.
Quando usar Decimal
math.fma() trabalha com ponto flutuante binário. Para cálculos monetários com regras decimais explícitas, o módulo decimal costuma ser mais adequado. FMA melhora uma operação, mas não transforma floats em decimais exatos.
Em ciência e engenharia, floats são frequentemente a escolha correta devido ao desempenho e às bibliotecas disponíveis. Em faturamento, impostos e contabilidade, use um modelo numérico que represente centavos e arredondamentos legais de forma explícita.
Boas práticas
Use FMA quando a expressão for realmente uma multiplicação seguida de soma, especialmente em acumulações, polinômios e interpolações. Não esconda a intenção em abstrações desnecessárias. Comente apenas quando a razão numérica não for óbvia.
Teste com valores grandes, pequenos, negativos, zero, infinito e NaN. Compare a implementação com uma referência de maior precisão quando a exatidão for importante. Meça desempenho antes de otimizar e mantenha um fallback documentado quando houver suporte a versões antigas.
Conteúdos relacionados
Para aprofundar, leia os artigos da Academify sobre módulo math, Decimal no Python, medição com timeit e otimização em Python. Consulte também a documentação oficial do módulo math e o padrão IEEE 754.
Conclusão
math.fma() é uma ferramenta pequena, mas valiosa para código numérico. Ela calcula x * y + z com uma única etapa de arredondamento, reduzindo erros intermediários em produtos escalares, polinômios, interpolações e outras rotinas. O ganho não substitui uma análise numérica completa, porém oferece uma forma clara e padronizada de melhorar operações comuns. Use-a quando a precisão adicional tiver propósito, valide valores especiais, teste tolerâncias e escolha Decimal, math.fsum() ou bibliotecas vetorizadas quando o problema exigir outra estratégia.
