2017

Tarea Lab#3
Mtodos numricos para ingeniera
CM-3207

ESTUDIANTES:
RICARDO CORRALES RETANA 200925308
EMANUEL MURILLO COTO 201048556

GRUPO 2 | I Semestre
Contenido
Descripcin del trabajo ................................................................................................................................. 4
Desarrollo ...................................................................................................................................................... 5
I PARTE .......................................................................................................................................................... 5
Integrales de Fresnel ................................................................................................................................. 5
Obtencin de las sumas ........................................................................................................................ 5
Programacin de las integrales de Fresnel ........................................................................................... 6
Valores pequeos ................................................................................................................................. 6
Valores grandes..................................................................................................................................... 7
Regla del Trapecio ..................................................................................................................................... 8
Regla del trapecio Simple...................................................................................................................... 8
Regla del trapecio compuesto .............................................................................................................. 9
Analisis de Resultados................................................................................................................................. 10
Para x=0,5................................................................................................................................................ 10
Para x=0,5 y 5 trminos de la serie. .................................................................................................... 10
Para x=0,5 y 10 trminos de la serie. .................................................................................................. 10
Para x=0,5 y 50 trminos de la serie. .................................................................................................. 11
Para TrapecioComp con 10 intervalos ................................................................................................ 11
Para TrapecioComp con 100 intervalos .............................................................................................. 12
Anlisis de datos ..................................................................................................................................... 12
Para x=50................................................................................................................................................. 13
Para TrapecioComp con 10 intervalos ................................................................................................ 13
Para TrapecioComp con 50 intervalos ................................................................................................ 14
Para TrapecioComp con 100 intervalos .............................................................................................. 14
Para TrapecioComp con 1000 intervalos ............................................................................................ 14
Anlisis de datos ..................................................................................................................................... 15
II PARTE ....................................................................................................................................................... 16
Condiciones iniciales: .............................................................................................................................. 16
Mtodo Taylor Orden 2 .......................................................................................................................... 17
Ruge Kutta de orden 2 ............................................................................................................................ 25
Ruge Kutta de orden 4 ........................................................................................................................... 34
Al aplicar el script ...................................................................................................................................... 0
Anlisis de Resultados:.............................................................................................................................. 2
Mtodos multipasos ..................................................................................................................................... 2
Caso particular .......................................................................................................................................... 3
Conclusiones ................................................................................................................................................. 6
Bibliografa consultada.................................................................................................................................. 6
Descripcin del trabajo

El trabajo que a continuacin se muestra, se encuentra subdividido en dos secciones. En la primera

parte se hace el uso de la herramienta computacional Matlab para el desarrollo de diferentes
ecuaciones integrales del tema de integracin numrica. Esta seccin se busca programar en el software
Matlab las integrales de Fresnel tanto para pequeos valores de x como grandes.

Tambin la programacin de una funcin que aproxime el valor de una integral indefinida mediante el
mtodo de la regla del trapecio simple. Y seguido de esto el uso de esta programacin para basar el
mtodo de trapecio compuesto.

Para cerrar con la primera seccin se hace el clculo de algunos resultados para comparar las diferencias
y similitudes que se puede encontrar entre el uso de las integrales Fresnel y las funciones de trapecio
simple y compuesto.

En la segunda parte del trabajo, se desea analizar el comportamiento de la caracterstica t en una

poblacin de escarabajos en sus siguientes generaciones, desde la 5 hasta la 50.

Para realizar esto se hizo uso del software computacional Matlab para la programacin de las funciones
de Taylor de orden 2, orden n, Ruge Kutta de orden 2 y 4. Haciendo uno de la derivacin implcita por
medio de la regla de la cadena para la funcin de Taylor de orden n.

Posterior a esto se implementa un script en el cual contenga las condiciones iniciales del problema
propuesto y utilice las funciones antes programadas, graficando los resultados.

Luego se realiz una pequea investigacin sobre los mtodos multipasos.

Desarrollo

I PARTE
Integrales de Fresnel
Obtencin de las sumas
I.Las integrales de Fresnel C(x) y S(x), son empleadas para el clculo de ondas en fsica, y se definen


() = cos ( 2 ) , () = sen ( 2 )
0 2 0 2

Para pequeos valores de x las integrales se pueden obtener a travs de un desarrollo en serie

2 5 4 9
C(x) = ( ) +( )
2 5 2! 2 9 4!
3 3 7 5 11
S(x) = ( ) ( ) +( )
2 3 1! 2 7 3! 2 11 5!

Para grandes valores de x se pueden aproximar a

1 1 1 1
() + ( 2 ) , () ( 2 )
2 2 2 2

El primer paso que se realiz fue determinar el comportamiento de los desarrollos de las series para
valores menores que 1 con el fin de convertirlo en la suma de una serie desde cero hasta infinito.

2 5 4 9
C(x) = ( ) +( )
2 5 2! 2 9 4!

2 4+1
() = ( ) (1)
2 (4 + 1) 2!
=0

3 3 7 5 11
S(x) = ( ) ( ) +( )
2 3 1! 2 7 3! 2 11 5!

21 41
() = ( ) (1)+1
2 (4 1) (2 1)!
=1

Al obtener las sumas de los valores C(x) y S(x) , se procedi a la programacin en Matlab.

Programacin de las integrales de Fresnel

Valores pequeos

1. [5 puntos] Programe una funcin en Matlab que aproxime C(x) y S(x) para pequeos valores (menores
a 1) de x

[C,S]=SerieFresnel[x,m]

x: valor donde se desea aproximar la integral.

m: es el nmero de trminos del desarrollo en serie que se suman.

Programacin

function [ C,S ] = SerieFresnel(x,m)

C = 0;
S = 0;
for i=0:m-1
C=C+(-1)^i*(pi/2)^(2*i)*x^(4*i+1)/((4*i+1)*factorial(2*i));
end

for i=1:m
S=S+(-1)^(i+1)*((pi/2)^(2*i-1))*(x^(4*i-1))/((4*i-1)*factorial(2*i-1));

