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

Steffensen..........................................................................................................................10

Códigos por cada método para dos ecuaciones no lineales.......................................................11

Newton...................................................................................................................................11

Punto Fijo...............................................................................................................................13

Existencia y unicidad de las soluciones de sistemas lineales......................................................14

Métodos directos.......................................................................................................................14

Eliminación de Gauss..............................................................................................................14

Triangularización........................................................................................................14

Sustitución regresiva (Back substitution)....................................................................14

Sustitución hacia adelante (Forward substitution).....................................................14

Métodos de Doolitle y Crout..................................................................................................15

Algoritmo de Doolittle........................................................................................................15

Algoritmo de Crout.............................................................................................................18

Métodos de Cholesky.............................................................................................................20

Métodos iterativos.....................................................................................................................22

Método de Jacobi...................................................................................................................23

Método de Gauss-Seidel........................................................................................................25

Interpolación..............................................................................................................................27

Método de lagrange:..............................................................................................................27

Método de Newton................................................................................................................28

Derivación numérica..................................................................................................................29

Por límites..............................................................................................................................29

Por Richardson.......................................................................................................................31

Integración numérica.................................................................................................................32

Cálculo Numérico

3

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:

Iteraciones a b f(a) f(c) c Error1 2 4 0.0166544 0.0003498 3 0.52 3 4 0.0003498 -0.0003199 3.5 0.253 3 3.5 0.0003498 -0.0001627 3.25 0.1254 3 3.25 0.0003498 0.000032 3.125 0.06255 3.125 3.25 0.000032 -0.0000782 3.1875 0.031256 3.125 3.1875 0.000032 -0.0000266 3.15625 0.0156257 3.125 3.15625 0.000032 0.0000018 3.140625 0.00781258 3.140625 3.15625 0.0000018 -0.0000126 3.1484375 0.00390639 3.140625 3.1484375 0.0000018 -0.0000055 3.1445313 0.0019531

10 3.140625 3.1445313 0.0000018 -0.0000018 3.1425781 0.000976611 3.140625 3.1425781 0.0000018 0 3.1416016 0.000488312 3.140625 3.1416016 0.0000018 0.0000009 3.1411133 0.000244113 3.1411133 3.1416016 0.0000009 0.0000004 3.1413574 0.0001221

14 3.1413574 3.1416016 0.0000004 0.0000002 3.1414795 0.000061

I. NEWTON:

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

Cálculo Numérico

6

it=it+1; x0=x0-d; fprintf(A,'\t%6.7f\t%6.7f\n',[it x0]); d= feval(func,x0)/feval(dfunc,x0);end;res=x0;

Ejemplo: Aplicando el método de Newton, resolver el ejemplo anterior:

De su gráfica:

Para la primera solución x0=3, y para la segunda x0=5

[a,b]=newton('f','df',3,0.0001)

a=3.1416 y b=3

[a,b]=newton('f','df',5,0.0001)

a=6.2832 y b=7

II. PUNTO FIJO

Para usar este método se lleva la ecuación: f ( x )=0 a la forma x=g ( x ).Fórmula de iteración: x i+1=g (x i )

function[k,p,errorAbsoluto, P]= puntoFijo(g,p0,tolerancia,iteracionesMaximas)P(1)=p0;

Iteración Valor1 3.11092312 3.13982873 3.1415865

Iteración Valor1 5.43557562 5.782473 6.04374534 6.20777955 6.27341176 6.28299827 6.2831852

Cálculo Numérico

7

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

Iteración Valor1 32 1.37890823 1.63667594 1.58345595 1.59386026 1.59180447 1.59220978 1.5921298

III. REGULA FALSA (REGLA FALSA)

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;

A=fopen('reglafalsa.xls','w');fprintf(A,'\tIteración\tValor\n');

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.

Iteración Valor1 3.57944812 3.2982363

Cálculo Numérico

9

3 3.18537374 3.15268855 3.14432696 3.14226167 3.1417568 3.14163259 3.1416024

IV. SECANTE

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

Cálculo Numérico

17

