Trabajo de calculo numerico

Universidad Nacional "JORGE BASADRE GROHMANN" 2012

INTRODUCCIÓN
Tanto la ciencia y la tecnología nos describen los fenómenos reales mediante modelos
matemáticos. El estudio de estos modelos permite un conocimiento más profundo del
fenómeno, así como de su evolución futura.

Desafortunadamente, no siempre es posible aplicar métodos analíticos clásicos por
diferentes razones:La solución formal es tan complicada que hace imposible cualquier
interpretación posterior; simplemente no existen métodos analíticos capaces de
proporcionar soluciones al problema; no se adecuan al modelo concreto; o su
aplicación resulta excesivamente compleja.

Para este tipos de casos son útiles las técnicas numéricas, que mediante una labor de
cálculo más o menos intensa, conducen a soluciones aproximadas que son siempre
numéricos.

La importante del cálculo radica en que implica la mayoría de estos métodos hacen
que su uso esté íntimamente ligado al empleo de computadores, que mediante la
programación nos permite la solución de problemas matemáticos.

Para la realización de este trabajo se utilizó el programa MATLAB.

1

| Cálculo numérico


CAPITULO I:

CÁLCULO DE RAÍCES DE ECUACIONES
1. MÉTODO DE LA BISECCIÓN:
1.1. TEORÍA:

En matemáticas, el método de bisección es un algoritmo de búsqueda de
raíces que trabaja dividiendo el intervalo a la mitad y seleccionando el
subintervalo que tiene la raíz.

PROCEDIMIENTO:

Elija valores Iniciales para “a” y “b” de forma tal que lea función
cambie de signo sobre el intervalo. Esto se puede verificar
asegurándose de que :

La primera aproximación a la raíz se determina con la fórmula:

Realizar las siguientes evaluaciones para determinar en que
subintervalo se encuentra la raíz:

< 0 Entonces

Entonces

Entonces Es la Raíz

Calcule la nueva aproximación:

Evaluar la aproximación relativa: 2



No. (Falso) Repetir el paso 3, 4 y 5

Sí. (Verdadero) Entonces Es la Raíz

1.2. DIAGRAMA DE FLUJO:

Inicio
f(x), a,
b, E

v F(a)*f(b)<0 F

| b-a|>E

Xap=(a+b)/2

No
V f(a)*f(Xap)=0 F existe
la raíz

a=b
V f(a)*f(Xap)<0 F

a = Xap
b = Xap

Xap
3

FIN



1.3. CÓDIGO DE PROGRAMA:
 CÓDIGO EN EL BOTON CALCULAR:

f=get(handles.edit1,'string');
f=inline(f);
a=str2double(get(handles.edit2,'string'));
b=str2double(get(handles.edit3,'string'));
E=str2double(get(handles.edit4,'string'));

if f(a)*f(b)< 0
while abs(b-a)>E
x=(a+b)/2;
if f(a)*f(x)==0
a=b;
else
if f(a)*f(x)<0
b=x;
else
a=x;
end
end
set(handles.edit5,'string',x);

end
else
set(handles.edit5,'string','No existe la raiz en el intervalo');
end

 CÓDIGO EN EL BOTÓN GRAFICAR:

functionvarargout = pushbutton2_Callback(h, eventdata, handles, varargin)

f=inline(f);
ezplot(f), grid on

 CÓDIGO EN EL BOTÓN SALIR:
4
function pushbutton6_Callback(hObject, eventdata, handles)
close



1.4. VENTANA DE DISEÑO Y APLICACIÓN:

2. MÉTODO DEL PUNTO FIJO:

2.1. TEORÍA:

Dada la ecuación , el método de las aproximaciones sucesivas
reemplaza esta ecuación por una equivalente, , definida en la
forma Para encontrar la solución, partimos de un valor
inicial y calculamos una nueva aproximación
Reemplazamos el nuevo valor obtenido y repetimos el proceso. Esto da
lugar a una sucesión de valores, que si converge, tendrá como
límite la solución del problema.

5

En la figura se representa la interpretación geométrica del método.
Partimos de un punto inicial x0 y calculamos . La intersección de



esta solución con la recta nos dará un nuevo valor más próximo a
la solución final.