end
Valores grandes
2. [2 puntos] Programe una funcin en Matlab que calcule C(x) y S(x) para valores grandes

de x

[C,S]=MaxFresnel[x]

donde x: valor donde se desea aproximar la integral.

Programacin

function [C,S ] = MaxFresnel(x)

C= 1/2 + (1/x*pi)*sin(pi*(x^2)/2);

S= 1/2 - (1/x*pi)*cos(pi*(x^2)/2);

end
Regla del Trapecio

Regla del trapecio Simple

3. [5 puntos] Programe una funcin en Matlab que aproxime el valor de una integral definida

basndose en la regla de Trapecio Simple:

[I]=Trapecio[f,a,b]

f: criterio de la funcin a integrar.

a,b: extremos del intervalo de integracin.

Programacin

function [I] = Trapecio(f,a,b)

syms x
I =(b-a)*(subs(f,x,b)+subs(f,x,a))/2;

end
Regla del trapecio compuesto

4. [5 puntos] Programe una funcin en Matlab que aproxime el valor de una integral definida

basndose en la regla de Trapecio Compuesto:

[I]=TrapecioComp[f,a,b,m]

f: criterio de la funcin a integrar.

a,b: extremos del intervalo de integracin.

m: nmero de puntos.

Esta funcin debe llamar a la funcin [I]=Trapecio[f,a,b] programada en el punto anterior, las veces que
sea necesario.

Programacin

function [ I ] = TrapecioComp( f,a,b,m )

I=0;
syms x
h = (b-a)/(m-1);
for i=1:m-1
I=I + Trapecio(f,a+(i-1)*h,a+i*h);
end
I=double(I)
end
Analisis de Resultados

5. [7 puntos] Calcule C y S para x = 0,5 obtenga el resultado de la suma con 5, 10 y 50 trminos de la

serie y usando la funcin TrapecioComp con 10, 50, 100 y 1000 subintervalos. Compare los resultados.

Para x=0,5
Para x=0,5 y 5 trminos de la serie.

Fuente: Matlab

Para x=0,5 y 10 trminos de la serie.

Fuente: Matlab
Para x=0,5 y 50 trminos de la serie.

Fuente: Matlab

Para TrapecioComp con 10 intervalos

0.0651058129004716

Para TrapecioComp con 50 intervalos

 0.0647450252053854

Para TrapecioComp con 100 intervalos

0.492342948126519

0.0647355176440919

Para TrapecioComp con 1000 intervalos

0.492344213323077

0.0647324631544457

Anlisis de datos
Para el mtodo Fresnel para valores pequeos se puede observar que del uso de 10 a 50 trminos para
aproximar la integral, el resultado fue el mismo. Tuvo una convergencia rpida con pocos datos. Para el
caso de trapecio compuesto, estos valores se acercaron ms a los primeros decimales del resultado que
para el segundo caso con valores grandes. Si no se tomara en cuenta todos los decimales como lo
hicimos nosotros en este trabajo y s slo se hiciera uso de 5 de estos, el resultado obtenido por los
diferentes mtodos sera el mismo.
6. [7 puntos] Calcule C y S para x = 50 obtenga el resultado de mediante las funciones de aproximacin
indicadas y usando la funcin TrapecioComp con 10, 50, 100 y 1000 subintervalos. Compare los
resultados.

Para x=50.

Fuente: Matlab

Para TrapecioComp con 10 intervalos

10.2898036894476

-16.9718847156501
Para TrapecioComp con 50 intervalos

7.39196376678401

0.287228572337709

Para TrapecioComp con 100 intervalos

2.16251400318923

2.51126038487882

Para TrapecioComp con 1000 intervalos

1.75835898969203
 -0.170032508217484

Anlisis de datos

Comparando los datos decidimos que el uso del mtodo de Fresnel para valores grandes (mayores a 1)
converge de una forma muchsimo ms rpida que el mtodo de Trapecio compuesto. Por ejemplo, para
Fresnel utilizamos 50 trminos para aproximar la integral, mientras que, en 50, 100 o 1000 puntos que
se utiliz en el trapecio compuesto no se haba acercado al valor an. Hay que rescatar que entre ms
puntos se probaban en la programacin de trapecio compuesto ms iban sus resultados convergiendo al
valor que se obtuvo por Fresnel.
II PARTE

II. Considere una poblacin de escarabajos, se quiere estudiar la evolucin de cierta caracterstica D de
una generacin a otra. Al inicio del estudio se encontr que la mitad de la poblacin posee dicha
caracterstica y cuatro generaciones despus se encontr que la posee el 80 % de la poblacin.

Sea y el porcentaje de la poblacin de escarabajos que portan la caracterstica t generaciones despus

de haber iniciado el estudio, as

8 + ln(8) ( 1)(2 ) = 0

Analice el comportamiento de la caracterstica en las siguientes 5, 10, 25 y 50 generaciones, despus de

haber iniciado el estudio. Para ello

1. [2 puntos] Determine todas las condiciones iniciales del problema de valor inicial asociado al
problema descrito anteriormente (f, y0, intervalo).

Condiciones iniciales:

Para poder aplicar los mtodos deseados se tiene que despejar el

(8) ( 1)(2 )
() =
8

(0) = 0,5

Se requiere averiguar dicha caracterstica para las siguientes 5,10.25.50 , y 1000 generaciones por lo que
t va a variar segn la cantidad de generaciones en estudio
Mtodo Taylor Orden 2

Programa en Matlab:
function [ matrizSol ] = taylor2( f,y0,a,b,n )
tic %Empieza a contar tiempo de ejecucion
syms t
syms y
syms h
h = (b-a)/(n);
ti(1) = a;
w(1) = y0;
%Para plotear ambos graficos y se puedan ver juntos para comparar entre
%diferentes metodos
subplot (3,2,1),plot(ti(1),w(1) ,'*');
hold on
subplot (3,2,4), plot(ti(1),w(1) ,'*'),title ('Taylor2');
hold on
for i= 1:n
df=diff(f,t) + diff(f,y)*f; % primera derivada
ti(i+1) = a + i*h ;
w(i+1) = w(i) + h*subs(f,[t,y], [ti(i),w(i)])+ subs(df,[t,y],
[ti(i),w(i)])*h^2/2 ; %Taylor Orden 2

