Informe final de métodos numéricos: Métodos para ecuaciones no lineales, sistemas lineales, interpolación, derivación e integración Nombre Profeso r Curso Ciclo : Julcarima Calle, Josué Mendoza Román, Max Celestino : Josué Angulo : Calculo Numérico : Universidad Nacional de Ingeniería Facultad de Ingeniería Industrial y de Sistemas. 2012-II
Informe de las clases y algoritmos usados en el curso
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Informe final de métodos numéricos: Métodos para
ecuaciones no lineales, sistemas lineales, interpolación, derivación e
integración numéricas.
: Julcarima Calle, JosuéMendoza Román, Max Celestino: Josué Angulo: Calculo Numérico:
Nombre
ProfesorCursoCiclo
Universidad Nacional de IngenieríaFacultad de Ingeniería Industrial y de Sistemas.
2012-II
Cálculo Numérico
2
CONTENIDO
Códigos por cada método para hallar las raíces de una función R -> R.......................................4
I. Bisección...........................................................................................................................4
I. Newton:............................................................................................................................5
II. Punto Fijo.........................................................................................................................6
III. Regula Falsa (Regla falsa)..............................................................................................7
IV. Secante.........................................................................................................................9
V. Von Misses:......................................................................................................................9
Métodos acelerados mediante Aitken:..................................................................................10
Método del trapecio...............................................................................................................32
Método de simpson simple 1/3..............................................................................................33
Método de simpson compuesto 1/3......................................................................................33
Método de simpson 3/8.........................................................................................................34
Métodos numéricos de solución de ecuaciones diferenciales...................................................35
Método de Euler (1º orden)...................................................................................................35
Método de Heun (2º orden)...................................................................................................35
Método de Taylor (3º orden).................................................................................................35
Método de Runge – Kutta - Fehlberg (4º orden)....................................................................36
Cálculo Numérico
4
CÓDIGOS POR CADA MÉTODO PARA HALLAR LAS RAÍCES DE UNA FUNCIÓN R -> R
I. BISECCIÓN:
En este método se deben tener 2 valores iniciales para ambos lados de la raíz, y sus valores funcionales deben ser de signos opuestos. En este caso se itera de la manera siguiente:
Se halla X3=X1+X22
, luego se evalúa en X3 , y se toma este como un
extremo del nuevo intervalo, siendo el otro extremo el valor funcional de signo opuesto. Donde el número de iteraciones es:
n=ln ( X2−X1 )−ln ε
ln 2 , si X2−X1>0 y ε la tolerancia.
function [res, i]=biseccion(f,a,b,tol)i=0;if( feval(f, a )*feval(f,b) >0 ) disp('No se puede aplicar el') disp(' método'); returnendif( feval(f,a)==0 ) disp('raiz en ini') res=ini; returnendif( feval(f,b)==0 ) disp('raiz en fin') res=fin returnendA=fopen('biseccion.xls','w');fprintf(A,'\t Iteraciones \t a \t b \t f(a) \t f(c) \t c \t Error \n');while(b-a)/2>=tol x=(a+b)/2; d1=feval(f,a); d2=feval(f,x); i=i+1; y=[ i a b d1 d2 x (b-a)/4 ]; if d1*d2 <0 b=x;
Cálculo Numérico
5
elseif d2==0 disp('Se encontró la raiz exacta') res=x; fclose(A); return; else a=x; end fprintf(A,'\t%d\t%6.7f\t%6.7f\t%6.7f\t%6.7f\t%6.7f\t%6.7f\n',y);end;res=(a+b)/2;fclose(A);Ejemplo: Hallar la solución de la ecuación sin x∗e−2 x=0, en el intervalo [2,4] con una tolerancia de 0.0001.Ingresando el comando en Matlab: [a,b]=biseccion('f',2,4,0.0001)Se obtiene:a=3.1415 y b=14, además también se puede observar en la tabla:
Este método se aplica para aproximar raíces reales no repetidas. Se lleva la ecuación: f ( x )=0 a la forma x=g ( x ), de modo que g ' (x i )=¿0.
Fórmula de iteración: x i+1=x i−f (x i )f ' (x i )
function [res, it]=newton(func,dfunc,x,precis)it=0;x0=x;d=feval(func,x0)/feval(dfunc,x0);A=fopen('newton.xls','w');fprintf(A,'\tIteración\tValor\n');while abs(d)>precis
A=fopen('puntoFijo.xls','w');fprintf(A,'\tIteración\tValor\n');fprintf(A,'\t%6.7f\t%6.7f\n',[1 p0]);for k=2:iteracionesMaximas P(k)=feval(g,P(k-1)); errorAbsoluto= abs(P(k)-P(k-1)); er=errorAbsoluto/(abs( P(k) )+eps ); p=P(k); fprintf(A,'\t%6.7f\t%6.7f\n',[k p]); if(errorAbsoluto <tolerancia) | (er<tolerancia) ,break; endendif(k== iteracionesMaximas) disp('Superado el numero maximo de iteraciones');endP=P';Ejemplo: Hallar la solución a la ecuación: ln ( x )+x2=3 con una tolerancia de 0.0001.Haciendo x=g ( x )=√3−ln (x )[a,b,c,d]=puntoFijo('f',3,0.0001,100)a=8, b=1.5921, c=7.9960e-005, y d=3.0000
En este método se deben tener dos valores iniciales de x, de modo que f (x1 )∗f (x2 )<0. Para usar este método se usa la iteración:
x3=x1−(x1−x2)∗f (x1 )f (x1 )−f (x2 )
, luego se actualiza el intervalo de modo que se
cumplaf (x3 )∗f (x i )<0
function [res, it]=reglafalsa(func,ini,fin,precis)
it=0;if( feval(func, ini )*feval(func,fin) >0 ) disp('No se puede aplicar el'); disp(' método porque hay un nùmero par de raices en este intervalo'); return;end
Cálculo Numérico
8
if( feval(func,ini)==0 ) disp('raiz en ini'); res=ini; return;endif( feval(func,fin)==0 ) disp('raiz en fin'); res=fin; return;endmed=fin-ini;ant=0;
while abs(ant-med)>= precis it=it+1; ant=med; med=fin-(fin-ini)*feval( func , fin )/ ( feval(func,fin) - feval(func,ini) ) ; %disp( [ini, fin] ); if feval(func,med)*feval(func,ini ) < 0 fin=med; elseif feval(func,med)==0.0 disp('Se encontró la raiz exacta') disp(med); res=med; return; else ini=med; end fprintf(A,'\t%6.7f\t%6.7f\n',[it med]);end;if( abs(feval(func,ini)) < abs(feval(func,fin))) res=ini;else res=fin;endEjemplo: Hallar la solución del primer ejemplo (ecuación sin x∗e−2 x=0), con una tolerancia de 0.0001. [2,4]Para esto se tomamos como puntos extremos dos valores cercanos a la solución en el intervalo dado. Para nuestra comodidad tomaremos x1=3 y x2=4.[a,b]=reglafalsa('f',3,4,0.0001)a=3.1416 y b=9.
Este método consiste en aproximar la derivada f (x) al cociente (x i−x i−1 )
f (x i )−f (x i−1 ). De modo que se siga la iteración:
x i+1=x i−(x i−x i−1 )∗f (x i)f (x i )−f ( xi−1 )
, por lo que se requerirán dos valores iniciales.
function [a, iter] =secante(fun,x0,x1,tol,maxiter)% Aproxima por el método de la secante una raiz de la ecuacion fun(x)=0%cercana a x0, tomando como criterio de parada abs(fun(x))<tol o la cota sobre%el numero de iteraciones dada por maxiter. %% Variables de entrada:% fun: funcion a calcular la raiz, se introduce en modo simbolico 'fun' % x0, x1: estimaciones iniciales para el proceso de iteración% tol: tolerancia en error absoluto para la raiz% maxiter: maximo numero de iteraciones permitidas%% Variables de salida:% a: valor aproximado de la raizA=fopen('secante.xls','w');fprintf(A, 'Metodo de la secante \n');f0=subs(fun,x0); f1=subs(fun,x1);iter=1;while(abs(f1)>tol) & (iter<maxiter)
a = x1-f1*((x1-x0)/(f1-f0)); % formula de iteracion f0=f1; f1=subs(fun,a); %Actualiza f0 y f1 fprintf(A, 'iter= %i, a= %x0,f= %e \n', iter,a ,f1)
iter = iter + 1; % Cuenta los pasosx0=x1; x1=a; % actualiza x
endfclose(A);% Salida
V. VON MISSES:
Cálculo Numérico
10
En este método al igual que en el de Newton, se aproxima usando la derivada del primer valor de X, siendo la fórmula de iteración:
x i+1=x i−f ( xi )f ' (x0 )
function [res, it]=vonMises(func,dfunc,x,precis)it=0;x0=x;m=feval(dfunc,x0);d=feval(func,x0)/m;A=fopen('vonMisses.xls','w');fprintf(A,'\tIteración\tValor\n');while abs(d)>precis it=it+1; x0=x0-d; fprintf(A,'\t%6.7f\t%6.7f\n',[it x0]); d=(feval(func,x0))/m;end;res=x0;return
Ejemplo: Hallar las soluciones a la ecuación 3∗x3−ex+ln ( x )+2=0, con una tolerancia de 0.00001Las raíces se encuentran en los intervalos [0,2] y [6,8][a,b]=vonMises('f','df',2,0.00001)a=0.4873 y b=90[a,b]=vonMises('f','df',8,0.00001)a=6.8590 y b=35 Para este método se usan x0 iniciales, tal que f ' (x0 ) se acerque a la raíz, de
lo contrario el método no convergerá.
MÉTODOS ACELERADOS MEDIANTE AITKEN:
El método de Aitken consiste en acelerar una iteración, para lo cual se necesitan tres valores en la serie de iteración, y luego se hace:
∆ x i=x i+1−x i y ∆2 x i=x i+1−2∗x i+x i−1 , para construir otra sucesión:
x i=x i−(∆ x i )
2
∆2 x i
STEFFENSEN
Es el método de Aitken aplicado al de punto fijo:
function [x,i]=steffensen(f,x0,tolx,nmax) err=tolx+1; x=x0; phi=0;
Cálculo Numérico
11
i=1;A=fopen('steffensen.xls','w');fprintf(A,'\t Precision:\t %6.7f\n',tolx);fprintf(A,'\tIteración\tValor\n'); while(i<nmax & err>tolx) xx=x; fxk=feval(f,x); tolf=tolx*abs(phi); if abs(fxk)<=tolf break end fxk2=feval(f,x+fxk); phi=(fxk2-fxk)/fxk; x=xx-fxk/phi; err=abs(x-xx); fprintf(A,'\t%6.7f\t%6.7f\n',[i x]); i=i+1; endEjemplo: Hallar la solución a la ecuación: ln ( x )+x2=3 con una tolerancia de 0.0001.
CÓDIGOS POR CADA MÉTODO PARA DOS ECUACIONES NO LINEALES
NEWTON
El método iterativo para sistemas de ecuaciones converge linealmente. Como en el método de una incógnita, puede crearse un método de convergencia cuadrática, es decir, el método de Newton-Raphson multivariabe, a continuación se obtendrá este procedimiento para dos variables; la extensión a tres o más variables es viable generalizando los resultados.
Sean: f 1(x , y ) y f 2(x , y ) , donde:
xk+1=xk+h y yk +1= yk+ j , siendo h y j soluciones de la ecuación:
∂ f 1∂x
∗h+∂ f 1∂ y
∗ j=−f 1 ( xk , yk )
∂ f 2∂x
∗h+∂ f 2∂ y
∗ j=−f 2 (xk , yk )
function [xsol, ysol] = newton2d(varargin)%NEWTON2D 2-dimensional Newton's method% The command% [xsol, ysol] = newton2d(eq1, eq2, xstart, ystart)
Cálculo Numérico
12
% searches for a root of the simultaneous (nonlinear) % equations eq1=0 and eq2=0, starting from the initial % guesses x=xstart, y=ystart. Here eq1 and eq2 should be% entered as strings in the variables 'x' and 'y' or % as symbolic expressions in x and y. Alternatively,% [xsol, ysol] = newton2d(eq1, eq2, xvar, yvar, xstart, ystart)% allows one to specify the names of the independent variables.% The optional argument 'maxiterations' at the end specifies the% maximum number of iterations to try. The default is 20.%% Example: [xsol, ysol] = newton2d('x^2 + y^2 - 4', 'x - y', 1, 1) % gives the output % xsol =%% 1.4142% %% ysol =%% 1.4142
if nargin<4 error('not enough input arguments -- need at least the two equations and starting values for x and y'); end
if nargin>7, error('too many input arguments'); end
eq1=varargin{1}; eq2=varargin{2};if ischar(eq1) & ~ischar(eq2) error('both equations must be of same form: strings or symbolic')endif ~ischar(eq1) & ischar(eq2) error('both equations must be of same form: strings or symbolic')end% Default value of maxiterations is 20.maxiterations=20;% Default values of xvar and yvar are 'x', 'y'.if nargin<6 xvar = 'x'; yvar = 'y'; xstart = varargin{3}; ystart = varargin{4}; endif nargin>5 xvar = varargin{3}; yvar = varargin{4}; xstart = varargin{5}; ystart = varargin{6}; endif nargin==5, maxiterations=varargin{5}; endif nargin==7, maxiterations=varargin{7}; end
Cálculo Numérico
13
% Start by computing partial derivatives.f11 = diff(sym(eq1), xvar);f12 = diff(sym(eq1), yvar);f21 = diff(sym(eq2), xvar);f22 = diff(sym(eq2), yvar);% Vector functions for evaluationF1 = inline(vectorize(eq1),xvar,yvar); F2 = inline(vectorize(eq2),xvar,yvar);A11 = inline(vectorize(f11),xvar,yvar);A12 = inline(vectorize(f21),xvar,yvar);A21 = inline(vectorize(f12),xvar,yvar);A22 = inline(vectorize(f22),xvar,yvar);X = [xstart, ystart];for counter=1:maxiterationsA = [A11(X(1), X(2)), A12(X(1), X(2)); A21(X(1), X(2)), A22(X(1), X(2))]; F = [F1(X(1), X(2)), F2(X(1), X(2))]; if max(abs(F)) < eps, xsol=X(1);% process has converged ysol=X(2); return; end if condest(A) > 10^10, error('matrix of partial derivatives singular or almost singular -- try again with different starting values'); end X = X - F/A;endxsol=X(1); ysol=X(2);
PUNTO FIJO
function x=puntoFijo2d(G,x0,tol,max)% Resuleve el sistema no lineal x=G(x) usando la iteraci¶on del punto fijo% Los vectores x y x0 son vectores fila% la funci¶on G da un vector columna [g1(x)...gn(x)]'% detener cuando la norma del cambio en el vector soluci¶on sea menor a la tolerancia% la siguiente aproximaci¶on de soluci¶on es x new=x old+y';disp([0 x0]);x_old=x0;iter=1;while (iter<=max) y=feval(G,x_old) x_new=y'; dif=norm(x_new-x_old); disp([iter x_new dif]); if dif<=tol x=x_new; disp('La iteraci¶on del punto fijo ha convergido') return; else
Cálculo Numérico
14
x_old=x_new; end iter=iter+1;enddisp('La iteracion del punto fijo no convirgio')x=x_new;%>> puntoFijo2d('ejem4',[1 1],0.01,10)
EXISTENCIA Y UNICIDAD DE LAS SOLUCIONES DE SISTEMAS LINEALES
Sea el sistema AX=b.A continuación se define la matriz aumentada B, formada con los elementos de la matriz coeficiente A y los del vector b de la siguiente manera:
B = [ A l b ]
Si el rango de la matriz coeficiente A y de la matriz aumentada B son iguales, se dice que el sistema es consistente. Si no ocurre esto, el sistema es inconsistente (por tanto, un sistema homogéneo siempre es consistente). Un sistema inconsistente no tiene solución, mientras que uno consistente tiene una solución única o un número infinito de soluciones, según como sea el rango de A en comparación con el número de incógnitas n.Si el rango de A es igual al número de incógnitas, la solución es única; si el rango de A es menor que dicho número, hay un número infinito de soluciones.
MÉTODOS DIRECTOS
Son aquellos que resuelven el sistema de ecuaciones obteniendo soluciones exactas y se basan en el método de eliminación de Gauss.
ELIMINACIÓN DE GAUSS
Para ello se utilizan tres algoritmos básicos:
TRIANGULARIZACIÓN
Se busca un matriz triangular superior o inferior a partir de A mediante operaciones elementales fila aplicadas a la matriz aumentada.
SUSTITUCIÓN REGRESIVA (BACK SUBSTITUTION)Resuelve el sistema UX=b, donde U es una matriz triangular superior.Algoritmo en Matlab:
function x = backsubs(U,x)[n,n] = size(U);x(n) = x(n)/U(n,n);for k = n-1:-1:1 j = k+1:n; x(k) = (x(k) - U(k,j)*x(j))/U(k,k);end
Cálculo Numérico
15
SUSTITUCIÓN HACIA ADELANTE (FORWARD SUBSTITUTION)Resuelve el sistema LX=b, donde L es una matriz triangular inferior.Algoritmo en Matlab:
function x = fordward(L,x)[n,n] = size(L);x(1) = x(1)/L(1,1);for k = 2:n j = 1:k-1; x(k) = (x(k) - L(k,j)*x(j))/L(k,k);end
Se realiza la triangularización (pivoteo) y luego se aplicada sustitución hacia atrás o adelante dependiendo del tipo de matriz obtenida (triangular superior o inferior).Ejemplo:Tenemos el sistema AX=B, donde:
A=[2 4 61 5 31 3 2]
B=[−4135 ]Con operaciones elementales fila se obtiene:
A '=[1 0 00 1 00 0 1]
B'=[−65−2]Aplicando Backsubs o Forwardsubs se obtiene:
X=[−65−2 ]MÉTODOS DE DOOLITLE Y CROUT
Aun cuando las matrices L y U pueden obtenerse en la triangularización de la matriz aumentada [A l b], es deseable encontrar un método más directo para su determinación. Pero para ello se requiere que los menores principales sean positivos.
Cálculo Numérico
16
El método de Doolitle es cuando se escoge como elementos de la diagonal de L el número uno, en el método de Crout se escoge más bien a los elementos de la diagonal de U como unos.
AX=bLUX=b
ALGORITMO DE DOOLITTLE
A continuación se presenta solo la parte de la factorización, es decir, la obtención de L y U, luego se debe usar sustitución hacia adelante para resolver para resolver L(UX)=b, de donde se obtendría el valor de UX, llámese Y. Al final se usa sustitución hacia atrás para resolver Y=UX y así obtener el vector solución X.
function [L,U] =lu_2(A) % Algoritmo de Doolittlen=length(A);for i=1:n-1 A(i+1:n,i)=A(i+1:n,i)/A(i,i); A(i+1:n,i+1:n)=A(i+1:n,i+1:n)-A(i+1:n,i)*A(i,i+1:n);endL=tril(A,-1)+eye(n);U=triu(A);
function [L,U] = lablu( a ) %Algortimo de Doolittlen=length(a);for k=1:n L(k,k)=1; for j=k:n suma=0; for s=1:k-1 suma=suma+L(k,s)*U(s,j); end U(k,j)=a(k,j)-suma; end for i=k:n suma=0; for s=1:k-1 suma=suma+L(i,s)*U(s,k); end L(i,k)=(a(i,k)-suma)/U(k,k); endend
Luego hallamos Y=UX con sustitución hacia adelante:
>> Y=fordward(L,B)
Y =
3
4
11
Luego resolvemos UX=Y
>> X=backsubs(U,Y)
X =
1.6000
4.0000
-2.2000
ALGORITMO DE CROUT
El siguiente código resuelve un sistema de ecuaciones lineales por el método de Crout:function x=Crout(A,b) n=length(b);M=zeros(n,n);U=zeros(n,n);x=zeros(n,1);y=zeros(n,1);for i=1:n M(i,i)=1;endfor j=1:n for i=1:j suma=A(i,j); for k=1:i-1 suma=suma-M(i,k)*U(k,j); end U(i,j)=suma; end for i=j+1:n
Cálculo Numérico
19
suma=A(i,j); for k=1:j-1 suma=suma-M(i,k)*U(k,j); end M(i,j)=suma/U(j,j); endend%Mostrando los valores obtenidos y la soluciónA;M;U;y=fordward(M,b); yx=backsubs(U,y); x
Ejemplo:
Tenemos el sistema AX=B, donde:
A =
1 2 3
0 1 0
2 1 1
B =
3
4
5
Aplicando crout:
>> X=Crout(A,B)
y =
3
4
11
x =
1.6000
Cálculo Numérico
20
4.0000
-2.2000
X =
1.6000
4.0000
-2.2000
MÉTODOS DE CHOLESKY
1. La matriz A que se va a factorizar debe ser simétrica y positiva definida, como A=AT a cada fila de la matriz U se le dividirá por √ui ,i; será suficiente que los valores de ui , i sean mayores que cero, para que todos los elementos de la matriz L sean números reales.
A=( √u1,1 ⋯ 0⋮ ⋱ ⋮
√u1 ,n√u1,1
⋯ √un, n)(√u1,1 ⋯√u1 ,n√u1,1
⋮ ⋱ ⋮0 ⋯ √un ,n
)→A=L LT
function m=menores(A)n=length(A);%Calculo de los menores principalesfor i=1:n disp(A(1:n-i+1,1:n-i+1)); m(i)=det(A(1:n-i+1,1:n-i+1)); disp(m(i));end
Luego hallamos Y=L’X con sustitución hacia adelante:
>> Y=fordward(L,B)
Y =
0.5000
0.7500
0.7500
0.7857
Luego resolvemos UX=Y
>> X=backsubs(L',Y)
X =
0.3563
0.2657
0.2185
0.1122
Cálculo Numérico
23
MÉTODOS ITERATIVOS
Hallan la solución mediante iteraciones convergentes si el radio espectral de T es menor o igual que uno. Tienen un error determinado por la k-ésima iteración menos la k-1 ésima iteración.
MÉTODO DE JACOBI
La fórmula de iteración de Jacobi para el sistema de ecuaciones AX=B es:
X i+1=inv (D )∗(L−U )∗X i+inv (D )∗B
Código modificado para que muestra las iteraciones en un archivo de Excel:
function [xl,it]=jacobilab(A,b,x0,tol)n=length(b);x1=x0;x0=x0+10*tol;it=0;Q=diag(diag(A));M=eye(n) -inv(Q)*A;c=inv(Q)*b;if (norm(M)>=1)
También llamado de desplazamientos sucesivos, el siguiente código obtiene la solución a un sistema lineal (AX=B) dada una tolerancia, mediante la sucesión:X i+1=inv (D−L )∗U∗X i+inv (D−L )∗B, donde: A=D-L-U, tal que D es matriz diagonal de A, L es matriz triangular inferior de (A-D) y U matriz triangular superior de (A-D).
function [xl,it]=gauss(A,b,x0,tol)n=length(b);x1=x0;x0=x0+10*tol;it=0;D=diag(diag(A));L=-tril(A);L=L+DU=-triu(A);U=U+D;M=inv(D-L)*U;c=inv(D-L)*b;if (norm(M)>=1)
Se parte de una función desconocida f(x) dada en forma tabular y se asume que un polinomio de primer grado (ecuación de una línea recta) puede escribirse:
pn ( x )=∑i=0
n
Li (x )∗f (x i) , donde: Li (x )=∏j=0j ≠i
n (x−x j )(x i−x j )
function [C,L]=lagrange (x,y) w=length(x); n=w-1; L=zeros(w,w); for k=1:n+1 v=1; for j=1:n+1 if k~=j v=conv(v,poly(x(j)))/(x(k)-x(j)); end end L(k,:)=v; end C=y*L;
>> pretty(poly2sym(C)) 4 3 2 2 x 2 x 4 x 129 x 19 - ---- + ---- - ---- + ----- + -- 25 5 5 100 10
MÉTODO DE NEWTON
Cuando la distancia h entre dos argumentos consecutivos cualesquiera, es la misma a lo largo de la tabla, el polinomio de Newton en diferencias divididas puede expresarse con más sencillez. Para este propósito se introduce un nuevo parámetro s, definido en x=xo+s∗h, con el cual se expresa el factor productoria:
∏i=0
k−1
(x−x i) , con lo que ‘s’ se puede expresar como:
(x−x i )=h(s−i) , para 0≤ i≤n . Con lo que en forma compacta quedaría de la forma:
function s=trapecioCompuesta(f,a,b,M) %M: número de intervalosh=(b-a)/M;s=0;for k=1:(M-1) x=a+h*k; s=s+feval(f,x);ends=h*(feval(f,a)+feval(f,b))/2+h*s;
Ejemplo:
Definimos la función, para integrarla de 0 a 2:
function y=integrando(x)y=1./(x.^2+1/10);
Cálculo Numérico
33
Aplicando:
>> trapecioCompuesta('integrando',0,2,14)
ans =
4.4710
MÉTODO DE SIMPSON SIMPLE 1/3
function Z=simpsonSimple(f,a,b)h=(b-a)/2;C=zeros(1,3);C=feval(f,[a (a+b)/2 b] );S=h*( C(1)+4*C(2)+C(3) )/3;S2=S;Z=[ a b S S2];
Ejemplo:
Definimos la función, para integrarla de 0 a 2:
function y=integrando(x)y=1./(x.^2+1/10);
Aplicando:
>> simpsonSimple('integrando',0,2)
ans =
0 2.0000 4.6268 4.6268
MÉTODO DE SIMPSON COMPUESTO 1/3
function s=simpsonCompuesta(f,a,b,M) %simpson 1/3, se usan 2M intevalosh=(b-a)/(2*M);s1=0;s2=0;
for k=1:M x=a+h*(2*k-1); s1=s1+feval(f,x);endfor k=1:(M-1) x=a+h*2*k; s2=s2+feval(f,x);
Cálculo Numérico
34
end
s=h*(feval(f,a)+feval(f,b)+4*s1+2*s2 )/3;
Ejemplo:
Definimos la función, para integrarla de 0 a 2:
function y=integrando(x)y=1./(x.^2+1/10);
Aplicando:
>> simpsonCompuesta('integrando', 0 ,2 ,7)
ans =
4.4682
MÉTODO DE SIMPSON 3/8
function s=simpson38(f,a,b,M) % el número de intervalos es 3*Mh=(b-a)/(3*M);s1=0;s2=0;
for k=1:M x=a+h*(3*k-1); s1=s1+feval(f,x); x=a+h*(3*k-2); s1=s1+feval(f,x);endfor k=1:(M-1) x=a+h*3*k; s2=s2+feval(f,x);end
s=3*h*(feval(f,a)+feval(f,b)+2*s2+3*s1 )/8;
Ejemplo:
Definimos la función, para integrarla de 0 a 2:
function y=integrando(x)y=1./(x.^2+1/10);
Cálculo Numérico
35
Aplicando:
>> simpson38('integrando',0,2,5)
ans =
4.4627
Cálculo Numérico
36
MÉTODOS NUMÉRICOS DE SOLUCIÓN DE ECUACIONES DIFERENCIALES
Para problemas de valor inicial de la forma y’=f(x,y)
MÉTODO DE EULER (1º ORDEN)
function E=euler(f,a,b,ya,M)%ya es la condicion inicial y(a)%Y es el vector de ordenadas de los puntos de la solucion%T es el vector de absisas de los puntos de la solucionh=(b-a)/M;
function H=heun(f,a,b,ya,M)%ya es la condicion inicial y(a)%Y es el vector de ordenadas de los puntos de la solucion%T es el vector de absisas de los puntos de la solucionh=(b-a)/M;
function R=rk4(f,a,b,ya,M)%ya es la condicion inicial y(a)%Y es el vector de ordenadas de los puntos de la solucion%T es el vector de absisas de los puntos de la solucionh=(b-a)/M;
T=zeros (1,M+1);Y=zeros(1,M+1);T=a:h:b;Y(1)=ya;
for j=1:M k1=h*feval(f,T(j),Y(j)); k2=h*feval(f,T(j)+h/2,Y(j)+k1/2); k3=h*feval(f,T(j)+h/2,Y(j)+k2/2); k4=h*feval(f,T(j)+h,Y(j)+k3); Y(j+1)=Y(j)+( k1+2*k2+2*k3+k4 )/6;end