Implementación de Newton-Raphson y Métodos de Relajación en C++

Implementación del Algoritmo de Newton-Raphson

En esta sección se detalla la lógica para el cálculo de la matriz derivada y la ejecución del proceso iterativo de Newton-Raphson.

/** HACER ALUMNO */
for (int i = 0; i < u.dim(); i++) {
    Array1D u2 = u.copy(); // vector auxiliar
    u2[i] += h;
    Array1D derivada2 = ((*f)(u2) - (*f)(u)) / h;

    for (int j = 0; j < u.dim(); j++) {
        derivada[j][i] = derivada2[j];
    }
}
return derivada;
}

/** HACER ALUMNO */
/** usar dentro del bucle la instrucción u.print("u"); para poder comparar los resultados
de cada iteración con los resultados que tienen que salir */

Array1D fu = (*f)(u);
Array1D fu2;

for (int Niter = 0; Niter < max_iter; Niter++) {
    if (fu.norm() < tol) {
        // Condición de convergencia alcanzada
    }

    // Resolución del sistema lineal por Gauss
    fu2 = mn_gauss(matriz_derivada(f, u, h), (*f)(u) * (-1));

    if (fu2.norm() < tol) {
        // Condición de parada por incremento
    }

    u += fu2;
    u.print("u");
}

return -1; // Ha excedido el número de iteraciones.

Método de Relajación para Sistemas Lineales

El siguiente código implementa el algoritmo de relajación (SOR) para resolver sistemas de ecuaciones de la forma Ax = b.

// REALIZAMOS LAS ITERACIONES DEL ALGORITMO
Array1D t(u.dim());

for (int num = 1; num < max_iter; num++) {
    // RECORREMOS LAS INCÓGNITAS DE MANERA ASCENDENTE
    real error = 0.0; // VARIABLE QUE ALMACENARÁ EL ERROR EN LA ITERACIÓN

    // RECORREMOS CADA FILA
    for (int i = 0; i < u.dim(); i++) {
        real save = b[i]; // CREAMOS LA VARIABLE QUE GUARDARÁ EL NUEVO VALOR u[i]

        for (int j = 0; j < i; j++) {
            save = save - A[i][j] * u[j];
        }

        for (int j = i + 1; j < u.dim(); j++) {
            save = save - A[i][j] * u[j];
        }

        save = w * save / A[i][i] + (1 - w) * u[i];
        t[i] = u[i];
        u[i] = save;
    }

    error = mn_error_vectores(u, t);

    if (error < tol) {
        return num;
    }
}

return -1;

Relajación para Matrices Escasas

Optimización del método de relajación diseñado para trabajar con estructuras de matrices escasas, mejorando el rendimiento computacional.

// HACER ALUMNO
for (int Niter = 1; Niter < max_iter; Niter++) {
    // RECORREMOS LAS INCÓGNITAS DE FORMA ASCENDENTE
    real error = 0.0; // variable para almacenar el error en la iteración

    for (int i = 0; i < u.dim(); i++) {
        // RECORREMOS CADA FILA
        real suma = b[i];

        for (int j = 1; j < A[i].size(); j++) {
            suma -= A[i][j] * u[J[i][j]];
        }

        if (A[i][0] == 0) return -1;

        suma = w * suma / A[i][0] + (1 - w) * u[i];
        error += mn_distancia(u[i], suma);
        u[i] = suma;
    }

    if ((error / u.dim()) < tol) {
        return Niter;
    }
}

return -1;