%Para plotear ambos graficos y se puedan ver juntos para comparar

entre
%diferentes metodos
subplot (3,2,1), plot (ti(i+1),w(i+1) ,'*');
hold on
subplot (3,2,4),plot (ti(i+1),w(i+1) ,'*'),title ('Taylor2');
hold on
end
toc %Termina a contar tiempo de ejecucion

matrizSol = [ ti' w'];

end

Fuente: Matlab

Para 5 generaciones n =5 [ , ]

0 0.5000

1.0000 0.5943

2.0000 0.6766

3.0000 0.7452

4.0000 0.8006
5.0000 0.8447

Fuente: Matlab

Tiempo 2.578453 s.

Para 10 generaciones n = 10 [ , ]

0 0.5000

1.0000 0.5943

2.0000 0.6766

3.0000 0.7452

4.0000 0.8006

5.0000 0.8447

6.0000 0.8793

7.0000 0.9064

8.0000 0.9275

9.0000 0.9438

10.0000 0.9565
 Fuente: Matlab

Tiempo 5.282742 s.

Para 25 generaciones n = 25 [ , ]

0 0.5000 13.0000 0.9798

1.0000 0.5943 14.0000 0.9844

2.0000 0.6766 15.0000 0.9879

3.0000 0.7452 16.0000 0.9907

4.0000 0.8006 17.0000 0.9928

5.0000 0.8447 18.0000 0.9944

6.0000 0.8793 19.0000 0.9957

7.0000 0.9064 20.0000 0.9966

8.0000 0.9275 21.0000 0.9974

9.0000 0.9438 22.0000 0.9980

10.0000 0.9565 23.0000 0.9984

11.0000 0.9663 24.0000 0.9988

12.0000 0.9739 25.0000 0.9991

 Fuente: Matlab

Tiempo 13.193256 s

Para 50 generaciones n = 50 [ , ]

0 0.5000 15.0000 0.9879 30.0000 0.9997

1.0000 0.5943 16.0000 0.9907 31.0000 0.9998

2.0000 0.6766 17.0000 0.9928 32.0000 0.9998

3.0000 0.7452 18.0000 0.9944 33.0000 0.9999

4.0000 0.8006 19.0000 0.9957 34.0000 0.9999

5.0000 0.8447 20.0000 0.9966 35.0000 0.9999

6.0000 0.8793 21.0000 0.9974 36.0000 0.9999

7.0000 0.9064 22.0000 0.9980 37.0000 1.0000

8.0000 0.9275 23.0000 0.9984 38.0000 1.0000

9.0000 0.9438 24.0000 0.9988 39.0000 1.0000

10.0000 0.9565 25.0000 0.9991 40.0000 1.0000

11.0000 0.9663 26.0000 0.9993 41.0000 1.0000

12.0000 0.9739 27.0000 0.9994 42.0000 1.0000

13.0000 0.9798 28.0000 0.9996 43.0000 1.0000

14.0000 0.9844 29.0000 0.9997 44.0000 1.0000

 45.0000 1.0000 47.0000 1.0000 49.0000 1.0000

46.0000 1.0000 48.0000 1.0000 50.0000 1.0000

Fuente: Matlab

Tiempo 19.351885 s

Para 100 generaciones n = 100 [ , ]

12.0000 0.9739 25.0000 0.9991

0 0.5000 13.0000 0.9798 26.0000 0.9993

1.0000 0.5943 14.0000 0.9844 27.0000 0.9994

2.0000 0.6766 15.0000 0.9879 28.0000 0.9996

3.0000 0.7452 16.0000 0.9907 29.0000 0.9997

4.0000 0.8006 17.0000 0.9928 30.0000 0.9997

5.0000 0.8447 18.0000 0.9944 31.0000 0.9998

6.0000 0.8793 19.0000 0.9957 32.0000 0.9998

7.0000 0.9064 20.0000 0.9966 33.0000 0.9999

8.0000 0.9275 21.0000 0.9974 34.0000 0.9999

9.0000 0.9438 22.0000 0.9980 35.0000 0.9999

10.0000 0.9565 23.0000 0.9984 36.0000 0.9999

11.0000 0.9663 24.0000 0.9988 37.0000 1.0000

38.0000 1.0000 59.0000 1.0000 80.0000 1.0000

39.0000 1.0000 60.0000 1.0000 81.0000 1.0000

40.0000 1.0000 61.0000 1.0000 82.0000 1.0000

41.0000 1.0000 62.0000 1.0000 83.0000 1.0000

42.0000 1.0000 63.0000 1.0000 84.0000 1.0000

43.0000 1.0000 64.0000 1.0000 85.0000 1.0000

44.0000 1.0000 65.0000 1.0000 86.0000 1.0000

45.0000 1.0000 66.0000 1.0000 87.0000 1.0000

46.0000 1.0000 67.0000 1.0000 88.0000 1.0000

47.0000 1.0000 68.0000 1.0000 89.0000 1.0000

48.0000 1.0000 69.0000 1.0000 90.0000 1.0000

49.0000 1.0000 70.0000 1.0000 91.0000 1.0000

50.0000 1.0000 71.0000 1.0000 92.0000 1.0000

51.0000 1.0000 72.0000 1.0000 93.0000 1.0000

52.0000 1.0000 73.0000 1.0000 94.0000 1.0000

53.0000 1.0000 74.0000 1.0000 95.0000 1.0000

54.0000 1.0000 75.0000 1.0000 96.0000 1.0000

55.0000 1.0000 76.0000 1.0000 97.0000 1.0000

56.0000 1.0000 77.0000 1.0000 98.0000 1.0000

57.0000 1.0000 78.0000 1.0000 99.0000 1.0000

58.0000 1.0000 79.0000 1.0000 100.0000 1.0000

Fuente: Matlab
 Fuente: Matlab

Tiempo 37.408223s

Para 1000 generaciones n = 1000 [ , ]