Sin embargo, el método puede divergir fácilmente. Es fácil comprobar que
el método sólo podrá converger si la derivada es menor en valor
absoluto que la unidad (que es la pendiente de la recta definida por
Un ejemplo de este caso se muestra en la figura. Esta condición, que a
prioripuede considerarse una severa restricción del método, puede
obviarse fácilmente. Para ello basta elegir la función del siguiente
modo:

De forma que tomando un valor de adecuado, siempre podemos hacer
que cumpla la condición de la derivada.

CONVERGENCIA:

El método de aproximaciones sucesivas converge si

C
o

Convergencia Monótona Divergencia Monótona


6
Inicio

f(x), g(x),
X0, E | Cálculo numérico

X1=g(X0)


 CÓDIGO EN EL BOTÓN CALCULAR:

functionvarargout = pushbutton2_Callback(h, eventdata, handles,
varargin)
g=inline(f)
n=str2double(get(handles.edit17,'string'));
x1=g(a)
k=1;
cadena1=sprintf('a = %8.6f valor inicialn',a);
whileabs(x1-a)>E&k<n
a=x1
x1=g(a)
k=k+1 7
cadena2=sprintf('x%d = %8.6fn',k-1,x1);
cadena1=[cadena1,cadena2];



end


varargin)
funcionf=get(handles.edit1,'string');
f=inline(funcionf);
figure(1);
ezplot(f),grid on


close


8



3. MÉTODO DE NEWTON RAPHSON:

3.1. TEORÍA:

Este método parte de una aproximación inicial y obtiene una
aproximación mejor, , dada por la fórmula:

Este método está definido por el denominador hace que
geométricamente se base en una aproximación a una recta tangente a la
curva trazada en el punto correspondiente a la aproximación
presente, esto puede observarse en la figura:

9



3.2. DIAGRAMA DE FLUJO CON LA DERIVADA:
Inicio

f(x), f’(x),
X0, E

X1 = X0 - f(X0)/f’(X0)

|X1-X0| >E

X0 = X1

X1 = X0 - f(X0) / f’(X0)

X1 10

FIN





varargin)

g=get(handles.edit2,'string');
f=inline(f);
g=inline(g);
x=str2double(get(handles.edit3,'string'));

x1=x-f(x)/g(x);

while abs (x1-x)>E
x=x1;
x1=x-f(x)/g(x);
end
set(handles.edit5,'string',x1);


varargin)

f=inline(f);
ezplot(f), grid on


close

11



3.5. SIN INGRESAR LA DERIVADA: f ’(x) DIAGRAMA DE FLUJO:
Inicio

f(x), X0, E

h = 0,00001;
df = [f(X0+h) - f(X0)] / h

X1 = X0 - f(X0)/df

|X1-X0| >E

X0 = X1

h = 0,00001

X1 = X0 - f(X0)/df

12
X1

FIN





varargin)

f=inline(f);
D=(f(x+0.0001)-f(x))/0.0001;
x1=x-(f(x))/D;
while abs (x1-x)>E
x=x1;
D=(f(x+0.0001)-f(x))/0.0001;
x1=x-(f(x))/D;
end


varargin)

f=inline(f);
ezplot(f), grid on

4. MÉTODO DE LA SECANTE:
4.1. TEORÍA:

El principal inconveniente del método de Newton estriba en que requiere
conocer el valor de la primera derivada de la función en el punto. Sin
embargo, la forma funcional de dificulta en ocasiones el cálculo de la
derivada. En estos casos es más útil emplear el método de la secante.

El método de la secante parte de dos puntos (y no sólo uno como el método
de Newton) y estima la tangente (es decir, la pendiente de la recta) por una 13
aproximación de acuerdo con la expresión:



En general, el método de la secante presenta las mismas ventajas y
limitaciones que el método de Newton-Raphson explicado anteriormente.

Inicio

f(x), X1, X0,
E

|X1-X0| >E

X2 = X1 – [f(X1)*(X1-X0)] / [f(X1)-f(X0)]

X0 = X1
X1 = X2

X2

FIN



varargin)

f=inline(get(handles.edit1,'string'));
x0=str2double(get(handles.edit2,'string'));
14

while abs(x1-x0)>E
x2=x1-(((x1-x0)*f(x1))/(f(x1)-f(x0)));



x0=x1;
x1=x2;
end
set(handles.edit5,'string',x2)


varargin)

f=inline(f);
ezplot(f), grid on


close(secante)

4.4. VENTANA DE DISEÑO y APLICACION:

15



5. MÉTODO DE LIN:
5.1. TEORÍA:

