Implementación de Algoritmos Numéricos para la Resolución de Ecuaciones No Lineales

Algoritmos para la Resolución de Ecuaciones No Lineales

A continuación se presentan las implementaciones técnicas de diversos métodos numéricos utilizados para encontrar raíces de funciones y manipular polinomios.

1. Método de Bisección

Este algoritmo busca la raíz de una función continua en un intervalo cerrado basándose en el teorema de Bolzano.

real f_a = f(a);
real f_b = f(b);

if (f_a * f_b > 0) {
    Niter = -1;
    return (-1.);
}

Niter = 0;
while (mn_distancia(a, b) >= TOL) {
    real paso = (a + b) * 0.5;
    real f_paso = f(paso);
    
    if (f_paso == 0.) return (paso);
    
    if (f_a * f_paso < 0.) {
        b = paso;
        f_b = f_paso;
    } else {
        a = paso;
        f_a = f_paso;
    }
    Niter++;
}

return ((a + b) * 0.5);

2. Método de la Regla Falsa (Regula Falsi)

El método de la regla falsa mejora la bisección uniendo los puntos mediante una línea recta para aproximar la intersección con el eje.

real f_a = f(a);
real f_b = f(b);

if (f_a * f_b > 0) return -1;

x = a - (b - a) * f_a / (f_b - f_a);
real f_x = f(x);

for (int k = 0; k < NiterMax; k++) {
    if (f_x == 0.) return k;
    
    if (f_a * f_x < 0) {
        b = x;
        f_b = f_x;
    } else {
        a = x;
        f_a = f_x;
    }
    
    real xnew = a - (b - a) * f_a / (f_b - f_a);
    
    if (mn_distancia(x, xnew) <= TOL) {
        x = xnew;
        return k;
    }
    x = xnew;
    f_x = f(x);
}

return -1;

3. Método de Newton-Raphson

Este es un método iterativo basado en la derivada de la función para encontrar aproximaciones sucesivas a la raíz.

real f_x0 = f(x0);
for (int i = 0; i < NiterMax; i++) {
    if (f_x0 == 0.) { return (i); }
    
    real derivada = mn_derivada1(f, x0);
    if (derivada == 0.) return (-1);
    
    real x1 = x0 - f_x0 / derivada;
    f_x0 = f(x1);
    
    if (mn_distancia(x1, x0) < TOL) {
        x0 = x1;
        return (i + 1);
    }
    x0 = x1;
}
return (-1);

4. Método de la Secante

Variante del método de Newton que utiliza una aproximación de la derivada mediante la pendiente de la secante.

// Implementación del Método de la Secante
real f_x0 = f(x0);
real f_x1 = f(x1);

for (int i = 0; i < NiterMax; i++) {
    if (f_x1 == 0.) { return (i); }
    
    real h = x1 - x0;
    if (h == 0.) return (-1);
    
    real derivada = (f_x1 - f_x0) / h;
    if (derivada == 0.) return (-1);
    
    real x2 = x1 - f_x1 / derivada;
    x0 = x1;
    x1 = x2;
    f_x0 = f_x1;
    f_x1 = f(x1);
    
    if (mn_distancia(x1, x0) < TOL) {
        return (i + 1);
    }
}
return (-1);

5. Método de Muller / Aproximación Cuadrática

Utiliza una parábola que pasa por tres puntos para aproximar la raíz de la función.

real f_x0 = f(x0);
for (int i = 0; i < NiterMax; i++) {
    if (f_x0 == 0.) { return (i); }
    
    real z1, z2;
    real fp = mn_derivada1(f, x0);
    real fpp = mn_derivada2(f, x0);
    
    int Nroots = mn_ceros_pol_grado_2(fpp / 2., fp, f_x0, z1, z2);
    if (Nroots == 0) return (-1);
    
    real x1 = x0 + z1;
    if (mn_distancia(x1, x0) < TOL) {
        x0 = x1;
        return (i + 1);
    }
    x0 = x1;
    f_x0 = f(x0);
}
return (-1);

6. Evaluación de Polinomios (Método de Horner)

Algoritmo eficiente para evaluar el valor de un polinomio y su derivada en un punto dado.

Px = a[a.dim() - 1];
PPx = a[a.dim() - 1];

for (int k = a.dim() - 2; k > 0; k--) {
    Px = Px * x + a[k];
    PPx = PPx * x + Px;
}
Px = Px * x + a[0];

7. Derivación Analítica de Polinomios

Cálculo de los coeficientes del polinomio derivado a partir de los coeficientes originales.

if (a.dim() == 1) return Array1D<real>();

Array1D<real> b(a.dim() - 1);
for (int k = 0; k < b.dim(); k++) {
    b[k] = (k + 1.) * a[k + 1];
}
return b;