Se utilizaron ms decimales para tener respuestas ms exactas

0 0.500000000000000 15 0.987920522683476 30 0.999741810018271

1 0.594306773590512 16 0.990652056429996 31 0.999800199251940

2 0.676606548525551 17 0.992765976398565 32 0.999845383858482

3 0.745161939107614 18 0.994401891580874 33 0.999880350041789

4 0.800618757251790 19 0.995667872612225 34 0.999907408681026

5 0.844687378168718 20 0.996647565883443 35 0.999928348054027

6 0.879334343284354 21 0.997405708592142 36 0.999944552022633

7 0.906400820711935 22 0.997992401108815 37 0.999957091490659

8 0.927465052876340 23 0.998446415255932 38 0.999966795178815

9 0.943820878864564 24 0.998797755399132 39 0.999974304394007

10 0.956503508795910 25 0.999069640803223 40 0.999980115412650

11 0.966329881915868 26 0.999280039890833 41 0.999984612279073

12 0.973939554997105 27 0.999442857627934 42 0.999988092186619

13 0.979830871292452 28 0.999568854429031 43 0.999990785118850

14 0.984391061967725 29 0.999666357274274 44 0.999992869048927

45 0.999994481701676 74 0.999999996742541 103 0.999999999998077

46 0.999995729655683 75 0.999999997479210 104 0.999999999998512

47 0.999996695386962 76 0.999999998049282 105 0.999999999998849

48 0.999997442719715 77 0.999999998490434 106 0.999999999999109

49 0.999998021044407 78 0.999999998831820 107 0.999999999999310

50 0.999998468581930 79 0.999999999096002 108 0.999999999999466

51 0.999998814909584 80 0.999999999300439 109 0.999999999999587

52 0.999999082915815 81 0.999999999458644 110 0.999999999999681

53 0.999999290312881 82 0.999999999581071 111 0.999999999999753

54 0.999999450807445 83 0.999999999675811 112 0.999999999999809

55 0.999999575006430 84 0.999999999749126 113 0.999999999999852

56 0.999999671118020 85 0.999999999805861 114 0.999999999999885

57 0.999999745494134 86 0.999999999849765 115 0.999999999999911

58 0.999999803050213 87 0.999999999883740 116 0.999999999999931

59 0.999999847590081 88 0.999999999910032 117 0.999999999999947

60 0.999999882057331 89 0.999999999930378 118 0.999999999999959

61 0.999999908729870 90 0.999999999946123 119 0.999999999999968

62 0.999999929370458 91 0.999999999958307 120 0.999999999999976

63 0.999999945343212 92 0.999999999967736 121 0.999999999999981

64 0.999999957703754 93 0.999999999975033 752 1

65 0.999999967268980 94 0.999999999980679 753 1

66 0.999999974671046 95 0.999999999985048 754 1

67 0.999999980399147 96 0.999999999988430 755 1

68 0.999999984831847 97 0.999999999991046 756 1

69 0.999999988262100 98 0.999999999993071 757 1

70 0.999999990916606 99 0.999999999994638 758 1

71 0.999999992970801 100 0.999999999995851 759 1

72 0.999999994560443 101 0.999999999996789 760 1

73 0.999999995790589 102 0.999999999997515 761 1

762 1 980 1 994 1

763 1 981 1 995 1

764 1 982 1 996 1

765 1 983 1 997 1

970 1 984 1 998 1

971 1 985 1 999 1

972 1 986 1 1000 1

973 1 987 1

974 1 988 1

975 1 989 1

976 1 990 1

977 1 991 1

978 1 992 1

979 1 993 1

Fuente: Matlab

Tiempo 370.300653 s

Ruge Kutta de orden 2

function [ matrizSol ] = RK2(f,y0,a,b,n)

tic %Empieza a contar tiempo de ejecucion
syms t
syms y
syms h
h = (b-a)/(n);
ti(1) = a;
w(1) = y0;
%Para plotear ambos graficos y se puedan ver juntos para comparar entre
%diferentes metodos
subplot (3,2,1),plot (ti(1),w(1) ,'*')
hold on
subplot (3,2,3),plot(ti(1),w(1) ,'*'),title ('RK2');
hold on
for i= 1:n
k1=h*subs(f,[t,y], [ti(i),w(i)]); %K1
ti(i+1) = a + i*h ;
k2=h*subs(f,[t,y], [ti(i+1),(w(i)+k1)]); %K2
w(i+1) = w(i) + (k1+k2)/2 ;
%Para plotear ambos graficos y se puedan ver juntos para comparar
entre
%diferentes metodos
subplot (3,2,1),plot (ti(i+1),w(i+1) ,'*');
hold on
subplot (3,2,3),plot (ti(i+1),w(i+1) ,'*'),title ('RK2');
hold on
end
toc %Termina de contar tiempo de ejecucion
matrizSol = [ ti' w']
end

Fuente: Matlab

Para 5 generaciones n =5 [ , ]

0 0.5000

1.0000 0.5926

2.0000 0.6740

3.0000 0.7423

4.0000 0.7980

5.0000 0.8424
Tiempo 1.407450 s.

Para 10 generaciones n = 10 [ , ]

0 0.5000 6.0000 0.8775

1.0000 0.5926 7.0000 0.9049

2.0000 0.6740 8.0000 0.9263

3.0000 0.7423 9.0000 0.9429

4.0000 0.7980 10.0000 0.9558

5.0000 0.8424

Tiempo 2.863813 s
Para 25 generaciones n = 25 [ , ]

0 0.500000000000000 13 0.979494552701764

1 0.592574909919925 14 0.984130541874367

2 0.673985532593660 15 0.987718798492632

3 0.742342816950055 16 0.990495896066986

4 0.798000722693560 17 0.992645105594924

5 0.842436609648928 18 0.994308343529001

6 0.877481562798060 19 0.995595474744873

7 0.904913590025844 20 0.996591538100538

8 0.926288810868689 21 0.997362350206894

9 0.942898733555309 22 0.997958847597810

10 0.955784340844172 23 0.998420449559654

