Aproximación de Raíces Usando el Método de Newton en C

Introducción

En este laboratorio, aprenderás a aproximar las raíces de una función utilizando el método de Newton en C. El laboratorio cubre los siguientes pasos:

En primer lugar, definirás la función f(x) y su derivada f'(x). A continuación, implementarás la fórmula iterativa del método de Newton para calcular la raíz aproximada. Finalmente, imprimirás la raíz aproximada resultante.

Este laboratorio proporciona un ejemplo práctico de la aplicación de métodos numéricos para resolver problemas matemáticos utilizando programación en C. Al final del laboratorio, tendrás una mejor comprensión de cómo utilizar el método de Newton para encontrar las raíces de una función.

Definir f(x) y f'(x)

En este paso, definiremos la función matemática f(x) y su derivada f'(x) para implementar el método de Newton y aproximar las raíces.

Primero, crearemos un nuevo archivo C en el directorio ~/project:

cd ~/project
nano newton_method.c

Ahora, escribiremos el código inicial para definir nuestra función y su derivada:

#include <stdio.h>
#include <math.h>

// Definir la función f(x)
double f(double x) {
    return x * x - 4;  // Función de ejemplo: f(x) = x^2 - 4
}

// Definir la derivada f'(x)
double f_derivative(double x) {
    return 2 * x;  // Derivada de f(x) = 2x
}

int main() {
    printf("Función f(x) = x^2 - 4\n");
    printf("Derivada f'(x) = 2x\n");
    return 0;
}

Salida de ejemplo:

Función f(x) = x^2 - 4
Derivada f'(x) = 2x

Desglose del código:

• f(x) se define como x^2 - 4, que tiene raíces en x = 2 y x = -2
• f_derivative(x) es la derivada de f(x), que es 2x
• Usaremos estas funciones en los siguientes pasos para implementar el método de Newton.

Compila el código para verificar:

gcc -o newton_method newton_method.c -lm
./newton_method

Iterar x_{n+1}=x_n - f(x_n)/f'(x_n)

En este paso, implementaremos la fórmula iterativa del método de Newton para aproximar la raíz de nuestra función.

Abre el archivo anterior newton_method.c:

cd ~/project
nano newton_method.c

Actualiza el código para incluir la iteración del método de Newton:

#include <stdio.h>
#include <math.h>

// Las definiciones de funciones anteriores permanecen igual
double f(double x) {
    return x * x - 4;
}

double f_derivative(double x) {
    return 2 * x;
}

// Implementación del método de Newton
double newton_method(double initial_guess, int max_iterations, double tolerance) {
    double x = initial_guess;

    for (int i = 0; i < max_iterations; i++) {
        double fx = f(x);
        double fpx = f_derivative(x);

        // Comprueba la división por cero
        if (fabs(fpx) < tolerance) {
            printf("La derivada está demasiado cerca de cero. No se puede continuar.\n");
            return x;
        }

        // Fórmula de iteración del método de Newton
        double x_next = x - fx / fpx;

        printf("Iteración %d: x = %f\n", i + 1, x_next);

        // Comprueba la convergencia
        if (fabs(x_next - x) < tolerance) {
            return x_next;
        }

        x = x_next;
    }

    printf("Se alcanzó el número máximo de iteraciones.\n");
    return x;
}

int main() {
    double initial_guess = 1.0;
    int max_iterations = 10;
    double tolerance = 1e-6;

    double root = newton_method(initial_guess, max_iterations, tolerance);

    printf("\nRaíz aproximada: %f\n", root);
    printf("f(raíz) = %f\n", f(root));

    return 0;
}

Compila y ejecuta el código:

gcc -o newton_method newton_method.c -lm
./newton_method

Salida de ejemplo:

Iteración 1: x = 2.500000
Iteración 2: x = 2.050000
Iteración 3: x = 2.000610
Iteración 4: x = 2.000000
Iteración 5: x = 2.000000

Raíz aproximada: 2.000000
f(raíz) = 0.000000

Puntos clave de la implementación:

• newton_method() recibe una suposición inicial, un número máximo de iteraciones y una tolerancia.
• Implementa la fórmula de iteración del método de Newton: x_{n+1} = x_n - f(x_n) / f'(x_n).
• Comprueba la convergencia y la posible división por cero.
• Imprime las iteraciones intermedias para mostrar el proceso de aproximación.

Imprimir la Raíz Aproximada

En este paso, mejoraremos la implementación del método de Newton para proporcionar una salida más detallada sobre la aproximación de la raíz.

Abre el archivo anterior newton_method.c:

cd ~/project
nano newton_method.c

Actualiza el código para mejorar la salida de la aproximación de la raíz:

#include <stdio.h>
#include <math.h>

// Las definiciones de funciones y métodos anteriores permanecen igual
double f(double x) {
    return x * x - 4;
}

double f_derivative(double x) {
    return 2 * x;
}

double newton_method(double initial_guess, int max_iterations, double tolerance) {
    double x = initial_guess;

    printf("Aproximación de la Raíz por el Método de Newton\n");
    printf("------------------------------------------------\n");
    printf("Valor Inicial: %f\n", x);
    printf("Tolerancia: %e\n", tolerance);
    printf("Iteraciones Máximas: %d\n\n", max_iterations);

    for (int i = 0; i < max_iterations; i++) {
        double fx = f(x);
        double fpx = f_derivative(x);

        if (fabs(fpx) < tolerance) {
            printf("Error: La derivada está demasiado cerca de cero.\n");
            return x;
        }

        double x_next = x - fx / fpx;

        printf("Iteración %d:\n", i + 1);
        printf("  x actual: %f\n", x_next);
        printf("  f(x): %f\n", f(x_next));
        printf("  |x_next - x|: %e\n\n", fabs(x_next - x));

        if (fabs(x_next - x) < tolerance) {
            printf("¡Convergencia alcanzada!\n");
            return x_next;
        }

        x = x_next;
    }

    printf("Se alcanzó el número máximo de iteraciones.\n");
    return x;
}

int main() {
    double initial_guess = 1.0;
    int max_iterations = 10;
    double tolerance = 1e-6;

    double root = newton_method(initial_guess, max_iterations, tolerance);

    printf("Resultados Finales:\n");
    printf("-----------------\n");
    printf("Raíz Aproximada: %f\n", root);
    printf("f(raíz): %f\n", f(root));
    printf("Error Absoluto: %e\n", fabs(f(root)));

    return 0;
}

Compila y ejecuta el código:

gcc -o newton_method newton_method.c -lm
./newton_method

Salida de ejemplo:

Aproximación de la Raíz por el Método de Newton
------------------------------------------------
Valor Inicial: 1.000000
Tolerancia: 1.000000e-06
Iteraciones Máximas: 10

Iteración 1:
  x actual: 2.500000
  f(x): 2.250000
  |x_next - x|: 1.500000e+00

Iteración 2:
  x actual: 2.050000
  f(x): 0.202500
  |x_next - x|: 4.500000e-01

... (más iteraciones)

¡Convergencia alcanzada!

Resultados Finales:
-----------------
Raíz Aproximada: 2.000000
f(raíz): 0.000000
Error Absoluto: 0.000000e+00

Mejoras clave:

• Se agregó información detallada de la iteración.
• Se mostraron los parámetros iniciales.
• Se mostró el progreso de la convergencia.
• Se imprimieron los resultados finales con el error absoluto.

Resumen

En este laboratorio, primero definimos la función matemática f(x) y su derivada f'(x) para implementar el método de Newton para aproximar raíces. Luego, implementamos la fórmula iterativa x_{n+1} = x_n - f(x_n)/f'(x_n) para realizar la aproximación de la raíz. Finalmente, imprimiremos la raíz aproximada obtenida a través de este proceso.

Los pasos clave cubiertos en este laboratorio son la definición de la función objetivo y su derivada, y luego la aplicación iterativa de la fórmula del método de Newton para converger a la raíz. Este enfoque nos permite encontrar de manera eficiente las raíces de diversas funciones matemáticas utilizando el lenguaje de programación C.