function [L,U,P]=palu_2(A)n=length(A);P=eye(n);for i=1:n-1 [aux,pos]= max( A(i:n,i:n) ); j=pos(1)+i-1; c=A(i,:);A(i,:)=A(j,:);A(j,:)=c; c=P(i,:);P(i,:)=P(j,:);P(j,:)=c; 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);

Ejemplo:

Tenemos el sistema AX=B, donde:

A =

1 2 3

0 1 0

2 1 1

B =

3

4

5

Al aplicar factorización LU sobre A obtenemos:

>> [L U]=lu_2(A)

L =

1 0 0

0 1 0

2 -3 1

U =

1 2 3

Cálculo Numérico

18

0 1 0

0 0 -5

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

El código de la factorización Cholesky es:

function [L,LT]=cholesky(A)n=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); A( i,i:n ) = A(i,i:n)/A(i,i)^0.5;endA(n,n)=A(n,n)^0.5;LT=triu(A);L=LT';

Ejemplo:

Cálculo Numérico

21

Tenemos el sistema AX=B, donde:

A =

4 -4 6 -6

-4 20 -22 26

6 -22 61 -59

-6 26 -59 108

B =

1

2

3

4

Verificamos que sea positiva definida:

>> menores(A)

4 -4 6 -6

-4 20 -22 26

6 -22 61 -59

-6 26 -59 108

112896 >0

4 -4 6

-4 20 -22

6 -22 61

2304>0

Cálculo Numérico

22

4 -4

-4 20

64>0

4>0

Hallamos L:

>> [L LT]=cholesky(A

L =

2 0 0 0

-2 4 0 0

3 -4 6 0

-3 5 -5 7

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)

disp('La matriz T no converge');return

endA=fopen('jacobi.xls','w');fprintf(A,'\t x0:');for i=1:n fprintf(A,'\t %6.7f',x0(i));endfprintf(A,'\ntol:\n');for i=1:n fprintf(A,'\t %6.7f',tol(i));endwhile(norm(x1-x0,inf)>tol)

x0=x1;x1=M*x0+c;it=it+1;

fprintf(A,'\n%6.7f ',it); for i=1:n fprintf(A,'\t %6.7f',x1(i)); endend

Cálculo Numérico

24

Ejemplo:

Tenemos el sistema AX=B, donde:

A =

5 1 2 0

1 5 1 1

2 1 5 -1

0 1 -1 5

B =

8

8

7

5

>> [xl it]=jacobilab(A,B,[0 0 0 0]',[0.0001 0.0001 0.0001 0.0001]' )

xl =

1.0000

1.0000

1.0000

1.0000

it =

18

Iteraciones y solución:

x0: 0.001 0.001 0.001 0.001tol:

0.0001 0.0001 0.0001 0.00011 1.6 1.6 1.4 12 0.72 0.8 0.64 0.963 1.184 1.136 1.144 0.9684 0.9152 0.9408 0.8928 1.0016

Cálculo Numérico

25

5 1.05472 1.03808 1.04608 0.99046 0.973952 0.98176 0.968576 1.00167 1.0162176 1.0111744 1.0143872 0.99736328 0.9920102 0.9944064 0.9907507 1.00064269 1.0048184 1.0033193 1.0044431 0.9992689

10 0.9975589 0.9982939 0.9972625 1.000224811 1.0014362 1.0009908 1.0013626 0.999793712 0.9992568 0.9994815 0.9991861 1.000074413 1.0004293 1.0002965 1.0004159 0.999940914 0.9997743 0.9998428 0.9997572 1.000023915 1.0001286 1.0000889 1.0001265 0.999982916 0.9999316 0.9999524 0.9999274 1.000007517 1.0000386 1.0000267 1.0000384 0.99999518 0.9999793 0.9999856 0.9999782 1.0000023

MÉTODO DE GAUSS-SEIDEL

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)

disp('La matriz T no converge');return

endA=fopen('gauss.xls','w');while(norm(x1-x0,inf)>tol)

x0=x1;x1=M*x0+c;it=it+1;

fprintf(A,'\n%6.7f ',it); for i=1:n fprintf(A,'\t %6.7f',x1(i));

