Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 40 vistas

    Taller

    Cargado por

    ferney gilberto beltran urrego
    1. Se presentan códigos para aplicar los métodos de bisección, Regula-Falsi y punto fijo para encontrar raíces de funciones. El método de Regula-Falsi converge más rápido que el de bisección. El método de punto fijo sólo converge para una de las dos formas de definir la función. 2. Se explica por qué el método de Newton-Raphson no se puede aplicar directamente al problema planteado. 3. Se incluyen códigos para aplicar los métodos de Jacobi y Gauss-Seidel a un sistema de ecuaciones line

    Copyright:

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

    Taller

    Cargado por

    ferney gilberto beltran urrego
    40 vistas8 páginas
    1. Se presentan códigos para aplicar los métodos de bisección, Regula-Falsi y punto fijo para encontrar raíces de funciones. El método de Regula-Falsi converge más rápido que el de bisección. El método de punto fijo sólo converge para una de las dos formas de definir la función. 2. Se explica por qué el método de Newton-Raphson no se puede aplicar directamente al problema planteado. 3. Se incluyen códigos para aplicar los métodos de Jacobi y Gauss-Seidel a un sistema de ecuaciones line

    Descripción original:

    metodos numericos

    Título original

    20210905 - taller (1)

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    1. Se presentan códigos para aplicar los métodos de bisección, Regula-Falsi y punto fijo para encontrar raíces de funciones. El método de Regula-Falsi converge más rápido que el de bisección. El método de punto fijo sólo converge para una de las dos formas de definir la función. 2. Se explica por qué el método de Newton-Raphson no se puede aplicar directamente al problema planteado. 3. Se incluyen códigos para aplicar los métodos de Jacobi y Gauss-Seidel a un sistema de ecuaciones line

    Copyright:

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

    Taller

    Cargado por

    ferney gilberto beltran urrego
    1. Se presentan códigos para aplicar los métodos de bisección, Regula-Falsi y punto fijo para encontrar raíces de funciones. El método de Regula-Falsi converge más rápido que el de bisección. El método de punto fijo sólo converge para una de las dos formas de definir la función. 2. Se explica por qué el método de Newton-Raphson no se puede aplicar directamente al problema planteado. 3. Se incluyen códigos para aplicar los métodos de Jacobi y Gauss-Seidel a un sistema de ecuaciones line

    Copyright:

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

    Universidad ECCI

    Taller Corte I
    Métodos Numéricos
    Profesor: Mauricio Munar
    Jonathan Barahona pineda cod: 45462
    Ferney Beltrán cod 46232

    1. Punto 1
    Se usan los códigos de extensión .m (para ejecutar en Octave o Matlab), el primero de ellos llamado funcion-
    punto1.m es para la función a la que se le quiere calcular la raı́z:
    Código funcionpunto1.m
    function y=funcionpunto1(x)
    y=((9.8/15)*x)*(1-exp(-135/x))-35;

    1.1. Solución por método de bisección


    La solución obtenida por el método de bisección se cálcula con el algoritmo de nombre biseccionpunto1.m:
    biseccionpunto1.m
    aant=55;cant=62;
    bant=62;
    Nmax=45;
    for i=1:Nmax
    fa=funcionpunto1(aant);
    fb=funcionpunto1(bant);
    c=0.5*(aant+bant);
    fc=funcionpunto1(c);
    if(fc==0)break;
    end
    if(sign(fa)~=sign(fc))
    anue=aant;
    bnue=c;
    else
    anue=c;
    bnue=bant;
    end
    fprintf(’c(%d)=%.10f\n’,i,c)
    fprintf(’ea(%d)=%.10f\n’,i,abs(bnue-anue))
    if abs(bnue-anue)<0.0005 break;
    end
    aant=anue;
    bant=bnue;

    1
    cant=c;
    end
    A continuación se presenta la tabla de datos generado por el algoritmo. Se obtiene el siguiente resultado donde
    se muestra la iteración, la raı́z y el error absoluto.
    c(1)=58.5000000000
    ea(1)=3.5000000000
    c(2)=60.2500000000
    ea(2)=1.7500000000
    c(3)=59.3750000000
    ea(3)=0.8750000000
    c(4)=59.8125000000
    ea(4)=0.4375000000
    c(5)=60.0312500000
    ea(5)=0.2187500000
    c(6)=59.9218750000
    ea(6)=0.1093750000
    c(7)=59.8671875000
    ea(7)=0.0546875000
    c(8)=59.8398437500
    ea(8)=0.0273437500
    c(9)=59.8535156250
    ea(9)=0.0136718750
    c(10)=59.8466796875
    ea(10)=0.0068359375
    c(11)=59.8432617188
    ea(11)=0.0034179688
    c(12)=59.8415527344
    ea(12)=0.0017089844
    c(13)=59.8406982422
    ea(13)=0.0008544922
    c(14)=59.8411254883
    ea(14)=0.0004272461

    1.2. Solución por método de Regula-Falsi


    En este punto presentamos un código llamado falsi.m para el método de Regula-Falsi. regulafalsipunto1.m
    Xi=55;
    Xs=62;
    delta=0.0005;
    Iter=35;

    Yi=funcionpunto1(Xi);
    Ys=funcionpunto1(Xs);

    if Yi==0
    fprintf(’\n\nSOLUCION:\n’)
    fprintf(’Xi es raiz\n\n’);
    else
    if Ys==0
    fprintf(’\n\nSOLUCION:\n’)
    fprintf(’Xs es raiz\n\n’);
    else
    if Yi*Ys<0

    2
    Xm=(Xi)-((funcionpunto1(Xi)*(Xi-Xs))/(funcionpunto1(Xi)-funcionpunto1(Xs)));
    Ym=funcionpunto1(Xm);
    Error=delta+1;
    Cont=1;
    Z=[Cont,Xi,Xs,Xm,Ym,Error];

    while Ym~=0 & Error>delta & Cont<Iter


    if Yi*Ym<0
    Xs=Xm;
    Ys=Ym;
    else
    Xi=Xm;
    Yi=Ym;
    end
    Xaux=Xm;
    Xm=(Xi)-((funcionpunto1(Xi)*(Xi-Xs))/(funcionpunto1(Xi)-funcionpunto1(Xs)));
    Ym=funcionpunto1(Xm);
    Error=abs(Xm-Xaux);
    Cont=Cont+1;
    Z(Cont,1)=Cont;
    Z(Cont,2)=Xi;
    Z(Cont,3)=Xs;
    Z(Cont,4)=Xm;
    Z(Cont,5)=Ym;
    Z(Cont,6)=Error;
    end
    if Ym==0
    fprintf(’\n\nSOLUCION:\n’)
    fprintf(’%.10f es ra~Az\n\n’,Xm);
    else
    if Error<delta
    fprintf(’\n\nSOLUCION:\n’)
    fprintf( ’%.10f es una aproximacion a una ra~
    Az con una tolerancia %.10f \n\n’,Xm,delta);
    else
    fprintf(’\n\nSOLUCION:\n’)
    fprintf(’Fracaso en %d iteraciones\n\n’,Iter);
    end
    end
    else
    fprintf(’\n\nSOLUCION:\n’)
    fprintf(’El intervalo es inadecuado\n\n’);
    end
    end
    end
    fprintf(’TABLA\n\nIteraciones Xi Xs Xm Ym Error Absoluto\n\n’);
    disp(Z);
    A continuación se presenta la tabla de datos generado por el algoritmo.
    SOLUCION:
    59.8410471102 es una aproximacion a una ra~
    Az con una tolerancia 0.0005000000

    TABLA

    Iteraciones Xi Xs Xm Ym Error Absoluto

    3
    1.0000e+00 5.5000e+01 6.2000e+01 5.9911e+01 3.0171e-02 1.0005e+00
    2.0000e+00 5.5000e+01 5.9911e+01 5.9843e+01 9.7498e-04 6.7858e-02
    3.0000e+00 5.5000e+01 5.9843e+01 5.9841e+01 3.1487e-05 2.1919e-03
    4.0000e+00 5.5000e+01 5.9841e+01 5.9841e+01 1.0169e-06 7.0785e-05

    1.3. Comparación
    Viendo el resultados de los dos programas anteriores, Se puede evidenciar que ambos metodos convergen y se
    obtiene la raı́z de la función en el internvalo. Además, también se ve que el método de la Regula-Falsi encuentra
    mucho más rápido la raı́z, pues solo necesita 4 iteraciones mientras que el método de bisección lo hace en 14
    iteraciones. Se concluye que el segundo método posee una mayor velocidad de convergencia.

    2. Punto 2
    De acuerdo al enunciado del problema, para aplicar el método de Newton-Raphson, se precisa de la función y
    la derivada de la función, pero no me fue es posible determinar la función, ya que se precisaba resolver la ecuación
    diferencial no lineal de primer orden, además se entiende que la solución en estado estable de una ecuación diferencial
    son las soluciones constantes, es decir las que tienen derivada nula, puesto que en el método se precisa dividir por
    la derivada, esta no se puede tomar nula; es ası́ que si se toma como la derivada de la funcion, la planteada en el
    enunciado, entonces no se puede obtener la función, y por otro lado si se tiene la función constante entonces no se
    tiene la derivada no nula para el método.

    2.1. Método del punto fijo


    Por otro, la segunda parte del ejercicio usa en efecto la derivada nula para despejar la función c(t):
     2
    W − Qc
    c(t) =
    KV

    funcionpunto2a.m
    function y=funcionpunto2a(x)
    y=(((10^6)-((10^5)*x))/(0.25*(10^6)))^2;
    funcionpunto2a.m
    clc
    clear
    x0=4;
    epsilon=5*10^-4;
    n=20;
    for i=1:n
    xn=x0;
    x0=funcionpunto2a(x0);
    if(abs(xn-x0)<epsilon)
    fprintf(’la raiz se obtuvo en la %d-esima iteracion y es %f’,i,funcionpunto2a(x0))
    fprintf(’\n\n’)
    return
    else
    fprintf(’x_%d = %f, x_%d = %f \n’,i-1,xn,i,funcionpunto2a(x0))
    fprintf(’\n\n’);
    end
    end
    fprintf(’\n\n’);

    4
    Se obtienen los siguientes resultados.

    x_0 = 4.000000, x_1 = 2.876416


    x_1 = 5.760000, x_2 = 8.119272
    x_2 = 2.876416, x_3 = 0.565942
    x_3 = 8.119272, x_4 = 14.240232
    x_4 = 0.565942, x_5 = 2.876730
    x_5 = 14.240232, x_6 = 8.118555
    x_6 = 2.876730, x_7 = 0.566373
    x_7 = 8.118555, x_8 = 14.238930
    x_8 = 0.566373, x_9 = 2.874964
    x_9 = 14.238930, x_10 = 8.122582
    x_10 = 2.874964, x_11 = 0.563952
    x_11 = 8.122582, x_12 = 14.246240
    x_12 = 0.563952, x_13 = 2.884889
    x_13 = 14.246240, x_14 = 8.099968
    x_14 = 2.884889, x_15 = 0.577619
    x_15 = 8.099968, x_16 = 14.205001
    x_16 = 0.577619, x_17 = 2.829126
    x_17 = 14.205001, x_18 = 8.227430
    x_18 = 2.829126, x_19 = 0.502721
    x_19 = 8.227430, x_20 = 14.431731
    Se puede evidenciar que el método no converge para esta función
    Función segunda forma la función c(t):
    √
    W − KV c
    c(t) =
    Q
    funcionpunto2b.m
    function y=funcionpunto2b(x)
    y=(((10^6)-((0.25*10^6)*(sqrt(x))))/(10^5));
    En este caso se obtiene la raı́z buscada
    x_0 = 3.500000, x_1 = 4.232132
    x_1 = 5.322928, x_2 = 4.856963
    x_2 = 4.232132, x_3 = 4.490370
    x_3 = 4.856963, x_4 = 4.702377
    x_4 = 4.490370, x_5 = 4.578759
    x_5 = 4.702377, x_6 = 4.650491
    x_6 = 4.578759, x_7 = 4.608751
    x_7 = 4.650491, x_8 = 4.633000
    x_8 = 4.608751, x_9 = 4.618899
    x_9 = 4.633000, x_10 = 4.627094
    x_10 = 4.618899, x_11 = 4.622330
    x_11 = 4.627094, x_12 = 4.625099
    x_12 = 4.622330, x_13 = 4.623489
    x_13 = 4.625099, x_14 = 4.624425
    x_14 = 4.623489, x_15 = 4.623881
    x_15 = 4.624425, x_16 = 4.624197

    la raiz se obtuvo en la 17-esima iteracion y es 4.624013


    De estos resultados se ve que por medio del mismo método la convergencia o no del algoritmo depende además
    de la forma en que se introduzca la función a la que se desea calcular la raiz.

    5
    3. Punto 3
    3.1. Método de Jacobi
    Se presenta un código en MATLAB llamado punto3Jacobi.m, en este código se presenta el método de Jacobi.

    punto3Jacobi.m
    clc
    clear
    A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
    -1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
    B=[0; 5; 0; 6; -2; 6];
    punto_inicial=[0; 0; 0; 0; 0; 0];
    error=5*10^(-4);
    cont_iteraciones=10;
    s=size(A);
    num_ecuaciones=s(1);
    for k=1:num_ecuaciones
    B(k)=B(k)/A(k,k);
    A(k,:)=A(k,:)/A(k,k);
    A(k,k)=0;
    end
    M=-A;
    x_ant=punto_inicial;
    x_sig=M*x_ant+B;
    deltax_n=x_sig-x_ant;
    while norm(deltax_n,inf) > error
    x_sig=M*x_ant+B;
    deltax_n=x_sig-x_ant;
    x_ant=x_sig;
    cont_iteraciones=cont_iteraciones+1;
    end
    solucion=x_sig
    num_iteraciones=cont_iteraciones
    Se obtienen los siguientes resultados.
    solucion =

    5.4724
    4.5800
    2.0105
    17.3095
    5.8379
    3.4620

    num_iteraciones = 58

    3.2. Método de Gauss-Seidel


    Se presenta un código en MATLAB llamado punto3GaussSeidel.m, en este código se presenta el método de
    Gauss-Seidel.

    punto3GaussSeidel.m

    6
    clc
    clear
    A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
    -1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
    B=[0; 5; 0; 6; -2; 6];
    punto_inicial=[0; 0; 0; 0; 0; 0];
    error=5*10^(-4);
    D=diag(diag(A));
    U=triu(A)-D;
    L=tril(A)-D;
    M=-inv(D+L)*U;
    N=inv(D+L)*B;
    cont=1;
    xant=punto_inicial;
    xsig=M*xant+N;
    while norm(xsig-xant,inf)>error
    cont=cont+1;
    xant=xsig;
    xsig=M*xant+N;
    end
    sol=xsig
    niteraciones=cont
    error=norm(xsig-xant,inf)
    Se obtuvieron los siguientes resultados.
    sol =

    5.4728
    4.5804
    2.0107
    17.3111
    5.8384
    3.4623

    niteraciones = 27
    error = 3.4934e-04

    3.3. Método SOR


    Se presenta un código en MATLAB llamado sor.m, en este código se presenta el método de SOR.

    punto3sor.m
    function [x] = punto3sor()
    n=6;
    A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
    -1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
    b=[0; 5; 0; 6; -2; 6];
    maxiter=30;
    x0=[0; 0; 0; 0; 0; 0];
    w=0.9;
    tol= 0.0005;
    [m n]= size(A);
    if m~=n
    fprintf(’Matriz del sistema no cuadrada’);

    7
    end
    if m~= length(b)
    fprintf(’sistema no coherente’);
    end
    x=zeros(size(b));
    x2=x;
    if any(abs(diag(A))<eps)
    fprintf(’Metodo no valido. Elemento diagonal nulo’);
    end
    for k=1:maxiter
    for i=1:n
    tem=(b(i)-sum(A(i,[1:i-1 i+1:n])*x0([1:i-1 i+1:n]’)))/A(i,i);
    x(i)=tem*w + (1-w)*x0(i);
    x0(i)=x(i);
    end
    if norm(x-x2)< tol
    fprintf(’\n SOR CONVERGE en %d iteraciones\n’,k);
    return
    end
    x2=x;
    end

    Se obtienen los siguientes resultados

    ans =

    5.4720
    4.5799
    2.0105
    17.3093
    5.8378
    3.4620

    3.4. Comparación
    De acuerdo a los resultados anteriores obtenemos que los 3 métodos convergen, pero los mejores métodos son los
    de Gauss-Seidel y SOR ya que convergen en 27 y 28 iteraciones respectivamente, mientras que el método de Jacobi
    lo hace en 58 iteraciones.

    También podría gustarte