Dada la ecuación donde P tiene la forma:

Sea el factor cuadrático:

Con lo cual la ecuación anterior resulta:

Donde es el residuo

Polinomio reducido

Multiplicando

Igualando coeficientes de la misma potencia

…. …….

En general:

Los residuos están dados por:

Para que sea un factor cuadrático R y S tienen que ser cero. 16



Se define:

Entonces

Si

IN IC IO V

LE E R
a (i); i= 1 ,2 ,3 ...n P >E & Q >E

p, q, E , n

p= p+ P ;
q=q+ Q ;
k= n :1 :-1

b(n+1)= 0
k= n :1 :-1
b(n+2)= 0
b(k )= a(k )-p*b(k +1)-q*b(k + 2)
b(k )= a(k )-p*b(k + 1)-q*b(k + 2);
b(n+ 1)= 0;
b(n+ 2)= 0;

i= n :1 :-1

c (n+1)= 0;
i= n :1 : -1
c (n+ 2)=0;
c (i)= b(i)-p*c (i+ 1)-q*b(i+ 2)
c (i)= b(i)-p*c (i+ 1)-q*b(i+2);
c (n+ 1)= 0;
c (n+ 2)= 0;

P = (b(1)*c (4)-b(2)*c (3))/(c (2)*c (4)-(c (3))^ 2);
Q = (b(2)*c (2)-b(1)*c (3))/(c (2)*c (4)-(c (3))^ 2);

P = (b(1)*c (4)-b(2)*c (3))/(c (2)*c (4)-(c (3))^ 2);
V Q = (b(2)*c (2)-b(1)*c (3))/(c (2)*c (4)-(c (3))^ 2

p= p+ P ;
q=q+ Q ;
x1= (-p+ s qrt(p^ 2-4*q))/2;
x2= (-p-s qrt(p^ 2-4*q))/2;

E S C R IB IR 17
X1, X2

F IN




% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

a=str2num(get(handles.edit1,'string'));
p=str2double(get(handles.edit2,'string'));
q=str2double(get(handles.edit3,'string'));
n=length(a);
for k=n:-1:1
b(n+1)=0;
b(n+2)=0;
b(k)=a(k)-p*b(k+1)-q*b(k+2);
end
for i=n:-1:1
c(n+1)=0;
c(n+2)=0;
c(i)=b(i)-p*c(i+1)-q*b(i+2);
end
P=(b(1)*c(4)-b(2)*c(3))/(c(2)*c(4)-(c(3))^2);
Q=(b(2)*c(2)-b(1)*c(3))/(c(2)*c(4)-(c(3))^2);
while P>E & Q>E
p=p+P;
q=q+Q;
for k=n:-1:1
b(k)=a(k)-p*b(k+1)-q*b(k+2);
b(n+1)=0;
b(n+2)=0;
end
for i=n:-1:1
c(i)=b(i)-p*c(i+1)-q*b(i+2);
c(n+1)=0;
c(n+2)=0;
end
P=(b(1)*c(4)-b(2)*c(3))/(c(2)*c(4)-(c(3))^2);
Q=(b(2)*c(2)-b(1)*c(3))/(c(2)*c(4)-(c(3))^2);
end
p=p+P; 18
q=q+Q;
x1=(-p+sqrt(p^2-4*q))/2;
x2=(-p-sqrt(p^2-4*q))/2;




close


CAPITULO II

SISTEMA DE ECUACIÓN LINEAL

6. MÉTODO DE GAUSS - JORDAN

6.1. TEORÍA:
19
Sea un sistema de ecuaciones lineales de la forma:



Se trata de un sistema de n ecuaciones con n incógnitas, x1, x2, ..., xn. Los
elementos aij y bi son números reales fijados.

El sistema de ecuaciones se puede escribir, empleando una muy útil
representación matricial, como:

Es decir

Donde A es la matriz de coeficientes, X es el vector incógnitas y B es el vector
términos independientes.

PROCEDIMIENTO:

Crear la matriz cuyos elementos son los de la matriz A y el vector B. A es la
matriz se le denomina la matriz aumentada.

Matriz aumentada

Mediante transformaciones elementales de filas en la matriz aumentada, los
elementos de la matriz de coeficientes A debe transformarse en la matriz
identidad y los elementos que están en la posición del vector de términos
independientes B, será la solución del sistema.

Matriz transformada 20



Y las raíces del sistema de ecuaciones son:

El proceso, requiere de multiplicaciones y sumas.

Inicio

Leer
n, aij

i = 0, n, 1

divisor = aii

j = 0, n+1, 1

aij = aij*divisor

k = 0, n, 1

i~=k

pivote = a(k, i)

j = 0, n, 1

akj = akj – pivote*aij

21
escribir
ai, n+1

FIN





varargin)