11 0.965770761254532 24 0.998777661683289

12 0.973505674110622 25 0.999054091192868

Fuente: Matlab

Tiempo 4.965691 s
Para 50 generaciones n = 50 [ , ]

25 0.999054091192868

0 0.500000000000000 26 0.999268006773562

1 0.592574909919925 27 0.999433545768350

2 0.673985532593660 28 0.999561648425562

3 0.742342816950055 29 0.999660780893993

4 0.798000722693560 30 0.999737494725959

5 0.842436609648928 31 0.999796859855276

6 0.877481562798060 32 0.999842799660579

7 0.904913590025844 33 0.999878350255835

8 0.926288810868689 34 0.999905861143292

9 0.942898733555309 35 0.999927150489358

10 0.955784340844172 36 0.999943625285214

11 0.965770761254532 37 0.999956374333364

12 0.973505674110622 38 0.999966240205450

13 0.979494552701764 39 0.999973874926946

14 0.984130541874367 40 0.999979783068851

15 0.987718798492632 41 0.999984355094273

16 0.990495896066986 42 0.999987893163734

17 0.992645105594924 43 0.999990631104660

18 0.994308343529001 44 0.999992749864791

19 0.995595474744873 45 0.999994389470834

20 0.996591538100538 46 0.999995658282692

21 0.997362350206894 47 0.999996640154855

22 0.997958847597810 48 0.999997399978258

23 0.998420449559654 49 0.999997987968859

24 0.998777661683289 50 0.999998442986362
 Fuente: Matlab

Tiempo 10.391707s.

Para 100 generaciones n = 100 [ , ]

15 0.987718798492632 31 0.999796859855276

0 0.500000000000000 16 0.990495896066986 32 0.999842799660579

1 0.592574909919925 17 0.992645105594924 33 0.999878350255835

2 0.673985532593660 18 0.994308343529001 34 0.999905861143292

3 0.742342816950055 19 0.995595474744873 35 0.999927150489358

4 0.798000722693560 20 0.996591538100538 36 0.999943625285214

5 0.842436609648928 21 0.997362350206894 37 0.999956374333364

6 0.877481562798060 22 0.997958847597810 38 0.999966240205450

7 0.904913590025844 23 0.998420449559654 39 0.999973874926946

8 0.926288810868689 24 0.998777661683289 40 0.999979783068851

9 0.942898733555309 25 0.999054091192868 41 0.999984355094273

10 0.955784340844172 26 0.999268006773562 42 0.999987893163734

11 0.965770761254532 27 0.999433545768350 43 0.999990631104660

12 0.973505674110622 28 0.999561648425562 44 0.999992749864791

13 0.979494552701764 29 0.999660780893993 45 0.999994389470834

14 0.984130541874367 30 0.999737494725959 46 0.999995658282692

47 0.999996640154855 65 0.999999966721925 83 0.999999999670393

48 0.999997399978258 66 0.999999974247707 84 0.999999999744933

49 0.999997987968859 67 0.999999980071545 85 0.999999999802616

50 0.999998442986362 68 0.999999984578332 86 0.999999999847254

51 0.999998795102412 69 0.999999988065917 87 0.999999999881797

52 0.999999067588002 70 0.999999990764790 88 0.999999999908529

53 0.999999278451427 71 0.999999992853317 89 0.999999999929215

54 0.999999441628440 72 0.999999994469528 90 0.999999999945223

55 0.999999567903241 73 0.999999995720235 91 0.999999999957611

56 0.999999665621206 74 0.999999996688097 92 0.999999999967197

57 0.999999741240415 75 0.999999997437078 93 0.999999999974615

58 0.999999799758466 76 0.999999998016679 94 0.999999999980356

59 0.999999845042756 77 0.999999998465204 95 0.999999999984798

60 0.999999880086080 78 0.999999998812295 96 0.999999999988236

61 0.999999907204414 79 0.999999999080893 97 0.999999999990897

62 0.999999928189982 80 0.999999999288747 98 0.999999999992955

63 0.999999944429698 81 0.999999999449596 99 0.999999999994548

64 0.999999956996830 82 0.999999999574069 100 0.999999999995781

Fuente: Matlab
Tiempo 22.296129 s.

Para 1000 generaciones n = 1000 [ , ]

0 0.500000000000000 24 0.998777661683289 48 0.999997399978258

1 0.592574909919925 25 0.999054091192868 49 0.999997987968859

2 0.673985532593660 26 0.999268006773562 50 0.999998442986362

3 0.742342816950055 27 0.999433545768350 51 0.999998795102412

4 0.798000722693560 28 0.999561648425562 52 0.999999067588002

5 0.842436609648928 29 0.999660780893993 53 0.999999278451427

6 0.877481562798060 30 0.999737494725959 54 0.999999441628440

7 0.904913590025844 31 0.999796859855276 55 0.999999567903241

8 0.926288810868689 32 0.999842799660579 56 0.999999665621206

9 0.942898733555309 33 0.999878350255835 57 0.999999741240415

10 0.955784340844172 34 0.999905861143292 58 0.999999799758466

11 0.965770761254532 35 0.999927150489358 59 0.999999845042756

12 0.973505674110622 36 0.999943625285214 60 0.999999880086080

13 0.979494552701764 37 0.999956374333364 61 0.999999907204414

14 0.984130541874367 38 0.999966240205450 62 0.999999928189982

15 0.987718798492632 39 0.999973874926946 63 0.999999944429698

16 0.990495896066986 40 0.999979783068851 64 0.999999956996830

17 0.992645105594924 41 0.999984355094273 65 0.999999966721925

18 0.994308343529001 42 0.999987893163734 66 0.999999974247707

19 0.995595474744873 43 0.999990631104660 67 0.999999980071545

20 0.996591538100538 44 0.999992749864791 68 0.999999984578332

21 0.997362350206894 45 0.999994389470834 69 0.999999988065917

22 0.997958847597810 46 0.999995658282692 70 0.999999990764790

23 0.998420449559654 47 0.999996640154855 71 0.999999992853317

72 0.999999994469528 99 0.999999999994548 126 1