Cálculo Numérico

26

endend

Ejemplo:

Tenemos el sistema AX=B, donde:

A =

5 1 2 0

1 5 1 1

2 1 5 -1

0 1 -1 5

B =

8

8

7

5

>> [xl it]=gauss(A,B,[0 0 0 0]',[0.0001 0.0001 0.0001 0.0001]' )

L =

0 0 0 0

-1 0 0 0

-2 -1 0 0

0 -1 1 0

xl =

1.0000

1.0000

1.0000

1.0000

Cálculo Numérico

27

it =

8

Iteraciones y solución:

1 1.6 1.28 0.504 0.84482 1.1424 1.10176 0.891648 0.95797763 1.0229888 1.0254771 0.9773046 0.99036554 1.0039827 1.0056694 0.9953461 0.99793535 1.0007277 1.0011982 0.9990564 0.99957166 1.0001378 1.0002468 0.9998098 0.99991267 1.0000267 1.0000502 0.9999618 0.99998238 1.0000052 1.0000101 0.9999923 0.9999964

INTERPOLACIÓN

MÉTODO DE LAGRANGE:

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;

Ejemplo:

Vamos a interpolar los datos siguientes:

>> X=[0 0.5 1 1.5 2]>> Y=[1.9 2.39 2.71 2.98 3.2]

Cálculo Numérico

28

Aplicando:

>> [C L]=lagrange(X,Y)

C =

-0.0800 0.4000 -0.8000 1.2900 1.9000

L =

0.6667 -3.3333 5.8333 -4.1667 1.0000 -2.6667 12.0000 -17.3333 8.0000 0 4.0000 -16.0000 19.0000 -6.0000 0 -2.6667 9.3333 -9.3333 2.6667 0 0.6667 -2.0000 1.8333 -0.5000 0

Se tiene el polinomio:

>> 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:

pn ( x )=∑k=0

n

ak hk∏i=0

k−1

(s−i) . O también con diferencias divididas:

pn ( x )=f (x0 )+s∆ f (x0 )+s (s−1)∆2 f (x0 )

2 !+…+

s (s−1 )…(s−(n−1))∆n f (x0 )n !

Y s=x−x0h

function[C,D]=pnewton(x,y)n=length(x);D=zeros(n,n);

Cálculo Numérico

29

D(:,1)=y';for j=2:n for k=j:n D(k,j)=(D(k,j-1)-D(k-1,j-1))/(x(k)-x(k-j+1)); endend

C=D(n,n);for k=(n-1):-1:1 C=conv(C,poly(x(k))); m=length(C); C(m)=C(m)+D(k,k);End

Ejemplo:

Vamos a interpolar los datos siguientes:

>> X=[0 0.5 1 1.5 2]>> Y=[1.9 2.39 2.71 2.98 3.2]

Aplicando:>> [C D]=pnewton(X,Y)

C =

-0.0800 0.4000 -0.8000 1.2900 1.9000

D = (tabla de diferencias divididas)

1.9000 0 0 0 0 2.3900 0.9800 0 0 0 2.7100 0.6400 -0.3400 0 0 2.9800 0.5400 -0.1000 0.1600 0 3.2000 0.4400 -0.1000 0 -0.0800

>> pretty(poly2sym(C)) 4 3 2 2 x 2 x 4 x 129 x 19 - ---- + ---- - ---- + ----- + -- 25 5 5 100 10

Cálculo Numérico

30

DERIVACIÓN NUMÉRICA

POR LÍMITES

function[L,n]=derivadalim(f,x,tolerancia,iteracionesMaximas)h=1;H(1)=h;D(1)=(feval(f,x+h)-feval(f,x-h))/(2*h);E(1)=0;R(1)=0;

for n=1:2 h=h/10; H(n+1)=h; D(n+1)=(feval(f,x+h)-feval(f,x-h))/(2*h); E(n+1)=abs(D(n+1)-D(n)); R(n+1)=2*E(n+1)*(abs(D(n+1))+abs(D(n))+eps);endn=2;

