1240
1240
PARTICIPANTES:
RESUMEN 4
INTRODUCCIN 4
METODOS Y MATERIALES 5
IMPACTO 6
A travs de este proyecto se llevo a cabo en el ambiente del programa Matlab, el desarrollo
de diferentes cdigos, para la solucin de problemas de metodologa numrica, segn el tipo
de problema sobre hidrulica que se pretenda analizar y resolver. De igual manera se
desarroll un Manual de Usuario, que contiene un breviario del objetivo principal de cada
codigo, as como su pseudocdigo y algoritmo que nos explican la actividad paso a paso que
desarrolla cada programa.
INTRODUCCION
Los mtodos numricos son fundamentales para el desarrollo de la programacin numrica
de problemas en el campo de la hidrulica y en general en todo el mbito de la ingeniera.
Es por eso, que a travs del desarrollo de stos cdigos de anlisis nmerico, se realizaron
varios procedimientos estandarizados, para que los alumnos que cursen materias, en las
cuales tengan la necesidad de desarrollar alguno de los programas que contenga la gua de
este trabajo, ahorre tiempo en la codificacin del programa, ya que solo tendr que delimitar
su problema y agregar los datos en la ventana de inicio del programa Matlab o bien a un
fichero, y ste correr sus datos en el algoritmo que se le designe.
Con el desarrollo de este proyecto se gener un paquete de cdigos, de los cuales nos
podremos auxiliar en la resolucin de problemas hidrulicos, as como una gua
prctica que nos permite conocer la utilidad de cada uno de los mtodos
desarrollados, su funcionamiento, su pseudocdigo (lista de acciones del programa),
su algoritmo (secuencia lgica y matemtica de los pasos que ejecuta el programa),
as como la codificacin detallada de cada uno de stos.
Por lo antes expuesto se puede considerar, que el proyecto es de gran importancia pes sus
resultados pueden utilizarse de una amplia forma, dentro del medio educativo, y de
investigacin, dentro del desarrollo de otros proyectos relacionados con la Hidrulica, cuyo
campo accin es muy grande.
METODOS Y MATERIALES
Para el alcance de los objetivos planteados, fue necesario recrear en Matlab todos y cada
uno de los componentes del anlisis numrico, para as a partir de ellos delimitar cada uno
de los elementos que se deban de analizar y desarrollar para generar los nuevos cdigos en
todos los temas de los Mtodos Numricos que nos permitieran su aplicacin para resolver
problemas en el campo hidrulico, para diferentes condiciones y situaciones que se
representaron, en dichos programas, lo cual tambin integran los resultados de este
proyecto. Lo antes expuesto se describe detalladamente en los diez captulos que se
presentan despus de la presentacin del IMPACTO del presente proyecto.
De igual manera de cada seccin se gener un men que permiti realizar la evaluacin de
los resultados generados, de manera rpida y concisa, demostrando la efectividad de las
metodologas empleadas.
AMBIENTE MATLAB.
Para llevar a cabo la aplicacin de dicha metodologa fue necesario, realizar un estudio del
comportamiento de los componentes que utilizaramos en matlab, para desarrollar el estudio
de los scrips o cdigos.
MATLAB es un programa para realizar clculos numricos con vectores y mtrices. Como
caso particular puede tambin trabajar con nmeros escalares, tanto reales como complejos.
Una de las capacidades ms atractivas es la de realizar una amplia variedad de grficos en
dos y tres dimensiones. MATLAB tiene tambin un lenguaje de programacin propio. 1
Es un gran programa para clculo tcnico y cientfico. Para ciertas operaciones es muy
rpido, cuando puede ejecutar sus funciones en cdigo nativo con los tamaos ms
adecuados para aprovechar sus capacidades de vectorizacin. En otras aplicaciones resulta
bastante ms lento que el cdigo equivalente desarrollado en C, C++ o Fortran. Sin
embargo, siempre es una magnfica herramienta de alto nivel para desarrollar aplicaciones
tcnicas, fcil de utilizar y que aumenta la productividad de los programadores respecto a
otros entornos de desarrollo.
IMPACTO
Por lo antes expuesto se puede concluir, que el proyecto tiene un gran impacto pues sus
resultados pueden utilizarse de una amplia forma, dentro del medio educativo, y de
investigacin, dentro del desarrollo de otros proyectos relacionados con la Hidrulica, cuyo
campo accin es muy grande.
En sistemas que permiten procesos mltiples, como el UNIX, ser conveniente tener activos a
la vez MATLAB y el editor local. Si se trabaja en una estacin de trabajo con ventanas
mltiples ser deseable tener activos MATLAB en una ventana y el editor en otra. Los detalles
de la instalacin local se pueden obtener del centro de clculo correspondiente, o consultando
al instructor.
Hay varias formas diferentes para introducir una matriz en MATLAB. A saber:
_ Introduciendo una lista explcita de elementos,
_ Generndola mediante funciones y declaraciones,
_ Crendola en un archivo .m,
_ Cargndola de un archivo de datos externo .
Por ejemplo, cualquiera de las declaraciones A = [1 2 3; 4 5 6; 7 8 9]
y A=[
123
456
789]
crea la matriz 3 _ 3 que se espera y la asigna a una variable A. Los elementos en una fila de
una matriz pueden separarse tanto por comas como por espacios en blanco. Cuando alguno de
los nmeros se escribe en forma exponencial (por ejemplo 2.34e-9), deben evitarse los
espacios en blanco. La escritura de una matriz grande debe hacerse preferentemente en un
archivo .m, donde es ms sencillo corregir errores.
Las entradas individuales de una matriz o de un vector se pueden obtener poniendo los ndices
entre parntesis de la forma usual. Por ejemplo, A(2; 3) denota la entrada en la segunda _la y
tercera columna de la matriz A y x(3) denota la tercera coordenada del vector x. Solo se
pueden usar como ndices de vectores y de matrices enteros positivos.
Estas operaciones para matrices se aplican tambin a escalares (matrices 1_1). Si los tamaos
de las matrices son incompatibles para la operacin matricial se obtiene un mensaje de error,
exceptuando el caso en que uno de los operandos sea un escalar y el otro una matriz (para la
adicin, sustraccin, divisin y multiplicacin). En esta situacin se opera el escalar con cada
trmino de la matriz.
La instruccin who muestra las variables que se encuentran en el espacio de trabajo. Para
eliminar una variable de la memoria se utiliza la instruccin clear nombre variable. Si se
escribe slo clear se borran todas las variables no permanentes.
Las instrucciones se repetirn mientras la relacin sea cierta. Por ejemplo, dado un nmero a,
las instrucciones siguientes calculan y muestran el menor entero no negativo n tal que 2n a.
if. La forma general de un bucle if simple es
if relacin
instrucciones
end
Las instrucciones se ejecutarn slo si la relacin es cierta.
Una posibilidad muy til es usar las echas arriba/abajo para recuperar los comandos previos.
Se puede, por tanto, recuperar una lnea de comandos previa, editarla, y ejecutarla revisada.
Para pequeas rutinas, esto es ms conveniente que usar un archivo.m lo que requiere moverse
entre MATLAB y el editor. Por ejemplo, el nmero de operaciones para el clculo de la
inversa de matrices de varios tamaos podr ser comparado recuperando, editando y
ejecutando repetidamente:
a = rand(8); flops(0), inv(a); flops
Si se desea comparar las grficas de las funciones y = senmx y y = cosnx en el intervalo [0;
2] para varios m y n, se podr hacer lo mismo con la lnea de comandos:
m=2; n=3; x=0:.01:2*pi; y=sin(m*x); z=cos(n*x); plot(x,y,x,z)
Archivos de funciones. Los archivos de funciones hacen que MATLAB tenga capacidad de
crecimiento. Se pueden crear funciones especficas para un problema concreto, y, a partir de su
introduccin, tendrn el mismo rango que las dems funciones del sistema.
Las variables en las funciones son locales. Veremos, en primer lugar, un ejemplo sencillo de
archivo de funcin:
function a = ental(m,n)
%ENTAL Matriz entera generada aleatoriamente.
% ental(m,n) produce una matriz mxn con entradas
% enteras entre 0 y 9
a = floor(10*rand(m,n));
Las cadenas de texto se introducen en MATLAB entre comillas simples. Por ejemplo, s =
'Esto es una prueba' asigna la cadena de texto dada a la variable s. Las cadenas de texto
pueden mostrarse con la funcin disp.
Por ejemplo: disp('Este mensaje se est mostrando aqu')
Los mensajes de error se muestran mejor con la funcin error ;
error('Lo siento, la matriz debe ser simtrica')
I.14. Hardcopy.
La forma ms sencilla de obtener una hardcopy1 es con la instruccin diary. La orden diary
nombre de archivo hace que todo lo que aparezca a continuacin en pantalla (excepto los
grficos) sea escrito en el archivo nombre de archivo (si se omite el nombre se toma por
defecto diary) hasta que se ordena diary off; la instruccin diary on har que se escriba al final
del archivo,etc. Al terminar, se puede editar el archivo como se desee e imprimirlo en el
sistema local.
I.15. Grficos.
MATLAB puede producir grficos planos y grficos de malla de superficies tridimensionales.
Para ver algunas de sus posibilidades escriba plotdemo.
Grficos planos. La instruccin plot crea grficos en el plano XY; si x e y son vectores de la
misma longitud, la orden plot(x,y) accede a la pantalla grfica y realiza un grfico plano de los
elementos de x contra los elementos de y. Por ejemplo, podemos dibujarla grfica de la
funcin seno sobre el intervalo [-4; 4] con las instrucciones siguientes:
x = -4:.01:4; y = sin(x); plot(x,y)
El vector x es una particin del dominio con paso 0.01 mientras que y es un vector (sin es
vectorial) con los valores que toma el seno en los nodos de esta particin. Para volver a la
pantalla alfanumrica desde la grfica, se pulsa cualquier tecla. Por el contrario, para acceder a
la pantalla grfica, se usa la orden shg (show graph). Si su mquina soporta ventanas mltiples
con una ventana grfica aparte, puede desear mantener la ventana expuesta |aunque a un lado|
y la ventana alfanumrica activa.
Pueden ponerse ttulos, comentarios en los ejes o en cualquier otra parte con los siguientes
comandos que tienen una cadena como argumento:
title t__tulo del gr_a_co
xlabel comentario en el eje x
ylabel comentario en el eje y
gtext texto posicionado interactivamente
text texto posicionado mediante coordenadas
II. Modelos matemticos en hidrulica, anlisis de
aproximaciones y errores en los problemas.
II.1. Ecuacin de Navier-Stokes
du
Fx = ma x = = ( dxdydz ) a x = x dydz +
dt
yx
x + dx dydz + yx + dy dxdz
x y
zx
yx dxdz + zx + dz dydx zx dydx +
z
gx dxdydz 2.1
x yx zx
a x = + + + g x 2.2a
x y z
y xy zy
a y = + + + g y 2.2b
y x z
z xz yz
a z = + + + g z 2.2c
z x y
S el fluido es de tipo newtoniano se sustituyen las ecuaciones 4.40 y 4.45 en las ecuaciones
2.2. Adems de considerar que el esfuerzo normal es igual a - p, segn la ecuacin 3.48,
la ecuacin 2.2a resulta ser igual a
p u 2 v u
a x = g x + 2 ( q) + + +
x x x 3 y x u
u w
+ 2.3
z z x
p u 2 v u
ax = g x + 2 ( q) + + +
x x x 3 y x u
u w
+ 2.4
z z x
p u u 2u
2 2
ax = g x
x
+ 2 + + + ( q)
y 2 z 2 3 x
2.5a
x
p v v v
2 2 2
a y = g y
y
+ z + + + ( q)
y z z z 3 x
2.5b
x
p w w w
2 2 2
a z = g z
z
+ z + + + ( q)
z 3 z
2.5c
x yz
q
a= + (q )q = g p + 2 q + ( q) 2.6
t 3
Por ejemplo, para el caso de la ecuacin 2.7 y sus componentes resultan ser
q 1
a= + (q )q = gh p + 2 q 2.8
t
h 1 p u u u
2 2 2
u u u u
+u +v +w = g + + + 2.9a
t x y z x x x 2 y 2 z 2
h 1 p v v v
2 2 2
v v v v
+u +v +w = g + + + 2.9b
t x y z y y x 2 y 2 z 2
h 1 p w w w
2 2 2
w w w w
+u +v +w = g + + + 2.9c
t x y z z z x 2 y 2 z 2
Debe observarse que ax , ay y az , fueron reemplazadas por los valores expresados en las
ecuaciones 3.9. Las ecuaciones 2.8 y 2.9 son tambin de Navier - Stokes en un sistema de
coordenadas cartesiano para un fluido newtoniano de viscosidad y densidad constante
(incompresible).
Para la direccin r
vr v r v v r v2 vz h 1 p
+ vr + + vz =g +
t r r r z r r
2 v v r
2 2
1 1 vr
r r r
( rv r ) +
r
2 2
r 2
+
z 2
2.10a
Para la direccin
v v v v v r v v h 1 p
+ vr + + + vz =g +
t r r r z r
1 2 v v
2 2
1 v
r r r
( rv ) + 2
r 2 + 2
r
+ 2
z
2.10b
Para la direccin z
vz v z v v z vz h 1 p
+ vr + + vz =g +
t r r z z z
1 v z 1 v z v z
2 2
r + + 2.10c
r r r r z 2 z 2
Todas estas ecuaciones son diferenciales parciales no lineales, que en muchos de los casos es
imposible obtener soluciones generales; por ello es que en algunos problemas de ingeniera es
necesario efectuar simplificaciones razonables que dan soluciones aproximadas con fines de
diseo, como se ver en incisos posteriores; sin embargo, para otros problemas de flujo se
pueden generar soluciones exactas, como es el caso de flujo entre placas paralelas y tuberas
de dimetro constante y flujos permanentes y plenamente desarrollados.
III. RESOLUCION DE ECUACIONES NO LINEALES
III.1. PLANTEAMIENTO DEL PROBLEMA
c). Factor de friccin para tubos comerciales, en la regin entre tubos lisos y la zona de
turbulencia completa, desarrollada por Colebrook y que es la base para el diagrama de Moody.
1 2.523
= 0.869 ln D +
f 3.7 R f
Donde:
f = Coeficiente de friccin
= Rugosidad relativa del tubo
D = Dimetro de la tubera, en m
R = Numero de Reynolds
a. Introduccin
b. Algoritmo
Entrada: f_nombre = Nombre de la funcion que define la ecuacion
p0 = Punto de partida, cercano a la solucion
Salida: it = Nmero de iteraciones realizadas
punto = Aproximacin al punto fijo
ErrorAbs = Diferencia entre dos valores consecutivos
Puntos' = Sucesion de puntos {pn}
Pasos computacionales:
*condiciones iniciales; Sean tolerancia= 0.000001
it_ limite=500 (limite de iteraciones)
Inicia la iteracin declarando puntos(1) = p0.
Para lmite de iteraciones igual a 2 hasta el lmite de iteraciones
*evaluacin de funciones; Puntos(it) f(Puntos(it-1))
Por lo que el:
error absoluto = valor absoluto de (Puntos(it)) menos(Puntos(it-1));
error relativo = error absoluto entre el valor absoluto de Puntos(it)
ms psilon.
Punto = Puntos(it).
S. El error absoluto es menor que la tolerancia el error
relativo es menor que la tolerancia en tonces
Termina, Finaliza
Finaliza
S la iteracin es identica a el lmite de iteraciones, entonces Indica que
seexcedi el nmero mximo de iteraciones y
Termina
Denota que Puntos=Puntos';
c. Cdigo en Matlab
%Parametros de control
Tolerancia=0.000001; %Tolerancia
it_limite=5000; %Nmero mximo de iteraciones
%Inicia Iteracin
Puntos(1)= p0;
for it=2:it_limite
Puntos(it)=feval(f_nombre,Puntos(it-1));
ErrorAbs=abs(Puntos(it)-Puntos(it-1));
ErrorRel=ErrorAbs/(abs(Puntos(it))+eps);
punto=Puntos(it);
if (ErrorAbs<Tolerancia) | (ErrorRel<Tolerancia),break;end
end
if it == it_limite
disp('Excedido el nmero mximo de iteraciones')
end
Puntos=Puntos';
a. Introduccin
b. Algoritmo
Entrada: X a, X c, f uncin.
Salida: Yb (solucin aproximada o mensaje de fracaso)
Pasos computacionales:
*condiciones iniciales; Sean tolerancia= 0.0000001
it_ limite=300 (limite de iteraciones)
it = 0.
c. Cdigo en Matlab
% METODO DE BISECCION.
% biseccin(funcin, a,c)
% Datos
% - funcin : Definicion de la ecuacin a resolver.
% - Xa, Xc : Extremos del intervalo inicial.
% Salida
% - tolerancia : Tolerancia.
% - it_limite : Limite del numero de iteraciones.
% - Ya, Yc : Valores "y" de los extremos actuales.
tolerancia = 0.0000001;
it_limite = 300;
it = 0;
if ( Ya*Yc > 0 )
a. Introduccin
La interseccin de sta lnea con el eje de las X representa una mejor estimacin de la raz.
El hecho de que se reemplace una lnea curva por una lnea recta da una posicin falsa de la
raz; de aqu el nombre del mtodo de la falsa posicin, o en latn, regula falsi. Tambin se le
conoce como el mtodo de la interpolacin lineal.
Usando tringulos semejantes, la interseccin de la lnea recta con el eje de las x puede ser
estimado como:
f (Xl) f (Xu)
---------- = -----------
Xr Xl Xr - Xu
El cual puede resolverse por;
f (Xu) (Xl Xu)
Xr = Xu -- --------------------
f (Xl) -- f (Xu)
El valor de Xl , calculado con la ecuacin anterior reemplaza uno de los dos valores iniciales
Xl o Xu, que produzca un valor de la funcin.
b. Algoritmo
Entrada: a, c, f uncin.
Salida: c, err, yc = f(c).
Pasos:
S no itera
S yb*yc>0,
Entonces b = c;
yb = yc;
S no a = c;
ya = yc; Termina
Calcula el valor mnimo de dx;
dx =min(abs(dx),ac);
Criterios de parada, detenemos la iteracin si sucede al menos alguna de
stas posibilidades:
Si (abs(dx)) <delta, Termina.
Si (abs(yc)) <epsilon, Termina.
Finaliza.
Damos salida al valor de c calculado,
Damos salida al clculo de el error err = abs (b a) / 2;
Evalamos: yc f (c).
c. Cdigo en Matlab
function [c]=regula(funcion,a,b)
% Datos
% - f es la funcin, introducida como una cadena de caracteres 'f'
% - a y b son el extremo izquierdo y el extremo derecho
% - delta es la tolerancia para el cero
% - epsiln es la tolerancia para el valor de f en el cero
% - max1 es el numero mximo de iteraciones
% Resultados
% - c es el cero
% - yc=f(c)
% - err es el error estimado de la aproximacin a c
delta = 0.0000001;
epsilon =0.0000001;
max1=300;
ya=feval(funcion,a);
yb=feval(funcion,b);
if ya*yb>0
disp('Nota: f(a)*f(b) >0'),
break,
end
for k=1:max1
dx=yb*(b-a)/(yb-ya);
c=b-dx;
ac=c-a;
yc=feval(funcion,c);
if yc==0,break;
elseif yb*yc>0
b=c;
yb=yc;
else
a=c;
ya=yc;
end
dx=min(abs(dx),ac);
if abs(dx)<delta,break,end
if abs(yc)<epsilon, break,end
end
c;
err=abs(b-a)/2;
yc=feval(funcion,c);
a. Introduccin
Este mtodo consiste en un procedimiento iterativo para calcular valores aproximados de una
raiz o un cero de la ecuacin f (x) = 0, partiendo de un punto conocido y cercano a la raz
buscada.
Sea r una raiz de f (x) = 0 situada en el intervalo (a, b) y supngase que f (x) existe en (a, b).
La recta tangente a la curva en el punto P(a, f(a)) de abscisa a (valor que se toma como la
aproximacin inicial de r) viene dada por:
y f(a) = f(a)(x-a) (punto pendiente)
Para determinar el punto de interseccin de esta recta con el eje x, que se llamar a1 y que se
considera como la siguiente aproximacin de r, se hace y = 0 en (1), de lo cual se obtiene:
f(a)
a1 = a - ----------- ; f(a) o
f(a)
En muchas ocasiones a1es una aproximacin a r mejor que a; en tales casos se repite de nuevo
el procedimiento reemplazando el punto a por a1. La recta tangente a la curva en el punto
P1(a1, f(a1)) y de pendiente f(a1) viene dada por:
y f(a1) = f(a1)(x-a1)
El intercepto de esta recta con el eje x, que se llamar a2 y que se considera la siguiente
aproximacin de r, se obtiene al hacer y = 0 en la ecuacin (2), y asi se obtiene:
f(a1)
a2 = a1 - ----------- ; f(a1) o
f(a1)
Son muchos los casos en los cuales la frmula anterior proporciona una sucesin de valores an
, que progresivamente se van acercando a la raz exacta.
b. Algoritmo
Entrada: X 0 (aproximacin inicial),
f uncin.
Salida: Xb
Pasos:
*condiciones iniciales; Sean X = Xo (punto inicial)
Xb = X 999,
del_X = 0.01
n = 0.
Mientras el valor absoluto de (x-xb) sea mayor que 0.00001
n=n+1;
Xb = X
S el valor de n es mayor que 300, Termina, Finaliza
*evaluacin de funciones; Y f(x)
por lo que
y_driv = f(x+del_x) y / del_x ;
x = Xb y / y_driv;
Termina.
c. Cdigo en Matlab
x = x0;
xb=x-999;
n=0;
del_x = 0.01;
a. Introduccin
f(xn)(xn - xn-1)
xn+1 = xn - ------------------ ; n = 1, 2,.
f(xn) - f(xn-1)
La aplicacin sucesiva de la iteracin anterior no es siempre posible, puede ocurrir que algn
punto xn no estuviera en el dominio de f o que el denominador sea casi cero, en cuyo caso la
secante es horizontal y, salvo que xn fuese ya un cero de f, no corta al eje de las abscisas.
f ( p k )( p k p k 1 )
p k +1 = p k
f ( p k ) f ( p k 1 )
b. Algoritmo
Se pretende obtener la raz de la ecuacin f (x) = 0 dados los valores de po y
p1, prximos a la raz.
El algoritmo construye una sucesin de aproximaciones p0, p1, p2.. pn..
Entrada: po, p1, f uncin.
Salida: y (funcin evaluada en p1), p1 (valor de la aproximacin a cero calculado por el mtodo de la
secante), err, k.
Pasos:
*condiciones iniciales; Sean delta = tolerancia para p1 = 0.00001
epsiln =tolerancia para los valores de la
funcin= =0.0000001
max1 = numero mximo de iteraciones =300
c. Cdigo en Matlab
%Datos
% - f es la funcin, introducida como una cadena de caracteres 'f'
% - p0 y p1 son las aproximaciones iniciales a un cero de la funcin
% - delta es la tolerancia para p1
% - epsilon es la tolerancia para los valores de la funcin
% - max1 es el numero mximo de iteraciones
% Resultados
% - p1 es la aproximacin al cero,
% obtenida con el mtodo de la secante
% - err es una estimacin del error de p1
% - k es el numero de iteraciones realizadas
% - y es el valor de la funcin f(p1)
delta = 0.00001;
epsilon = 0.0000001;
max1 = 300;
for k=1:max1
p2=p1-feval(funcion,p1)*(p1-p0)/(feval(funcion,p1)-feval(funcion,p0));
err=abs(p2-p1);
relerr=2*err/(abs(p2)+delta);
p0=p1;
p1=p2;
y=feval(funcion,p1);
if (err<delta)|(relerr<delta)|(abs(y)<epsilon),break,end
end
a. Introduccin
MATLAB dispone de funciones que minimizan y calculan races de funciones no
lineales de una y varias variables, funciones que calculan integrales de funciones de
una y dos variables y, funciones que resuelven sistemas de ecuaciones diferenciales
ordinarias de primer orden con condiciones iniciales. Una de sta funciones que
optimiza y calcula races de funciones es la funcin fzero la cual encuentra races de
una funcin de una variable.
En la primera ecuacin asumimos que el flujo sale del depsito 1, a la unin (punto2),
continuando al depsito ms bajo (punto 4)
P1 V L V L V P V
+ Z1 + 1 V1 f12 12 12 V12 f 24 24 24 V24 = 4 + Z 4 + 4 V4
2g D12 2 g D24 2 g 2g
Si la presin es la atmosfrica P = 0 y si se considera que el nivel del agua en los depsitos es
constante, V1 y V4 =0
L V L V
f 12 12 12 V12 + f 24 24 24 V24 + (Z 4 Z 1 ) = 0
D12 2 g D24 2 g
En la segunda ecuacin asumidos que el flujo sale del deposito 1 hacia la unin (punto2),
hasta el deposito 3
P1 V1 L V L V P V
+ Z1 + V1 f12 12 12 V12 f 23 23 23 V23 = 3 + Z 3 + 3 V3
2g D12 2 g D23 2 g 2g
L12 V12 L V
f 12 V12 + f 23 23 23 V23 + (Z 3 Z 1 ) = 0
D12 2 g D23 2 g
Donde:
V = Velocidad media del flujo, en m/s
D2
A = rea de la tubera =
4
f = Coeficiente de friccin, adimensional
L = Longitud de la tubera, en metros
D = Dimetro de la tubera, en metros
g = Aceleracin de la gravedad = 9.81 m/s2
Z = Cota de la superficie libre del agua, en metros
a. Introduccin
b. Algoritmo
Entrada: A, B.
Salida: X (matriz solucin de AX = B).
Pasos computacionales:
Para q = 1 hasta N -1
Determina la fila pivote parcial para la columna q-
sima
[Y,j]=valor mximo absoluto de (Aug(p hasta N,p));
Intercambio de filas q-sima y j+p-1 sima.
C=la columna q de Aug;
La columna q de Aug = la columna j+p-1, de Aug;
La columna j+p-1, de Aug = C;
S Aug(q,q) es una igualdad con cero,
entonces imprime que A es singular, que no hay
solucin o que no es nica, y por tanto termina el ciclo,
Termina.
Proceso de eliminacin en la columna q-sima.
Para k = p+1 hasta N
m = Aug(k,q) / Aug(q,q);
Aug(k, q hasta N+1) = Aug(k, q hasta N+1) m * Aug(desde q,q hasta N+1);
Termina el ciclo
Termina.
Calcula la Sustitucin regresiva en la matriz [U|Y] usando el programa anterior.
X llama al programa backsub.m
X=backsub(Aug(1 de N,1 hasta N), Aug(1 de N,N+1));
c. Cdigo en Matlab
function X = uptrbk(A,B)
%Datos
% - A es una matriz invertible de orden N x N
% - B es una matriz de N x N
%Resultados
% - X es una matriz de orden N x 1 que contiene al solucion de AX=B.
if Aug(p,p)==0
'A es singular. No hay solucion o no es unica'
break
end
%Proceso de eliminacion de la columna q-sima
for k=p+1:N
m=Aug(k,p)/Aug(p,p);
Aug(k,p:N+1)=Aug(k,p:N+1)-m*Aug(p,p:N+1);
end
end
a. Introduccin
b. Algoritmo
Entrada: A, B.
Salida: X (matriz solucin de AX = B).
Pasos computacionales:
c. Cdigo en Matlab
function X = lufact(A,B)
%Datos
% - A es una matriz de orden N X N
% - B es una mtriz de orden N x 1
%Resultado
% - X es una matriz de orden N x 1 de AX = B.
[N,N]=size(A);
X=zeros(N,1);
Y=zeros(N,1);
C=zeros(1,N);
R=1:N;
for p=1:N-1
%Determinacin de la fila pivote para la columna q-sima
[max1,j]=max(abs(A(p:N,p)));
for k=p+1:N
mult=A(k,p)/A(p,p);
A(k,p) = mult;
A(k,p+1:N)=A(k,p+1:N)-mult*A(p,p+1:N);
end
end
Y(1) = B(R(1));
for k=2:N
Y(k)= B(R(k))-A(k,1:k-1)*Y(1:k-1);
end
X(N)=Y(N)/A(N,N);
for k=N-1:-1:1
X(k)=(Y(k)-A(k,k+1:N)*X(k+1:N))/A(k,k);
end
a. Introduccin
c. Cdigo en Matlab
% Datos:
% - A es una matriz invertida de orden N x N
% - B es una matriz de orden N x 1
% - P es una matriz de orden N x 1: el punto inicial
% - delta es la tolerancia para P
% - max1 es el numero mximo de iteraciones
% Resultados:
% - X es una matriz de orden N x 1: la aproximacin a la
% solucin de AX = B
% generada por el mtodo iterativo de Gauss Seidel
N = length(B);
for k=1:max1
for j=1:N
if j==1
X(1)=(B(1)-A(1,2:N)*P(2:N))/A(1,1);
elseif j==N
X(N)=(B(N)-A(N,1:N-1)*(X(1:N-1))')/A(N,N);
else
X(j)=(B(j)-A(j,1:j-1)*X(1:j-1)'-A(j,j+1:N)*P(j+1:N))/A(j,j);
end
end
err=abs(norm(X'-P));
relerr=err/(norm(X)+eps);
P=X';
if (err<delta)|(relerr<delta)
break
end
end
X=X';
a. Introduccin
b. Algoritmo
Entrada:
Input -F es la funcin salvada en el M-file como F.m
JF is the Jacobian of F saved as the M-file JF.M
P es la aproximacin inicial a la solucin
delta es la tolerancia para P
epsiln es la tolerancia para F(P)
max1 es el nmero mximo de iteraciones.
c. Cdigo en Matlab
function [P,iter,err]=raphson(F,JF,P,delta,epsilon,max1)
Y=feval(F,P);
for k=1:max1
J=feval(JF,P);
Q=P-(J\Y')';
Z=feval(F,Q);
err=norm(Q-P);
relerr=err/(norm(Q)+eps);
P=Q;
Y=Z;
iter=k;
if (err<delta)|(relerr<delta)|(abs(Y)<epsilon)
break
end
end
V. INTERPOLACIN Y APROXIMACIN POLINOMIAL
V.1. PLANTEAMIENTO DEL PROBLEMA
Cuando se tiene un conjunto de datos que han sido obtenidos de un experimento o por
observacin de un fenmeno fsico. Estos datos generalmente pueden considerarse como
coordenadas de puntos de una funcin f(x).
Existen diferentes mtodos para encontrar un polinomio interpolador que ajuste de la mejor
forma posible un conjunto de puntos.
a. Introduccin
El polinomio integrador de Lagrange que pasa por los N+1 puntos (Xk,Yk), para k=0,1, ....., N,
se expresa como:
N
P( x ) = y k L N ,k ( x )
k =0
donde:
(x x )
N
j
j =0
L N ,k (x ) =
jk
(x xj )
N
k
j =0
jk
b. Algoritmo
Entrada: X, Y.
Salida: C (matriz solucin), L (matriz de coeficientes).
Pasos computacionales:
*condiciones iniciales; Sean w = longitud de (X);
n = w-1;
L = matriz nula (w,w);
Para k=1 hasta n+1
V =1;
Para j = 1 hasta n+1
Si k es igual o semejante a j
V = obtencin de coeficientes de los polinomios
(V,poly(X(j)))/(X(k)-X(j));
Termina.
Termina.
La columna k de L = V;
Termina.
Clcula los coeficientes de polinomio interpolador
C=Y*L;
c. Cdigo en Matlab
function [C,L]=lagran(X,Y)
% Datos
% - X es el vector que contiene la lista de las abcisas
% - Y es un vector que contiene la lista de las ordenadas
% Resultados
% - C es la matriz que contiene los coeficientes del
% polinomio interpolaodor de Lagrange
% - L es la matriz que contiene los coeficientes de los polinomios
% coeficientes de Lagrange
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;
a. Introduccin
P(x) = d 0,0 + d 1,1 (x-x0) + d 2,2 (x-x0) (x-x1) + + d N,N (x-x0) (x-x1) (x-xN-1) ,
Siendo
d k,j -1 - d k-1,j-1
d k,0 = yk y d k,j = ------------------
X k - X k-j
b. Algoritmo
Entrada: X, Y.
Salida: C (vector de coeficientes), D (tabla de diferencias divididas).
Pasos computacionales:
*condiciones iniciales; Sean n = longitud de (X);
D = matriz nula (n,n);
La fila 1 de la matriz D = Y';
Para j = 2 hasta n
Para k=j hasta n
D(k,j) = (D(k,j-1) - D(k-1,j-1)) / (X(k) - X(k-j+1));
Termina.
Termina.
C = D(n,n);
Para k = (n-1) de -1 hasta 1
C = obtencin de coeficientes de los polinomios (C,poly(X(k)));
m = longitud de (C);
C(m) = C(m) + D(k,k);
Termina.
c. Cdigo en Matlab
function [C,D]=newpoly(X,Y)
%Datos
% - X es un vector con la lista de las abcisas
% - Y es un vector con la lista de las ordenadas
%Resultados
% - C es un vector que contiene los coeficientes
% del polinomio interpolador de newton. escrito de
% forma habitual, en potencias decrecientes de x
% - D es la tabla de diferencias divididas
n=length(X);
D=zeros(n,n);
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));
end
end
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
a. Introduccin
d k,j -1 - d k-1,j-1
P(x) = N J=0 cJ T,j 2 ------------------
X k - X k-j
b. Algoritmo
Entrada: fun, n, a, b.
Salida: C, X, Y.
Pasos computacionales:
*condiciones iniciales; dado que d = pi / (2*n+2);
C = matriz nula (1,n+1);
S el numero de argumentos de entrada es una igualdad con 2, a = -1 y
b=1
Termina.
c. Cdigo en Matlab
% METODO DE LA APROXIMACION DE CHEBYSHEV
function [C,X,Y]=cheby(fun,n,a,b)
%Datos
% - fun es la funcion que deseamos aproximar, dada como una
% cadena de caracteres
% - n es el grado del polinomio de aproximacin
% - a es el extremo izquierdo
% - b es el extremo derecho
%Resultados
% - C es la lista de coeficientes del polinomio
% - X contiene las abcisas de los nodos
% - Y contiene los valores de fun en los nodos
if nargin==2, a=-1;b=1;end
d=pi/(2*n+2);
C=zeros(1,n+1);
for k=1:n+1
X(k)=cos((2*k-1)*d);
end
X=(b-a)*X/2+(a+b)/2;
x=X;
Y=eval(fun);
for k =1:n+1
z=(2*k-1)*d;
for j=1:n+1
C(j)=C(j)+Y(k)*cos((j-1)*z);
end
end
C=2*C/(n+1);
C(1)=C(1)/2;
VI. AJUSTE DE CURVAS
VI.1. PLANTEAMIENTO DEL PROBLEMA
Consiste en obtener una curva que represente el comportamiento general de los datos
experimentales o medidos, se recomienda para datos sin un grado significativo de error o
ruido. La curva resultante permite estimar razonablemente valores no obtenidos o medidos.
a. Introduccin
Donde:
N N N
N x k y k xk y k
A= k =1 k =1 k =1
2
N
N
N x
k =1
2
k xk
k =1
N N N N
xk2 y k xk xk y k
B= k =1 k =1 k =1 k =1
2
N
N
N x xk 2
k
k =1 k =1
b. Algoritmo
Entrada: X, Y.
Salida: A, B.
Pasos computacionales:
*condiciones iniciales; Sean xmean=mean(X);
ymean=mean(Y);
c. Cdigo en Matlab
function [A,B]=lsline(X,Y)
%Datos
% - X es el vector de abcisas 1 x n
% - Y es el vector de ordenadas 1 x n
%Resultados
% - A es el coeficiente de x en Ax + B
% - B es el termino independiente en Ax + B
xmean=mean(X);
ymean=mean(Y);
sumx2=(X-xmean)*(X-xmean)';
sumxy=(Y-ymean)*(X-xmean)';
A=sumxy/sumx2;
B=ymean-A*xmean;
d. Funcin
[A,B]=polyfit(X,Y,1)
a. Introduccin
f ( x + 10 k ) f ( x 10 k )
f ' ( x ) Dk = , para k = 0,...., n
2(10 k h)
Donde las iteraciones continan hasta que:
Dn +1 Dn Dn Dn 1 O Dn Dn 1 < tolerancia
b. Algoritmo
c. Cdigo en Matlab
function [L,n]=difflim(f,x,toler)
%Datos
% - f es la funcion, introducida como una cadena de caracteres 'f'
% - x es el punto en el que se deriva
% - toler es la tolerancia para el error
%Resultados
% - L=[H' D' E']:
% -H es el vector de lso incrementos
% -D es el vector de las aproximaciones a la derivada
% -E es el vector de las cotas del error
% -n es la coordenada de la "mejor aproximacion"
max1=15;
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);
end
n=2;
while((E(n)>E(n+1))&(R(n)>toler))&n<max1
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'];
a. Introduccin
f ( x + 2 j h) f ( x 2 j h)
D ( j ,1) =
2 j +1 h
D( j , k 1) D( j 1, k 1)
D ( j , k ) = D( j , k 1) + , para 2 k j
4k 1
b. Algoritmo
c. Cdigo en Matlab
function [D,err,relerr,n]=diffext(f,x,delta,toler)
%Datos
% - f es la funcion, introducida como una cadena de caracteres 'f'
% - x es el punto en el que se deriva
% - delta es la tolerancia para el error
% - toler es la toleranci apara el error relativo
%Resultados
% - D es la matriz de las aproximaciones de la derivada
% - err es la cota del error
% - relerr es la cota del error relativo
% - n es la coordenada de la "mejor aproximacion"
err=1;
relerr=1;
h=1;
j=1;
D(1,1)=(feval(f,x+h)-feval(f,x-h))/(2*h);
while relerr > toler & err > 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
err=abs(D(j+1,j+1)-D(j,j));
relerr=2*err/(abs(D(j+1,j+1))+abs(D(j,j))+eps);
j=j+1;
end
a. Introduccin
P ( x) = a0 + a1 ( x x0 ) + a 2 ( x x0 )( x x1 ) + ..... + a N ( x x0 )( x x1 )....( x x N 1 )
c. Cdigo en Matlab
function [A,df]=diffnew(X,Y)
%Datos
% - X es un vector 1 x n que contiene las abcisas
% - Y es un vector 1 x n que contiene las ordenadas
%Resultados
% - A es unj vector 1 x n que contiene los coeficientes del
% polinomio de Newton de grado N
% - df es la derivada aproximada
A=Y;
N=length(X);
for j=2:N
for k=N:-1:j
A(k)=(A(k)-A(k-1))/(X(k)-X(k-j+1));
end
end
x0=X(1);
df=A(2);
prod=1;
n1=length(A)-1;
for k=2:n1
prod=prod*(x0-X(k));
df=df+prod*A(k+1);
end
VIII. INTEGRACION NUMERICA
VIII.1. PLANTEAMIENTO DEL PROBLEMA
Estimar el rea de la seccin transversal de un escurrimiento (A), es una actividad que se
requiere realizar para varios tareas dentro de la ingeniera de recurso hidrulicos, incluso en
el pronostico de avenidas y en el diseo de presas. A menos que los dispositivos sondeo
electrnicos estn disponibles obtener perfiles continuos del fondo del cauce, el ingeniero
debe confiar de las dimensiones discretas de profundidad para calcular . Un ejemplo de una
seccin transversal del arroyo tpica se muestra debajo.
Distancia 6.5 13.0 19.5 26.0 32.5 39.0 46.5 52.5 59.0 65.5 72.0 78.5
Profundidad 0.0 2.0 2.0 4.0 4.0 7 5.5 4 3.5 2.8 1.4 0.0
a. Introduccin
Aproxima la integral definida de la funcin f(x) entre dos puntos a y b de la siguiente forma:
M 1
h
( )
b
a f ( x ) dx
2
f ( a ) + f (b ) + h
k =1
f ( xk )
Calculndose f(x) en los puntos equidistantes xk=a+kh, para k=0,1,..M con x0=a y
xM=b
b. Algoritmo
c. Cdigo en Matlab
function s=traprl(f,a,b,M)
%Datos
% - f es el integrando, dado como una cadena de caracteres 'f'
% - a y b son los extremos inferior y superior del intervalo
% de integracion
% - M es el numero de subintervalos
%Resultado
% - s es la aproximacion obtenida con la regla compuesta del
% trapecio
h=(b-a)/M;
s=0;
for k=1:(M-1)
x=a+h*k;
s=s+feval(f,x);
end
s=h*(feval(f,a)+feval(f,b))/2+h*s;
a. Introduccin
Considera que los puntos xk=a+kh, para k=0,1,.M con x0=a y xM=b dividen el intervalo
[a,b] en 2j=2M subintervalos del mismo tamao h=(b-a)/2. En esta situacin se consideran la
siguientes formulas recursivas.
h
T (0) = ( f (a ) + f (b) )
2
T ( J 1) M
T (J ) = + h f ( x 2 k 1 ) , para J=1,2,
2 k =1
Y la integral definida de la funcin f(x) entre los puntos a y b puede calcularse de la siguiente
forma
b J
h 2
a f ( x)dx = 2 ( f ( xk ) + f ( xk 1 ) )
k =1
Utilizando la recursion del trapecio segn se aumenta el numero de subintervalos de [a,b] y
tomando en la iteracin J un conjunto de 2J+1 puntos equidistantes.
b. Algoritmo
c. Cdigo en Matlab
function T=rctrap(f,a,b,n)
%Datos
% - f es el integrando, dado como una cadena de caracteres 'f'
% - a y b son los extremos inferior y superior del intervalo
% de integracion.
% - n es el numero de veces que se hace la recursion
%Resultado
% - T es la lista de las proximaciones obtenidas con la regla recursiva
% del trapecio
M=1;
h=b-a;
T=zeros(1,n+1);
T(1)=h*(feval(f,a)+feval(f,b))/2;
for j=1:n
M=2*M;
h=h/2;
s=0;
for k=1:M/2
x=a+h*(2*k-1);
s=s+feval(f,x);
end
T(j+1)=T(j)/2+h*s;
end
a. Introduccin
Aproxima la integral definida de la funcin f(x) entre los puntos a y b de la siguiente forma:
h a+b
f ( x)dx 3 ( f (a) + f (b) + 4 f (c)) c=
c
B. Regla compuesta de Simpson aproxima la integral definida de la funcin f(x) entre los
puntos a y b de la siguiente forma:
h 2h M 1 4h M
f ( x ) dx ( f ( a ) + f (b ) ) + f ( x 2 k ) + f ( x2k 1 )
3 3 k =1 3 k =1
Calculndose f(x) en los puntos equidistantes xk=a+kh para k=0,1,2M con x0=a y x2M=b
b. Algoritmo
c. Cdigo en Matlab
function s=simprl(f,a,b,M)
%Datos
% - f is the integrand input as a string 'f'
% - a and b are upper and lower limits of integration
% - M is the number of subintervals
%Resultado
% - s is the simpson rule sum
h=(b-a)/(2*M);
s1=0;
s2=0;
for k=1:M
x=a+h*(2*k-1);
s1=s1+feval(f,x);
end
for k=1:(M-1)
x=a+h*2*k;
s2=s2+feval(f,x);
end
s=h*(feval(f,a)+feval(f,b)+4*s1+2*s2)/3;
f(x)dx R (J, K)
a
dando R(J+1, J+1) como respuesta final. Las aproximaciones R(J,K) se guardan en una
matriz triangular inferior R: los elementos R(J,0) estn en la primera columna de R y son las
aproximaciones obtenidas con la regla recursiva del trapecio con 2j-1 subintervalos de [a, b];
los restantes elementos R(J,K) (que se almacena en R(J,K+1) se calculan usando el mtodo de
Romberg de manera que los elementos de la fila J-sima de R son
b. Algoritmo
c. Cdigo en Matlab
function [R,quad,err,h]=romber(f,a,b,n,tol)
%Datos
% - f es el integrando dado como una cadena de caracteres 'f'
% - a y b son los limites inferior y superior del intervalo de integracion
% - n es el numero maximo de filas de la tabla
% - tol es la tolerancia
%Resultados
% - R es el esquema de Romberg
% - quad es la aproximacion a la integral
% - err es el error estimado
% - es el menor de los incrementos usados
M=1;
h=b-a;
err=1;
J=0;
R=zeros(4,4);
R(1,1)=h*(feval(f,a)+feval(f,b))/2;
while((err>tol)&(J<n))|(J<4)
J=J+1;
h=h/2;
s=0;
for p=1:M
x=a+h*(2*p-1);
s=s+feval(f,x);
end
R(J+1,1)=R(J,1)/2+h*s;
M=2*M;
for K=1:J
R(J+1,K+1)=R(J+1,K)+(R(J+1,K)-R(J,K))/(4^K-1);
end
err=abs(R(J,J)-R(J+1,K+1));
end
quad=R(J+1,J+1);
IX. ECUACIONES DIFERENCIALES ORDINARIAS
IX.1. PLANTEAMIENTO DEL PROBLEMA
Ecuacin del flujo gradualmente graduado.
2
Q
1
dy S0 S dy Q
= o = S0 n 2
dx Q 2T dx Q
cos 3 1
gA Qc
Donde:
Q = Descarga del flujo gradualmente variado para la profundidad actual y
Qn = Descarga normal para una profundidad igual a y
Qn = Descarga critica para una profundidad igual a y
1 n
dy y
= S0 3
dx y
1 c
y
Para canales anchos rectangulares y usando la formula de Chezy
3
y
1 n
dy y
= S 0 3
dx y
1 c
y
Donde:
y =
yn = Tirante normal
yc = Tirante critico
a. Introduccin
Este mtodo permite la construccin de las aproximaciones a la solucin del problema inicial
y = f(t,y) con y(a) = y0 en [a, b] dadas por
c. Cdigo en Matlab
function E=euler2(funcion,a,b,ya,M)
%Datos:
% - funcion = Funcion almacenada como cadena de caracteres
% 'funcion'
% - a y b = Extremos derecho e izquierdo del intervalo
% - ya = Condicion inicial y(a)
% - M = Numero de pasos
%Resultados:
% - E = [T' Y'] siendo T el vector de las abcisas e
% Y el vector de las ordenadas
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
Y(j+1)=Y(j)+h*feval(funcion,T(j),Y(j));
end
E=[T' Y'];
a. Introduccin
Este mtodo permite calcular la construccin de las aproximaciones a la solucin del
problema inicial y = f(t,y) con y(a) = y0 en [a, b] dadas por
h
yk+1 = yk + --- ( f (tk,yk) + f (tk+1,yk + f (tk,yk))) para k = 0, 1, , M-1.
2
b. Algoritmo
Entrada f,a,b,ya,M
Salida funcion H
Pasos computacionales:
Condiciones iniciales; Sea h = (b-a)/M;
T = matriz nula(1,M+1);
Y = matriz nula(1,M+1);
T = a:h:b;
Y(1) = ya;
Para j = 1 hasta M evaluar
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);
Termina
H=[T' Y'];
c. Cdigo en Matlab
function H=heun(f,a,b,ya,M)
%Datos
% - f es la funcion almacenada como una cadena de caracteres 'f'
% - a y b son los extremos izquierdo y derecho del intervalo
% - ya es la condicion inicial y(a)
% - M es el numero de pasos
%Resultados
% - H=[T' Y'] siendo T el vector de las abcisas e
% Y el vector de las ordenadas
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
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'];
a. Introduccin
b. Algoritmo
Entrada df,a,b,ya,M
Salida funcion T4
Pasos computacionales:
Condiciones iniciales; Sean h = (b-a)/M;
T = matriz nula(1,M+1);
Y = matriz nula(1,M+1);
T = a:h:b;
Y(1) = ya;
Para j = 1 hasta M evaluar
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)));
Termina
T4=[T' Y']
c. Cdigo en Matlab
function T4=taylor(df,a,b,ya,M)
%Datos
% - df=[y' y'' y''' y'''']almacenada como una cadena de caracteres
% 'df' siendo y'=f(t,y)
% - a y b son los extremos derecho e izquierdo del intervalo
% - ya es la condicion inicial y(a)
% - M es el numero de pasos
%Resultados
% - T4=[T' Y'] siendo T el vector de las abcisas e
% Y el vector de las ordenadas
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'];
a. Introduccin
Este mtodo permite la aproximacin a la solucin del problema de valor inicial y = f(t,y)
con y(a) = y0 en [a, b] usando la frmula;
h
yk+1 = yk + --- ( k1 + 2k2 + 2k3 + k4 ).
6
b. Algoritmo
Entrada f,a,b,ya,M
Salida funcion R
Pasos computacionales:
Condiciones iniciales; Sean h = (b-a)/M;
T=matriz nula(1,M+1);
Y=matriz nula(1,M+1);
T=a:h:b;
Y(1)=ya;
Para j = 1 hasta M evaluar
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;
Termina
Calcula el valor de R = [T' Y']
c. Cdigo en Matlab
function [T,Z]=rks4(F,a,b,Za, M)
%Datos
% - F es la funcin almacenada como una cadena de caracteres 'F'
% - a son los extremos derecho e izquierdo del intervalo
% - Za=[x(a) y(a)] es la condicin inicial
% - M es el numero de pasos
%Resultados
% - T es el vector de los nodos
% - Z=[x1(t) . . . xn(t)]donde xk(t) es la aproximacin
% a la k-sima variable independiente
h=(b-a)/M;
T=zeros(1,M+1);
Z=zeros(M+1,length(Za));
T=a:h:b;
Z(1,:)=Za;
for j=1:M
k1=h*feval(F,T(j),Z(j,:));
k2=h*feval(F,T(j)+h/2,Z(j,:)+k1/2);
k3=h*feval(F,T(j)+h/2,Z(j,:)+k2/2);
k4=h*feval(F,T(j)+h,Z(j,:)+k3);
Z(j+1,:)=Z(j,:)+(k1+2*k2+2*k3+k4)/6;
end
a. Introduccin
h
pk+1 = yk + --- ( -9fk-3 + 37fk-2 - 59fk-1 + 55f k ).
24
y el valor corrector
h
yk+1 = yk + --- ( fk-2 - 5fk-1 + 19fk + 9f k+1 ).
24
b. Algoritmo
Entrada f,T,Y
Salida A
Pasos computacionales:
Condiciones iniciales; Sea n = longitud de (T);
c. Cdigo en Matlab
function A=abm(f,T,Y)
%Datos
% - f es la funcion almacenada como una cadena de caracteres 'f'
% - T es el vector de abcisas; su dimensin es el numero de pasos
% - Y es el vector de las ordenadas
%Observacin
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el mtodo RK4
%Resultado
% - A=[T' Y'] siendo T el vector de las abcisas
% - Y el vector de las ordenadas
n=length(T);
if n<5, returm, end;
F=zeros(1,4);
F=feval(f,T(1:4),Y(1:4));
h=T(2)-T(1);
for k=4:n-1
%Predictor
p=Y(k)+(h/24)*(F*[-9 37 -59 55]');
T(k+1)=T(1)+h*k;
F=[F(2) F(3) F(4) feval(f,T(k+1),p)];
%Corrector
Y(k+1)=Y(k)+(h/24)*(F*[1 -5 19 9]');
F(4)=feval(f,T(k+1),Y(k+1));
end
A=[T' Y'];
a. Introduccin
4h
pk+1 = yk-3 + --- ( 2fk-2 - fk-1 + 2f k ).
3
la modificacin
y k - pk
mk+1 = pk+1 + 28 ------------- fk+1 = f(tk+1 , mk+1).
29
y el valor corrector
h
yk+1 = yk-1 + --- ( fk-1 + 4fk + f k+1 ).
3
b. Algoritmo
Entrada f,T,Y
Salida funcion M
Pasos computacionales:
Condiciones iniciales; Sea n = longitud (T);
Si n < 5 termina el ciclo,
termina.
F = matriz nula(1,4);
F = evaluar(f,T(1 hasta 4),Y(1 hasta 4));
h = T(2)-T(1);
pold = 0;
yold = 0;
Para k = 4 hasta n-1
El predictor es: pnew = Y(k-3)+(4*h/3)*(F(2 hasta 4)*[2 -1 2]');
El modificador es: pmod = pnew+28*(yold-pold)/29;
T(k+1)=T(1)+h*k;
F=[F(2) F(3) F(4) feval(f,T(k+1),pmod)];
El corrector es: Y(k+1)=Y(k-1)+(h/3)*(F(2 hasta 4)*[1 4 1]');
pold=pnew;
yold=Y(k+1);
F(4)= evaluar(f,T(k+1),Y(k+1));
Termina
c. Cdigo en Matlab
function M=milne(f,T,Y)
%Datos
% - f es la funcion almacenada como una cadena de caracteres 'f'
% - T es el vector de abcisas; su dimensin es el numero de pasos
% - Y es el vector de las ordenadas
%Observacin
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el mtodo RK4
%Resultado
% - M=[T' Y'] siendo T el vector de las abcisas
% - Y el vector de las ordenadas
n=length(T);
if n<5, returm, end;
F=zeros(1,4);
F=feval(f,T(1:4),Y(1:4));
h=T(2)-T(1);
pold=0;
yold=0;
for k=4:n-1
%Predictor
pnew=Y(k-3)+(4*h/3)*(F(2:4)*[2 -1 2]');
%Modifier
pmod=pnew+28*(yold-pold)/29;
T(k+1)=T(1)+h*k;
F=[F(2) F(3) F(4) feval(f,T(k+1),pmod)];
%Corrector
Y(k+1)=Y(k-1)+(h/3)*(F(2:4)*[1 4 1]');
pold=pnew;
yold=Y(k+1);
F(4)=feval(f,T(k+1),Y(k+1));
end
M=[T' Y'];
IX.2.7. Mtodo de Hamming
a. Introduccin
-yk-2 +9yk 3h
yk+1 = ---------------- + ------ (-fk-1 + 2fk + f k+1 ).
8 8
b. Algoritmo
Entrada f,T,Y
Salida funcion H
Pasos computacionales:
Condiciones iniciales; Sea n=longitud(T);
Si n<5, regresa, sino
termina el ciclo.
F=matriz nula(1,4);
Evalua la funcin: F=feval(f,T(1 hasta 4),Y(1 hasta 4));
h=T(2)-T(1);
pold=0;
cold=0;
c. Cdigo en Matlab
function H=hamming1(f,T,Y)
%Datos
% - f es la funcion almacenada como una cadena de caracteres 'f'
% - T es el vector de abcisas; su dimensin es el numero de pasos
% - Y es el vector de las ordenadas
%Observacin
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el mtodo RK4
%Resultado
% - H=[T' Y'] siendo T el vector de las abcisas
% - Y el vector de las ordenadas
n=length(T);
if n<5, returm, end;
F=zeros(1,4);
F=feval(f,T(1:4),Y(1:4));
h=T(2)-T(1);
pold=0;
cold=0;
for k=4:n-1
%Predictor
pnew=Y(k-3)+(4*h/3)*(F(2:4)*[2 -1 2]');
%Modifier
pmod=pnew+112*(cold-pold)/121;
T(k+1)=T(1)+h*k;
F=[F(2) F(3) F(4) feval(f,T(k+1),pmod)];
%Corrector
cnew=(9*Y(k)-Y(k-2)+3*h*(F(2:4)*[-1 2 1]'))/8;
Y(k+1)=cnew+9*(pnew-cnew)/121;
pold=pnew;
cold=cnew;
F(4)=feval(f,T(k+1),Y(k+1));
end
H=[T' Y'];
X. SOLUCION NUMERICA DE ECUACIONES EN DERIVADAS
PARCIALES
En ingeniera las ecuaciones elpticas se usan para caracterizar problemas de estado estable
(independiente del tiempo) y con valores en la frontera; por ejemplo:
2u( x, y ) 2u( x, y )
+ + f ( x , y ) u ( x, y ) = g ( x, y ) ; Ecuacin de Helmholts
x 2 y 2
2 u ( x, y ) 2 u ( x , y )
+ = g ( x, y ) ; Ecuacin de Poisson
x 2 y 2
Donde, g ( x, y ) es la funcin que describe la entrada del problema en la regin R cuya
frontera denotaremos por S, cuando g ( x, y ) = 0
2 u ( x, y ) 2 u ( x, y )
+ = 0 ; para 0 x < 1 y 0 < y < 1 Ecuacin de la Laplace
x 2 y 2
Cuando la temperatura dentro de la regin esta determinada por la distribucin de
temperaturas en la frontera de la regin, la condicin de frontera de Dirichlet y esta dada
por:
u( x, y ) = f ( x, y ) , para toda (x,y) en S
Donde:
u(x,y) = rgimen permanente de la distribucin de flujo o temperatura en una regin.
k
k'= = coeficiente de conductividad trmica (cal/s cm C)
k = coeficiente de conductividad trmica
= densidad del material
= calor especifico
Condiciones de frontera
u ( x,0) = f 1 ( x ) ; para y = 0 y 0 x 1 (abajo)
u ( x,1) = f 2 (x ) ; para y = 1 y 0 x 1 (arriba )
u (0, y ) = f 3 ( x ) ; para x = 0 y 0 y 1 (a la izquierda )
u (1, y ) = f 4 ( x ) ; para x = 1 y 0 y 1 (a la derecha)
X.1.2.1. Modelo unidimensional del flujo de calor en un alambre (barra larga y delgada)
aislado de longitud L
u ( x, t ) 2 u ( x, t )
k '' = 0 ; para 0 x < L y 0 < t <
t x 2
Donde:
u(x,t) = temperatura en la posicin x del alambre en el instante t.
k
k''= = coeficiente de difusividad trmica y esta determinado por las propiedades de
conductividad del calor del material de que esta compuesta la barra y se supone que es
independiente de la posicin de la barra.
Ejemplo:
a). Modelo unidimensional de la cuerda vibrante (ecuacin de la onda)
Supongamos que una cuerda elastica de longitud L se estira tensamente entre dos soportes
al mismo nivel horizontal. Si la cuerda se pone en movimiento de tal marera que vibre en
un plano vertical, entonces el desplazamiento vertical u(x,t) de un punto x en el tiempo t
satisface la ecuacin diferencial parcial:
2 u ( x, t ) 1 2 u ( x, t )
= 0 ; para 0 x < L y 0 < t < , siempre y cuando los efectos
x 2 c t 2
de resistencia sean despreciables y la amplitud no sea muy grande.
Donde:
u(x,t) = desplazamiento de la cuerda
T
c= = constante
T = tensin de la cuerda
= masa de la cuerda por unidad de longitud
b. Algoritmo
Entrada: f1, f2, f3, f4, a, b, h, tol, max1Y.
Salida: U.
Pasos computacionales:
Determinar el incremento en el eje X, usando el cociente del valor del extremo
del eje con el tamao de paso, sumarle una unidad por el tratamiento que
Matlab tiene acerca del inicio de la malla computacional.
Determinar el incremento en el eje Y, usando el cociente del valor del extremo
del eje con el tamao de paso, sumarle una unidad por el tratamiento que
Matlab tiene acerca del inicio de la malla computacional.
Discretizacin del problema: clculo del valor inicial en los puntos interiores de
la malla, definido como el valor de la media de los 2n + 2m 4 valores en el
contorno dado por f1,f2,f3,f4.
Declaracin de la malla solucin, incluyendo el valor inicial en cada nodo.
Asignar los valores de la condicin de frontera correspondientes a las partes
superior, inferior, izquierda y derecha de la malla solucin.
Calcular los valores de los nodos que se encuentran en las esquinas de las
mallas, dependiendo de la posicin de la esquina, utilizar:
u1,1 =( u2,1+u1,2)/2; u1,m =( u2,m+u1,m-1)/2; un,1 =( un-1,1+un,2)/2;
u1,1 =( un-1,m+un,m-1)/2
Obtencin del parmetro de sobrerelajacin, utilizando:
w = 4/(2+sqrt(4-(cos(pi/(n-1))+cos(pi/(m-1)))^2));
Iniciar el proceso iterativo para calcular el valor residual de cada uno de los
nodos de la malla:
relx = w*(U(i,j+1)+U(i,j-1)+U(i+1,j)+U(i-1,j)-4*U(i,j))/4
donde i es la posicin del nodo en el eje de las abscisas y j declara la
posicin que tiene el nodo en el eje de las ordenadas.
El proceso se interrumpe cuando el trmino residual se aproxima o reduce a
cero.
Debido al tratamiento de Matlab, invertir la matriz solucin (malla
computacional) y graficar.
c. Cdigo en Matlab
function U=dirich(f1,f2,f3,f4,a,b,h,tol,max1)
% ________________________________________________________
% Esta funcion encuentra la solucin de Dirichlet a la ecuacion
% de Laplace
% u (x, y) + u (x, y) = 0,
% xx yy
%
% con las condiciones de frontera:
%
% u(x, 0) = f1, u(x, b) = f2 para toda 0 <= x <= a, y
%
% u(0, y) = f3, u(a, y) = f4 para toda 0 <= y <= b.
%
% Los subndices xx y yy indican la segunda derivada parcial de u(x,y)
% con respecto a x y y, respectivamente.
%
% Sintaxis para utilizar la funcion:
% >> U = dirich(f1,f2,f3,f4,a,b,h,tol,max1)
%
% Parametros de entrada:
% f1: es el valor de frontera correspondiente a la parte inferior %
de la misma.
% f2: es el valor de frontera correspondiente a la parte superior %
de la misma.
% f3: es el valor de frontera correspondiente a la parte izquierda %
de la misma.
% f4: es el valor de frontera correspondiente a la parte derecha %
de la misma.
% a: es el extremo superior de [0,a] (intervalo del valores en el %
eje de las abscisas).
% b: es el extremo superior de [0,b] (intervalo del valores en el %
eje de las ordenadas).
% h: tamao del paso.
% tol: tolerancia de la convergencia.
% max1: numero maximo de iteraciones,
% Parametros de salida:
% U: es la matriz solucion.
% Requerimientos:
% f1,f2,f3,f4: deben ser manejados como funciones
% independientes del este script y deben contener los valores
% numericos correspondientes a cada condicion de frontera.
% Ejemplo:
% >> U = dirich(f1, f2, f3, f4, 4, 4, 0.1, 0.0001, 200)
% _______________________________________________________
n=fix(a/h)+1;
m=fix(b/h)+1;
ave=(a*(feval(f1,0)+feval(f2,0))+b*(feval(f3,0)+
feval(f4,0)))/(2*a+2*b);
U=ave*ones(n,m);
U(1,1:m)=feval(f3,0:h:(m-1)*h)';
U(n,1:m)=feval(f4,0:h:(m-1)*h)';
U(1:n,1)=feval(f1,0:h:(n-1)*h);
U(1:n,m)=feval(f2,0:h:(n-1)*h);
U(1,1)=(U(1,2)+U(2,1))/2;
U(1,m)=(U(1,m-1)+U(2,m))/2;
U(n,1)=(U(n-1,1)+U(n,2))/2;
U(n,m)=(U(n-1,m)+U(n,m-1))/2;
w = 4/(2+sqrt(4-(cos(pi/(n-1))+cos(pi/(m-1)))^2));
err = 1;
cnt = 0;
while((err > tol) & (cnt <= max1))
err=0;
for j = 2:m-1
for i = 2:n-1
relx = w*(U(i,j+1)+U(i,j-1)+U(i+1,j)+U(i-1,j)-4*U(i,j))/4;
U(i,j) = U(i,j)+relx;
if (err <= abs(relx))
err = abs(relx);
end
end
end
cnt=cnt+1;
end
U=flipud(U');
a. Introduccin
b. Algoritmo
Entrada: f, c1, c2, a, b, c, n, m.
Salida: U.
Pasos computacionales:
Determinar el incremento en el eje correspondiente a la variable espacial.
Determinar el incremento en el eje correspondiente a la variable temporal.
De la ecuacin general de diferencias explcitas progresivas:
ui,j+1=(1-2r)ui,j +r(ui-1,j+ui+1,j)
obtener la variable r y el trmino (1-2r).
Declaracin de la malla solucin, incluyendo el valor inicial de cada nodo como
cero.
Asignar los valores de la condicin de frontera correspondientes a las partes
inferior y superior de la malla solucin.
Calcular los valores de los nodos que se encuentran en la primera fila.
Iniciar el proceso iterativo para calcular el valor de cada uno de los nodos de la
malla, utilizando la ecuacin general de diferencias explcitas progresivas.
Debido al tratamiento de Matlab, invertir la matriz solucin (malla
computacional) y graficar.
c. Cdigo en Matlab
function U = forwdif(f,c1,c2,a,b,c,n,m)
% _____________________________________________________
% Funcion que tu puedes aplicar para usar el metodo explicito de
% diferencias finitas.
% Parametros de entrada:
% f = contiene la funcion a calcular.
% c1 = es la primer condicion de frontera u(0,t).
% c2 = es la segunda condicion de frontera u(a,t).
% a = es la longitud de la variable espacial.
% b = es la longitud de la variable temporal
% c = Es la constante de Courant constant (depende de la
% ecuacion).
% m = numero de columnas.
% n = numero de filas.
% Parametros de salida:
% U = matriz solucion
% _____________________________________________________
h = a / ( n - 1 );
k = b / ( m - 1 );
r = c ^ 2 * ( k / h ^ 2);
s = 1 - 2 * r;
U = zeros(n,m);
U(1,1:m) = 0;
U(n,1:m) = 0;
for j =2:m
for i =2:n-1
U(i,j)= s * U(i , j-1) + r * (U (i-1 , j-1) + U(i+1, j-1));
end
end
U = U';
a. Introduccin
b. Algoritmo
Entrada: f, c1, c2, a, b, c, n, m.
Salida: U.
Pasos computacionales:
Determinar el incremento en el eje correspondiente a la variable espacial.
Determinar el incremento en el eje correspondiente a la variable temporal.
De la ecuacin en diferencias implcitas:
-rui-1,j+1+(2+2r)ui,j+1-rui+1,j+1=rui-1,j+(2-2r)ui,j +ui+1,j
obtener la variable r y los trminos (2-2r) y (2+2r) .
Declaracin de la malla solucin, incluyendo el valor inicial de cada nodo como
cero.
Asignar los valores de la condicin de frontera correspondientes a las partes
inferior y superior de la malla solucin.
Calcular los valores de los nodos que se encuentran en la primera fila.
Formar la diagonal principal para la resolucin del sistema AX = B.
Crear un arreglo numrico (elementos de la diagonal principal de la matriz de
coeficientes) y asignar el valor del trmino (2+2r) a cada elemento del mismo;
en los extremos del arreglo asignar como valo, la unidad.
Crear un arreglo numrico unitario negativo de dimensiones 1 x n-1
(subdiagonal de la matriz de coeficientes). El ltimo elemento del arreglo
deber tener un valor nulo.
Crear un arreglo numrico unitario negativo de dimensiones 1 x n-1
(superdiagonal de la matriz de coeficientes). El primer elemento del arreglo
deber tener un valor nulo.
Crear una matriz computacional de dimensiones n x m (trminos independientes
del sistema lineal), donde al primer y el ltimo elemento de la primera columna
se les asignar los valores correspondientes a las condiciones de frontera
inicial y final respectivamente; mediante iteraciones y utilizando
bi=ui-1,j-1+ui+1,j-1+(2/r-2)ui,j-1;
obtener los valores correspondientes a las filas correspondientes a la primer
columna. Resolver el sistema tridiagonal para cada columna y los valores
conseguidos, enviarlos a la matriz solucin del mtodo de Crank-Nicholson.
Iterar hasta obtener todos los valores correspondientes a la dimension de la
matriz solucin.
Debido al tratamiento de Matlab, invertir la matriz solucin (malla
computacional) y graficar.
c. Cdigo en Matlab
function U=crnich(f,c1,c2,a,b,c,n,m)
%Metodo de Crank-Nicholson para la ecuacion del calor
%Entradas
% - f = u(x,0) como una cadena de caracteres 'f'
% - c1 = u(0,t) y c2 = u(a,t)
% - a y b extremos derechos de los intervalos [0,a] y [0,b]
% - c constante de la ecuacion del calor
% - n y m numero de nodos en [0,a] y [0,b]
%Salidas
% - U matriz solucion
h=a/(n-1);
k=b/(m-1);
r=c^2*k/h^2;
s1=2+2/r;
s2=2/r-2;
U=zeros(n,m);
U(1,1:m)=c1;
U(n,1:m)=c2;
U(2:n-1,1)=feval(f,h:h:(n-2)*h)';
Vd(1,1:n)=s1*ones(1,n);
Vd(1)=1;
Vd(n)=1;
Va=-ones(1,n-1);
Va(n-1)=0;
Vc=-ones(1,n-1);
Vc(1)=0;
Vb(1)=c1;
Vb(n)=c2;
for j=2:m
for i=2:n-1
Vb(i)=U(i-1,j-1)+U(i+1,j-1)+s2*U(i,j-1);
end
X=trisys(Va,Vd,Vc,Vb);
U(1:n,j)=X';
end
U=U'
a. Introduccin
El mtodo de diferencias finitas puede ser usado para resolver ecuaciones del
utt(x,t) = c2uxx(x,t)
en
R = { (x,t) : 0 x a, 0 t b}
Como por ejemplo la ecuacin de la onda, con u(0,t) = 0, u(a,t) = 0 para 0 t b y
u(x,0) =f(x), u(x,0) = g(x) para 0 x a.
b. Algoritmo
Entrada: funcion_f, funcion_g, a, b, c, n, m.
Salida: U.
Pasos computacionales:
Determinar el incremento en el eje correspondiente a la variable espacial.
Determinar el incremento en el eje correspondiente a la variable temporal.
De la ecuacin en diferencias finitas:
ui,j+1 = (2-2r2)ui,j +r2(ui+1,j+ ui-1,j,)-rui,j-1
obtener la variable r y los trminos (2-2r2).
A partir de la ecuacin de los elementos de la segunda fila:
ui,2=(1-r2)fi +kgi+(r2/2)(fi+1+fi-1)
Calcular los valores de (1-r2) y r2/2.
Declaracin de la malla solucin, incluyendo el valor inicial de cada nodo como
cero.
Iterar tanto la primer como la segunda fila de la malla solucin; los valores de
los elementos de la primer fila se obtendran del valor que toma la funcin f,
correspondiente al valor de la variable independiente d el nodo anterior al nodo
donde se desea conocer el valor. Para determinar los valores de los elementos
de la segunda fila, se debe aplicar la ecuacin que lleva el mismo nombre.
Iterar la ecuacin de diferencias finitas para encontrar los valores de los
elementos de la matriz solucin.
c. Cdigo en Matlab
function U = finedif(funcion_f,funcion_g,a,b,c,n,m)
%Resolucion de la ecuacion de la onda por el metodo de las diferencias
%finitas
%Entradas
% - funcion_f = u(x,0) como una cadena de caracteres 'funcion_f'
% - funcion_g = ut(x,0) como una cadena de caracteres 'funcion_g'
% - a y b extremos superiores de los intervalos [0,a] y [0,b]
% - c constante de la ecuacion de la onda
% - n y m numero de nodos en [0,a] y [0,b]
%Salidas
% - U matriz solucion
h = a/(n-1);
k = b/(m-1);
r = c*k/h;
r2=r^2;
r22=r^2/2;
s1 = 1 - r^2;
s2 = 2 - 2*r^2;
U = zeros(n,m);
for i=2:n-1
U(i,1)=feval(funcion_f,h*(i-1));
U(i,2)=s1*feval(funcion_f,h*(i-1))+k*feval(funcion_g,h*(i-1)) ...
+r22*(feval(funcion_f,h*i)+feval(funcion_f,h*(i-2)));
end
for j=3:m,
for i=2:(n-1),
U(i,j) = s2*U(i,j-1)+r2*(U(i-1,j-1)+U(i+1,j-1))-U(i,j-2);
end
end
U=U';
REFERENCIAS BIBLIOGRFICAS
Mathews H, John. METODOS NUMERICOS CON MATLAB. Editorial
Prentice Hall. Universidad de Sevilla. 2000.
Nakamura, Shoichiro. ANALISIS NUMERICO Y VISUALIZACION
GRAFICA CON MATLAB. Pearson educacin. Universidad de Ohio.
2001.
Garca, Javier., APRENDA MATLAB COMO SI ESTUVIERA EN
PRIMERO. Macmillan. Universidad Politcnica de Madrid, 2003.
Rodrguez, Ignacio, et all. TALLER DE PROGRAMACION DE MATLAB.
XIII Foro de Matemticas en la D. A. C. B. UJAT. 2002.
Sigmon, Kermit. INTRODUCCION AL MATHLAB. Departamento de
Matemticas de la Universidad de Florida. 1992.
Brazalez, Alfonso. TUTORIAL COMPLETO DE MATLAB, articulo de
divulgacin Universidad de Sevilla. 2001.
D. Hanselman and B. Litte_eld, THE STUDENT EDITION OF MATLAB:
version 4, Prentice-Hall, 1995.
A. Biran and M. Breiner, MATLAB FOR ENGINEERS, Addison-Wesley,
1995.
Eva P art-Enander, Anders Sj oberg, Bo Melin and Pernilla Isaksson,
THE MATLAB HANDBOOK, Addison-Wesley, 1996.
W. H. Press, S. A. Teukolsky, W. T. Vetterling and B. P. Flannery,
NUMERICAL RECIPES IN FORTRAN, 2da. Edicin.
ANEXO
RESUMEN
A travs de este proyecto se llevo a cabo en el ambiente del programa Matlab, el desarrollo
de diferentes cdigos, para la solucin de problemas de metodologa numrica, segn el tipo
de problema sobre hidrulica que se pretenda analizar y resolver. De igual manera se
desarrollo un manual de usuario que contiene un breviario del objetivo principal de cada
codigo, as como su pseudocdigo y algoritmo que nos explican la actividad paso a paso que
desarrolla cada programa.
2 Profesor Investigador de la Escuela Superior de Ingeniera y Arquitectura, Unidad Zacatenco, del Instituto Politcnico Nacional. Edificio No. 12 de
la Unidad Profesional Zacatenco, Col. Lindavista, C. P. 07738, Mxico D. F. 5729-6000, Ext. 53-037.
3 Becario PIFI Escuela Superior de Ingeniera y Arquitectura, Unidad Zacatenco, del Instituto Politcnico Nacional. Edificio No. 12 de la Unidad