Grados de la EPSE

Prcticas de Matlab
Prctica 3

1.

Programar en Matlab (parte II)

1.1.

Bucles

Los bucles son una herramienta fundamental en programacin. Veamos cmo se utilizan en Matlab.
1.1.1.

Bucles simples

Permiten repetir un nmero determinado de veces un conjunto de instrucciones. Su

sintaxis es la siguiente:
for var = vector
Instrucciones que deben ejecutarse
end
El argumento vector puede ser efectivamente un vector, en cuyo caso la variable va
tomando los valores de las componentes del vector, o una estructura de la forma
inicio : incremento : n;
en cuyo caso la variable va tomando valores desde inicio hasta n con un determinado
incremento. Si no se indica el valor del incremento, ste se toma como unidad. El nmero
de veces que se repite el bucle viene dado por la dimensin del vector.
La ejecucin del bucle puede interrumpirse en cualquier momento mediante la instruccin break.
Veamos algunos ejemplos, como pueden ser el clculo de una serie o un factorial:
P
Ejemplo. Calcular la serie ni=1 i2
function serie=SumaCuadrados(n)
serie=0;
for i=1:n
serie=serie+i*i;
end

Ejercicio 1 Escribir un programa para calcular n!.

Ejercicio 2 Escribir un programa cuya variable de entrada sea una matriz y que calcule
la suma de todos sus nmeros. Nota: hay que utilizar un bucle f or doble y el comando
size para hallar el nmero de las y columnas de la matriz.

1.1.2.

Bucles condicionales

Permiten repetir un conjunto de instrucciones, en tanto se satisfaga una condicin

lgica. Su sintaxis es la siguiente:
while condicin
Instrucciones que deben ejecutarse mientras la condicin sea cierta.
end
Ejemplo. Calcular el valor de n 2 N ms pequeo tal que 2

<"

function n=Epsilon(eps)
n=1;
h=2^(-n);
while h>=eps
n=n+1;
h=2^(-n);
end
Ejercicio 3 Usando el comando while escribir un programa para calcular n!.
Ejercicio para casa: Escribir un programa (usando el comando while) que calcule
la parte entera de un nmero x 0:

1.2.

Entradas del usuario

Los valores de una variable, ya sea un escalar, un vector, una funcin o una matriz
pueden introducirse a travs del teclado usando el comando input. Por ejemplo
x = input(`Introduzca valores de x entre corchetes:`);
solicita la introduccin de un vector.
Si terminamos con ; despus de introducir los valores de x no los escribir en pantalla,
sin embargo si no ponemos ; despus de introducir los valores lo volver a imprimir en
pantalla.
Exhibicin de texto y valores
El comando disp permite escribir texto encerrado entre apstrofes y el valor actual
de una variable. Por ejemplo, si en el progama escribimos:
2

a=2;
disp(a);
disp(unidades);
obtenemos en pantalla
2
unidades
Si queremos tener un mayor control en la salida de datos o de texto , es decir, darles
con un formato determinado utilizaremos el comando fprintf. La forma general de este
formato es:
f printf (f ormato; matrices):
Dentro del formato se utilizan los especicadores %e, %f, %g, %d, %s para especicar
donde se escribirn los valores de la matriz:
%e: notacin exponencial.
%f: punto jo o decimal.
%d: variables enteras.
%g: formato %e, %d o %f, el que sea ms corto.
%s: cadenas de caracteres.
Por ejemplo:
a=2;
fprintf(El valor obtenido es nn %g unidades nn, a)
La salida correspondiente es:
El valor obtenido es
2 unidades
Nota: nn nos indica retorno de carro.
Los especicadores tambin pueden contener informacin sobre el nmero de posiciones decimales que aparecern y el nmero de posiciones que se destinarn al valor
correspondiente. Es decir, si ponemos %4.1f el valor correspondiente aparecer usando
cuatro dgitos, uno de los cuales es decimal.
Ejemplo. Calcular el valor de n 2 N ms pequeo tal que 2 n < ". El valor de epsilon
se solicitar al usuario. Al nal del programa se imprimir el valor de n con formato de
nmros enteros con algn comentario explicativo.
function n=Epsilon
eps=input(Introduzca el valor de epsilon:);
n=1;
h=2^(-n);
3

while h>=eps
n=n+1;
h=2^(-n);
end
fprintf(El valor de n es %d,n);
Si ejecutamos, por ejemplo, el comando
Epsilon
el valor de n se imprimir dos veces:
El valor de n es 10
ans =
10
En cambio, si escribimos
Epsilon;
slo se imprimir una vez.