while( (E(n)>E(n+1)) & (R(n)>tolerancia) & (n<iteracionesMaximas)) h=h/10; H(n+2)=h; D(n+2)=(feval(f,x+h)-feval(f,x-h))/(2*h); E(n+2)=abs(D(n+2)-D(n+1)); R(n+2)=2*E(n+2)*(abs(D(n+2))+abs(D(n+1))+eps); n=n+1;end

n=length(D)-1;L=[ H' D' E' ];

Ejemplo:

Definimos la función:

function f=funcion(x)f=sin(cos(1./x));

Aplicando:

>> [L n]=derivadalim('funcion',(1-sqrt(5))/2 , 0.01, 100)

L =

1.0000 -0.7448 0

0.1000 -2.6045 1.8598

Cálculo Numérico

31

0.0100 -2.6122 0.0077

0.0010 -2.6122 0.0000

0.0001 -2.6122 0.0000

n =

4

Se obtiene que la derivada es -2.6122.

POR RICHARDSON

function [D,errorabsoluto,errorrelativo,n]=richardson(f,x,delta,tol)

%delta es la tolerancia del error y tol es la tolerancia del error relativo

errorabsoluto=1;errorrelativo=1;h=1;j=1;D(1,1)=(feval(f,x+h)-feval(f,x-h))/(2*h);

while errorrelativo > tol & errorabsoluto >delta & j<12 h=h/2; D(j+1,1)=(feval(f,x+h)-feval(f,x-h))/(2*h); for k=1:j D(j+1,k+1)= D(j+1,k)+ (D(j+1,k)-D(j,k))/((4^k)-1); end errorabsoluto=abs(D(j+1,j+1)-D(j,j)); errorrelativo=2*errorabsoluto/(abs( D(j+1,j+1) ) + abs(D(j,j))+eps); j=j+1;end

[n,n]=size(D);

Ejemplo:

Definimos la función:

function f=funcion(x)f=sin(cos(1./x));

Aplicando:

Cálculo Numérico

32

>> [D errorRelativo errorAbsoluto]=richardson('funcion',(1-sqrt(5))/2 , 0.01, 0.01)

D =

-0.7448 0 0 0 0 0

-1.1335 -1.2631 0 0 0 0

-2.3716 -2.7843 -2.8857 0 0 0

-2.5947 -2.6691 -2.6614 -2.6578 0 0

-2.6107 -2.6160 -2.6125 -2.6117 -2.6115 0

-2.6120 -2.6124 -2.6122 -2.6122 -2.6122 -2.6122

errorRelativo =

6.9003e-004

errorAbsoluto =

2.6419e-004

Se obtiene que la derivada es -2.6122

INTEGRACIÓN NUMÉRICA

MÉTODO DEL TRAPECIO

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;

T=zeros (1,M+1);Y=zeros(1,M+1);T=a:h:b;Y(1)=ya;for j=1:M Y(j+1)=Y(j)+h*feval(f,T(j),Y(j));end

E=[T' Y'];

MÉTODO DE HEUN (2º ORDEN)

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;

T=zeros (1,M+1);Y=zeros(1,M+1);T=a:h:b;Y(1)=ya;for j=1:M k1=feval(f,T(j),Y(j)); k2=feval(f,T(j+1),Y(j)+h*k1) Y(j+1)=Y(j)+(h/2)*(k1+k2);end

H=[T' Y'];

MÉTODO DE TAYLOR (3º ORDEN)

function T4=taylor(df,a,b,ya,M)%ya es la condicion inicial y(a)%Y es el vector de ordenadas de los puntos de la solucion

Cálculo Numérico

37

%T es el vector de absisas de los puntos de la solucion% df=[ Y' Y'' Y''' Y'''' ]h=(b-a)/M;

T=zeros (1,M+1);Y=zeros(1,M+1);T=a:h:b;Y(1)=ya;for j=1:M D=feval(df,T(j),Y(j)); Y(j+1)=Y(j)+h*( D(1)+h*(D(2)/2+h*( D(3)/6 + h*D(4)/24)) );end

T4=[T' Y'];

MÉTODO DE RUNGE – KUTTA - FEHLBERG (4º ORDEN)

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

R=[T' Y'];