73 0.999999995720235 100 0.999999999995781 642 1

74 0.999999996688097 101 0.999999999996735 643 1

75 0.999999997437078 102 0.999999999997474 644 1

76 0.999999998016679 103 0.999999999998045 645 1

77 0.999999998465204 104 0.999999999998487 646 1

78 0.999999998812295 105 0.999999999998829 647 1

79 0.999999999080893 106 0.999999999999094 648 1

80 0.999999999288747 107 0.999999999999299 649 1

81 0.999999999449596 108 0.999999999999457 650 1

82 0.999999999574069 109 0.999999999999580 651 1

83 0.999999999670393 110 0.999999999999675 652 1

84 0.999999999744933 111 0.999999999999749 653 1

85 0.999999999802616 112 0.999999999999805 654 1

86 0.999999999847254 113 0.999999999999849 655 1

87 0.999999999881797 114 0.999999999999883 991 1

88 0.999999999908529 115 0.999999999999910 992 1

89 0.999999999929215 116 0.999999999999930 993 1

90 0.999999999945223 117 0.999999999999946 994 1

91 0.999999999957611 118 0.999999999999958 995 1

92 0.999999999967197 119 0.999999999999968 996 1

93 0.999999999974615 120 0.999999999999975 997 1

94 0.999999999980356 121 0.999999999999981 998 1

95 0.999999999984798 122 1 999 1

96 0.999999999988236 123 1 1000 1

97 0.999999999990897 124 1

98 0.999999999992955 125 1

.
 Fuente: Matlab

Tiempo 196.542958 s.

Ruge Kutta de orden 4

tic %Empieza a contar tiempo de ejecucion

syms t
syms y
syms h
h = (b-a)/(n);
ti(1) = a;
w(1) = y0;
%Para plotear ambos graficos y se puedan ver juntos para comparar entre
%diferentes metodos
subplot(3,2,1) ,plot(ti(1),w(1) ,'*');
hold on
subplot (3,2,2) ,plot(ti(1),w(1),'*'),title('RK4');
hold on

for i= 1:n
k1=h*subs(f,[t,y], [ti(i),w(i)]);
%sera la primera derivada
ti(i+1) = a + i*h ;
%Calculo de k1 , k2, k3, k4
k2=h*subs(f,[t,y], [(ti(i)+0.5*h),(w(i)+0.5*k1)]);
k3=h*subs(f,[t,y], [(ti(i)+0.5*h),(w(i)+0.5*k2)]);
k4=h*subs(f,[t,y], [(ti(i)+h),(w(i)+k3)]);
%RK orden 4
w(i+1) = w(i) + (k1+2*k2+2*k3+k4)/6 ;

%Para plotear ambos graficos y se puedan ver juntos para comparar entre
%diferentes metodos
subplot (3,2,1) ,plot(ti(i+1),w(i+1) ,'*');
hold on
 subplot (3,2,2),plot (ti(i+1),w(i+1) ,'*'),title ('RK4');
hold on
end
toc %Termina de contar tiempo de ejecucion
matrizSol = [ ti' w'];
end
Fuente: Matlab

Para 5 generaciones n =5 [ , ]

0 0.5000

1.0000 0.5933

2.0000 0.6753

3.0000 0.7441

4.0000 0.8000

5.0000 0.8445

Fuente: Matlab

Tiempo 2.030195s

Para 10 generaciones n = 10 [ , ]

0 0.5000

1.0000 0.5933
 2.0000 0.6753

3.0000 0.7441

4.0000 0.8000

5.0000 0.8445

6.0000 0.8795

7.0000 0.9068

8.0000 0.9280

9.0000 0.9444

10.0000 0.9571

Fuente: Matlab

Tiempo 4.048232s

Para 25 generaciones n = 25 [ , ]

0 0.500000000000000 5 0.844506887616311 10 0.957123337633893

1 0.593285274889824 6 0.879505077275776 11 0.966924842166170

2 0.675302281111274 7 0.906809962584303 12 0.974489597026553

3 0.744093315902712 8 0.928012967829262 13 0.980325953554798

4 0.799994258825547 9 0.944431338379094 14 0.984827859689530

15 0.988299990899385 19 0.995862971066678 23 0.998537256551973

16 0.990977698495882 20 0.996809864333956 24 0.998872056261378

17 0.993042654214091 21 0.997540033820823 25 0.999130225566502

18 0.994635034457381 22 0.998103081129868

Fuente: Matlab

Tiempo 9.178677s

Para 50 generaciones n = 50 [ , ]

0 0.500000000000000 13 0.980325953554798 26 0.999329303882640

1 0.593285274889824 14 0.984827859689530 27 0.999482816191692

2 0.675302281111274 15 0.988299990899385 28 0.999601191844164

3 0.744093315902712 16 0.990977698495882 29 0.999692473083822

4 0.799994258825547 17 0.993042654214091 30 0.999762861412049

5 0.844506887616311 18 0.994635034457381 31 0.999817138902320

6 0.879505077275776 19 0.995862971066678 32 0.999858993084259

7 0.906809962584303 20 0.996809864333956 33 0.999891267467578

8 0.928012967829262 21 0.997540033820823 34 0.999916154725281

9 0.944431338379094 22 0.998103081129868 35 0.999935345660316

10 0.957123337633893 23 0.998537256551973 36 0.999950144076079

11 0.966924842166170 24 0.998872056261378 37 0.999961555354809

12 0.974489597026553 25 0.999130225566502 38 0.999970354761736

39 0.999977140115424 43 0.999991917413053 47 0.999997142233526

40 0.999982372402672 44 0.999993767396874 48 0.999997796333726

41 0.999986407097267 45 0.999995193946941 49 0.999998300720129

42 0.999989518310336 46 0.999996293980936 50 0.999998689659993

Fuente: Matlab

Tiempo 18.202649s

Para 100 generaciones n = 100 [ , ]

8 0.928012967829262 17 0.993042654214091

0 0.500000000000000 9 0.944431338379094 18 0.994635034457381

