Académique Documents
Professionnel Documents
Culture Documents
PARTICIPANTES:
RESUMEN 4
INTRODUCCIÓN 4
METODOS Y MATERIALES 5
IMPACTO 6
A través de este proyecto se llevo a cabo en el ambiente del programa Matlab, el desarrollo
de diferentes códigos, para la solución de problemas de metodología numérica, según el tipo
de problema sobre hidráulica 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 pseudocódigo y algoritmo que nos explican la actividad paso a paso que
desarrolla cada programa.
INTRODUCCION
Los métodos numéricos son fundamentales para el desarrollo de la programación numérica
de problemas en el campo de la hidráulica y en general en todo el ámbito de la ingeniería.
Es por eso, que a través del desarrollo de éstos códigos de análisis númerico, 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 guía de
este trabajo, ahorre tiempo en la codificación 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 códigos, de los cuales nos
podremos auxiliar en la resolución de problemas hidráulicos, así como una guía
práctica que nos permite conocer la utilidad de cada uno de los métodos
desarrollados, su funcionamiento, su pseudocódigo (lista de acciones del programa),
su algoritmo (secuencia lógica y matemática de los pasos que ejecuta el programa),
así como la codificación detallada de cada uno de éstos.
Por lo antes expuesto se puede considerar, que el proyecto es de gran importancia púes sus
resultados pueden utilizarse de una amplia forma, dentro del medio educativo, y de
investigación, dentro del desarrollo de otros proyectos relacionados con la Hidráulica, cuyo
campo acción 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 análisis numérico, para así a partir de ellos delimitar cada uno
de los elementos que se debían de analizar y desarrollar para generar los nuevos códigos en
todos los temas de los Métodos Numéricos que nos permitieran su aplicación para resolver
problemas en el campo hidráulico, para diferentes condiciones y situaciones que se
representaron, en dichos programas, lo cual también integran los resultados de este
proyecto. Lo antes expuesto se describe detalladamente en los diez capítulos que se
presentan después de la presentación del IMPACTO del presente proyecto.
De igual manera de cada sección se generó un menú que permitió realizar la evaluación de
los resultados generados, de manera rápida y concisa, demostrando la efectividad de las
metodologías empleadas.
AMBIENTE MATLAB.
Para llevar a cabo la aplicación de dicha metodología fue necesario, realizar un estudio del
comportamiento de los componentes que utilizaríamos en matlab, para desarrollar el estudio
de los scrips o códigos.
MATLAB es un programa para realizar cálculos numéricos con vectores y mátrices. Como
caso particular puede también trabajar con números escalares, tanto reales como complejos.
Una de las capacidades más atractivas es la de realizar una amplia variedad de gráficos en
dos y tres dimensiones. MATLAB tiene también un lenguaje de programación propio. 1
Es un gran programa para cálculo técnico y científico. Para ciertas operaciones es muy
rápido, cuando puede ejecutar sus funciones en código nativo con los tamaños más
adecuados para aprovechar sus capacidades de vectorización. En otras aplicaciones resulta
bastante más lento que el código equivalente desarrollado en C, C++ o Fortran. Sin
embargo, siempre es una magnífica herramienta de alto nivel para desarrollar aplicaciones
técnicas, fácil 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
investigación, dentro del desarrollo de otros proyectos relacionados con la Hidráulica, cuyo
campo acción es muy grande.
En sistemas que permiten procesos múltiples, como el UNIX, será conveniente tener activos a
la vez MATLAB y el editor local. Si se trabaja en una estación de trabajo con ventanas
múltiples será deseable tener activos MATLAB en una ventana y el editor en otra. Los detalles
de la instalación local se pueden obtener del centro de cálculo correspondiente, o consultando
al instructor.
Hay varias formas diferentes para introducir una matriz en MATLAB. A saber:
_ Introduciendo una lista explícita de elementos,
_ Generándola mediante funciones y declaraciones,
_ Creándola en un archivo .m,
_ Cargándola 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 números 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 más sencillo corregir errores.
Las entradas individuales de una matriz o de un vector se pueden obtener poniendo los índices
entre paréntesis 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 también a escalares (matrices 1_1). Si los tamaños
de las matrices son incompatibles para la operación 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
adición, sustracción, división y multiplicación). En esta situación se opera el escalar con cada
término de la matriz.
La instrucción who muestra las variables que se encuentran en el espacio de trabajo. Para
eliminar una variable de la memoria se utiliza la instrucción clear nombre variable. Si se
escribe sólo clear se borran todas las variables no permanentes.
Las instrucciones se repetirán mientras la relación sea cierta. Por ejemplo, dado un número 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 relación
instrucciones
end
Las instrucciones se ejecutarán sólo si la relación es cierta.
Una posibilidad muy útil es usar las echas arriba/abajo para recuperar los comandos previos.
Se puede, por tanto, recuperar una línea de comandos previa, editarla, y ejecutarla revisada.
Para pequeñas rutinas, esto es más conveniente que usar un archivo.m lo que requiere moverse
entre MATLAB y el editor. Por ejemplo, el número de operaciones para el cálculo de la
inversa de matrices de varios tamaños podrá ser comparado recuperando, editando y
ejecutando repetidamente:
a = rand(8); flops(0), inv(a); flops
Si se desea comparar las gráficas 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 línea 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 específicas para un problema concreto, y, a partir de su
introducción, tendrán el mismo rango que las demás funciones del sistema.
Las variables en las funciones son locales. Veremos, en primer lugar, un ejemplo sencillo de
archivo de función:
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 función disp.
Por ejemplo: disp('Este mensaje se está mostrando aquí')
Los mensajes de error se muestran mejor con la función error ;
error('Lo siento, la matriz debe ser simétrica')
I.14. Hardcopy.
La forma más sencilla de obtener una hardcopy1 es con la instrucción diary. La orden diary
nombre de archivo hace que todo lo que aparezca a continuación en pantalla (excepto los
gráficos) 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 instrucción 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. Gráficos.
MATLAB puede producir gráficos planos y gráficos de malla de superficies tridimensionales.
Para ver algunas de sus posibilidades escriba plotdemo.
Gráficos planos. La instrucción plot crea gráficos en el plano XY; si x e y son vectores de la
misma longitud, la orden plot(x,y) accede a la pantalla gráfica y realiza un gráfico plano de los
elementos de x contra los elementos de y. Por ejemplo, podemos dibujarla gráfica de la
función 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 partición 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 partición. Para volver a la
pantalla alfanumérica desde la gráfica, se pulsa cualquier tecla. Por el contrario, para acceder a
la pantalla gráfica, se usa la orden shg (show graph). Si su máquina soporta ventanas múltiples
con una ventana gráfica aparte, puede desear mantener la ventana expuesta |aunque a un lado|
y la ventana alfanumérica activa.
Pueden ponerse títulos, 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 matemáticos en hidráulica, análisis de
aproximaciones y errores en los problemas.
II.1. Ecuación 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
∂σ 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. Además de considerar que el esfuerzo normal σ es igual a - p, según la ecuación 3.48,
la ecuación 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 ecuación 2.7 y sus componentes resultan ser
∂ q 1 µ
a= + (q • ∇)q = − g∇h − ∇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 también de Navier - Stokes en un sistema de
coordenadas cartesiano para un fluido newtoniano de viscosidad y densidad constante
(incompresible).
Para la dirección r
∂ vr ∂ v r vθ ∂ v r vθ2 ∂ 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 dirección θ
∂ 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 dirección 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 ingeniería es
necesario efectuar simplificaciones razonables que dan soluciones aproximadas con fines de
diseño, 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 tuberías
de diámetro constante y flujos permanentes y plenamente desarrollados.
III. RESOLUCION DE ECUACIONES NO LINEALES
III.1. PLANTEAMIENTO DEL PROBLEMA
c). Factor de fricción para tubos comerciales, en la región 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 fricción
ε = Rugosidad relativa del tubo
D = Diámetro de la tubería, en m
R = Numero de Reynolds
a. Introducción
b. Algoritmo
Entrada: f_nombre = Nombre de la funcion que define la ecuacion
p0 = Punto de partida, cercano a la solucion
Salida: it = Número de iteraciones realizadas
punto = Aproximación 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 iteración declarando puntos(1) = p0.
Para límite de iteraciones igual a 2 hasta el límite de iteraciones
*evaluación 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)
más é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 iteración es identica a el límite de iteraciones, entonces Indica que
se’excedió el número máximo de iteraciones’ y
Termina
Denota que Puntos=Puntos';
c. Código en Matlab
%Parametros de control
Tolerancia=0.000001; %Tolerancia
it_limite=5000; %Número máximo de iteraciones
%Inicia Iteración
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 número máximo de iteraciones')
end
Puntos=Puntos';
a. Introducción
El método de bisección es el más sencillo posible. Dada una función f real y continua en el
intervalo compacto I0 = [a; b] y que toma valores de signos contrario en a y b, esto es f(a) f(b)
< 0, el teorema de Bolzano asegura que f se anula en algún punto interior de I0.
El método de bisección calcula f(c) donde c = (a+b)/2 es el punto medio del intervalo. Si f
(c) = 0, hemos acabado, pero si no es así tiene el mismo signo que f(a) o f(b), es decir, en uno
de los dos intervalos [a; c] o [c; b] la función toma valores de signo contrario en los
extremos y por lo tanto contiene una raíz. Llamando ahora I1 a dicho intervalo estamos en la
situación anterior pero con I1 en lugar de I0, la ventaja es que la longitud de I1 es la mitad de
la I0. Repetimos el procedimiento de evaluar f en el punto intermedio de I1 y quedarnos con la
mitad I2 donde haya un cambio de signo en los valores de los extremos.
b. Algoritmo
Entrada: X a, X c, f unción.
Salida: Yb (solución aproximada o mensaje de fracaso)
Pasos computacionales:
*condiciones iniciales; Sean tolerancia= 0.0000001
it_ limite=300 (limite de iteraciones)
it = 0.
c. Código en Matlab
% METODO DE BISECCION.
% bisección(función, a,c)
% Datos
% - función : Definicion de la ecuación 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. Introducción
La intersección de ésta línea con el eje de las X representa una mejor estimación de la raíz.
El hecho de que se reemplace una línea curva por una línea recta da una “posición falsa” de la
raíz; de aquí el nombre del método de la falsa posición, o en latín, regula falsi. También se le
conoce como el método de la interpolación lineal.
Usando triángulos semejantes, la intersección de la línea 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 ecuación anterior reemplaza uno de los dos valores iniciales
Xl o Xu, que produzca un valor de la función.
b. Algoritmo
Entrada: a, c, f unción.
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 mínimo de dx;
dx =min(abs(dx),ac);
Criterios de parada, detenemos la iteración 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 cálculo de el error err = abs (b – a) / 2;
Evalúamos: yc f (c).
c. Código en Matlab
function [c]=regula(funcion,a,b)
% Datos
% - f es la función, 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
% - epsilón es la tolerancia para el valor de f en el cero
% - max1 es el numero máximo de iteraciones
% Resultados
% - c es el cero
% - yc=f(c)
% - err es el error estimado de la aproximación 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. Introducción
Este método consiste en un procedimiento iterativo para calcular valores aproximados de una
raiz o un cero de la ecuación f (x) = 0, partiendo de un punto conocido y cercano a la raíz
buscada.
Sea r una raiz de f (x) = 0 situada en el intervalo (a, b) y supóngase 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
aproximación inicial de r) viene dada por:
y – f(a) = f’(a)(x-a) (punto – pendiente)
Para determinar el punto de intersección de esta recta con el eje x, que se llamará a1 y que se
considera como la siguiente aproximación 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 aproximación 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
aproximación de r, se obtiene al hacer y = 0 en la ecuación (2), y asi se obtiene:
f(a1)
a2 = a1 - ----------- ; f’(a1)≠ o
f’’(a1)
Son muchos los casos en los cuales la fórmula anterior proporciona una sucesión de valores an
, que progresivamente se van acercando a la raíz exacta.
b. Algoritmo
Entrada: X 0 (aproximación inicial),
f unción.
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
*evaluación de funciones; Y f(x)
por lo que
y_driv = f(x+del_x) – y / del_x ;
x = Xb – y / y_driv;
Termina.
c. Código en Matlab
x = x0;
xb=x-999;
n=0;
del_x = 0.01;
a. Introducción
f(xn)(xn - xn-1)
xn+1 = xn - ------------------ ; n = 1, 2,….
f(xn) - f(xn-1)
La aplicación sucesiva de la iteración anterior no es siempre posible, puede ocurrir que algún
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 raíz de la ecuación f (x) = 0 dados los valores de po y
p1, próximos a la raíz.
El algoritmo construye una sucesión de aproximaciones p0, p1, p2….. pn..
Entrada: po, p1, f unción.
Salida: y (función evaluada en p1), p1 (valor de la aproximación a cero calculado por el método de la
secante), err, k.
Pasos:
*condiciones iniciales; Sean delta = tolerancia para p1 = 0.00001
epsilón =tolerancia para los valores de la
función= =0.0000001
max1 = numero máximo de iteraciones =300
c. Código en Matlab
%Datos
% - f es la función, introducida como una cadena de caracteres 'f'
% - p0 y p1 son las aproximaciones iniciales a un cero de la función
% - delta es la tolerancia para p1
% - epsilon es la tolerancia para los valores de la función
% - max1 es el numero máximo de iteraciones
% Resultados
% - p1 es la aproximación al cero,
% obtenida con el método de la secante
% - err es una estimación del error de p1
% - k es el numero de iteraciones realizadas
% - y es el valor de la función 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. Introducción
MATLAB dispone de funciones que minimizan y calculan raíces 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 raíces de funciones es la función fzero la cual encuentra raíces de
una función de una variable.
En la primera ecuación asumimos que el flujo sale del depósito 1, a la unión (punto2),
continuando al depósito más 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 presión es la atmosférica P = 0 y si se considera que el nivel del agua en los depósitos 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 ecuación asumidos que el flujo sale del deposito 1 hacia la unión (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 tubería =
4
f = Coeficiente de fricción, adimensional
L = Longitud de la tubería, en metros
D = Diámetro de la tubería, en metros
g = Aceleración de la gravedad = 9.81 m/s2
Z = Cota de la superficie libre del agua, en metros
a. Introducción
b. Algoritmo
Entrada: A, B.
Salida: X (matriz solución de AX = B).
Pasos computacionales:
Para q = 1 hasta N -1
Determina la fila pivote parcial para la columna q-
ésima
[Y,j]=valor máximo 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
solución o que no es única, y por tanto termina el ciclo,
Termina.
Proceso de eliminación 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 Sustitución 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. Código 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. Introducción
b. Algoritmo
Entrada: A, B.
Salida: X (matriz solución de AX = B).
Pasos computacionales:
c. Código 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
%Determinación 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. Introducción
c. Código 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 máximo de iteraciones
% Resultados:
% - X es una matriz de orden N x 1: la aproximación a la
% solución de AX = B
% generada por el método 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. Introducción
b. Algoritmo
Entrada:
Input -F es la función salvada en el M-file como F.m
JF is the Jacobian of F saved as the M-file JF.M
P es la aproximación inicial a la solución
delta es la tolerancia para P
epsilón es la tolerancia para F(P)
max1 es el número máximo de iteraciones.
c. Código 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. INTERPOLACIÓN Y APROXIMACIÓN POLINOMIAL
V.1. PLANTEAMIENTO DEL PROBLEMA
Cuando se tiene un conjunto de datos que han sido obtenidos de un experimento o por
observación de un fenómeno físico. Estos datos generalmente pueden considerarse como
coordenadas de puntos de una función f(x).
Existen diferentes métodos para encontrar un polinomio interpolador que ajuste de la mejor
forma posible un conjunto de puntos.
a. Introducción
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 ) =
j≠k
∏ (x − xj )
N
k
j =0
j≠k
b. Algoritmo
Entrada: X, Y.
Salida: C (matriz solución), 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 = obtención de coeficientes de los polinomios
(V,poly(X(j)))/(X(k)-X(j));
Termina.
Termina.
La columna k de L = V;
Termina.
Cálcula los coeficientes de polinomio interpolador
C=Y*L;
c. Código 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. Introducción
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 = obtención de coeficientes de los polinomios (C,poly(X(k)));
m = longitud de (C);
C(m) = C(m) + D(k,k);
Termina.
c. Código 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. Introducción
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. Código 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 aproximación
% - 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. Introducción
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. Código 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. Función
[A,B]=polyfit(X,Y,1)
a. Introducción
f ( x + 10 − k ) − f ( x − 10 − k )
f ' ( x ) ≈ Dk = , para k = 0,...., n
2(10 − k h)
Donde las iteraciones continúan hasta que:
Dn +1 − Dn ≥ Dn − Dn −1 O Dn − Dn −1 < tolerancia
b. Algoritmo
c. Código 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. Introducción
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. Código 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. Introducción
P ( x) = a0 + a1 ( x − x0 ) + a 2 ( x − x0 )( x − x1 ) + ..... + a N ( x − x0 )( x − x1 )....( x − x N −1 )
c. Código 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 sección transversal de un escurrimiento (A), es una actividad que se
requiere realizar para varios tareas dentro de la ingeniería de recurso hidráulicos, incluso en
el pronostico de avenidas y en el diseño de presas. A menos que los dispositivos sondeo
electrónicos están disponibles obtener perfiles continuos del fondo del cauce, el ingeniero
debe confiar de las dimensiones discretas de profundidad para calcular À. Un ejemplo de una
sección transversal del arroyo típica 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. Introducción
Aproxima la integral definida de la función 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 )
Calculándose f(x) en los puntos equidistantes xk=a+kh, para k=0,1,…..M con x0=a y
xM=b
b. Algoritmo
c. Código 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. Introducción
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 tamaño h=(b-a)/2. En esta situación 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 función 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 según se aumenta el numero de subintervalos de [a,b] y
tomando en la iteración J un conjunto de 2J+1 puntos equidistantes.
b. Algoritmo
c. Código 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. Introducción
Aproxima la integral definida de la función 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 función 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
Calculándose f(x) en los puntos equidistantes xk=a+kh para k=0,1,…2M con x0=a y x2M=b
b. Algoritmo
c. Código 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) están 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 método de
Romberg de manera que los elementos de la fila J-ésima de R son
b. Algoritmo
c. Código 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
Ecuación 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. Introducción
Este método permite la construcción de las aproximaciones a la solución del problema inicial
y’ = f(t,y) con y(a) = y0 en [a, b] dadas por
c. Código 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. Introducción
Este método permite calcular la construcción de las aproximaciones a la solución 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. Código 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. Introducción
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. Código 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. Introducción
Este método permite la aproximación a la solución del problema de valor inicial y’ = f(t,y)
con y(a) = y0 en [a, b] usando la fórmula;
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. Código en Matlab
function [T,Z]=rks4(F,a,b,Za, M)
%Datos
% - F es la función almacenada como una cadena de caracteres 'F'
% - a son los extremos derecho e izquierdo del intervalo
% - Za=[x(a) y(a)] es la condición 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 aproximación
% 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. Introducción
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. Código 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 dimensión es el numero de pasos
% - Y es el vector de las ordenadas
%Observación
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el método 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. Introducción
4h
pk+1 = yk-3 + --- ( 2fk-2 - fk-1 + 2f k ).
3
la modificación
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. Código 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 dimensión es el numero de pasos
% - Y es el vector de las ordenadas
%Observación
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el método 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. Método de Hamming
a. Introducción
-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 función: F=feval(f,T(1 hasta 4),Y(1 hasta 4));
h=T(2)-T(1);
pold=0;
cold=0;
c. Código 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 dimensión es el numero de pasos
% - Y es el vector de las ordenadas
%Observación
% - las cuatro primeras coordenadas de T e Y deben contener los
% valores iniciales calculados con el método 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 ingeniería las ecuaciones elípticas 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 ) ; Ecuación de Helmholts
∂x 2 ∂y 2
∂ 2 u ( x, y ) ∂ 2 u ( x , y )
+ = g ( x, y ) ; Ecuación de Poisson
∂x 2 ∂y 2
Donde, g ( x, y ) es la función que describe la entrada del problema en la región 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 Ecuación de la Laplace
∂x 2 ∂y 2
Cuando la temperatura dentro de la región esta determinada por la distribución de
temperaturas en la frontera de la región, la condición de frontera de Dirichlet y esta dada
por:
u( x, y ) = f ( x, y ) , para toda (x,y) en S
Donde:
u(x,y) = régimen permanente de la distribución de flujo o temperatura en una región.
k
k'= = coeficiente de conductividad térmica (cal/s cm C)
σρ
k = coeficiente de conductividad térmica
ρ = 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 posición x del alambre en el instante t.
k
k''= = coeficiente de difusividad térmica 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 posición de la barra.
Ejemplo:
a). Modelo unidimensional de la cuerda vibrante (ecuación 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 ecuación 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 = tensión 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 tamaño 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 tamaño de paso, sumarle una unidad por el tratamiento que
Matlab tiene acerca del inicio de la malla computacional.
Discretización del problema: cálculo 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.
Declaración de la malla solución, incluyendo el valor inicial en cada nodo.
Asignar los valores de la condición de frontera correspondientes a las partes
superior, inferior, izquierda y derecha de la malla solución.
Calcular los valores de los nodos que se encuentran en las esquinas de las
mallas, dependiendo de la posición 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
Obtención del parámetro de sobrerelajación, 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 posición del nodo en el eje de las abscisas y j declara la
posición que tiene el nodo en el eje de las ordenadas.
El proceso se interrumpe cuando el término residual se aproxima o reduce a
cero.
Debido al tratamiento de Matlab, invertir la matriz solución (malla
computacional) y graficar.
c. Código en Matlab
function U=dirich(f1,f2,f3,f4,a,b,h,tol,max1)
% ________________________________________________________
% Esta funcion encuentra la solución 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 subíndices 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: tamaño 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. Introducción
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 ecuación general de diferencias explícitas progresivas:
ui,j+1=(1-2r)ui,j +r(ui-1,j+ui+1,j)
obtener la variable r y el término (1-2r).
Declaración de la malla solución, incluyendo el valor inicial de cada nodo como
cero.
Asignar los valores de la condición de frontera correspondientes a las partes
inferior y superior de la malla solución.
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 ecuación general de diferencias explícitas progresivas.
Debido al tratamiento de Matlab, invertir la matriz solución (malla
computacional) y graficar.
c. Código 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. Introducción
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 ecuación en diferencias implícitas:
-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 términos (2-2r) y (2+2r) .
Declaración de la malla solución, incluyendo el valor inicial de cada nodo como
cero.
Asignar los valores de la condición de frontera correspondientes a las partes
inferior y superior de la malla solución.
Calcular los valores de los nodos que se encuentran en la primera fila.
Formar la diagonal principal para la resolución del sistema AX = B.
Crear un arreglo numérico (elementos de la diagonal principal de la matriz de
coeficientes) y asignar el valor del término (2+2r) a cada elemento del mismo;
en los extremos del arreglo asignar como valo, la unidad.
Crear un arreglo numérico 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 numérico 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 (términos 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 solución del método de Crank-Nicholson.
Iterar hasta obtener todos los valores correspondientes a la dimension de la
matriz solución.
Debido al tratamiento de Matlab, invertir la matriz solución (malla
computacional) y graficar.
c. Código 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. Introducción
El método 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 ecuación 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 ecuación 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 términos (2-2r2).
A partir de la ecuación 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.
Declaración de la malla solución, incluyendo el valor inicial de cada nodo como
cero.
Iterar tanto la primer como la segunda fila de la malla solución; los valores de
los elementos de la primer fila se obtendran del valor que toma la función 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 ecuación que lleva el mismo nombre.
Iterar la ecuación de diferencias finitas para encontrar los valores de los
elementos de la matriz solución.
c. Código 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 BIBLIOGRÁFICAS
• Mathews H, John. METODOS NUMERICOS CON MATLAB. Editorial
Prentice Hall. Universidad de Sevilla. 2000.
• Nakamura, Shoichiro. ANALISIS NUMERICO Y VISUALIZACION
GRAFICA CON MATLAB. Pearson educación. Universidad de Ohio.
2001.
• García, Javier., APRENDA MATLAB COMO SI ESTUVIERA EN
PRIMERO. Macmillan. Universidad Politécnica de Madrid, 2003.
• Rodríguez, Ignacio, et all. TALLER DE PROGRAMACION DE MATLAB.
XIII Foro de Matemáticas en la D. A. C. B. – UJAT. 2002.
• Sigmon, Kermit. INTRODUCCION AL MATHLAB. Departamento de
Matemáticas de la Universidad de Florida. 1992.
• Brazalez, Alfonso. TUTORIAL COMPLETO DE MATLAB, articulo de
divulgación 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. Edición.
ANEXO
RESUMEN
A través de este proyecto se llevo a cabo en el ambiente del programa Matlab, el desarrollo
de diferentes códigos, para la solución de problemas de metodología numérica, según el tipo
de problema sobre hidráulica 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 pseudocódigo y algoritmo que nos explican la actividad paso a paso que
desarrolla cada programa.
2 Profesor Investigador de la Escuela Superior de Ingeniería y Arquitectura, Unidad Zacatenco, del Instituto Politécnico Nacional. Edificio No. 12 de
la Unidad Profesional Zacatenco, Col. Lindavista, C. P. 07738, México D. F. 5729-6000, Ext. 53-037.
3 Becario PIFI Escuela Superior de Ingeniería y Arquitectura, Unidad Zacatenco, del Instituto Politécnico Nacional. Edificio No. 12 de la Unidad