1.3.

Variables nargin y nargout

Al ejecutar un programa se asigna a la variable nargin el nmero de argumentos de

entrada (al ejecutar la funcin desde la lnea de comandos) y a la variable nargout el
nmero de argumentos de salida. Esto permite crear programas con diferentes nmeros
de argumentos de entrada y de salida.
Por ejemplo, podemos crear una funcin en la que es opcional introducir los argumento
de entrada o no. Usando la funcin nargin podemos comprobar si el usuario ejecuta
la funcin introduciendo menos argumentos de entrada de los necesarios, en cuyo caso
podemos obligarle a introducirlos a travs de la funcin input, y as evitamos que el
ejecutar el programa nos d error.
Ejemplo.
Vamos a modicar el programa de clculo del valor de n 2 N ms pequeo tal que
n
2 <":
function n=Epsilon3(eps)
if nargin<1
eps=input(Introduzca el valor de epsilon:);
end
n=1;
h=2^(-n);
while h>=eps
n=n+1;
h=2^(-n);
end
4

Ejercicio 4 Modicar el programa del ejercicio 3 de forme que si el nmero de argumentos de entrada es menor que 1 se solicite esta informacin mediante el comando input.
Adems, utilizar el comando fprintf para imprimir la siguiente frase: El factorial de n
es f . Imprimir n y f en formato de enteros. Poner al nal un salto de lnea.

1.4.

rdenes de ruptura

Puede ocurrir que al ejecutar un programa, si se da una determinada circunstancia,

queramos parar la ejecucin del mismo denitivamente o hasta que pase cierto intervalo
de tiempo. Las rdenes break, return y pause permiten realizar esto, bajo diferentes
circunstancias y con los resultados que se detallan.
1. La orden break para la ejecucin de un bucle de tipo for o while.
2. La orden return detiene la ejecucin del chero .m donde se halle esta instruccin,
es decir, si el chero donde se encuentra la orden return haba sido llamado por uno
anterior, contina la ejecucin de ste.
3. La instruccin pause(x) realiza una pausa de x segundos antes de ejecutar la siguiente orden de programa.
Ejemplo.
Vamos a modicar el programa de clculo del valor de n 2 N ms pequeo tal que
n
2 < ", de forma que abortemos el programa si no se introduce el error mximo:
function n=Epsilon4(eps)
if nargin<1
disp(Es necesario introducir el error maximo permitido)
return
end
n=1;
h=2^(-n);
while h>=eps
n=n+1;
h=2^(-n);
end

2.
2.1.

Ecuaciones diferenciales ordinarias

El mtodo de Euler

A la hora de resolver la ecuacin diferencial numricamente no buscaremos una funcin

diferenciable, sino que hallaremos el valor aproximado de la solucin en un nmero nito
de puntos. El primer mtodo que veremos es el mtodo Euler.

Consideremos la ecuacin difeencial

dy
= f (t; y) :
dt
Por comodidad dividiremos el intervalo [t0 ; t0 + ] en el que buscamos la solucin en
N intervalos de igual longitud h = N denidos por los puntos
t0 < t1 = t0 + h < t2 = t0 + 2h < ::: < tN = t0 + N h = t0 + :
En cada punto tj ; j = 0; 1; :::; N 1 aproximamos la derivada con el esquema hacia
delante
y (t + h) y (t)
dy
(t) '
:
dt
h
Entonces tenemos
yj+1 yj
= f (tj ; yj ) ;
h
yj+1 = yj + hf (tj ; yj ) ;
j = 0; 1; 2; :::; N 1;

(1)

donde yj es la aproximacin de y (tj ) :

Para programar este mtodo en Matlab slo tenemos que escribir un bucle de tipo
"for". Si N es el nmero de intervalos, g es una funcin de las variables t e y denida con
el comando inline, t0 es el momento inicial, T es el momento nal y y0 es la condicin
inicial, entonces el bucle quedara de la siguiente manera:
%Calculamos el valor del paso h
h=(T-t0)/N;
%Calculamos el vector t = [t0 t0 + h t0 + 2h ::: T
t=t0:h:T;
%Resolvemos la ecuacin por el mtodo de Euler
y(1)=y0;
for i=1:N
y(i+1)=y(i)+h*g(t(i),y(i));
end

h T]