1 0.593285274889824 10 0.957123337633893 19 0.995862971066678

2 0.675302281111274 11 0.966924842166170 20 0.996809864333956

3 0.744093315902712 12 0.974489597026553 21 0.997540033820823

4 0.799994258825547 13 0.980325953554798 22 0.998103081129868

5 0.844506887616311 14 0.984827859689530 23 0.998537256551973

6 0.879505077275776 15 0.988299990899385 24 0.998872056261378

7 0.906809962584303 16 0.990977698495882 25 0.999130225566502

26 0.999329303882640 51 0.999998989577313 76 0.999999998477770

27 0.999482816191692 52 0.999999220848023 77 0.999999998826186

28 0.999601191844164 53 0.999999399184311 78 0.999999999094854

29 0.999692473083822 54 0.999999536702078 79 0.999999999302029

30 0.999762861412049 55 0.999999642744075 80 0.999999999461784

31 0.999817138902320 56 0.999999724514637 81 0.999999999584974

32 0.999858993084259 57 0.999999787569135 82 0.999999999679967

33 0.999891267467578 58 0.999999836191398 83 0.999999999753218

34 0.999916154725281 59 0.999999873684748 84 0.999999999809703

35 0.999935345660316 60 0.999999902596429 85 0.999999999853259

36 0.999950144076079 61 0.999999924890656 86 0.999999999886846

37 0.999961555354809 62 0.999999942082067 87 0.999999999912745

38 0.999970354761736 63 0.999999955338619 88 0.999999999932716

39 0.999977140115424 64 0.999999965560944 89 0.999999999948117

40 0.999982372402672 65 0.999999973443532 90 0.999999999959992

41 0.999986407097267 66 0.999999979521912 91 0.999999999969149

42 0.999989518310336 67 0.999999984209041 92 0.999999999976211

43 0.999991917413053 68 0.999999987823357 93 0.999999999981656

44 0.999993767396874 69 0.999999990610409 94 0.999999999985854

45 0.999995193946941 70 0.999999992759547 95 0.999999999989092

46 0.999996293980936 71 0.999999994416779 96 0.999999999991589

47 0.999997142233526 72 0.999999995694695 97 0.999999999993514

48 0.999997796333726 73 0.999999996680115 98 0.999999999994999

49 0.999998300720129 74 0.999999997439987 99 0.999999999996143

50 0.999998689659993 75 0.999999998025936 100 0.999999999997026

 Fuente: Matlab

Tiempo 40.875884 s

Para 1000 generaciones n = 1000 [ , ]

0 0.500000000000000 16 0.990977698495882 32 0.999858993084259

1 0.593285274889824 17 0.993042654214091 33 0.999891267467578

2 0.675302281111274 18 0.994635034457381 34 0.999916154725281

3 0.744093315902712 19 0.995862971066678 35 0.999935345660316

4 0.799994258825547 20 0.996809864333956 36 0.999950144076079

5 0.844506887616311 21 0.997540033820823 37 0.999961555354809

6 0.879505077275776 22 0.998103081129868 38 0.999970354761736

7 0.906809962584303 23 0.998537256551973 39 0.999977140115424

8 0.928012967829262 24 0.998872056261378 40 0.999982372402672

9 0.944431338379094 25 0.999130225566502 41 0.999986407097267

10 0.957123337633893 26 0.999329303882640 42 0.999989518310336

11 0.966924842166170 27 0.999482816191692 43 0.999991917413053

12 0.974489597026553 28 0.999601191844164 44 0.999993767396874

13 0.980325953554798 29 0.999692473083822 45 0.999995193946941

14 0.984827859689530 30 0.999762861412049 46 0.999996293980936

15 0.988299990899385 31 0.999817138902320 47 0.999997142233526

48 0.999997796333726 77 0.999999998826186 106 0.999999999999375

49 0.999998300720129 78 0.999999999094854 107 0.999999999999518

50 0.999998689659993 79 0.999999999302029 108 0.999999999999628

51 0.999998989577313 80 0.999999999461784 109 0.999999999999713

52 0.999999220848023 81 0.999999999584974 110 0.999999999999779

53 0.999999399184311 82 0.999999999679967 111 0.999999999999830

54 0.999999536702078 83 0.999999999753218 112 0.999999999999869

55 0.999999642744075 84 0.999999999809703 113 0.999999999999899

56 0.999999724514637 85 0.999999999853259 114 0.999999999999922

57 0.999999787569135 86 0.999999999886846 115 0.999999999999940

58 0.999999836191398 87 0.999999999912745 116 0.999999999999954

59 0.999999873684748 88 0.999999999932716 117 0.999999999999964

60 0.999999902596429 89 0.999999999948117 118 0.999999999999972

61 0.999999924890656 90 0.999999999959992 119 0.999999999999979

62 0.999999942082067 91 0.999999999969149 120 1

63 0.999999955338619 92 0.999999999976211 121 1

64 0.999999965560944 93 0.999999999981656 122 1

65 0.999999973443532 94 0.999999999985854 123 1

66 0.999999979521912 95 0.999999999989092 124 1

67 0.999999984209041 96 0.999999999991589 125 1

68 0.999999987823357 97 0.999999999993514 126 1

69 0.999999990610409 98 0.999999999994999 127 1

70 0.999999992759547 99 0.999999999996143 128 1

71 0.999999994416779 100 0.999999999997026 129 1

72 0.999999995694695 101 0.999999999997707 130 1

73 0.999999996680115 102 0.999999999998232 131 1

74 0.999999997439987 103 0.999999999998636 132 1

75 0.999999998025936 104 0.999999999998949 133 1

76 0.999999998477770 105 0.999999999999189 655 1

656 1 994 1

657 1 995 1

658 1 996 1

659 1 997 1

660 1 998 1

661 1 999 1

662 1 1000 1

972 1

973 1

974 1

975 1

976 1

977 1

978 1

979 1

980 1

981 1

982 1

983 1

984 1

985 1

986 1

987 1

988 1

989 1

990 1

991 1

992 1

993 1
 Fuente: Matlab

Tiempo 994.822842s