A=str2num(get(handles.edit1,'string'));

[m,n]=size(A);
for i=1:m
divisor=A(i,i);
for j=i:n
A(i,j)=A(i,j)/divisor;
end
for k=1:m
if i~=k
pivote = A(k,i);
for j=i:n
A(k,j)=A(k,j)- pivote*A(i,j);
end
end
end
end

for i=1:m
x(i)=A(i,n);
end
x=x'; t=1:m; t=t';
cadena='';
for t=1:m
cad=sprintf('x%d=%6.2f',t,x(t));
cadena=[cadena;cad];
end
set(handles.edit2,'string',cadena);


functionvarargout = pushbutton3_Callback(h, eventdata, handles, 22
varargin)
close




7. MÉTODO DE GAUSS SEIDEL
7.1. TEORÍA:

Método iterativo que su utiliza para resolver sistema de ecuaciones de la
forma:

Que matricialmente se puede escribir como A X=B, supongamos que
Despejamos los X

23
……



El proceso se inicia dando un valor inicial para los puntos
se podría usar, por ejemplo la solución trivial si
este fuera el caso se tendría que:

…..

Los son los nuevos valores iníciales que serán utilizados en una
segunda iteración.

La convergencia puede definirse mediante

Dónde:

: Error relativo porcentual dela raíz
: Iteración actual
: Iteración anterior
: Tolerancia prefijada

RE ARREGLO DE ECUACIONES

El proceso de gauss - Seidel converge si la matriz coeficientes cada
elemento de la diagonal es el mayor en valor absoluto que la suma de todos
los demás elementos de la misma fila o columna .Es decir se asegura la
convergencia sí.


24



Inicio

Leer
N, m, aij, bi, vi

k = 1, m, 1

i = 1, n, 1

Xi = Vi

i = 1, n, 1

S=0

j = 1, n, 1

j~=1

S = S + aij * Xj

vi = (bi-S) / aii

Xi = vi

i = 1, n, 1

escribir
vi

25

FIN





varargin)

maxite=str2double(get(handles.edit1,'string'));
v=str2num(get(handles.edit2,'string'));
b=str2num(get(handles.edit4,'string'));
[n,n]=size(a);

cad1='';
for k=1:maxite
for i=1:n
x(i)=v(i);
end
for i=1:n
s=0;
for j=1:n
if j~=i
s=s+a(i,j)*x(j);
end
end
v(i)=(b(i)-s)/a(i,i);
x(i)=v(i);
end
for t=1:n
cad2=sprintf('x%d=%10.8f ',t,x(t));
cad1=[cad1,cad2];
end
cad2=sprintf('n',t);
cad1=[cad1,cad2];
end

set(handles.edit5,'string',cad1);

26
function varargout = pushbutton3_Callback(h, eventdata, handles,
varargin)



close(gauusseidel)


INTERPOLACIÓN

8. INTERPOLACIÓN LINEAL:

8.1. TEORÍA:

Nos centraremos ahora en el problema de obtener, a partir de una tabla de
parejas definida en un cierto intervalo el valor de la función
para cualquier xperteneciente a dicho intervalo.
27
Supongamos que disponemos de las siguientes parejas de datos:



x x0 x1 x2 … xn
y y0 y1 y2 …

El objetivo es encontrar una función continua lo más sencilla posible tal que:

Se dice entonces que la función definida por la ecuación es una función
de interpolación de los datos representados en la tabla.

Existen muchas formas de definir las funciones de interpolación, lo que da
origen a un gran número de métodos (polinomios de interpolación de
Newton, interpolación de Lagrange, interpolación de Hermite, etc). Sin
embargo, nos centraremos exclusivamente en dos funciones de
interpolación:

Los polinomios de interpolación de Lagrange.
Las funciones de interpolación splines. Estas funciones son
especialmente importantes debido a su idoneidad en los cálculos
realizados con ordenador.

8.2. DIAGRAMA DE FLUJO: Inicio

Leer
X, ai, bi, n

i = 1, n-1, 1

