Função Quadratica

Como resolver função quadratica na prática

Vou direto ao método que eu uso desde 2014, quando precisava de algo mais rápido que o WolframAlpha para validar resultados numéricos. O processo começa com a forma padrão ax² + bx + c = 0. Você identifica os três coeficientes, calcula o discriminante = b² - 4ac, e então aplica a fórmula de Bhaskara: x = (-b ± ) / (2a). Aí você separa em duas soluções. A definição básica diz que é uma função do segundo grau, tudo certo. O que os livros não enfatizam é que o discriminante é essencialmente um sistema de decisão com três ramos: se > 0, dois reais distintos; se = 0, uma raiz real dupla; se

0, nenhum real, apenas complexo. Esse último caso é onde a maioria das pessoas trava porque continua tentando encontrar raízes reais que não existem. Outro detalhe prático que causa dor de cabeça: a fórmula do vértice. O ponto de máximo ou mínimo está em x_v = -b/(2a). Isso não é só teoria — em problemas de otimização, como maximizar área com perímetro fixo, o vértice é literalmente a resposta. Eu já perdi tempo recalculando derivadas parciais para funções que eram quadráticas escondidas. Achei que era mais complexo do que era porque não identifiquei a forma reduzida.

Um caso específico que eu encontrei: estava implementando um detector de intersecção entre uma parábola e uma reta em Python, e o código falhava silenciosamente quando o discriminante era muito pequeno, da ordem de 1e-15. O problema é que flutuadores de precisão dupla representam esses valores de forma imprecisa. A solução foi aplicar um tol = 1e-12 antes de checar se 0. Qualquer valor menor que isso, tratamento como zero. Outra armadilha: quando a 0. A função deixa de ser quadrática e vira linear, mas a fórmula de Bhaskara divide por 2a, então o resultado explode numericamente. O workaround é checar primeiro se |a|

1e-10. Se for, resolve bx + c = 0 normalmente, resultando em x = -c/b.

Implementação em código

Aqui está uma função robusta que eu uso rotineiramente: def funcao_quadratica(a, b, c):
    if abs(a) < 1e-12:
        return [-c/b] if b != 0 else []
    delt = b2 - 4*a*c
    if delt < -1e-12:
        real = -b / (2*a)
        imag = sqrt(-delt) / (2*a)
        return [complex(real, imag), complex(real, -imag)]
    elif delt < 1e-12:
        return [-b / (2*a)]
    else:
        s = sqrt(delt)
        return [(-b - s)/(2*a), (-b + s)/(2*a)] Esse código retorna raízes reais como float e raízes complexas como objetos complex do Python. A tolerância de 1e-12 nos comparadores é o que evita os falsos negativos que eu descrevi acima.

Limitações reais

Função quadratica funciona bem para problemas fechados, mas tem limitações importantes. Em malhas finitas ou elementos finitos, equações quadráticas surgem como subproblemas, e o custo de resolver uma pode se acumular. Para sistemas com milhares de equações, métodos iterativos como Newton-Raphson são mais eficientes porque evitam a radiciação explícita a cada passo. Além disso, se os coeficientes vêm de medições experimentais com erro, as raízes calculadas terão incerteza propagada de forma não trivial — nesse cenário, a propagação de erro via matriz Jacobiana é mais honesta do que reportar valores pontuais. Para encontrar um pacote pronto, a biblioteca numpy oferece numpy.roots, que aceita coeficientes diretamente. A versão mais recente está disponível em pypi.org/project/numpy. A função recebe um array como [a, b, c] e retorna todas as raízes, incluindo as complexas automaticamente.

Exemplo resolvido passo a passo

Considere 3x² - 5x + 1 = 0. Os coeficientes são a=3, b=-5, c=1. O discriminante é 25 - 12 = 13. Como 13 > 0, duas raízes reais. x = (5 ± 13)/6. Aproximações: x 1.434 e x 0.233. Verificação substituindo x na equação original: 3(1.434)² - 5(1.434) + 1 = 6.179 - 7.170 + 1 0. O pequeno resíduo vem do arredondamento, não de erro no método. Outro exemplo: x² + 4x + 5 = 0. Discriminante 16 - 20 = -4. Raízes complexas: x = (-4 ± 2i)/2 = -2 ± i. Aqui é importante manter a forma exata sempre que possível, especialmente se essas raízes forem usadas como entrada para outro cálculo. Arredondar para -2.0 + 1.0j introduz erro que se propaga. Graphicamente, o sinal de 'a' determina a concavidade. Quando a > 0, a parábola abre para cima e o vértice é mínimo. Quando a

0, fecha para baixo e o vértice é máximo. Isso parece óbvio, mas esqueci dessa regra na primeira vez que interpretei o resultado de um otimizador — confundi máximo com mínimo porque o sinal de 'a' estava negativo e eu esperava um mínimo global.