Al aplicar el script

RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,5,5);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,10,10);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,25,25);
RK2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,50,50);
RK2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,100,100);
RK2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,1000,1000);

RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,5,5);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,10,10);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,25,25);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,50,50);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,100,100);
RK4('-log(8)*y*(y-1)*(2-y)/8',0.5,0,1000,1000);

taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,5,5);
taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,10,10);
taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,25,25);
taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,50,50);
taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,100,100);
taylor2('-log(8)*y*(y-1)*(2-y)/8',0.5,0,1000,1000);
Se obtuvo :

Resultados en el orden del script

Figura Grafico de los mtodos juntos y de cada uno por aparte con n = 1000
Anlisis de Resultados:

En los diferentes mtodos utilizados el que tiene mejores aproximaciones es el RK4, aunque para
este ejemplo no hubo mucha diferencia entre cada uno de ellos esto se puede observar en los
grficos obtenidos , pero si se analiza con la mayor cantidad de decimales posibles el RK4 es el de
mejor comportamiento pero ese mtodo es el que toma ms tiempo de los tres ya que el proceso
lleva ms clculos .

Es importante sealar que el tiempo que le tomaba correr el mtodo variaba en las diferentes
pruebas con la misma cantidad de iteraciones. Entre las razones que pueden explicar esta
diferencia estn: velocidad del procesador de la computadora, uso que se le est dando a la
computadora aparte del correr el programa.

Estos mtodos al ser orden 2 y orden 4 sus aproximaciones pueden no ser tan exactas al usar gran
cantidad de intervalos , en este casi no hubo ese problema ya que la funcin que se analiz se
puede considerar continua que no tiene mximos o mnimos locales y su derivadas no son cclicas.

Mtodos multipasos

La idea de extender el mtodo de Euler para permitir la solucin aproximada en un punto,

dependa de los valores de la solucin y de los valores de las derivadas en varios puntos fue
propuesta originalmente por Bashforth y Adams (1883).

Se conoce como mtodos multipasos a aquellos que emplea la aproximacin en ms de uno de los
puntos de la red precedentes para determinar la aproximacin en el siguiente punto. A
continuacin, se da la definicin exacta de este mtodo.

Un mtodo multipasos de paso m para resolver el problema de valor inicial

= (, ), , () = ,

Es aquel cuya ecuacin de diferencias para obtener la aproximacin de wi+1 en el punto de red
ti+1 puede representarse por medio de la siguiente ecuacin, donde m es un entero mayor que 1:

+1 = 1 + 1 1 + + 0 +1 +
[ (+1 +1) + 1 ( ) +
+ 0 (1 1)

= 1, , , 1, = , 0 , 1 , , 1 0 , 1 , ,

0 = , 1 = 1 , 2 = 2 , , 1 = 1 ,

son especificados.

Cuando = 0, el mtodo es explcito o abierto, ya que la ecuacin da entonces +1 de manera

explcita en trminos de los valores previamente determinados. Cuando 0 , el mtodo es
implcito o cerrado, ya que +1 se encuentra en ambos lados de la ecuacin y se especifica slo
implcitamente.

En palabras simples el mtodo multipaso es utilizar los valores previos para construir un polinomio
que aproxime a la funcin (, ()).

El nmero de valores previos que consideremos para determinar el polinomio nos determina el
grado que vamos a obtener del polinomio.

Caso particular

El mtodo de Heun sin autoinicio

Obtenido del libro: Mtodos numricos para ingenieros

El procedimiento de Heun utiliza el mtodo de Euler como un predictor:

y la regla del trapecio como un corrector:

As, el predictor y el corrector tienen errores de truncamiento local de O(h2) y O(h3),

respectivamente. Esto sugiere que el predictor es la parte dbil en el mtodo, a causa de que tiene
el error ms grande. Esta debilidad es significativa puesto que la eficiencia del paso corrector
depende de la exactitud de la prediccin inicial. En consecuencia, una forma de mejorar el mtodo
de Heun consiste en desarrollar un predictor que tenga un error local de O(h3). Esto se obtiene
usando el mtodo de Euler y la pendiente, as como una informacin extra de un valor anterior yi1
como en:

Observe que la ecuacin alcanza O(h3) a expensas de emplear un tamao de paso mayor, 2h.
Adems, note que la ecuacin no es de autoinicio, ya que necesita un valor previo de la variable
dependiente yi1. Tal valor no est disponible en un problema comn de valor inicial. Por ello, las
ecuaciones se denominan mtodo de Heun sin autoinicio.

Como se indica en la figura 26.4, la derivada estimada para la ecuacin se localiza ahora en el
punto medio y no al inicio del intervalo sobre el cual se hace prediccin.

Como se consider anteriormente, esta ubicacin centrada mejora el error del predictor a O(h3).
Sin embargo, antes de realizar una deduccin formal del mtodo de Heun sin autoinicio, lo
resumiremos y lo expresaremos utilizando una nomenclatura ligeramente modificada:
donde los superndices se agregaron para denotar que el corrector se aplica iterativamente desde
j=1 hasta m para obtener mejores soluciones. Observe que

son los resultados finales del corrector en los pasos anteriores. Las iteraciones terminan en
cualquier paso considerando el criterio de terminacin:
Conclusiones

La programacin del mtodo de Fresnel para valores menores que 1 converge tan rpido
como la programacin del trapecio compuesto.

La programacin para trapecio compuesto para valores mayores a uno no coverge a la

misma velocidad que la programacin de MaxFresnel.

El mtodo que mejor aproxima es el RK4, aunque es el mtodo que se toma ms tiempo
en completar.

Bibliografa consultada

Burden, R. L., & Faires, J. (s.f.). Anlisis numrico. Math learning.

Chapra, S. C., & Canale, R. P. (2007). Mtodos numricos para ingenieros. Mexico D.F.: McGraw-
Hill interamericana.

http://ocw.um.es. (3 de Junio de 2017). Obtenido de http://ocw.um.es/ingenierias/ampliacion-de-

calculo-numerico/material-de-clase-1/ivp-ode.pdf