ai <= X <= a(i+1)

y = b(i)+(((X+a(i))*(b(i))) / (a(i+1)-a(i)))

i=n

Escribir 28
y

FIN





functionvarargout = togglebutton3_Callback(h, eventdata, handles,
varargin)

n=length(a);
for i=1:n-1
if x>=a(i) & x<=a(i+1)
y = b(i)+(((x-a(i))*(b(i+1)-b(i)))/(a(i+1)-a(i)));
i=n;
end
end
set(handles.edit4,'string',y);


varargin)

close(interpolacionlineal)


29



INTERPOLACIÓN POLINÓMICA

9. POLINOMIO DE LAGRANGE:
9.1. TEORÍA:

Si son puntos distintos y es una funcion cuyos
valores estan dados en esos puntos entonces existe un único polinomio P
de grado a lo mas de grado n con la propiedad que para cada
k=0, 1,2,…n.

Este polinomio está dado por:

Dónde:

Para un polinomio lineal la aproximación es:

Dónde:

Entonces:

Para un polinomio de segundo grado está dado por:

30

Dónde:



Entonces el polinomio para segundo grado es:

Donde x es el valor a interpolar.

INICIO

Leer
y(i), x(i) a, x

S=0

K = 1, n, 1

N=1
D=1

i = 1, n, 1

i~=k

N = N(x-x(i))
D = D(x(k)-x(i))

L = N/D

S=
S+L(x)*Y(k)

31
Escribir
Y0

FIN





n=length(X);
s=0;
for k=1:1:n
NUM=1;
DEN=1;
for i=1:1:n
if i~=k
NUM=NUM*(x-X(i));
DEN=DEN*(X(k)-X(i));
end
L(k)=NUM/DEN;
end reserved - to be definedinafutureversionofMATLAB

s=s+(L(k)*f(X(k)));
end
set(handles.edit4,'string',s);


ezplot(f),gridon


varargin)
close(polinomiolagrange)

32




AJUSTES POLINOMIALES

10. REGRESIÓN POLINOMIAL :
10.1. TEORÍA:

Supongamos que se conocen los datos o o 1 1 n n con
0 1 números reales distintos, y se desea encontrar un polinomio:

33

Tal que:



n 2 n 2
2 m
S(a 0 , a 1 ,....., a m ) pm xk yk a0 a 1x k a 2x k
,....., a m x k
yk
k 0 k 0

Sea mínima.

El grado m del polinomio m se puede escoger previamente con base en
algún resultado teórico, alguna expectativa o por la aplicación que se le
pretenda dar al polinomio. En cualquier caso estamos “libres” de elegir el
grado que parezca mejor. En muchos casos el grado será uno y el polinomio
obtenido se llamará la recta que mejor se ajusta o la recta de mínimos
cuadrados para la tabla de datos.

Volviendo a la función 0 1 m una condición necesaria para la
existencia de un mínimo relativo de esta función es que las derivadas
parciales de 0 1 m con respecto a j, sean cero.

Resultan entonces las siguientes m+1 ecuaciones lineales en las incógnitas
0 1 m:

n
S 2 m
2 a0 a 1x k a 2x k ..... amxk yk 0
a0 k 0

n
S 2 m
2 a0 a 1x k a 2x k ..... amxk yk xk 0
a1 k 0

n
S 2 m 2
a2 k 0

..........
n
S 2 m j
a j k 0

.......... ..
n
S 2 m m
am k 0

Si en las ecuaciones anteriores cancelamos el 2, desarrollamos los paréntesis
y usamos que
n
34
a0 n 1 a0
k 0



Obtenemos:

n n n n
2 m
n 1 a0 x k a1 xk a2 ..... xk am yk
k 0 k 0 k 0 k 0
n n n n n
2 3 m 1
xk a0 x k a1 xk a2 ..... xk am xkyk
k 0 k 0 k 0 k 0 k 0
n n n n n
2 3 4 m 2 2
xk a0 x k a1 xk a2 ..... xk am xkyk
k 0 k 0 k 0 k 0 k 0

.
... ...
.
n n n n n
j 1 j 2 j m j j
xk a0 xk a1 xk a2 ..... xk am xkyk
k 0 k 0 k 0 k 0 k 0

:::
n n n n n
m 1 m 2 m m m m
xk a0 xk a1 xk a2 ..... xk am xk yk
k 0 k 0 k 0 k 0 k 0

