Matlab Aplicado

Capítulo
10 Aplicaciones
a problemas con MATLAB
10.1 INTRODUCCIÓN A MATLAB
En este capítulo haremos una breve introducción a MATLAB dirigida a usuarios que no han trabajado
nunca con MATLAB. El objetivo principal de este capítulo es que Usted aprenda a programar en MATLAB, es
decir, que sea capaz de crear y modificar programas basados en los algoritmos dados en el libro «Métodos
Numéricos aplicados a la Ingeniería». Vale la pena añadir de que el uso de este software adquiere gran
importancia cuando se aplica a sistemas de gran número de ecuaciones, ya sea de tipo algebraicas o del
tipo de sistemas de ecuaciones algebraicas no lineales. Una ventaja adicional es la fácil representación
gráfica del resultado para su análisis e interpretación.
10.2 ¿QUÉ ES MATLAB?
MATLAB (MATrix LABoratory) es un entorno integrado de computación orientado hacia la resolución de

problemas científicos y de ingeniería. MATLAB integra en un solo paquete cálculo (numérico y simbólico),
visualización gráfica y programación.
Algunas características notables de MATLAB son:

• La programación es más sencilla.
• No hay distinción entre números enteros, reales y complejos.
• La amplitud de intervalo y la exactitud de los números son mayores.
• Cuenta con una biblioteca matemática amplia.
• Abundantes herramientas gráficas.
• Capacidad de vincularse con los lenguajes de programación tradicionales, tales como FORTRAN, C/
C++, Visual Basic, etc.
• Transportabilidad de los programas MATLAB.
Además, el entorno básico de MATLAB se complementa con una amplia colección de cajas de herramientas
(toolboxes) que contienen funciones específicas para determinadas aplicaciones en diferentes ramas de
las ciencias y la ingeniería (por ejemplo: modelado, simulación y optimización de sistemas, control de
procesos, adquisición de datos, estadística y control de calidad, etc.)
Estas características han hecho de MATLAB una herramienta muy efectiva para la educación y la
investigación.
1
Métodos Numéricos - Aplicados a la Ingeniería
10.3 EJECUTANDO MATLAB
Si ya tiene instalado MATLAB, para ejecutarlo proceda igual que con cualquier otra aplicación WINDOWS,
hacer doble clic sobre el icono correspondiente. En seguida se presentará la ventana de comandos, similar
a la figura mostrada:
El símbolo » nos indica que MATLAB está esperando que introduzcamos datos o alguna instrucción
(comando). Una vez que se escribe la orden deseada, hay que pulsar la tecla de retorno, entonces el
programa realiza la operación indicada y muestra la respuesta (ans=). En las guías de uso y de referencia
(PDF) que acompañan al programa, así como en la ayuda (HELP) del programa pueden consultarse
información adicional sobre las instrucciones y el uso de MATLAB.
10.4 TIPOS DE DATOS
Los tipos de datos básicos que soporta MATLAB son números (enteros, reales y complejos), vectores y
matrices.
Ejemplos:
» -2 (entero)
» 0.8205 (real)
» 1.600 + 2.800i (complejo, donde i es la unidad imaginaria)
» [1, -2, 0, 5.23] (vector fila de 4 elementos)
» [1; -2; 0; 5.23] (vector columna de 4 elementos)
» [2, 3, 0; (matriz de orden 2 × 3)
» [1, 4, 3]
Observar que los elementos de un vector fila están separados por comas (o alternativamente por espacios
en blanco), mientras que los elementos de un vector columna están separados por punto y coma. De
igual forma los puntos y comas separan las filas de una matriz, mientras que los elementos de la misma
fila deben separarse mediante comas.
2
Aplicaciones a problemas con MATLAB CAP. 10
10.5 VARIABLES
Una variable almacena un dato cuyo valor puede cambiar durante la ejecución de un programa. En
MATLAB no es necesario declarar las variables ni sus tipos. Sencillamente se crea la variable mediante
asignación directa de su valor. La sintaxis es:
NOMBRE_VARIABLE = VALOR
Ejemplos:
Para definir una variable de tipo real, se puede realizar mediante la siguiente orden:
» R = 0.08205
Para definir una variable de tipo vector, la orden a utilizar sería similar a la siguiente:
» X1 = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
Para definir una variable tipo matriz, se puede realizar de la siguiente forma:
» A = [2, 3, 0;
1, 4, 3;
2, 1, 0]
Luego, para acceder a un elemento individual de un vector o matriz lo hacemos escribiendo el nombre de
la variable y a continuación el o los índices entre paréntesis. Por ejemplo:
» X1(6)
ans = 0.5
» A(2, 3)
ans = 3
Importante: Tener en cuenta que MATLAB distingue las letras mayúsculas de las minúsculas en los
nombres dados a las variables, así por ejemplo:
VOLUMEN Volumen volumen
Son identificadores válidos y diferentes entre sí.
10.6 OPERADORES EN MATLAB

Operadores aritméticos
A+B Adición
A–B Sustracción
A*B Multiplicación
A’ Transpuesta
A^B Potenciación
A/B División-derecha
A\B División-izquierda
A.*B Producto elemento a elemento
A./B y A.\B División elementoa a elemento
A.^B Elevar a una potecia elemento a elemento
3
Ejemplo 10.1
» R = 2
» V = (4/3) * pi * R^3
V = 33.5103
Observar que hemos utilizado la orden pi, la cual es una constante predefinida de MATLAB y que
corresponde al número π = 3.14159265358979.
Ejemplo 10.2
» A = [1 2 ; 3 4]
A =
1 2
3 4
» A * 2
ans =
2 4
6 8
» A - 4
ans =
-3 -2
-1 0
Operadores relacionales:
A == B Igual a
A ~= B Diferente
A<B Menor
A>B Mayor
A <= B Menor o igual
A => B Mayor o igual
Operadores lógicos:
~P Negación
P&Q Conjunción
P|Q Disyunción inclusiva
xor(P, Q) Disyunción exclusiva. Devuelve unos donde x o y es distinto de cero (verdadero). Devuelve
ceros donde ambos x e y son ceros (falso) o ambos son distintos de ceros (verdadero).
Funciones relacionales y lógicas
Funciones exponenciales y logarítmicas

Devuelve uno si algún elemento en un vector x no es nulo. Devuelve uno
any(x)
para cada columna en una matriz x que tiene elementos no nulos
Devuelve uno si algún elemento en un vector x no es nulo. Devuelve uno
all(x)
para cada columna en una matriz x que tiene elementos no nulos
isnan(x) Devuelve unos en magnitudes no numéricas (NaN) en x.
isinf(x) Devuelve unos en magnitudes no numéricas (NaN) en x.
finite(x) Devuelve unos en magnitudes no numéricas (NaN) en x.
4
En MATLAB los valores lógicos 0 y 1 corresponden a verdadero y falso, respectivamente.
Ejemplo:
» Q = (15 > 22) & (18 < 20)
Q = 0
Funciones predefinidas de MATLAB
Funciones con números enteros y divisibilidad

mod(n,m) Resto de la división de n entre m
sign(n) Signo de n (1 para n < 0, – 1 para n > 0)
max(n,m) Máximo de los números n y m
min(n,m) Mínimo de los números n y m
gcd(n,m) Máximo común divisor de n y m
lcm(n,m) Mínimo común múltiplo de n y m
factorial(n) Factorial de n
factor(n) Descompone n en factores primos
Funciones trigonométricas Funciones hiperbólicas

Función Inversa Función Inversa
sin(x) asin(x) sinh(x) asinh(x)
cos(x) cos(x) cosh(x) cosh(x)
tan(x) atan(x), atan2(x) tanh(x) atanh(x)
cot(x) acot(x) coth(x) acoth(x)
sec(x) asec(x) sech(x) asech(x)
csc(x) acsc(x) csch(x) acsch(x)
Funciones exponenciales y logarítmicas

exp(x) Función exponencial en base e
log(x) Función logarítmica en base e de x
log10(x) Función logarítmica en base 10 de x
log2(x) Función logarítmica en base 2 de x
pow2(x) Función potencial en base 2 de x
sqrt(x) Función raíz cuadrada de x
5
Funciones específicas de variable numérica real

abs(x) Valor absoluto del real x
floor(x) Valor entero más próximo hacia –∞
ceil(x) Valor entero más próximo hacia +∞
round(x) Redondeo hacía el entero más próximo de x
fix(x) Redondeo hacía el entero más próximo a 0
mod(a,b) Resto de la división entre los reales a y b
Devuelve 1 si x>0 y – 1 si x<0. Aplicado en números complejos
sign(x)
devuelve un vector unitario en la misma dirección
10.7 FORMATOS DE VISUALIZACIÓN DE NÚMEROS
En la Tabla siguiente se muestran los formatos numéricos establecidos por MatLab.
Orden de MatLab Comentarios

Format long 16 dígitos
Format ahort e 5 dígitos más exponente
Format long e 16 dígitos más exponente
Format hex Hexadecimal
Format bank 2 dígitos decimales
Format + Positivo, negativo o cero
Format rat Aproximación racional
Format short Visualización por defecto
10.8 INFORMACIÓN SOBRE LAS VARIABLES
MatLab por defecto almacena los resultados en la variable ans. Las variables son sensibles a las mayúsculas
y puede contner hasta 19 caracteres y todos deben comenzar por una letra. Algunas variables especiales
se muestran a continuación:
Variable Valor
ans Nombre por defecto de la variable usada para los resultados.
pi Razón de una circunferencia a su diámetro.
Número más pequeño tal que, cuando se le suma 1, crea un número
eps
en coma flotante en el computador mayor que 1.
inf Infinito.
NaN Magnitud no numérica.
i y j i=1=v–1
realmin El número real positivo más pequeño que es utilizable.
realmax El número real positivo más grande que es utilizable.
6
10.9 MATRICES
La potencia de MATLAB radica en la capacidad de cálculo matricial que posee, se puede trabajar con
matrices de forma muy cómoda y extensa.
Hay ciertas matrices espaciales que se pueden definir en MATLAB de forma directa, usando las siguientes
funciones:
Variable Valor
diag(VECTOR) Crea un matriz diagonal con los elementos de VECTOR en la diagonal.
eye(n) Crea una matriz de orden n
zeros(m,n) Crea una matriz de orden mxn
ones(m,n) Crea una matriz de orden mxn con todos sus elementos 1
rand(m,n) Crea una matriz aleatoria uniforme de orden mxn
randn(m,n) Crea una matriz aleatoria normal de orden mxn
Ejemplos:
» A = diag([5, 4, 3])
A =
5 0 0
0 4 0
0 0 3
» I4 = eye(4)
I4 =
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
» K = zeros(4, 3)
K =
0 0 0
0 0 0
0 0 0
0 0 0
» B = ones(2, 3)
B =
1 1 1
1 1 1
Para el caso de las operaciones matriciales estas se rigen por las reglas del álgebra lineal. A continuación
se especifican las operaciones más importantes:
A+B Suma de matrices
A–B Resta de matrices
A*B Multiplicación de matrices
A’ Transpuesta de una matriz
A^n Potencia escalar de una matriz
7
Ejemplo 10.4
» B = [1, 13, 169]
» B = B’
B =
1
13
169
» A = [1, 1, 1; 7, 9, 11; 49, 81, 121]
A =
1 1 1
7 9 11
49 81 121
» X = A^(-1) * B
X =
1.0000
-3.0000
3.0000
El mismo resultado se obtiene si utilizamos cualquiera de las siguientes órdenes:

» X = inv(A) * B
» X = A \ B
El operador divisor izquierda es aplicable aunque la matriz no tenga inversa e incluso no sea cuadrada,
encuyo caso la solución que se obtiene es la que proporciona el método de mínimos cuadrados.
Ejemplo 10.5
» A = [1, 2], B =[2]
A =
1 2
B =
2
» A \ 2
x =
0
1
Observar que mediante el ejemplo anterior hemos obtenido la solución del sistema de ecuaciones
lineales dado por:
x+ y+ z= 1
7x + 9y + 11z = 13
49x + 81y + 121z = 169
Una de las características más útiles de MATLAB es que dispone de un conjunto de operadores que operan
sobre una matriz, elemento a elemento, estos son:
A .* B
A ./ B
A.^n
8
Ejemplo 10.6
» A = [0, 2; -1, 3]
A =
1 2
2 4
» A^2
ans =
-2 6
-3 7
» A.^2
ans =
0 4
1 9
10.10 GRAFICACIÓN
El comando plot grafica el conjunto de puntos (x, y) sobre el plano euclidiano (2D). Su sintaxis es:
» plot(X, Y, S)
Donde X e Y son vectores fila que representan a las abscisas y las ordenadas, respectivamente. S es una
cadena que indica el tipo de línea y/o carácter a usar en el ploteo y el color de la curva. Su formato es:
S = [TIPO DE LÍNEA][MARCA][COLOR]
Tipos de línea Tipo de marca Color de línea

Continua – Punto . Rojo r
Guiones ––– Cruz + Amarillo y
Punteada : Asterísco * Verde g
Guiones y puntos –.
Círculo ° Azul b
Aspa x Magenta m
Cian c
Negro k
Blanco w
Ejemplo 10.7
» X = [0: 0.05: 10];
» Y = sin(X) .* exp(-0.4 * X);
» plot(X, Y, ‘k’);
» xlabel(‘X’);
» ylabel(‘Y’);
» title(‘Graficación en 2D’);
9
En la primera línea se especifica el dominio y el tamaño de paso, en este caso 0.05. En la siguiente línea
se define la función. Luego mediante la orden plot graficamos la función mediante una curva simple de
color negro (k). La cuarta y quinta líneas muestran un rótulo para los ejes X e Y, respectivamente. La última
línea muestra un título para el gráfico.
El comando plot3 es la versión tridimensional de plot. Todas las reglas y comandos ya explicados para plot
se aplican a plot3.
Ejemplo 10.8
Como ejemplo vamos a graficar la hélice paramétrica definida por:
x(t) = sin(t) ; y(t) = cos(t) ; z(t) = t
» t = [0: pi/50: 10*pi];
» X = sin(t); Y = cos(t); Z = t;
» plot3(X, Y, Z);
» grid on;
» xlabel(‘X’); ylabel(‘Y’); zlabel(‘Z’);
» title(‘Hélice paramétrica’);
10
Las gráficas de superficie permiten obtener representaciones densas de figuras tridimensionales y en

especial de funciones de dos variables, de la forma:
z = ƒ(x, y)
Para graficar una función de este tipo, el procedimiento es el siguiente:

1. Utilizar el comando meshgrid para definir la malla (matriz de puntos) sobre los cuales se evaluará la
función para hacer su representación gráfica.
2. Usar el comando surf o contour, o cualquiera de sus variantes.
La sintaxis básica de estos comandos es:

» [X, Y] = meshgrid(VECTORX, VECTORY)
» surf(X, Y, Z)
» countour(X, Y, Z)
Ejemplo 10.9
Como ejemplo vamos a graficar la superficie dada por la siguiente ecuación:
» [X, Y] = meshgrid(-7.5: 0.5: 7.5);

» warning off all;
» Z = sin(sqrt(X.^2 + Y.^2)) ./ sqrt(X.^2 + Y.^2);
» warning on all;
» figure(1);
» surf(X, Y, Z);
» xlabel(‘X’); ylabel(‘Y’); zlabel(‘Z’);
» figure(2);
» contour(X, Y, Z);
» xlabel(‘X’); ylabel(‘Y’);
11
Mediante el comando contour también es posible graficar funciones implícitas, cuya sintaxis para graficar
curvas implícitas es:
» contour(X, Y, F(X, Y), [0, 0])
Donde X e Y son vectores fila que representan los valores de x e y, respectivamente. F(X, Y) es la función en
x e y. El vector [0, 0] sirve para especificar el nivel de contorno, pues el único contorno que nos interesa es
el del nivel 0, pero los niveles de contorno deben estar en forma de vector, por lo que repetimos el cero.
Ejemplo 10.10
Suponga que se desea graficar la siguiente función implícita:
y3 + exp(y) – tanh(x) = 0
» X = [-3: 0.2: 3];

» Y = [-2: 0.2: 1];
» [X, Y] = meshgrid(X, Y);
» F = Y .^3 + exp(Y) - tanh(X);
» contour(X, Y, F, [0, 0]);
» xlabel(‘X’); ylabel(‘Y’);
12
10.11 ESCRITURA DE PROGRAMAS
Un programa MATLAB es una secuencia de instrucciones escritas en lenguaje MATLAB, que puede aceptar
argumentos de entrada y produce una salida (resultados). Los programas de MATLAB suelen escribirse en
archivos denominados «archivos M». La ventaja de escribir programas es que estos se pueden guardar en
disco y pueden modificarse tantas veces como sea necesario.
Los archivos M se pueden crear utilizando el editor de programas de MATLAB, para ello teclear la siguiente
orden en la ventana de comandos:
» edit
En la ventana de edición de programas (Editor/Debugger) se abre con un archivo en blanco en el cual

debemos crear nuestro archivo M. Para guardar los cambios realizados en un archivo M ingresar al menú
File → Save. Si se desea crear un nuevo archivo M ingresar File → New. Para abrir un archivo M ya existente
utilizar File → Open.
10.12 INSTRUCCIONES DE ENTRADA Y SALIDA
Un programa MATLAB puede aceptar datos de entrada a través del teclado mediante el comando input.
Si se desea leer un valor numérico (escalar, vector o matriz), su sintaxis es la siguiente:
N = input(‘MENSAJE’)
Donde MENSAJE es una cadena que se exhibe en la pantalla y le indica al usuario que información debe
ingresar.
De forma similar un programa MATLAB puede imprimir mensajes y resultados numéricos si se utiliza el
comando disp, cuya sintaxis es:
disp(EXPRESIÓN)
Donde EXPRESIÓN puede ser un valor numérico o una cadena de caracteres.
13
Ejemplo 10.11
Suponga que se le pide escribir un programa MATLAB para resolver el siguiente sistema de dos ecuaciones
lineales:
ax + by = c
dx + ey = ƒ
Recordar que la solución del sistema está dada por:
Para resolver este problema, cargar el editor de programas de MATLAB e ingresar el siguiente código:
Listado SISLIN2.m
% Ingreso de datos
a = input(‘INGRESE A? ‘);
b = input(‘INGRESE B? ‘);
c = input(‘INGRESE C? ‘);
d = input(‘INGRESE D? ‘);
e = input(‘INGRESE E? ‘);
f = input(‘INGRESE F? ‘);
% Cálculo de x e y
x = (c * e - b * f) / (a * e - b * d);
y = (a * f - c * d) / (a * e - b * d);
% Impresión de resultados
disp(‘SOLUCIÓN (X,Y)= ‘);
disp([x, y]);
Una vez escrito el código mostrado, guarde el programa como «SisLin2.M». Para probar el código que
acaba de escribir, vamos a resolver el sistema:
6x + y = 9
2x + 5y = 17
Para ello ingrese en la ventana de comandos de MATLAB lo siguiente:

» SISLIN2
INGRESE A? 6
INGRESE B? 1
INGRESE C? 9
INGRESE D? 2
INGRESE E? 5
INGRESE F? 17
SOLUCIÓN (X, Y)=
1 3
Observar que las sentencias que comienzan con el símbolo % son comentarios, es decir son ignoradas
por el programa, pero sirven como referencia para hacer más legible el código.
14
10.13 CONTROL DE FLUJO
Las estructuras de control permiten tomar decisiones y en función de ello el flujo de control de un
programa se bifurca a una de entre dos o más posibles acciones. También se utilizan para realizar un
proceso repetidas veces (procesos iterativos). MATLAB dispone de las estructuras de control if, for y
while, las cuales operan de manera similar a sus homólogas en otros lenguajes de programación. Estas
instrucciones adoptan la sintaxis básica siguiente:
if CONDICIÓN
COMANDOS_VERDADEROS;
else
COMANDOS_FALSOS;
end
-------------------------------------------
for CONTADOR = INICIO : INCREMENTO/DECREMENTO : FINAL
COMANDOS A EJECUTARSE;
end
-------------------------------------------
while CONDICIÓN
COMANDOS A EJECUTARSE;
end
-------------------------------------------
Ejemplo 10.12
Escríbase un programa que permita leer un entero y determine todos sus divisores.
Listado DIVISORES.m
N = input(‘INGRESE UN ENTERO?’);
disp(‘LOS DIVISORES SON:’);
for I = 1 : N
if mod(N, I) == 0
disp(I);
end
end
» DIVISORES
INGRESE UN ENTERO? 12
LOS DIVISORES SON:
1
2
3
4
6
12
15
Ejemplo 10.13
Escriba un programa que permita leer un número e imprima en pantalla la suma de cifras del mismo.
Listado SUMCIFRASM.m
S = 0;
NUM = input(‘INGRESE UN NÚMERO?’);
while NUM > 0
S = S + mod(NUM, 10);
NUM = fix(NUM / 10);
end
disp(‘SUMA DE CIFRAS DEL NÚMERO=’);
disp(S);
» SUMCIFRAS
INGRESE UN NÚMERO? 290175
SUMA DE CIFRAS DEL NÚMERO=
24
Ejemplo 10.14
Escriba un programa que para un número x permita calcular la siguiente sumatoria:
Hasta que el valor absoluto del término sea menor que el error ε = 1 × 10–6.
Listado SUMCIFRASM.m
EPS = 1e-6;
X = input(‘VALOR DE X?’);
SUMA = 1 + X;
TERMINO = X;
N = 1;
while abs(TERMINO) > EPS
N = N + 1;
TERMINO = TERMINO * X / N;
SUMA = SUMA + TERMINO;
end
disp(‘SUMA=’);
disp(SUMA);
» SERIE_EXP
VALOR DE X? 1
SUMA=
2.71828180114638
Ejemplo 10.15
Escriba un programa para obtener una solución real de la ecuación:
cosx – 3x = 0
Utilizando el algoritmo de Newton–Raphson, tomando como valor inicial .
16
Listado NEWTON.m
X0 = input(‘VALOR INICIAL?’);
EPS1 = input(‘CRITERIO DE CONVERGENCIA?’);
EPS2 = input(‘CRITERIO DE EXACTITUD?’);
MAXIT = input(‘MÁXIMO NÚMERO DE ITERACIONES?’);
for I = 1 : MAXIT
FX = cos(X0) - 3 * X0;
dFX = -1 * sin(X0) - 3;
Xp = X0 - FX / dFX;
if (abs(Xp - X0) < EPS1) | (abs(FX) < EPS2)
disp(‘RAIZ APROXIMADA Xp=’);
disp(Xp);
break;
end
X0 = Xp;
end
if K == MAXIT
disp(‘EL MÉTODO NO CONVERGE A UNA RAÍZ’);
end
» NEWTON
VALOR INICIAL? pi/8
CRITERIO DE CONVERGENCIA? 1e-6
CRITERIO DE EXACTITUD? 1e-6
MÁXIMO NÚMERO DE ITERACIONES? 10
RAIZ APROXIMADA Xp=
0.31675082877122
La instrucción break permite salir de un bucle antes de que este se complete.
10.14 FUNCIONES
MATLAB dispone de una amplia gama de funciones que permiten realizar una gran variedad de tareas. Sin
embargo, se pueden crear funciones definidas por el usuario para realizar tareas específicas. Para ello se
debe definir la función como un archivo M, el nombre del archivo debe ser igual al nombre de la función
y se debe guardar en el directorio de trabajo por defecto.
La sintaxis para definir una función es:

function PARÁMETROS_SALIDA = NOMBRE_FUNCIÓN(PARÁMETROS _ENTRADA)
.
.
CUERPO DE LA FUNCIÓN
.
.
return;
Para invocar una función hacemos uso de la siguiente sintaxis:

VARIABLE = NOMBRE_FUNCIÓN(LISTA_ARGUMENTOS)
Donde LISTA_ARGUMENTOS debe coincidir con el número de PARÁMETROS_ENTRADA, de lo contrario

se produce un error.
17
Ejemplo 10.16
Escriba la siguiente función en MATLAB:
ƒ(x) = x3 + 2x2 + 10x = 20
Listado FX.m
function y = FX(x)
y = x^3 + 2 * x^2 + 10 * x - 20;
return;
Importante: No olvide guardar el archivo con el nombre «FX.M». En MATLAB el nombre la función debe
coincidir con el nombre del correspondiente archivo M.
Luego, desde la ventana de comandos vamos a invocar a la función recientemente creada:

» y = FX(3)
y = 55
Sin embargo, en MATLAB es común evaluar una función mediante la orden feval, tal como se indica a
continuación:
» y = feval(FX, 3)
Lo cual produce el mismo resultado.
Ejemplo 10.17
La ecuación de Antoine para estimar la presión de vapor está dada por:
Escriba una función en MATLAB que acepte como argumentos de entrada los valores de las constantes de
Antoine y la temperatura, y retorne el valor de la presión de vapor.
Listado ANTOINE.m
function P = ANTOINE(A, B, C, T)
P = exp(A - B / (T + C));
return;
Para probar la función que acaba de crear estimar la presión de vapor del etilbenceno a 347.2 ºK
Las constantes de Antoine para el etilbenceno son (donde PSat está en KPa y T en ºC):
A = 14.0045
B = 3279.47
C = 213.2
» PSAT = ANTOINE(14.0045, 3279.47, 213.2, 347.20 - 273.15)

PSAT= 13.2994
Una forma eficiente de construir programas es crear nuevas funciones que se almacenan como
archivos m. Estas funciones nos permiten especificar los datos que se deben introducir y los nos
retornan los resultados que deben mostrarse y pueden ser llamados como subprogramas desde
otros programas.
18
10.15 PROBLEMAS DESARROLLADOS APLICANDO MATLAB
Listado BISECCION.m
Aproximación a una solución de la ecuación no líneal ƒ(x) = 0 mediante el método de la bisección.
function [Xp, ITER, FLAG] = BISECCION(F, a, b, EPS1, EPS2, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = BISECCION(F, a, b, EPS1, EPS2, MAXIT)
% Entrada
% - F es la función, almacenada como un archivo F.m
% - a, b son los extremos del intervalo inicial
% - EPS1 es el criterio de convergencia
% - EPS2 es el criterio de exactitud
% - MAXIT es el número máximo de iteraciones
% Salida
% - Xp es el valor de la raíz aproximada
% - ITER es el número de iteraciones realizadas
% - FLAG es una variable lógica, es 1 si hubo convergencia, caso
% contrario es 0
Ya = feval(F, a);
Yb = feval(F, b);
if (Ya * Yb > 0)
disp(‘Detenido porque F(a)*F(b) > 0’);
return;
else
for K = 1 : MAXIT
Xm = (a + b) / 2;
Ym = feval(F, Xm);
if Ym > 0
a = Xm;
else
b = Xm;
end
if (abs(a - b)) < EPS1 | abs(Ym) < EPS2
Xp = Xm;
ITER = K;
FLAG = 1;
return;
end
end
disp(‘Se ha excedido el máximo número de iteraciones...’);
ITER = MAXIT;
FLAG = 0;
end
Para usar este programa y resolver la ecuación ƒ(x) = lnx – x + 2 = 0, dada en el Problema 1.1 (pág. 17), es
necesario almacenar la función de iteración como un archivo M, por ejemplo F1.m, tal como se muestra
a continuación:
Listado F1.m
function Y = F1(X)
Y = log(X) - X + 2;
return;
19
Luego, para obtener el resultado, en la ventana de comandos de MATLAB ingresar lo siguiente:
» [Xp, ITER, FLAG] = BISECCION(@F1, 2, 4, 1e-6, 1e-6, 25)

Xp =
3.14619445800781
ITER =
17
FLAG =
1
Listado PUNTOFIJO.m
Aproximación a una solución de la ecuación x = g(x) mediante el método del punto fijo.
function [Xp, ITER, FLAG] = PUNTOFIJO(G, X0, EPS1, MAXIT)

% Sintaxis
% [Xp, ITER, FLAG] = PUNTOFIJO(G, X0, EPS1, MAXIT)
% Entrada
% - G es la función, almacenada como un archivo G.m
% - X0 es el valor inicial
% Salida
% contrario es 0
for K = 1 : MAXIT
X = feval(G, X0);
if (abs(X - X0)) < EPS1
Xp = X;
ITER = K;
FLAG = 1;
return;
end
X0 = X;
end
ITER = MAXIT;
FLAG = 0;
La función de iteración g(x) = lnx + 2 , dada en el Problema 1.2 (pág. 24) la ingresamos como un archivo
M, en este caso G1.m, cuya codificación se muestra a continuación:
Listado G1.m
function Y = G1(X)
Y = log(X) + 2;
return;
20
Luego, en la ventana de comandos tipear lo siguiente para obtener el resultado:
» [Xp, ITER, FLAG] = PUNTOFIJO(@G1, 3, 1e-6, 25)

Xp =
3.14619305968798
ITER =
12
FLAG =
1
Listado NEWTON.m
Aproximación a una solución de la ecuación no lineal ƒ(x) = 0 mediante el método de Newton – Raphson
function [Xp, ITER, FLAG] = NEWTON(F, dF, X0, EPS1, EPS2, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = NEWTON(F, dF, X0, EPS1, EPS2, MAXIT)
% Entrada
% - dF es la derivada de de la función, almacenada como un archivo dF.m
% - X0 es el valor inicial
% Salida
% contrario es 0
for K = 1 : MAXIT
Xp = X0 - feval(F, X0) / feval(dF, X0);
if (abs(Xp - X0) <= EPS1) | (abs(feval(F, Xp)) <= EPS2)
ITER = K;
FLAG = 1;
return;
end
X0 = Xp;
end
ITER = MAXIT;
FLAG = 0;
En este caso vamos a utilizar el programa NEWTON.m para resolver la ecuación ƒ(x) = lnx – x + 2 = 0,
Problema 1.5 (pág. 33), la cual ya está almacenada como un archivo F1.m (problema anterior, método de
la bisección).
Listado F1.m
function Y = F1(X)
Y = log(X) - X + 2;
return;
21
Sin embargo, para el método de Newton – Raphson es necesaria la derivada de la función:
la cual también debe ser guardada como un archivo, por ejemplo dF1.m.
Listado dF1.m
function Y = dF1(X)
Y = 1 / X - 1;
return;
Para obtener el resultado ingresar lo siguiente en la ventana de comandos de MATLAB:

» [Xp, ITER, FLAG] = NEWTON(@F1, @dF1, 3, 1e-6, 1e-6, 25)
Xp = 3.14619344079791
ITER = 2
FLAG = 1
El método de Newton – Raphson también es aplicable para la obtención de raíces complejas, con la
diferencia que el valor inicial debe ser un valor complejo. Por ejemplo, para hallar las raíces complejas de
la ecuación ƒ(x) = x2 + 8, dada en el Problema 1.4 (pág. 31), primero almacenamos la función y su derivada
como archivos, por ejemplo F2.m y dF2, respectivamente.
Listado F2.m
function Y = F2(X)
Y = X^2 + 8;
return;
Listado dF2.m
function Y = dF2(X)
Y = 2 * X;
return;
Luego, en la ventana de comandos:

» [Xp, ITER, FLAG] = NEWTON(@F2, @dF2, 2*i, 1e-6, 1e-6, 25)
Xp = 0 + 2.82842712474938i
ITER = 4
FLAG = 1
Donde la raíz compleja es 2.828427i y la raíz compleja conjugada será –2.828427i . Para obtener el valor de
la raíz conjugada dar como valor inicial –2i (esto último se deja como ejercicio para el lector).
Listado SECANTE.m
Aproximación a una solución de la ecuación ƒ(x) = 0 mediante el método de la secante.
function [Xp, ITER, FLAG] = SECANTE(F, X0, X1, EPS1, EPS2, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = SECANTE(F, X0, X1, EPS1, EPS2, MAXIT)
% Entrada
% - X0, X1 son los valores iniciales
22

% Salida
% contrario es 0
for K = 1 : MAXIT
Xp = X0 - (X1 - X0) * feval(F, X0) / (feval(F, X1) - feval(F, X0));
if (abs(Xp - X1) <= EPS1) | (abs(feval(F, Xp)) <= EPS2)
ITER = K;
FLAG = 1;
return;
end
X0 = X1;
X1 = Xp;
end
ITER = MAXIT;
FLAG = 0;
En este caso vamos a utilizar el programa SECANTE.m para resolver la ecuación ƒ(x) = lnx – x + 2 = 0, dada
en el Problema 1.6 (pág. 35), la cual ya está almacenada como un archivo F1.m (problema anterior, método
de la bisección). Por tanto, para obtener el resultado ingresar lo siguiente en la ventana de comandos de
MATLAB:
» [Xp, ITER, FLAG] = SECANTE(@F1, 3, 3.15, 1e-6, 1e-6, 25)
Xp = 3.14619320852215
ITER = 2
FLAG = 1
Listado MULLER.m
Aproximación a una solución de la ecuación ƒ(x) = 0 mediante el método de la Müller.
function [Xp, ITER, FLAG] = MULLER(F, X0, X1, X2, EPS1, EPS2, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = MULLER(F, X0, X1, X2, EPS1, EPS2, MAXIT)
% Entrada
% - X0, X1, X2 son los valores iniciales
% Salida
% contrario es 0
for K = 1 : MAXIT
F10 = (feval(F, X1) - feval(F, X0)) / (X1 - X0);
F21 = (feval(F, X2) - feval(F, X1)) / (X2 - X1);
23
F210 = (F21 - F10) / (X2 - X0);

A2 = F210;
A1 = F21 - (X2 + X1) * A2;
A0 = feval(F, X2) - X2 * (F21 - X1 * A2);
D1 = -A1 + sqrt(A1^2 - 4 * A0 * A2);
D2 = -A1 - sqrt(A1^2 - 4 * A0 * A2);
if abs(D1) > abs(D2)
X3 = 2 * A0 / D1;
else
X3 = 2 * A0 / D2;
end
if (abs(X3 - X0) <= EPS1) | (abs(feval(F, X3)) <= EPS2)
Xp = X3;
ITER = K;
FLAG = 1;
return;
end
X0 = X1;
X1 = X2;
X2 = X3;
end
ITER = MAXIT;
FLAG = 0;
Para resolver la ecuación ƒ(x) = lnx – x + 2 = 0, Problema 1.9 (pág. 45), mediante el programa MULLER.m,
ingresar lo siguiente en la ventana de comandos de MATLAB:
» [Xp, ITER, FLAG] = MULLER(@F1, 2, 3, 4, 1e-6, 1e-6, 25)
Xp = 3.14619322048079
ITER = 3
FLAG = 1
Gráficas
Como las gráficas son parte natural de MATLAB se puede aprovechar esa característica para graficar
previamente la función de la cual deseamos encontrar sus raíces, Sabiendo el comportamiento
de la función, el número de raíces y su valor aproximado, el resto puede hacerse fácilmente con una
computadora, o incluso con una calculadora de bolsillo.
Por ejemplo, para analizar gráficamente la siguiente función ƒ(x) = lnx – x + 2 = 0, escribimos el siguiente
programa MATLAB:
Listado GRAFICA_F1.m
close all;
clear;
X = [0: 0.1: 5];
Y = feval(@F1, X);
plot(X, Y, ‘k’, X, 0, ‘k’);
xlabel(‘X’);
ylabel(‘Y’);
24
Luego, para ejecutar el programa en la ventana de comandos de MATLAB ingresar la siguiente orden:
» GRAFICA_F1
Como puede apreciar en la gráfica obtenida se puede ver claramente que la función presenta dos raíces,
una de las cuales se encuentra aproximadamente entre 0.1 y 0.2, y la otra que se encuentra entre 3.0 y 3.2.
Listado APROXILIN.m
Aproximación polinomial simple. Construcción del polinomio interpolador de grado N que pasa
por los (N + 1) puntos
function [YINT, C] = APROXLIN(X, Y, XINT)
% Sintaxis
% [YINT, C] = APROXLIN(X, Y, XINT)
% Entrada
% - X es un vector fila que contiene la lista de abscisas
% - Y es un vector fila que contiene la lista de ordenadas
% - XINT es el valor para el que se desea la interpolación
% Salida
% - YINT es el valor de la función en XINT
% - C es el vector de coeficientes (en forma ascendente, a0, a1, ..., aN)
% del polinomio de grado N que pasa por los (N + 1) puntos
N = length(X) - 1;
X = X’;
Y = Y’;
for I = 1 : N + 1
B(I, 1) = 1;
for J = 2 : N + 1
B(I, J) = B(I, J - 1) * X(I);
end
end
C = inv(B) * Y;
YINT = 0;
for I = N + 1 : -1 : 1
YINT = YINT * XINT + C(I);
end
25
Por ejemplo para la función tabular dada en el Problema 2.7 (pág. 101):
x 0 1 2 5
y = f (x) 5 7 9 15
Para hallar el valor de la función en x = 3, en la ventana de comandos de MATLAB tipear:

» X = [0, 1, 2, 5];
» Y = [5, 7, 9, 15];
» [YINT, C] = APROXLIN(X, Y, 3)
YINT = 11
C = 5
2
-7.7715611723761e-016
-5.55111512312578e-017
Listado LAGRANGE1.m
Interpolación con polinomios de Lagrange de grado N.
function YINT = LAGRANGE1(X, Y, XINT)
% Sintaxis
% YINT = LAGRANGE1(X, Y, XINT)
% Entrada
% - X es un vector que contiene la lista de abscisas
% - Y es un vector que contiene la lista de ordenadas
% Salida
N = length(X) - 1;
YINT = 0;
for I = 1 : N + 1
L = 1;
for J = 1 : N + 1
if I ~= J
L = L * (XINT - X(J)) / (X(I) - X(J));
end
end
YINT = YINT + L * Y(I);
end
Para el mismo caso anterior (Problema 2.7, pág. 107), tipear en la ventana de comandos de MATLAB lo
siguiente:
» X = [0, 1, 2, 5];
» Y = [5, 7, 9, 15];
» YINT = LAGRANGE1(X, Y, 3)
YINT = 11
26
Listado LAGRANGE2.m
Construcción del polinomio interpolador de Lagrange de grado N que pasa por los (N + 1) puntos
function [YINT, C, L] = LAGRANGE2(X, Y, XINT)
% Sintaxis
% [YINT, C, L] = LAGRANGE2(X, Y, XINT)
% Entrada
% Salida
% - C es la matriz que contiene los coeficientes del polinomio
% interpolador de Lagrange, en forma ascendente (a0, a1, a2, ..., aN)
% - L es la matriz que contiene los coeficientes de los polinomios
% coeficientes de Lagrange
N = length(X) - 1;
L = zeros(N + 1, N + 1);
for I = 1 : N + 1
V = 1;
for J = 1 : N + 1
if I ~= J
V = conv(V, poly(X(J))) / (X(I) - X(J));
end
end
L(I, :) = V;
end
C = (Y * L)’;
C = flipud(C);
YINT = 0;
for I = N + 1 : -1 : 1
YINT = YINT * XINT + C(I);
end
Para el mismo caso anterior (Problema 2.7, pág. 107), tipear en la ventana de comandos de MATLAB lo
siguiente:
» [YINT, C, L] = LAGRANGE2(X, Y, 3)
YINT = 11
C =
5
2
-1.11022302462516e-016
0
L =
-0.1000 0.8000 -1.7000 1.0000
0.2500 -1.7500 2.5000 0
-0.1667 1.0000 -0.8333 0
0.0167 -0.0500 0.0333 0
27
Listado NEVILLE.m
Interpolación mediante el método de Neville
function [YINT, Q] = NEVILLE(X, Y, XINT)
% Sintaxis
% [YINT, Q] = NEVILLE(X, Y, XINT)
% Entrada
% Salida
% - Q es el esquema de Neville
N = length(X);
Q = Y’;
for J = 2 : N
for I = J : N
Q(I, J) = ((XINT - X(I - J + 1)) * Q(I, J - 1) - (XINT - X(I)) ...
* Q(I - 1, J - 1)) / (X(I) - X(I - J + 1));
end
end
YINT = Q(end);
Para la función tabular mostrada en el Problema 2.9 (página 109), vamos a hallar el valor de y = ƒ(x) cuando
x = 1.5, veamos:
x 1.0 1.3 1.6 1.9 2.2

y = f (x) 0.7651977 0.6200860 0.4554022 0.2818186 0.1103623
Para ello en la ventana de comandos de MATLAB ingresar la siguiente orden:

» X = [1.0, 1.3, 1.6, 1.9, 2.2];
» Y = [0.7651977, 0.6200860, 0.4554022, 0.2818186, 0.1103623];
» [YINT, Q] = NEVILLE(X, Y, 1.5)
YINT = 0.511819994238683
Q =
0.7652 0 0 0 0
0.6201 0.5233 0 0 0
0.4554 0.5103 0.5125 0 0
0.2818 0.5133 0.5113 0.5118 0
0.1104 0.5104 0.5137 0.5118 0.5118
Listado MINCUAD.m
Interpolación por mínimos cuadrados.
function [YC] = MINCUAD(X, Y, N)
% Sintaxis
% YC = MINCUAD(X, Y, N)
% Entrada
% - N es el orden del polinomio
28
% Salida
% - YC es un vector que contiene los coeficientes del polinomio en forma
% ascendente (a0, a1, a2, ..., aN), es decir de menor a mayor exponente
% de la variable
M = length(X);
X = X’;
Y = Y’;
for I = 1 : M
B(I, 1) = 1;
for J = 2 : N + 1
B(I, J) = B(I, J - 1) * X(I);
end
end
YC = inv(B’ * B) * (B’ * Y);
Por ejemplo para la función dada en el Problema 2.11 (página 135), se tiene:
x –2 –1 0 1 2
y = f (x) 0 0 1 1 3
Para ajustar la función a una recta escriba las siguientes instrucciones en la ventana de comandos de
MATLAB:
» X = [-2, -1, 0, 1, 2];
» Y = [0, 0, 1, 1, 3];
» YC = MINCUAD(X, Y, 1)
YC = 1
0.7
Con los mismos datos del problema anterior, para ajustarlos a un polinomio de segundo grado, tipear lo
siguiente en la ventana de comandos:
YC =
0.571428571428571
0.700000000000000
0.214285714285714
Para ajustar los datos anteriores a un polinomio de tercer grado hacer:

YC =
0.5714285714285710
0.4166666666666670
0.2142857142857140
0.0833333333333335
29
Listado MINCUAD2.m
Ajuste por mínimos cuadrados para una ecuación de la forma
function [YC] = MINCUAD2(X1, X2, Y)
% Sintaxis
% YC = MINCUAD2(X1, X2, Y)
% Entrada
% - X1 es un vector fila que contiene los valores de la variable
% independiente X1
% - X2 es un vector fila que contiene los valores de la variable
% independiente X2
% - Y es un vector fila que contiene los valores de la variable
% dependiente Y
% Salida
% - YC es un vector que contiene los coeficientes de la curva ajustada
% en el orden: a0, a1, a2
N = length(X1);
X1 = X1’;
X2 = X2’;
Y = Y’;
X = [ones(N, 1), X1, X2];
YC = inv(X’ * X) * (X’ * Y);
Para utilizar el programa anterior con los datos de la tabla mostrada en el Problema 2.16 (página 140):
y x1 x2
27.8 2.0 18.0
28.0 3.5 16.5
28.8 4.5 10.5
29.1 2.5 2.5
30.0 8.5 9.0
31.0 10.5 4.5
32.0 13.5 1.5
En la ventana de comandos de MATLAB ingresamos lo siguiente:

» X1 = [2.0, 3.5, 4.5, 2.5, 8.5, 10.5, 13.5]
» X2 = [18.0, 16.5, 10.5, 2.5, 9.0, 4.5, 1.5]
» Y = [27.5, 28.0, 28.8, 29.1, 30.0, 31.0, 32.0]
» YC = MINCUAD2(X1, X2, Y)
YC =
28.6917135088340000
0.25693926572616200
-0.0960681843122408
30
Gráficas
Para graficar los siguientes datos del problema 2.11 (pág. 135) y las curvas ajustadas mediante mínimos
cuadrados:
x –2 –1 0 1 2
y = f (x) 0 0 1 1 3
Lo podemos realizar mediante el siguiente programa:
Listado GRAFICA_MC.m
close all;
clear;
X = [-2, -1, 0, 1, 2];
Y = [0, 0, 1, 1, 3];
YC1= MINCUAD(X, Y, 1);
YC1 = YC1(1) + YC1(2) .* X;
YC2 = YC2(1) + YC2(2) .* X + YC2(3) .* X.^2;
YC3 = YC3(1) + YC3(2) .* X + YC3(3) .* X.^2 + YC3(4) .* X.^3;
figure(1);
plot(X, Y, ‘*’, X, YC1)
xlabel(‘X’); ylabel(‘Y’);
title(‘Polinomio de 1er. grado’);
figure(2);
plot(X, Y, ‘*’, X, YC2);
title(‘Polinomio de 2do. grado’);
figure(3);
plot(X, Y, ‘*’, X, YC3)
title(‘Polinomio de 3er. grado’);
31
Listado DIFLAGRANGE.m
Diferenciación numérica mediante el polinomio interpolador de Lagrange
function DY = DIFLAGRANGE(X, Y, XD)
% Sintaxis
% DY = DIFLAGRANGE(X, Y, XD)
% Entrada
% - XD es punto en que se desea evaluar la derivada
% Salida
% - DY es la aproximación a la primera derivada en XD
N = length(X);
DY = 0;
for I = 1 : N
32
P = 1;
for J = 1 : N
if I ~= J
P = P * (X(I) - X(J));
end
end
S = 0;
for K = 1 : N
if I ~= K
P1 = 1;
for J = 1 : N
if (J ~= I) & (J ~= K)
P1 = P1 * (XD - X(J));
end
end
S = S + P1;
end
end
DY = DY + Y(I) / P * S;
end
Para evaluar la derivada de la función dada en el Problema 3.1 (pág. 169), cuando x = 0:
x 0 1 2 3 4 5
y = f (x) –5 1 9 25 55 105
Ingresar lo siguiente en la ventana de comandos de MATLAB:

» X = [0, 1, 2, 3, 4, 5]
» Y = [-5, 1, 9, 25, 55, 105]
» DY = DIFLAGRANGE(X, Y, 0)
DY = 7
Para evaluar la derivada de la misma función para x = 0.5 y x = 3.5 (Problema 3.2, pág. 170), hacemos lo
siguiente:
» DY = DIFLAGRANGE(X, Y, 0.5)
DY = 5.75
DY = 29.75
Para evaluar la primera derivada de la función tabular dada en la página 180,
x 1 2 3 4 5 5
y = f (x) –13 –10 –5 2 11 105
Tipear lo siguiente en la ventana de comandos de MATLAB:

» X = [1, 2, 3, 4, 5]
» Y = [-13, -10, -5, 2, 11]
DY = 5
33
Listado DIFLIM.m
Diferenciación numérica mediante límites
function [L, N] = DIFLIM(F, X, EPS)
% Sintaxis
% [L, N] = DIFLIM(F, X, EPS)
% Entrada
% - X es el punto en el que se deriva
% - EPS es la tolerancia para el error
% Salida
% - L = [H, D, E]
% H es el vector de los 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 aproximación»
EPS = 2^(-52);
MAX = 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) > TOL)) & N < MAX
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;
H = H’;
D = D’;
E = E’;
L = [H, D, E];
Por ejemplo para obtener la derivada de ƒ(x) = cos(x) en x = 0.8, primero almacenamos la función como
un archivo, por ejemplo, F6.m, tal como se indica a continuación:
Listado F6.m
function Y = F6(X)
Y = cos(X);
return;
34
Luego en la ventana de comandos de MATLAB ingresar lo siguiente:

» [L, N] = DIFLIM(@F6, 0.8, 1e-9)
L =
1.0000 -0.603634336267164 0
0.1000 -0.716161095069120 0.1125267588019560000
0.0100 -0.717344135024456 0.0011830399553358600
0.0010 -0.717355971340150 1.18363156942358e-005
0.0001 -0.717356089703913 1.18363763235152e-007
1e-005 -0.717356090884635 1.18072207566655e-009
1e-006 -0.717356090917942 3.33066907387547e-011
1e-007 -0.717356090640386 2.77555756156289e-010
N = 7
Listado TRAPECIO.m
Regla compuesta del trapecio para aproximar la integral de una función dada en forma tabular, en
el intervalo
function S = TRAPECIO(X, FX)
% Sintaxis
% I = TRAPECIO(X, FX)
% Entrada
% - X es un vector que contiene la lista de variables independientes
% - FX es un vector que contiene la lista de variables dependientes o
% integrando
% - a y b son los extremos inferior y superior del intervalo de
% integración
% Salida
% - S es la aproximación a la integral con la regla compuesta del
% trapecio
N = length(X);
a = X(1);
b = X(N);
H = (b - a) / (N - 1);
S = 0;
for K = 2 : (N - 1)
S = S + FX(K);
end
S = (H / 2) * (FX(1) + 2 * S + FX(N));
Para integrar la función dada en forma tabular del Problema 4.1 (página 202):
x 0 1 2 3 4 5 6
y = f(x) –5 1 9 25 55 105 181
Digitar lo siguiente en la ventana de comandos de MATLAB:

» X = [0, 1, 2, 3, 4, 5, 6]
» Y = [-5, 1, 9, 25, 55, 105, 181]
» I = TRAPECIO(X, Y)
I = 283
35
Listado SIMPSON13.m
Regla compuesta de Simpson 1/3 para aproximar la integral de una función dada en forma tabular,
en el intervalo [a, b].
function S = SIMPSON13(X, FX)
% Sintaxis
% I = SIMPSON13(X, FX)
% Entrada
% integrando
% integración
% Salida
% Simpson 1/3
N = length(X);
a = X(1);
b = X(N);
H = (b - a) / (N - 1);
S1 = 0;
S2 = 0;
for K = 2 : 2 : (N - 1)
S1 = S1 + FX(K);
end
for K = 3 : 2 : (N - 2)
S2 = S2 + FX(K);
end
S = (H / 3) * (FX(1) + 4 * S1 + 2 * S2 + FX(N));
Para integrar la misma función del ejemplo anterior (Problema 4.1, página 202), ingresar lo siguiente en
la ventana de comandos de MATLAB:
» X = [0, 1, 2, 3, 4, 5, 6]
» Y = [-5, 1, 9, 25, 55, 105, 181]
» I = SIMPSON13(X, Y)
I = 276
Listado SIMPSON38.m
Regla compuesta de Simpson 3/8 para aproximar la integral de una función dada en forma tabular,
en el intervalo [a, b].
function S = SIMPSON38(X, FX)
% Sintaxis
% I = SIMPSON38(X, FX)
% Entrada
% integrando
% integración
% Salida
36

% Simpson 3/8
N = length(X);
a = X(1);
b = X(N);
H = (b - a) / (N - 1);
S1 = 0;
S2 = 0;
for K = 2 : (N - 1)
if mod(K - 1, 3) == 0
S1 = S1 + FX(K);
else
S2 = S2 + FX(K);
end
end
S = (3 * H / 8) * (FX(1) + 2 * S1 + 3 * S2 + FX(N));
Para integrar la misma función del ejemplo anterior , ingresar lo siguiente en la ventana de comandos de
MATLAB:
» X = [0, 1, 2, 3, 4, 5, 6]
» Y = [-5, 1, 9, 25, 55, 105, 181]
» I = SIMPSON38(X, Y)
I = 276
Para integrar la función tabular dada en el Problema 4.2 (página 203), desde tal como se muestra:
x 0 1 2 3 4 5
y = f(x) –5 1 9 25 55 105
Como el número de subintervalos es impar (en este caso 5) aplicamos una combinación de las fórmulas
de Simpson 1/3 y Simpson 3/8, veamos:
» X1 = [0, 1, 2, 3]
» Y1 = [-5, 1, 9, 25]
» X2 = [3, 4, 5]
» Y2 = [25, 55, 105]
» I = SIMPSON38(X1, Y1) + SIMPSON13(X2, Y2)
I = 135.4167
Listado ROMBERG.m
Aproximación a la integral de una función y = ƒ(x) dada en forma analítica mediante el método de
integración de Romberg, en el intervalo [a, b].
function [R, Q, EPS, H] = ROMBERG(F, a, b, K, TOL)
% Sintaxis
% [R, Q, EPS, H] = ROMBERG(F, a, b, K, TOL)
% Entrada
% - F es la función integrando, almacenada como un archivo F.m
% integración
37
% - K es el número máximo de filas de la tabla

% - TOL es la tolerancia
% Salida
% - R es el esquema de Romberg
% - Q es la aproximación a la integral
% - EPS es una estimación del error
% - H es el menor de los incrementos utilizados
N = 1;
H = b - a;
EPS = 1;
J = 0;
R = zeros(4, 4);
R(1, 1) = H * (feval(F, a) + feval(F, b)) / 2;
while ((EPS > TOL) & (J < K)) | (J < 4)
J = J + 1;
H = H / 2;
S = 0;
for P = 1 : N
X = a + H * (2 * P - 1);
S = S + feval(F, X);
end
R(J + 1, 1) = R(J, 1) / 2 + H * S;
N = 2 * N;
for M = 1 : J
R(J + 1, M + 1) = R(J + 1, M) + (R(J + 1, M) - R(J, M)) / (4^M - 1);
end
EPS = abs(R(J, J) - R(J + 1, M + 1));
end
Q = R(J + 1, J + 1);
Luego, para obtener el valor de la siguiente integral , dada en el Problema 4.7

(pág. 217), primero tiene que almacenar la función como un archivo, por ejemplo F3.m, tal como se
muestra a continuación:
Listado F3.m
function Y = F3(X)
Y = 4 * X^3 - 3 * X^2 + 2 * X + 1;
return;
Luego, en la ventana de comandos de MATLAB ingresar las siguientes instrucciones:

» [R, I, EPS, H] = ROMBERG(@F3, 0, 1, 4, 1e-2)
R =
2.500000000 0 0 0 0
2.125000000 2.0000 0 0 0
2.031250000 2.0000 2.0000 0 0
2.007812500 2.0000 2.0000 2.0000 0
2.001953125 2.0000 2.0000 2.0000 2.0000
I = 2
EPS = 0
H = 0.0625
38
Listado GAUSS_LEGENDRE.m
Aproximación a la integral de una función dada en forma analítica mediante la fórmula de la
cuadratura de Gauss-Legendre, en el intervalo [a, b].
function Q = GAUSS_LEGENDRE(F, a, b, N)
% Sintaxis
% I = GAUSS_LEGENDRE(F, a, b, N)
% Entrada
% - F es la función integrando, almacenada como un archivo F.m
% integración
% - N es el número de puntos a utilizar (2, 3, 4, 5 ó 6)
% Salida
% - Q es la aproximación a la integral
NP(1) = 2; NP(2) = 3; NP(3) = 4; NP(4) = 5; NP(5) = 6;
IAUX(1) = 1; IAUX(2) = 2; IAUX(3) = 4;
IAUX(4) = 6; IAUX(5) = 9; IAUX(6) = 12;
Z(1) = 0.577350269; Z(2) = 0.0; Z(3) = 0.774596669;
Z(4) = 0.339981044; Z(5) = 0.861136312; Z(6) = 0.0;
Z(7) = 0.53846931; Z(8) = 0.906179846; Z(9) = 0.238619186;
Z(10) = 0.661209387; Z(11) = 0.932469514;
W(1) = 1.0; W(2) = 0.888888889; W(3) = 0.555555556;
W(4) = 0.652145155; W(5) = 0.347854845; W(6) = 0.568888889;
W(7) = 0.478628671; W(8) = 0.236926885; W(9) = 0.467913935;
W(10) = 0.360761573; W(11) = 0.171324493;
I= 0;
for J =1 : 5
if N == NP(J)
I = J;
end
if I == 0
Q = 0;
else
J1 = IAUX(I);
J2 = IAUX(I + 1) - 1;
C = (b - a) / 2;
D = (b + a) / 2;
S = 0;
for J=J1 : J2
if Z(J) == 0
S = S + W(J) * F(D);
end
if Z(J) ~= 0
S = S + W(J) * (F(Z(J) * C + D) + F(-Z(J) * C + D));
end
end
Q = C * S;
end
end
39
Luego, para obtener la integral de la función , dada en el Problema 4.8 (pág. 222),
primero se debe almacenar la función como un archivo, por ejemplo F4.m, veamos:
Listado F4.m
function Y = F4(X)
Y = X^3 + X^2 + X + 1;
return;
Luego, en la ventana de comandos de MATLAB ingresar las siguientes instrucciones, para calcular la
integral mediante la fórmula de Gauss-Legendre de 2 puntos:
» I = GAUSS_LEGENDRE(@F4, -1, 1, 2)
I = 2.66666666622874
Para la misma función, la integral evaluada desde a = 1 hasta b = 3 (ver pág. 224), el resultado se puede
obtener mediante las siguientes instrucciones en la ventana de comandos:
» I = GAUSS_LEGENDRE(@F4, 1, 3, 2)
I = 34.66666666360121
Para calcular la integral de la función (Problema 4.9, pág. 223) mediante la fórmula de Gauss-
Legendre de 5 puntos, primero almacenamos la función como un archivo, para este caso F5.m, tal como
se indica a continuación:
Listado F5.m
function Y = F5(X)
Y = 1 / X;
return;
Luego, en la ventana de comandos de MATLAB digitar lo siguiente:
» I = GAUSS_LEGENDRE(@F5, 1, 2, 5)
I = 0.69314715819178
Listado THOMAS.m
Método de Thomas para la resolución de un sistema tridiagonal AX = B
function [X] = THOMAS(A, B)
% Sintaxis
% X = THOMAS(A, B)
% Entrada
% - A es la matriz de coeficientes del sistema tridiagonal
% - B es el vector de términos independientes (vector columna)
% Salida
% - X es el vector solución del sistema tridiagonal AX = B
N = length(B);
b = diag(A, 0);
a = [0; diag(A, -1)];
c = [diag(A, 1); 0];
d = B;
for I = 1 : (N - 1)
if b(I) == 0
40
disp(‘El sistema no tiene solución...’);

return;
end
b(I + 1) = b(I + 1) - a(I + 1) * c(I) / b(I);
d(I + 1) = d(I + 1) - a(I + 1) * d(I) / b(I);
end
if b(N) == 0
disp(‘El sistema no tiene solución...’);
return;
end
X(N) = d(N) / b(N);
for I = (N - 1) : -1 : 1
X(I) = (d(I) - c(I) * X(I + 1)) / b(I);
end
X = X’;
Para resolver el sistema dado en el Problema 5.2 (página 265), ingresamos las siguientes instrucciones en
la ventana de comandos de MATLAB:
» A = [ 4, 1, 0, 0, 0;
-8, -1, 1, 0, 0;
0, 3, -2, 4, 0;
0, 0, 1, -1, 1;
0, 0, 0, 2, 6]
» B = [-1; 13; -3; 2.1; 3.4]
» [X] = THOMAS(A, B)
X =
0.9250
-4.7000
15.7000
10.6250
-2.9750
Nota: En MATLAB este sistema pudo resolverse directamente mediante la siguiente orden en la ventana
de comandos:
» X = inv(A) * B
X =
0.9250
-4.7000
15.7000
10.6250
-2.9750
El mismo resultado se obtiene si hacemos:

» X = A^(-1) * B
O también:
» X = A \ B
Queda como tarea para el lector comprobar los resultados de estas dos últimas órdenes.
41
Listado TRIDIAG3.m
Resolución de un sistema tridiagonal por bloques en tres etapas, de la forma:
function [X1, X2, X3] = TRIDIAG3(A1, A2, A3, B1, B2, B3, C1, C2, C3, D1, D2, D3)
P1 = inv(B1) * C1;
Q1 = inv(B1) * D1;
P2 = inv(B2 - A2 * P1) * C2;
Q2 = inv(B2 - A2 * P1) * (D2 - A2 * Q1);
P3 = inv(B3 - A3 * P2) * C3;
Q3 = inv(B3 - A3 * P2) * (D3 - A3 * Q2);
X3 = Q3;
X2 = Q2 - P2 * X3;
X1 = Q1 - P1 * X2;
Luego, para resolver el sistema tridiagonal por bloques planteado en el Problema 5.3 (página 269),
primero ingresamos las matrices bloques:
» b1 = [1, 2, 1; » b2 = [1, 2,
1; » b3 = [2, 1, 1;
2, 1, 1; 2, 2,
0; 1, 1, 1;
1, 2, 2] 2, 1,
1] 3, 1, 2]
» a1 = zeros(3) » a2 = [0, 1,
3; » a3 = [0, 1, 2;
0, 0, 1; 0, 0, 2;
0, 0, 2] 0, 0, 1]
» c1 = [2, 2, 1; » c2 = [1, 2, 1; » c3 = zeros(3)
2, 1, 0; 1, 2, 0;
1, 2, 0] 1, 1, 0]
» d1 = [9; 7; 8] » d2 = [12; 8; 8] » d3 = [7; 5; 6]
Luego, llamamos al programa que acabamos de crear:

» [X1, X2, X3] = TRIDIAG3(a1, a2, a3, b1, b2, b3, c1, c2, c3, d1, d2, d3)
X1 = 1.0000 X2 = 1.0000 X3 = 1.0000
1.0000 1.0000 1.0000
1.0000 1.0000 1.0000
Nota: Otra forma de resolver el problema anterior es aprovechando la capacidad de MATLAB para el
cálculo matricial, veamos:
Primero construimos la matriz de coeficientes A y la matriz de términos independientes B, respectivamente:
» A = [b1, c1, zeros(3); a2, b2, c2; zeros(3), a3, b3]
A =
1 2 1 2 2 1 0 0 0
2 1 1 2 1 0 0 0 0
1 2 2 1 2 0 0 0 0
0 1 3 1 2 1 1 2 1
0 0 1 2 2 0 1 2 0
0 0 2 2 1 1 1 1 0
0 0 0 0 1 2 2 1 1
0 0 0 0 0 2 1 1 1
0 0 0 0 0 1 2 1 2
42
» B = [d1; d2; d3]

B = 9
7
8
12
8
8
7
5
6
Luego, el sistema se resuelve mediante la siguiente orden:

» X = inv(A) * B
X =
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
Listado PUNTOFIJO_MV.m
Resolución de un sistema de ecuaciones no lineales F(X) = 0 mediante el método del punto fijo
multivariable con desplazamientos simultáneos
function [Xp, ITER, FLAG] = PUNTOFIJO_MV(G, X0, EPS, MAXIT)
% Sintaxis
% PUNTOFIJO_MV(G, X0, EPS, MAXIT)
% Entrada
% - G es el sistema de ecuaciones no lineales, almacenado como G.m
% - X0 es el vector de valores iniciales
% - EPS es el criterio de convergencia
% Salida
% - Xp es el vector solución
% contrario es 0
for K = 1 : MAXIT
X = feval(G, X0);
if norm(X - X0) <= EPS
Xp = real(X);
ITER = K;
FLAG = 1;
return;
end
X0 = X;
end
ITER = MAXIT;
FLAG = 0;
43
Luego, para resolver el sistema de ecuaciones no lineales dado en el Problema 6.1 (página 287),
Primero tenemos que almacenar el sistema como un archivo, por ejemplo FG_2EC.m, veamos:
Listado FG_2EC.m
function G = FG_2EC(X)
G(1) = (4 - sqrt(X(2)))^3 / 8;
G(2) = sqrt(17 - X(1)^2);
return;
Ahora, en la ventana de comandos de MATLAB digitar lo siguiente:

» [Xp, ITER, FLAG] = PUNTOFIJO_MV(@FG_2EC, [0.5, 0.5], 1e-6, 25)
Xp = 0.999999719761863 4.0000000005318
ITER = 17
FLAG = 1
Listado NEWTON_MV.m
Resolución de un sistema de ecuaciones no lineales mediante el método de Newton – Raphson
estándar
function [Xp, ITER, FLAG] = NEWTON_MV(F, JF, X, EPS1, EPS2, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = NEWTON_MV(F, JF, X, EPS1, EPS2, MAXIT)
% Entrada
% - F es el sistema de ecuaciones no lineales, almacenado como F.m
% - JF es la matriz jacobiana, almacenada como JF.m
% - X es el vector de valores iniciales
% Salida
% contrario es 0
Y = feval(F, X);
for K = 1 : MAXIT
J = feval(JF, X);
Q = X + (inv(J) * (-Y)’)’;
Y = feval(F, Q);
if (norm(Q - X) < EPS1) | (abs(Y) < EPS2)
ITER = K;
FLAG = 1;
Xp = real(Q);
return;
end
X = Q;
end
ITER = MAXIT;
FLAG = 0;
44
Luego, para resolver el sistema dado en el Problema 6.2 (página 293),
Primero almacenamos el sistema como un archivo F_2EC.m, tal como se muestra a continuación:
Listado F1_2EC.m
function Y = F1_2EC(X)
Y(1) = 1.6*X(1)^2 + 3.6*X(1)*X(2) - 7.8*X(1) - 2.6*X(2) + 5.2;
Y(2) = 0.9*X(2)^2 + 3.1*X(1)^2 - 6.2*X(1) + 6.2*X(2);
return;
Luego, la matriz jacobiana está dada por:
La cual almacenamos como un archivo, por ejemplo JF_2EC.m, tal como se indica:
Listado JF1_2EC.m
function W = JF1_2EC(X)
W(1, 1) = 3.2 * X(1) + 3.6 * X(2) - 7.8;
W(1, 2) = 6.2 * X(1) - 6.2;
W(2, 1) = 3.2 * X(1) - 2.6 * X(2);
W(2, 2) = 1.8 * X(2) + 6.2;
return;
Luego, para resolver el sistema, en la ventana de comandos de MATLAB ingresamos la siguiente orden:
» [Xp, ITER, FLAG] = NEWTON_MV(@F1_2EC, @JF1_2EC, [0.5, 0.4], 1e-6, 1e-
6, 25)
Xp = 0.831437674158452 0.45565479630685
ITER = 6
FLAG = 1
Listado NEWTON_MODIF.M
Resolución de un sistema de ecuaciones no lineales F(X) = 0 mediante el método de Newton –
Raphson modificado con desplazamientos sucesivos
function [Xp, ITER, FLAG] = NEWTON_MODIF(F, D, X, EPS1, MAXIT)
% Sintaxis
% [Xp, ITER, FLAG] = NEWTON_MODIF(F, D, X, EPS1, MAXIT)
% Entrada
% - F es el sistema de ecuaciones no lineales, almacenado como F.m
% - D son las derivadas, almacenadas como D.m
% - X es el vector de valores iniciales
% Salida
45

% contrario es 0
for K = 1 : MAXIT
XAUX = X;
for I = 1 : 2
FX = feval(F, X);
DX = feval(D, X);
X(I) = X(I) - FX(I) / DX(I);
end
if norm(XAUX - X) < EPS1
ITER = K;
FLAG = 1;
Xp = X;
return;
end
end
ITER = MAXIT;
FLAG = 0;
En este caso para resolver el sistema mostrado en el Problema 6.3 (página 297), el cual está dado por las
siguientes ecuaciones:
En primer lugar almacenamos el sistema como un archivo, por ejemplo:
Listado F2_2EC.m
function Y = F2_2EC(X)
Y(1) = 4 - (8 * X(1))^(1/3) - X(2)^(1/2);
Y(2) = 17 - X(1)^2 - X(2)^2;
return;
Además requerimos las siguientes derivadas:
Las cuales también deben estar almacenadas como un archivo, por ejemplo DF2.m:
Listado DF2_2EC.m
function dY = DF2_2EC(X)
dY(1) = -(8/3) * (8 * X(1))^(-2/3);
dY(2) = -2 * X(2);
return
Luego, para resolver el sistema, en la ventana de comandos de MATLAB ingresar la siguiente instrucción:
» [Xp, ITER, FLAG] = NEWTON_MODIF(@F2_2EC, @DF2_2EC, [4, 3], 1e-6, 25)
Xp = 0.9999999839973 4.00000000400067
ITER = 9
FLAG = 1
46
Listado EULER.m
Aproximación a la solución del problema del valor inicial y’ = ƒ(t, x) con y0 = y(a) en el intervalo [a, b],
mediante el método de Euler
function [t, Y] = EULER(F, a, b, Y0, N)
% Sintaxis
% [t, Y] = EULER(F, a, b, Y0, N)
% Entrada
% - a y b son los extremos del intervalo
% - Y0 es la condición inicial YO = Y(a)
% - N es ell número de pasos
% Salida
% - t es el vector de la abscisas o variable independiente
% - Y es el vector de las ordenadas o variable dependiente
H = (b - a) / N;
t = zeros(1, N + 1);
Y = zeros(1, N + 1);
t = [a: H: b];
Y(1) = Y0;
for J = 1 : N
Y(J + 1) = Y(J) + H * feval(F, t(J), Y(J));
end
t = t’;
Y = Y’;
Para resolver la ecuación diferencial dada en el Problema 7.1 (página 367),
; y(0) = 1
primero almacenamos la función como un archivo, por ejemplo ODEF1.m, según se indica a continuación:
Listado ODEF1.m
function DYDX = ODEF1(X, Y)
DYDX = (Y + 1) / (X - 1);
return;
Luego, en la ventana de comandos ingresar la siguiente orden:

» [X, Y] = EULER(@ODEF1, 0, 0.4, 1, 4)
X = 0 Y = 1.0
0.1 0.8
0.2 0.6
0.3 0.4
0.4 0.2
Listado RK2.m
Aproximación a la solución del problema del valor inicial y’ = ƒ(t, x) con y0 = y(a) el intervalo [a, b],
mediante el método de Runge – Kutta de segundo orden
function [t, Y] = RK2(F, a, b, Y0, N)
% Sintaxis
% [t, Y] = RK2(F, a, b, Y0, N)
47
% Entrada
% Salida
H = (b - a) / N;
t = zeros(1, N + 1);
Y = zeros(1, N + 1);
t = [a: H: b];
Y(1) = Y0;
for J = 1 : N
K1 = H * feval(F, t(J), Y(J));
K2 = H * feval(F, t(J) + H, Y(J) + K1);
Y(J + 1) = Y(J) + 0.5 * (K1 + K2);
end
t = t’;
Y = Y’;
Luego, para resolver la ecuación diferencial del ejemplo anterior Problema 7.1 (pág. 367) simplemente
ingresar la siguiente orden en la ventana de comandos de MATLAB:
» [X, Y] = RK2(@ODEF1, 0, 0.4, 1, 4)
X = 0 Y = 1.0
0.1 0.8
0.2 0.6
0.3 0.4
0.4 0.2
Para resolver la ecuación diferencial del Problema 7.5 (página 377), dada por:
; y(0.5) = 1
En primer lugar la almacenamos como un archivo, por ejemplo ODEF2.m, veamos:
Listado ODEF2.m
function DYDX = ODEF2(X, Y)
DYDX = X + 2 * X * Y;
return;
Luego, en la ventana de comandos de MATLAB ingresar la siguiente orden:

» [X, Y] = RK2(@ODEF2, 0.5, 1, 1, 5)
X = 0.5000 Y = 1.0000
0.6000 1.1740
0.7000 1.4057
0.8000 1.7129
0.9000 2.1209
1.0000 2.6661
48
Listado RK4.m
Aproximación a la solución del problema del valor inicial y’ = ƒ(t, x) con y0 = y(a) en el intervalo [a, b],
mediante el método de Runge – Kutta de cuarto orden
function [t, Y] = RK4(F, a, b, Y0, N)
% Sintaxis
% [t, Y] = RK4(F, a, b, Y0, N)
% Entrada
% Salida
H = (b - a) / N;
t = zeros(1, N + 1);
Y = zeros(1, N + 1);
t = [a: H: b];
Y(1) = Y0;
for J = 1 : N
K1 = H * feval(F, t(J), Y(J));
K2 = H * feval(F, t(J) + H/2, Y(J) + K1/2);
K3 = H * feval(F, t(J) + H/2, Y(J) + K2/2);
K4 = H * feval(F, t(J) + H, Y(J) + K3);
Y(J + 1) = Y(J) + (K1 + 2 * K2 + 2 * K3 + K4)/6;
end
t = t’;
Y = Y’;
Por ejemplo, para resolver la ecuación diferencial anterior (Problema 7.7, pág. 379), que está dada por:
; y(0.5) = 1
Como ya esta almacenada como ODEF2.m, simplemente digitar lo siguiente en la ventana de comandos
de MATLAB:
» [X, Y] = RK4(@ODEF2, 0.5, 1, 1, 5)
X = 0.5000 Y = 1.0000
0.6000 1.1744
0.7000 1.4069
0.8000 1.7155
0.9000 2.1260
1.0000 2.6755
Listado RK4_S.m
Aproximación a la solución del sistema de ecuaciones diferenciales:
x1’ = ƒ1(t, x1(t), x2(t), ... xm(t))
x2’ = ƒ2(t, x1(t), x2(t), ... xm(t))
.
.
.
xm’ = ƒm(t, x1(t), x2(t), ... xm(t))
49
Con x1(a) = α1 , x2(a) = α2 , ... xm(a) = αm en el intervalo [a, b], mediante el método de Runge – Kutta de
cuarto orden
function [t, Z] = RK4_S(F, a, b, Z0, N)
% Sintaxis
% [t, Z] = RK4_S(F, a, b, Z0, N)
% Entrada
% - F es el sistema de ecuaciones diferenciales, almacenado como un
% archivo F.m
% - Z0 es la condición inicial ZO = [X10, X20, X30, . . ., XM0]
% Salida
% - Z es el vector de resultados, Z = [X1, X2, X3, . . ., XM]
H = (b - a) / N;
t = zeros(1, N + 1);
Z = zeros(N + 1, length(Z0));
t = [a : H : b]’;
Z(1, :) = Z0;
for J = 1 : N
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
Para resolver el sistema dado en el Problema 7.14 (página 400), dado por:
y’ = 4x – y + 1
z’ = 2z – y
Con: y(0) = 1 ; z(0) = 1
En primer lugar debemos almacenar el sistema como un archivo, por ejemplo ODE1_S2.m, tal como se
indica:
Listado ODE1_S2.m
function [F] = ODE1_S2(X, Z)
F(1) = 4 * X - Z(1) + 1;
F(2) = 2 * Z(2) - Z(1);
return;
Luego, en la ventana de comandos de MATLAB ingresar la siguiente instrucción:

» [X, Z] = RK4_S(@ODE1_S2, 0, 0.6, [1, 1], 3)
X = 0.0000 Z = 1.0000 1.0000
0.2000 1.0749 1.2403
0.4000 1.2813 1.5646
0.6000 1.5953 1.9850
50
Listado TC_UESG_CR.m
Aproximación a la solución la ecuación diferencial de transferencia de calor, unidireccional,
régimen estacionario, sin generación en coordenadas rectangulares
function T = TC_UESG_CR(TA, TB)
% Sintaxis
% T = TC_UESG_CR(TA, TB)
% Entrada
% - TA, TB son las temperaturas en los extremos de la barra
% Salida
% - T = [T1, T2, T3, T4, T5]’ es un vector que retorna las temperaturas
% interiores de la barra
D(1) = -3;
D(5) = -3;
for I = 2 : 4
D(I) = -2;
end
for I = 1 : 4
D1(I) = 1;
end
A = diag(D1, -1) + diag(D, 0) + diag(D1, 1);
B(1) = -2 * TA;
B(5) = -2 * TB;
B = B’;
T = inv(A) * B;
Para resolver el problema 8.1 dado en la página 562, ingresar la siguiente orden en la ventana de comandos
de MATLAB:
» T = TC_UESG_CR(100, 500)
T =
140.00
220.00
300.00
380.00
460.00
Listado TC_UECG_CR.m
Aproximación a la solución la ecuación diferencial de transferencia de calor, unidireccional,
régimen estacionario, con generación en coordenadas rectangulares
function T = TC_UECG_CR(TA, TB, G, K, DX)
% Sintaxis
% T = TC_UECG_CR(TA, TB)
% Entrada
% - TA, TB son las temperaturas en los extremos de la barra
% - G es el término de generación
% - K es el coeficiente de conductividad
% - DX es el incremento de longitud
% Salida
C = G * DX^2 / K;
51
D(1) = -3;
D(5) = -3;
for I = 2 : 4
D(I) = -2;
end
for I = 1 : 4
D1(I) = 1;
end
B(1) = -2 * TA - C;
B(5) = -2 * TB - C;
for I = 2 : 4
B(I) = -C;
end
B = B’;
T = inv(A) * B;
de MATLAB:
» T = TC_UECG_CR(100, 200, 1e6, 0.5, 0.004)
T =
150.00
218.00
254.00
258.00
230.00
Listado TC_COND_CONV_UE_CR.m
Aproximación a la solución la ecuación diferencial de transferencia de calor por conducción y
convección, unidireccional, régimen estacionario, en coordenadas rectangulares
function T = TC_COND_CONV_UE_CR(TA, TInf, H, K, P, A, DX)
% Sintaxis
% T = TC_UECG_CR(TA, TInf, H, DX)
% Entrada
% - TA es la temperatura de la pared de la aleta
% - TInf es la temperatura del fluido
% - H es el coeficiente de transferencia de calor por convección
% - K es el coeficiente de transferencia de calor por conducción
% - P es el perímetro del sólido
% - DX es el incremento de longitud
% Salida
C = (H * P) / (K * A) * DX^2;
D(1) = -(3 + C);
D(5) = -(1 + C);
for I = 2 : 4
D(I) = -(2 + C);
end
for I = 1 : 4
D1(I) = 1;
end
52
B(1) = -(C * TInf) - (2 * TA);

for I = 2 : 5
B(I) = -(C * TInf);
end
B = B’;
T = inv(A) * B;
de MATLAB:
» T = TC_COND_CONV_UE_CR(100, 20, 20, 1, 1, 1, 0.2)
T =
67.3513
39.9351
28.4670
23.7724
22.0958
Listado EXPLICITO.m
Resolución de la ecuación diferencial parcial:
Mediante el método explícito.

function [TMALLA] = EXPLICITO(CI, CF1, CF2, NX, Nt, XF, tF, ALFA)
% Sintaxis
% [TMALLA] = EXPLICITO(CI, CF1, CF2, NX, Nt, XF, tF, ALFA)
% Entrada
% - CI es la condición inicial, almacenada como un archivo CI.m
% - CF1 y CF2 son las condiciones de frontera, almacenadas como archivos
% CF1.m y CF2.m, respectivamente
% - NX es el número de puntos de la malla en el eje X
% - Nt es el número de puntos de la malla en el eje t
% - XF es la longitud total del eje X
% - tF es la longitud total del eje t
% - ALFA es el coeficiente de la derivada de segundo orden
% Salida
% - TMALLA es una matriz que contiene la tabla (malla) con los valores de
% la variable dependiente T a lo largo del eje X a distintos tiempos t
DX = XF / (NX - 1);
Dt = tF / (Nt - 1);
LAMBDA = ALFA * Dt / DX^2;
for I = 2 : (NX - 1)
T(I) = CI(DX * (I - 1));
end
T(1) = (CI(DX) + CF1(Dt)) / 2;
53
T(NX) = (CI(XF - DX) + CF2(Dt)) / 2;

TMALLA(1, :) = T;
for J = 1 : (Nt - 1)
for I = 2 : (NX - 1)
T1(I) = LAMBDA * T(I - 1) + (1 - 2 * LAMBDA) * T(I) + LAMBDA * T(I
+ 1);
end
for I = 2 : (NX - 1)
T(I) = T1(I);
end
T(1) = CF1(Dt * J);
T(NX) = CF2(Dt * J);
TMALLA(J + 1, :) = T;
end
Por ejemplo, para resolver el Problema 9.3 (página 692), el cual presenta los siguientes datos:
u(x;0) = 0 u(0;t) = 50 u(1;t) = 50
Entonces primero tenemos que crear los archivos para la condición inicial y para las condiciones de
frontera.
Listado C1.m
function T0 = CI(X)
T0 = 0;
return;
Listado CF1.m
function T = CF1(t)
T = 50;
return;
Listado CF2.m
function T = CF2(t)
T = 50;
return;
Luego, en la ventana de comandos de MATLAB ingresar la siguiente orden:

» TMALLA = EXPLICITO(@CI, @CF1, @CF2, 6, 4, 1, 0.03, 1)
TMALLA =
25.0000 0 0 0 0 25.0000
50.0000 6.2500 0 0 6.2500 50.0000
50.0000 15.6250 1.5625 1.5625 15.6250 50.0000
50.0000 20.7031 5.0781 5.0781 20.7031 50.0000
Para obtener de manera gráfica una distribución de la temperatura en la barra para diferentes tiempos,
ingresar las siguientes órdenes en la ventana de comandos de MATLAB:
» plot(X, TMALLA(1, :), X, TMALLA(2, :), X, TMALLA(3, :), X, TMALLA(4, :))
» xlabel(‘X’);
» ylabel(‘T’);
54
Para obtener la gráfica de la solución numérica de la EDP de conducción de calor en una sola dimensión
hacer:
» surf(X, t, TMALLA)
» xlabel(‘X’); ylabel(‘t’); zlabel(‘T’);
Listado IMPLICITO.m
Resolución de la ecuación diferencial parcial:
55
Mediante el método implícito.

function [TMALLA] = IMPLICITO(CI, CF1, CF2, NX, Nt, XF, tF, ALFA)
% Sintaxis
% [TMALLA] = IMPLICITO(CI, CF1, CF2, NX, Nt, XF, tF, ALFA)
% Entrada
% - CI es la condición inicial, almacenada como un archivo CI.m
% - CF1 y CF2 son las condiciones de frontera, almacenadas como archivos
% CF1.m y CF2.m, respectivamente
% - NX es el número de puntos de la malla en el eje X
% - Nt es el número de puntos de la malla en el eje t
% - XF es la longitud total del eje X
% - tF es la longitud total del eje t
% - ALFA es el coeficiente de la derivada de segundo orden
% Salida
% - TMALLA es una matriz que contiene la tabla (malla) con los valores de
% la variable dependiente T a lo largo del eje X a distintos tiempos t
DX = XF / (NX - 1);
Dt = tF / (Nt - 1);
LAMBDA = ALFA * Dt / DX^2;
for I = 2 : (NX - 1)
T(I) = CI(DX * (I - 1));
end
T(1) = (CI(DX) + CF1(Dt)) / 2;
T(NX) = (CI(XF - DX) + CF2(Dt)) / 2;
TMALLA(1, :) = T;
for I = 1 : (NX - 3)
A(I) = - LAMBDA;
C(I) = - LAMBDA;
end
for I = 1 : (NX - 2)
B(I) = 1 + 2 * LAMBDA;
end
for J = 1 : (Nt – 1)
T(1) = CF1(Dt * J);
T(NX) = CF2(Dt * J);
for I = 1 : (NX - 2)
D(I) = T(I + 1);
end
D(1) = D(1) + LAMBDA * T(1);
D(NX - 2) = D(NX - 2) + LAMBDA * T(NX);
AA = diag(A, -1) + diag(B, 0) + diag(C, 1);
X = inv(AA) * D’;
for I = 1 : (NX - 2)
T(I + 1) = X(I);
end
TMALLA(J + 1, :) = T;
end
Para el problema del caso anterior, en la ventana de comandos de MATLAB ingresar la siguiente orden:
» TMALLA = IMPLICITO(@CI, @CF1, @CF2, 6, 4, 1, 0.03, 1)
TMALLA =
25.0000 0 0 0 0 25.0000
50.0000 8.6207 1.7241 1.7241 8.6207 50.0000
50.0000 14.8038 4.3401 4.3401 14.8038 50.0000
50.0000 19.4288 7.3578 7.3578 19.4288 50.0000
56

Matlab Aplicado

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Matlab Aplicado

Caricato da

Copyright:

Formati disponibili

Capítulo

10.1 INTRODUCCIÓN A MATLAB

10.2 ¿QUÉ ES MATLAB?

MATLAB (MATrix LABoratory) es un entorno integrado de computación orientado hacia la resolución de

Algunas características notables de MATLAB son:

• Transportabilidad de los programas MATLAB.

10.3 EJECUTANDO MATLAB

10.4 TIPOS DE DATOS

Son identificadores válidos y diferentes entre sí.

10.6 OPERADORES EN MATLAB

Funciones relacionales y lógicas

Funciones exponenciales y logarítmicas

En MATLAB los valores lógicos 0 y 1 corresponden a verdadero y falso, respectivamente.

Funciones predefinidas de MATLAB

Funciones con números enteros y divisibilidad

Funciones trigonométricas Funciones hiperbólicas

cos(x) cos(x) cosh(x) cosh(x)

tan(x) atan(x), atan2(x) tanh(x) atanh(x)

cot(x) acot(x) coth(x) acoth(x)

sec(x) asec(x) sech(x) asech(x)

csc(x) acsc(x) csch(x) acsch(x)

Funciones exponenciales y logarítmicas

Funciones específicas de variable numérica real

10.7 FORMATOS DE VISUALIZACIÓN DE NÚMEROS

En la Tabla siguiente se muestran los formatos numéricos establecidos por MatLab.

Orden de MatLab Comentarios

10.8 INFORMACIÓN SOBRE LAS VARIABLES

El mismo resultado se obtiene si utilizamos cualquiera de las siguientes órdenes:

Tipos de línea Tipo de marca Color de línea

Las gráficas de superficie permiten obtener representaciones densas de figuras tridimensionales y en

Para graficar una función de este tipo, el procedimiento es el siguiente:

La sintaxis básica de estos comandos es:

» [X, Y] = meshgrid(-7.5: 0.5: 7.5);

» X = [-3: 0.2: 3];

10.11 ESCRITURA DE PROGRAMAS

En la ventana de edición de programas (Editor/Debugger) se abre con un archivo en blanco en el cual

10.12 INSTRUCCIONES DE ENTRADA Y SALIDA

Donde EXPRESIÓN puede ser un valor numérico o una cadena de caracteres.

Recordar que la solución del sistema está dada por:

Para ello ingrese en la ventana de comandos de MATLAB lo siguiente:

10.13 CONTROL DE FLUJO

Utilizando el algoritmo de Newton–Raphson, tomando como valor inicial .

La instrucción break permite salir de un bucle antes de que este se complete.

La sintaxis para definir una función es:

Para invocar una función hacemos uso de la siguiente sintaxis:

Donde LISTA_ARGUMENTOS debe coincidir con el número de PARÁMETROS_ENTRADA, de lo contrario

Luego, desde la ventana de comandos vamos a invocar a la función recientemente creada:

Lo cual produce el mismo resultado.

» PSAT = ANTOINE(14.0045, 3279.47, 213.2, 347.20 - 273.15)

10.15 PROBLEMAS DESARROLLADOS APLICANDO MATLAB

Luego, para obtener el resultado, en la ventana de comandos de MATLAB ingresar lo siguiente:

» [Xp, ITER, FLAG] = BISECCION(@F1, 2, 4, 1e-6, 1e-6, 25)

function [Xp, ITER, FLAG] = PUNTOFIJO(G, X0, EPS1, MAXIT)

Luego, en la ventana de comandos tipear lo siguiente para obtener el resultado:

» [Xp, ITER, FLAG] = PUNTOFIJO(@G1, 3, 1e-6, 25)

Sin embargo, para el método de Newton – Raphson es necesaria la derivada de la función:

Para obtener el resultado ingresar lo siguiente en la ventana de comandos de MATLAB:

Luego, en la ventana de comandos:

% - EPS1 es el criterio de convergencia

F210 = (F21 - F10) / (X2 - X0);

Para hallar el valor de la función en x = 3, en la ventana de comandos de MATLAB tipear:

x 1.0 1.3 1.6 1.9 2.2

Para ello en la ventana de comandos de MATLAB ingresar la siguiente orden: