Ecuaciones cubicas

Ecuaciones Cúbicas (Método de Tartaglia-Giordano)

¿Qué son las ecuaciones cúbicas?

Las ecuaciones cúbicas son polinomios de grado tres con la forma general:
ax³ + bx² + cx + d = 0, donde a ≠ 0.
Resolver estas ecuaciones significa encontrar los valores de x que satisfacen la igualdad.

¿Qué es el método de Tartaglia-Giordano?

El método de Tartaglia-Giordano, también conocido como fórmula de Cardano, es una técnica algebraica para encontrar las raíces de una ecuación cúbica. Fue desarrollado en el siglo XVI por matemáticos italianos como Scipione del Ferro, Niccolò Tartaglia y Girolamo Cardano.
Consiste en transformar la ecuación cúbica en una forma reducida y luego aplicar una fórmula que utiliza raíces cuadradas y cúbicas para obtener las soluciones.

¿Para qué sirve?

Este método sirve para encontrar todas las raíces reales y complejas de cualquier ecuación cúbica. Es fundamental en álgebra y ha sido la base para métodos más avanzados en matemáticas y ciencias.

¿Cómo se usa en la vida real?

La resolución de ecuaciones cúbicas mediante el método de Tartaglia-Giordano es útil en varias áreas prácticas, tales como:

Ingeniería: análisis y diseño de estructuras y sistemas que modelan fenómenos con ecuaciones cúbicas.
Física: cálculo de movimientos y fuerzas en sistemas no lineales.
Economía y finanzas: modelado de curvas de oferta y demanda o ecuaciones de equilibrio con polinomios de grado tres.
Ciencias computacionales: desarrollo de algoritmos para simulaciones y gráficos 3D.

Aunque hoy en día se utilizan métodos numéricos y computacionales, conocer esta fórmula permite entender la base algebraica de las soluciones exactas para polinomios cúbicos.

Algoritmo:

Definir la función cúbica con coeficientes reales:
Ejemplo:
```
f(x) = 6x³ + 7x² - 9x + 2
```
Obtener los coeficientes de la ecuación:
- a = coeficiente de x²
- b = coeficiente de x
- c = término independiente
Reescribir la ecuación en la forma reducida:
```
y³ + py + q = 0
```
Entonces, calcular los valores de p y q:
```
p = (3b - a²) / 3
q = (2a³ - 9ab + 27c) / 27
```
Calcular el discriminante Δ:
```
Δ = (q/2)² + (p/3)³
```
Analizar el discriminante Δ para determinar las raíces:
- Si Δ = 0:
  - Si p = 0 y q = 0, la ecuación tiene una raíz triple:
```
x = -a / 3
```
  - Si p ≠ 0 y q ≠ 0, la ecuación tiene una raíz doble y una simple:
```
Raíz doble:   x = -(3q)/(2p) - a/3
Raíz simple:  x = -(4p²)/(9q) - a/3
```
- Si Δ > 0:
  Existe una raíz real y dos raíces complejas conjugadas.
```
u = ((-q/2) + √Δ)^(1/3)
v = ((-q/2) - √Δ)^(1/3)
```
  La raíz real es:
```
x = u + v - a/3
```
  Las raíces complejas son:
```
x = - (u + v)/2 - a/3 ± (√3 / 2) * (u - v)·i
```
- Si Δ < 0:
  La ecuación tiene tres raíces reales simples.
```
θ = arccos [ (-q/2) / √(-(p/3)³) ]    con 0 < θ < π
xₖ = 2 √(-p/3) * cos[(θ + 2kπ) / 3] - a/3,   donde k = 0, 1, 2
```
  Obtener las tres raíces x₁, x₂, x₃ para k = 0, 1, 2.

Ejemplo 1

f(x) = x³ - x - 2

Este método solo permite buscar las raíces de cada función cubica.
En este ejemplo tenemos tres raíces reales diferentes.

Ejemplo 2

f(x) = x³ − 6x² + 11x − 6

Este método solo permite buscar las raíces de cada función cubica.
En este ejemplo tenemos tres raíces reales diferentes.

Ejemplo 3

f(x) = x³ + 4x² − 10

Este método solo permite buscar las raíces de cada función cubica.
En este ejemplo tenemos una raiz real triple.

EXPLICACIÓN DE CODIGO

Resolución de una Ecuación Cúbica en Python


import sympy as sp

x = sp.Symbol("x")

def f(x):
    return 6*x**3 + 7*x**2 - 9*x + 2

coeficientes = sp.Poly(f(x), x).all_coeffs()

a = coeficientes[1]
b = coeficientes[2]
c = coeficientes[3]

p = (3*b - a**2)/3
q = (2*a**3 - 9*a*b + 27*c)/27

delta = (q/2)**2 + (p/3)**3

if delta == 0:
    if p == 0 and q == 0:
        x = -a/3
        print("Raíz triple:", x)
    elif p*q != 0:
        x = (-(3*q)/(2*p)) - (a/3)
        print("Raíz doble:", x)
        X1 = (-(4*p**2)/(9*q))-(a/3)
        print("Raíz simple:", X1)
elif delta > 0:
    u = ((-q/2)+(delta)**(1/2))**(1/3)
    v = ((-q/2)-(delta)**(1/2))**(1/3)
    x = u + v - (a/3)
    print("Raíz real:", x)
    pImaginaria = ((3**(1/2))/2)*(u-v)
    X1 = -((u+v)/2) - (a/3)+pImaginaria
    print("Primera raíz imaginaria:", X1)
    X1 = -((u+v)/2) - (a/3)-pImaginaria
    print("Segunda raíz imaginaria:", X1)
else:
    print("Tres raíces reales simples:")
    teta = sp.acos((-q/2)/((-(p/3)**3)**(1/2)))
    k = [0, 1, 2]
    for i in range(3):
        X1 = (2*(-p/3)**(1/2))*(sp.cos((teta + 2*k[i]*sp.pi)/3)) - a/3
        print("Raíz real #", i+1, ":", X1)