Este es un SEL de m+1 ecuaciones lineales en las m+1 incógnitas a 0, a1, …..,
am, que se llama Sistema deEcuaciones Normales. Este sistema de ecuaciones
normales se puede escribir en forma simplificada como sigue:
m n n
i j j
ai xk xkyk con j 0,1,....,. m
i 0 k 0 k 0

Estas ecuaciones se pueden reproducir a partir de:
2 m
pm xk a0 a 1x k a 2x k ,....., a m x k yk

Multiplicando a ambos lados por
j j 2 j m j j
a 0x k a 1x k x k a 2 x k x k ,....., a m x k x k ykxk
j 1 j 2 j m j j
a 0x k a 1x k a 2x k ,....., a m x k xkyk

Sumando sobre k
n n n m m
j 1 j 2 j m j j
a0 xk a1 xk a2 xk ..... am xk xkyk con j 0,1,2,.... ., m
k 0 k 0 k 0 k 0 k 0

10.2. DIAGRAMA DE FLUJO: 35



Inicio

Leer
m, x, y

A11 = 0
A12 = 0
A22 = m
B1 = 0
B2 = 0

i = 1, m, 1

A11 = A11 + [(X(i))^2]
A12 = A12 + X(i)
A22 = A12
B1 = B1 + [X(i)*Y(i)]
B2 = B2 + Y(i)

a = ((B1*A22)-(B2*A12) / ((A11*A22)-(A12-A21));
b = ((B2*A11)-(B1-A21)) / (A11*A22)-(A12*A21));

escribir
a, b

FIN

 CÓDIGO EN EL BOTÓN ACEPTAR:

m=str2double(get(handles.edit1,'string'));
x=str2num(get(handles.edit2,'string'));
y=str2num(get(handles.edit3,'string'));
A11=0;
A12=0; 36
A22=m;
B1=0;
B2=0;



for i=1:m
A11=A11+((x(i))^2);
A12=A12+x(i);
A21=A12;
B1=B1+(x(i)*y(i));
B2=B2+y(i);
end
a=((B1*A22)-(B2*A12))/((A11*A22)-(A12*A21));
b=((B2*A11)-(B1*A21))/((A11*A22)-(A12*A21));
ard=sprintf('y = %6.4fx + %6.4f',a,b);
set(handles.edit4,'string',ard);


figure(1);
xx=min(x)-1:0.2:max(x)+1;
yy=a*xx+b;
ezplot(x,y,'or',xx,yy),grid on

10.4. VENTANA DE DISEÑO Y APLICACION:

37



CAPITULO - III

INTEGRACIÓN NUMÉRICA
11. REGLA DEL TRAPECIO:
11.1. TEORÍA:

Este método resulta de sustituir la función por un polinomio
de primer grado en al polinomio
se le puede representar mediante un polinomio se le puede
representar mediante un polinomio de Lagrange, es decir:

Resolviendo:

Generalizando:

Aplicando la regla del trapecio a c/u de las integrales se tiene:


38
Inicio

Leer
f(X), a, b, n

h = (a+b) / n

S = f(a) - f(b)



 CÓDIGO EN EL BOTÓN ACEPTAR:

varargin)

h=(b-a)/n;
s=f(a)+f(b);
for i=2:n
x(i)=a+(i-1)*h;
s=s+2*f(x(i));
end
I=s*(h/2);
set(handles.edit5,'string',I); 39




varargin)
h=(b-a)/n;
for i=1:n+1
x(i)=a+(i-1)*h;
y(i)=f(x(i));
end
x=[x,b,a,a];
y=[y,0,0,f(a)];
fill(x,y,[0.8 0.8 0.9])
for i=1:n+1

x(i)=a+(i-1)*h;
y(i)=f(x(i));
end
hold on
ezplot(f,[min(x):0.2:max(x)])
plot(x,y,'og')
plot(x,y,'g')


varargin)
close(trapecio)

11.4. VENTANA DE DISEÑO Y APLICACION:

40



12. REGLA DE SIMPSON 1/3:
12.1. TEORÍA:

La regla de Simpson de 1/3 resulta cuando se sustituye la función y=f(x)
por un polinomio de segundo grado es decir:

En el intervalo al polinomio se le puede representar
por un polinomio de LaGrange de segundo orden
Es decir:

Resolviendo la integral se obtiene:

GENERALIZANDO PARA ''n'' INTERVALOS