El resultado de los clculos son los vectores t e y, que contienen los momentos del
tiempo
t = [t (1) t (2) ::: t (N ) t (N + 1)]
= [t0 t0 + h t0 + 2h ::: T h T ]
y los valores aproximados de la solucin
y = [y (1) y (2) ::: y (N ) y (N + 1)]
= [y0 y1 ::: yN ] :
6

Es importante tener en cuenta que la numeracin del ndice i no es la misma que en las
frmulas (1). Esto es debido a que en Matlab no podemos utilizar el subndice i = 0 (los
vectores empiezan siempre con i = 1).
El cdigo del programa quedara de la siguiente manera:
function [t,y]=Euler(f,N,t0,T,y0)
g=inline(f,t,y);
h=(T-t0)/N;
t=t0:h:T;
y(1)=y0;
for i=1:N
y(i+1)=y(i)+h*g(t(i),y(i));
end
Ejercicio 5 Escribir el programa en un archivo *.m. Dado el problema
dy
= y + t; y (0) = 2; t 2 [0; 4];
dt
probar que funciona con N = 1000:
Abrir un script y efectuar los siguientes pasos:
1. Usando el programa con N = 1000 calcular el valor aproximado de la solucin en
t = 4: Mostrar el resultado con el comando f printf , indicando en la frase qu N se
utiliza. Utilizar el retorno de carro al nal.
2. Repetir los mismos pasos con N = 2000:
3. Resolver el problema con el comando dsolve y calcular el valor exacto de la solucin
en t = 4: Mostrar el resultado con el comando f printf:
4. Calcular el error de la solucin en ambos casos. Mostrar ambos resultados con el
comando f printf:
5. Calcular el cociente de los dos errores y ver si al doblar el nmero de intervalos el
error se reduce a la mitad, aproximadamente. Mostrar el cociente con el comando
f printf:

Ejercicio 6 Escribir un programa que resuelva una ecuacin diferencial para varias condiciones iniciales. Efectuar los siguientes pasos:
1. Las variables de entrada del programa son: f; N; t0 ; T; y0 ; donde y0 = [y01 ::::y0m ] es
un vector de condiciones iniciales.
2. Detectar en el programa el tamao del vector m con el comando length;
7

3. Usando un bucle de tipo f or y el progama de Euler resolver el problema para cada

una de las m condiciones iniciales, dibujndolas todas en una misma grca.
Aplicar el programa al problema
dy
= y + t; y (0) = y0 ; t 2 [0; 4]:
dt
Usar los siguientes datos iniciales: N = 1000, y0 = [ 3; 2; 0; 1; 3]:
Ejercicio 7 Escribir un programa que dibuje la soluciones del problema
dy
= y (y
dt

3) ; y (0) = y0 ; t 2 [t0 ; T ];

1) (y + 2) (y

para varias condiciones iniciales:

1. Las variables de entrada del programa son: N; t0 ; T; y0 ; donde y0 = [y01 ::::y0m ] es un
vector de condiciones iniciales.
2. Detectar en el programa el tamao del vector m con el comando length:
3. Fijar los ejes en
t0

T; 3;5

4:

4. Usando un bucle de tipo f or y el progama de Euler resolver el problema para cada

una de las m condiciones iniciales, dibujndolas todas en una misma grca.
5. Ejecutar el programa para N = 1000, t0 = 0, T = 1, y0 = [0; 1; 2; 3; 3; 0.1; 0.1; 2.8; 3;0001].
Otra posibilidad es introducir el tamao del paso h en lugar del nmero de intervalos.
En este caso conviene poner una comprobacin de que h es un divisor exacto de la longitud
del intervalo temporal. Para ello se puede poner la siguiente condicin: si el resto de la
T t0
divisin
es distinto de 0, entonces se imprimir un mensaje de aviso al usuario y
h
a
se abortar el programa con el comando return: Para calcular el resto de la divisin se
b
utiliza el comando rem (a; b) :
Ejercicios para casa:
1. Modicar el programa del ejercicio 5 de forma que en lugar del nmero de intervalos
N se introduzca el tamao del paso h. Poner en el programa la comprobacin de
que h es mltiplo de T t0: Probar el programa con el mismo ejemplo que en el
ejercicio anterior.
2. Repetir el ejercicio 5 para el problema
dy
= y 2 t; y (0) = 1; t 2 [0; 1]:
dt
8

3. Modicar el archivo 5 de forma que se obtenga tambin el grco de las dos soluciones aproximadas, una en azul y otra con cruces rojas.
4. Modicar el programa de Euler de forma que si el nmero de variables de entrada que
introduce el usuario es inferior a 5, el programa solicite los datos (usar el comando
input).