Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 23 vistas

    PNZGP 9 N 4

    Cargado por

    Dany Sanchez
    Este documento describe el método de Newton-Raphson para calcular raíces de una función. Explica cómo iterar entre una aproximación inicial y subsiguientes hasta que el error sea menor que una tolerancia dada, encontrando así la raíz aproximada. Incluye código C++ que implementa este método para una función dada.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd

    PNZGP 9 N 4

    Cargado por

    Dany Sanchez
    23 vistas3 páginas
    Este documento describe el método de Newton-Raphson para calcular raíces de una función. Explica cómo iterar entre una aproximación inicial y subsiguientes hasta que el error sea menor que una tolerancia dada, encontrando así la raíz aproximada. Incluye código C++ que implementa este método para una función dada.

    Título original

    pnzgp9n4

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    TXT, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Este documento describe el método de Newton-Raphson para calcular raíces de una función. Explica cómo iterar entre una aproximación inicial y subsiguientes hasta que el error sea menor que una tolerancia dada, encontrando así la raíz aproximada. Incluye código C++ que implementa este método para una función dada.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    23 vistas3 páginas

    PNZGP 9 N 4

    Cargado por

    Dany Sanchez
    Este documento describe el método de Newton-Raphson para calcular raíces de una función. Explica cómo iterar entre una aproximación inicial y subsiguientes hasta que el error sea menor que una tolerancia dada, encontrando así la raíz aproximada. Incluye código C++ que implementa este método para una función dada.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    de 3

    // Método de NEWTON - RAPHSON para el cálculo de raíces

    // Autor: Canal de Youtube: Algoritmos y Algo más


    // 25/12/2015

    #include <iostream>
    #include <iomanip> // setprecision
    #include <cmath>
    #include <windows.h>

    #define PRECISION 10
    #define MAX_ITERACIONES 100
    #define INTERVALOS 6

    using namespace std;

    void tabula(double a, double b, int intervalos); // Muestra un # tabulado de


    intervalos
    double f(double x); // Retorna el valor de la función evaluada en x
    double f_derivada(double x); // Retorna la derivada de la función evaluada en x
    void newton_raphson(double x0, double tolerancia, int max_interaciones); //
    Función que calcula la raiz aproximada de una función

    int main()
    {
    double a;
    double b;
    double tolerancia; // Tolerancia
    double x0; // Primera aproximación

    cout << setprecision(PRECISION); // Se establece la precisión


    cout << "\nCalculo de las raices de una funcion aplicando el metodo de Newton
    - Raphson\n";
    cout << "\nIngrese el intervalo inicial [a,b]:" << endl;

    // Se ingresa el intervalo
    cout << "\na = ";
    cin >> a;

    cout << "b = ";


    cin >> b;

    // Se tabulan los valores de f para INTERVALOS intervalos


    tabula(a, b, INTERVALOS);

    // Se pide elegir una aproximación inicial


    cout << "\nEscoja el punto inicial adecuado: x0 = ";
    cin >> x0;

    // Se pide ingresar la tolerancia


    cout << "Tolerancia = ";
    cin >> tolerancia;

    // Newton Raphson
    newton_raphson(x0, tolerancia, MAX_ITERACIONES);

    cin.get();
    cin.get();
    return 0;
    }

    void tabula(double a, double b, int intervalos)


    {
    int puntos = intervalos + 1;

    double ancho = (b - a) / intervalos;

    cout << "\n\tx\t\tf(x) " << endl;


    for (int i = 0; i < puntos; i++) {
    cout << "\t" << a << "\t\t" << f(a) << endl;
    a = a + ancho;
    }
    }

    double f(double x)
    {
    return x * exp(cos(x)) / 1.5 - 1;
    //return exp(-x) + 3 * x - 3;
    }

    double f_derivada(double x)
    {
    return exp(cos(x)) * (1 - x * sin(x)) / 1.5;
    //return -1 * exp(-x) + 3;
    }

    void newton_raphson(double x0, double tolerancia, int max_iteraciones)


    {
    double x1; // Siguiente aproximación
    double error; // Diferencia entre dos aproximaciones sucesivas: x1 - x0
    int iteracion; // # de iteraciones
    bool converge = true;

    // Se imprimen los valores de la primera aproximación


    cout << "\nAproximacion inicial:\n";
    cout << "x0 = " << x0 << "\n"
    << "f(x0) = " << f(x0) << "\n"
    << "f'(x0) = " << f_derivada(x0) << endl;

    iteracion = 1;
    do {

    if (iteracion > max_iteraciones) {


    converge = false; // Se sobrepasó la máxima cantidad de iteraciones
    permitidas
    break;

    } else {
    x1 = x0 - f(x0) / f_derivada(x0); // Cálculo de la siguiente
    aproximación
    error = fabs(x1 - x0); // El error es la diferencia entre dos
    aproximaciones sucesivas

    // Se imprimen los valores de la siguiente aproximación x1,


    f(x1), f_derivada(x1), error
    cout << "\a";
    Sleep(500);
    cout << "\n\nIteracion #" << iteracion << endl;
    cout << "\nx" << iteracion << " = " << x1 << "\n"
    << "f(x" << iteracion << ") = " << f(x1) << "\n"
    << "f'(x" << iteracion << ") = " << f_derivada(x1) <<
    "\n"
    << "error = " << error << endl;

    // La diferencia entre dos aproximaciones sucesivas es también conocida


    como error.
    // La condición de terminación consiste en que que el error debe ser <=
    que la tolerancia dada
    // Si se cumple la condición de terminación, se ha encontrado la raiz
    aproximada buscada.
    if (error <= tolerancia) { // Condición de terminación
    converge = true;
    break;

    // Si no se cumple el criterio de terminación, se pasa a la siguiente


    iteración
    } else {
    x0 = x1;
    iteracion++;
    }
    }

    } while (1);

    // Respuesta final
    cout << "\a";
    Sleep(500);
    if (converge) {
    cout << "\n\nPara una tolerancia de " << tolerancia << " la RAIZ APROXIMADA
    de f es = " << x1 << endl;

    } else {
    cout << "\n\nSe sobrepasó la máxima cantidad de iteraciones permitidas"
    << endl;
    }
    }

    También podría gustarte