Los intervalos se toman de dos en dos:

Aplicando la regla de Simpson de 1/3 para cada integral de tiene:

Dónde:

41


Inicio

Leer
f(X), a, b, n

h = (a+b) / n

i = 0, n, 1

Xi = a +h

n par

S=0

i = 2, n, 1

S = S +f(Xi-2) + 4f(Xi+1) + f(Xi)

I = S*h/3

Escribir
AREA

FIN



b=str2double(get(handles.edit3,'string')); 42
h=(b-a)/n;
for i=1:n+1



x(i)=a+(i-1)*h;
end
if rem(n,2)==0
s=0;
for i=3:2:n+1
s=s+f(x(i-2))+4*f(x(i-1))+f(x(i))
end
I=(h/3)*s
set(handles.edit5,'string',I);
end


h=(b-a)/n;
s=f(a)+f(b);
for i=1:n+1
x(i)=a+((i-1)*h);
y(i)=f(x(i));
end
x=[x,b,a,a];
y=[y,0,0,f(a)];
fill(x,y,[0.8 0.4 0.9])
for i=1:n+1
x(i)=a+((i-1)*h);
y(i)=f(x(i));
line([x(i),x(i)],[0,f(x(i))]);
end
hold on
ezplot(f,[min(x):0.2:max(x)])


function varargout = pushbutton3_Callback(h, eventdata, handles, varargin)
close(sinpson1/3)

43



13. REGLA DE SIMPSON DE 3/8:

13.1. TEORÍA:

La regla de Simpson de 3/8 resulta cuando se sustituye la función
por un polinomio de tercer grado es decir:

En el intervalo al polinomio se le puede representar
por un polinomio de LaGrange de tercer orden.
Es decir:

Resolviendo la integral se obtiene:

44

Inicio

S=0

Leer
f(X), a, b, n





f=inline(get(handles.edit1,'string'))
a=str2double(get(handles.edit2,'string'))
b=str2double(get(handles.edit3,'string'))
n=str2double(get(handles.edit4,'string'))
h=(b-a)/n
for i=1:n+1
x(i)=a+(i-1)*h 45
end
if rem(n,3)==0
s=0



for i=3:n+1:3
s=s+f(x(i-2))+3*f(x(i-1))+3*f(x(i))+f(x(i-1))
end
I=((3*h)/8)*s;
set(handles.edit5,'string',I)
end



f=inline(get(handles.edit1,'string'))
a=str2double(get(handles.edit2,'string'))
b=str2double(get(handles.edit3,'string'))
n=str2double(get(handles.edit4,'string'))
h=(b-a)/n;
s=f(a)+f(b)
for i=1:n+1
x(i)=a+((i-1)*h)
y(i)=f(x(i));
end
x=[x,b,a,a]
y=[y,0,0,f(a)]
fill(x,y,[0.6 0.8 0.4])
for i=1:n+1
x(i)=a+((i-1)*h)
y(i)=f(x(i));
line([x(i),x(i)],[0,f(x(i))])
end
hold on
ezplot(f,[min(x):0.2:max(x)]);


close


46



14. INTEGRALES MÚLTIPLES
14.1. TEORÍA:
Para el cálculo de integrales de funciones de varia variables se pueden
usar las reglas ya estudiadas como la regla del trapecio, regla de Simpson
1/3 y 3/8 son útiles para resolver integrales dobles y triples.

En esta ocasión usaremos Simpson de 1/3 para el cálculo de una integral
doble de la forma:

Dónde:

Para aproximar la solución de la integral

Utilizando la regla de Simpson 1/3

Por lo tanto:

47

Dónde:



14.2. DIAGRAMA DE FLUJO
IN IC IO

LE E R
f(x ,y ), g 1 (x ), g 2 (x ), a , b

h = (b -a )/2
x0= a
s= 0

i= 1 :3

h 2 = (g 2 (x 0 )-g 1 (x 0 ))/2
w (i)= (h 2 /3 )*(f((x 0 ),g 1 (x 0 ))+ 4 *f (x 0 ,g 1 (x 0 )+ h 2 )+ f(x 0 ,g 2 (x 0 )))
x0= x0+h

I= (h /3 )*(w (1 )+ 4 *w (2 )+ w (3 ))

E S C R IB IR
I

F IN

48




