Os fundamentos que todo mundo esqueceu
Eu passei três horas num projeto de cálculo financeiro porque 0,1 + 0,2 não dava exatamente 0,3 em JavaScript. O resultado era algo como 0,30000000000000004. Não é um erro conceitual — é a forma como o IEEE 754 representa números decimais em binário. A solução foi simples: eu multipliquei tudo por 100, fiz as operações com inteiros e depois dividi. Levei uma manhã inteira para descobrir isso.
O que são operações básicas de matemática
Adição, subtração, multiplicação e divisão. Você já sabia disso. Mas a forma como essas operações se comportam em situações reais costuma surpreender quem só viu a teoria na escola. Por exemplo, muitos acham que multiplicar sempre aumenta o número. Se você multiplicar 5 por 0,2, o resultado é 1. Se dividir 5 por 0,2, o resultado é 25. A intuição falha porque estamos acostumados a trabalhar com inteiros desde criança. A ordem das operações — multiplicações e divisões antes de adições e subtrações — não é uma convenção arbitrária. É uma necessidade prática. Sem ela, expressões como 2 + 3 × 4 seriam ambíguas. A resposta seria 20 ou 14, dependendo de quem lê. Os matemáticos do século XVI já percebiam isso e padronizaram a convenção que chamamos de PEMDAS nos EUA ou BODMAS no Reino Unido. No Brasil, geralmente usamos a regra dos parênteses primeiro, depois exponenciação, depois multiplicação e divisão (da esquerda para a direita), e por fim adição e subtração (também da esquerda para a direita).
Erros que você provavelmente vai cometer
O primeiro erro clássico é confundir subtrair um número negativo com adicionar. Quando eu precisei calcular variações térmicas em um sistema de climatização, escrevi algo como -5 - (-3) e obtive -8 em vez de -2. O problema era que o operador de subtração tem precedência sobre a negação no código, mas a notação visual do menos era ambígua para quem lia. A solução foi colocar parênteses: -5 - (-3) vira -5 + 3 e o resultado fica claro. O segundo erro é achar que divisão por zero pode ser trabalhada com limites ou aproximada. Em programação, divide por zero gera erro de execução ou exceção. Em matemática pura, é indefinido. Eu tentei criar uma função que lidava com divisões próximas de zero em um algoritmo de recomendação e o resultado era algo como infinito ou NaN. A solução foi verificar se o divisor era menor que uma tolerância epsilon antes de dividir, e retornar um valor padrão se fosse.
O terceiro erro é achar que multiplicação distributiva funciona com subtrações de forma direta. Quando eu precisei expandir expressões algébricas em um sistema de otimização, escrevi algo como a(b - c) e obtive ab - c em vez de ab - ac. O problema era que o operador de multiplicação tem precedência sobre a subtração no código, mas a notação visual era ambígua para quem lia. A solução foi colocar parênteses explicitamente em cada termo.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Insights que ninguém ensina
A primeira coisa contra-intuitiva é que subtração não é comutativa. 5 - 3 não é o mesmo que 3 - 5. A segunda é que divisão não é associativa. (8 ÷ 4) ÷ 2 não é o mesmo que 8 ÷ (4 ÷ 2). Esses detalhes parecem triviais, mas causam bugs em produção quando você menos espera. A terceira coisa que ninguém ensina é que precisão flutuante não é exata. 0,1 + 0,2 não dá exatamente 0,3 na maioria das linguagens de programação. A quarta é que multiplicação por frações menores que 1 diminui o número, não aumenta. Isso quebra a intuição de quem só trabalhou com inteiros.
O quinto insight é que ordem das operações importa mais do que você pensa. 2 + 3 × 4 dá 14, não 20. A sexta é que parênteses podem mudar completamente o resultado. (2 + 3) × 4 dá 20. A sétima é que subtrair um número negativo é adicionar. 5 - (-3) vira 5 + 3. A oitava é que dividir por uma fração é multiplicar pelo inverso. 5 ÷ 0,2 vira 5 × 5.
Quando essas operações falham completamente
Divisão por zero é o cenário mais óbvio onde operações básicas de matemática falham. Em programação, gera erro de execução ou exceção. Em cálculos científicos, o resultado é infinito ou NaN. A solução é verificar se o divisor é diferente de zero antes de dividir, e tratar o caso especial se necessário. Precisão flutuante é outro cenário onde operações básicas de matemática falham. Em finanças, usar float para moedas causa erros de arredondamento. A solução é usar decimal ou BigDecimal, ou então trabalhar com inteiros de centavos. Eu levei dois dias para migrar um sistema de pagamentos de float para decimal porque os erros de arredondamento acumulavam e o resultado final estava errado em até 0,03 reais por transação.
Alternativas quando as operações básicas não bastam
Quando operações básicas de matemática não conseguem lidar com precisão ou complexidade, existem alternativas. Para cálculos financeiros, use decimal ou BigDecimal. Para cálculos científicos, use libraries de precisão arbitrária. Para otimizações, use frameworks de álgebra linear. Eu migrei um sistema de cálculos de precificação de float para decimal porque os erros de arredondamento causavam diferenças de até 2% no preço final, e o resultado era algo como preço de R$ 100,00 virando R$ 102,00 sem motivo aparente. Para operações com números negativos, use aritmética de complemento de dois em hardware ou bibliotecas especializadas. Para operações com frações, use aritmética rational ou simplifique para decimal com precisão suficiente. Para operações com extensões de casa decimal, use aritmética fixa ou round para uma precisão padrão de N casas decimais.
O processo de conversão de operações básicas de matemática para implementações robustas geralmente leva tempo. Eu gastei uma semana inteira migrando um sistema de cálculos estatísticos de float para decimal porque os erros de precisão causavam diferenças de até 5% nos resultados, e o resultado final estava errado em até 10 unidades em amostras de 10.000 registros.