f=inline(get(handles.edit1,'string'),'x','y');
g1=inline(get(handles.edit2,'string'));
g2=inline(get(handles.edit3,'string'));
h=(b-a)/2;
x0=a;
s=0;
for i=1:3
h2=(g2(x0)-g1(x0))/2;
w(i)=(h2/3)*(f((x0),g1(x0))+4*f(x0,g1(x0)+h2)+f(x0,g2(x0)));
x0=x0+h;
end
I=(h/3)*(w(1)+4*w(2)+w(3));
set(handles.edit6,'string',I);


f1=inline(f,'x','y');
ezmesh(f1);
gridon


close

14.4. VENTANA DE DISEÑO Y APLICACIÓN: 49



CAPITULO - IV

ECUACIONES DIFERENCIALES ORDINARIAS
15. METODO DE EULER:
15.1. TEORÍA:

Este método consiste en dividir el intervalo en n subintervalos de
longitud 'h'; ,de manera que se obtiene los n+ 1 puntos
donde la condición
inicial representada por el punto por donde pasa
la curva solución, donde :

50



FORMULADE EULER

Es decir, se genera una sucesión de aproximación:

…


Inicio
51
Leer
f(X, Y), a, b, n, 0

h = (a+b) / n

i = 1, n, 1





f1=get(handles.edit1,'string'); f=inline(f1,'x','y');
y0=str2double(get(handles.edit3,'string'));
h=(b-x0)/n;
for i=1:n
y0=y0+h*f(x0,y0);
x0=x0+h;
end 52
set(handles.edit6,'string',y0);

 CÓDIGO EN EL BOTÓN ITERACIONES:




f1=get(handles.edit1,'string'); f=inline(f1,'x','y');
x(1)=str2double(get(handles.edit2,'string'));
y(1)=str2double(get(handles.edit3,'string'));

h=(b-x(1))/n;

cad1=sprintf('Iter. x %d. %8.4f %8.4fn',1,x(1),y(1));

for i=1:n
y(i+1)=y(i)+h*f(x(i),y(i));
x(i+1)=x(i)+h;
cad2=sprintf('%d. %8.4f %8.4fn',i+1,x(i+1),y(i+1));
cad1=[cad1,cad2];
end
set(handles.edit7,'string',cad1);



f1=get(handles.edit1,'string');
f=inline(f1,'x','y');
ezmesh(f);
gridon


close

53



16. METODO RUNGE – KUTTA DE CUARTO ORDEN :

16.1. TEORÍA:

El método de Runge-Kutta es un método genérico de resolución numérica
de ecuaciones diferenciales. Este conjunto de métodos fue desarrollado
alrededor del año 1900 por los matemáticos C. Runge y M. W. Kutta.

Este método puede ser usado para resolver un número grande de
ecuaciones diferenciales.
Dada la ecuación diferencial ordinaria con condiciones
iniciales entonces por el segundo teorema fundamenta del
cálculo se tiene:

Para aplicar la regla de Simpson de 1/3 a se le dividió en dos
intervalos es decir:
Entonces

Al término se le expresa como:
para aproximar la pendiente de en el punto promedio 54



Pero

Por EULER se tiene que:
Hacemos cambios de variables:

 Hagamos entonces
 Hagamos entonces por
euler : entonces

euler entonces:

euler entonces:

Por lo tanto:

Dónde:


Inicio

Leer
f(X), Xo, Yo, b, n

h = (a+b) / n
55
i = 1, n, 1

K1 = f(Xo, Yo)
K2 = f(Xo+h/2, Yo+h/2*K1)
K3 = f(Xo+h/2, Yo+h/2*K2)
K4 = f(Xo+h, Yo+h*K3) | Cálculo numérico

Y1 = Yo – (h/6)*(K1+ 2*K2+2*K3+K4)





y0=str2double(get(handles.edit5,'string'));
x0=a;
h=(b-a)/n;
for i=1:n
k1=f(x0,y0);
k2=f(x0+h/2,y0+(h/2)*k1);
k3=f(x0+h/2,y0+(h/2)*k2);
k4=f(x0+h,y0+h*k3);
y1=y0+h*(k1+2*k2+2*k3+k4)/6;
x1=x0+h;
x0=x1;
y0=y1;
56
end
set (handles.edit6,'string',y1);



ezmesh(f);
gridon


varargin)
close(kutta1)


57


Trabajo de calculo numerico

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Trabajo de calculo numerico

Similaire à Trabajo de calculo numerico (20)

Trabajo de calculo numerico