Introduccin al Matlab

El propsito de estas notas es hacer una rpida introduccin al matlab. Son slo unas
pequeas
muestras para dar idea de como funciona este programa. Para un estudio ms serio deben
consultarse otras referencias. En particular las que damos al final de esta pgina.
El nombre de Matlab viene de Matrix Laboratory y como el nombre indica matlab es
especialmente fuerte
en el tratamiento de matrices. Estos fueron sus orgenes, a los que se han ido incorporando
sucesivamente
ms capacidades, sobretodo grficas.
Matlab es una potente calculadora, por ejemplo calcula la suma de dos nmeros

>> 2+2
ans =
4
Aunque el ejemplo es sencillo ya vemos como actua matlab, se escriben las instrucciones
en
la lnea de comandos >> y despus de pulsar la tecla Intro aparece el resultado ms abajo
como variable ans.
El resultado no aparece visible en la pantalla si ponemos punto y coma ; al final de las
instrucciones, como en

>> A=rand(6); B=inv(A); B*A;
Si quitamos los puntos y comas de esta ltima expresin veremos el resultado. Para
escribirla de nuevo podemos usar la flecha hacia arriba del teclado, que nos recupera
los comandos escritos anteriormente en la sesin.

>> A=rand(6), B=inv(A), B*A
A =
0.1338 0.4514 0.6831 0.0164
0.7176 0.1536
0.2071 0.0439 0.0928 0.1901
0.6927 0.6756
0.6072 0.0272 0.0353 0.5869
0.0841 0.6992
0.6299 0.3127 0.6124 0.0576
0.4544 0.7275
0.3705 0.0129 0.6085 0.3676
0.4418 0.4784
0.5751 0.3840 0.0158 0.6315
0.3533 0.5548
B =
-18.9422 -0.1768 -27.4583 8.2189
14.1721 17.0665
10.6427 -0.8112 14.3231 -3.3853 -
9.0470 -7.7695
5.3157 -0.9261 7.4863 -1.8170 -
2.6566 -5.1051
4.6141 -0.4972 6.8101 -3.2198 -
2.1772 -3.1550
-9.7318 1.3315 -15.5596 3.3890
7.9718 9.3641
13.0642 0.4891 20.4944 -4.6187 -10.9522
-12.7382
ans =
1.0000 0.0000 0.0000 0.0000
0.0000 0.0000
0.0000 1.0000 0.0000 0
0.0000 0
-0.0000 -0.0000 1.0000 0.0000 -
0.0000 -0.0000
-0.0000 -0.0000 0.0000 1.0000 -
0.0000 0.0000
0.0000 0.0000 -0.0000 0.0000
1.0000 0.0000
0.0000 -0.0000 0.0000 0
0.0000 1.0000
Obsrvese la rapidez con que se han calculado estas matrices A=rand(6) encuentra una
matriz 6x6 de
nmeros aleatorios (cada uno entre 0 y 1), inv(A) calcula su inversa y luego comprobamos
que B*A
es la matriz identidad. Los nmeros negativos que aparecen son debido al redondeo (en este
caso
seran nmeros muy pequeos, pero negativos).
Veamos como maneja matab los nmeros:

>> pi
ans =
3.1416
>> format long
>> pi
ans =
3.14159265358979
Aunque nos da el valor de pi con distinto nmero de decimales en realidad matlab trabaja
internamente
con doble presicin, pero nos muestra distintos formatos. Para ver los distintos formatos
basta con usar el help:

>> help format (aparece el cuadro de la derecha -->)
Ejemplo: 10*pi 10*exp(1)
format short
31.4159
format long
31.41592653589793
format short e
3.1416e+001
format long e
3.141592653589793e+001
format short g
31.416
format long g
31.4159265358979
format hex
403f6a7a2955385e
format bank
31.42
format rat
3550/113
27.1828
27.18281828459045
2.7183e+001
2.718281828459045e+001
27.183
27.1828182845905
403b2ecd2dd96d44
27.18
2528/93
FORMAT SHORT Scaled
fixed point format
with 5 digits.
FORMAT LONG
Scaled fixed point
format with 15
digits.
FORMAT SHORT E
Floating point
format with 5
digits.
FORMAT LONG E
Floating point
format with 15
digits.
FORMAT SHORT G Best
of fixed or floating
point format with 5
digits.
FORMAT LONG G Best
of fixed or floating
point format with 15
digits.
FORMAT HEX
Hexadecimal format.
FORMAT + The
symbols +, - and
blank are printed

for positive,
negative and zero
elements.

Imaginary parts are
ignored.
FORMAT BANK Fixed
format for dollars
and cents.
FORMAT RAT
Approximation by
ratio of small
integers.
All computations in MATLAB are done in double precision.
Cada nmero se guarda en memoria como un vector de 8 bytes, lo que da una mantisa de
unos 15 16
dgitos decimales. Al ser 8 bytes = 64 bits de memoria, cada bit es como si fuera una cajita
donde se almacenan
los ceros o unos corrspondientes al nmero en binario. De estas cajitas o bits, una de ellas
corresponde al
signo (+ -), 11 bits al exponente y el resto, esto es 52 bits a la mantisa. Un nmero x ser
por tanto
x= signo x mantisa x 10
E


Los 2
11
=2048 posibles exponentes E se distribuyen entre -1023 s E s 1024, siendo el
nmero ms
grande posible del orden de (2-eps)*2
1023
~ 1,7977 x 10
308
y el nmero ms pequeo del
orden de
2
-1022
~ 2,25 x10
-308
. La mantisa de 52 bits nos da un epsilon mquina del orden de eps=2
-
52
~ 2,22 x10
-16
.
Recordenmos que el epsilon mquina eps se define como el nmero ms grande eps tal
que la mquina no
distingue entre 1 y 1+eps.
El nmero real ms grande, ms pequeo y epsilon mquina respectivamente, se
obtienen con

>>realmin
>>realmax
>>eps

Con matlab podemos ir escribiendo los comandos uno tras otro, pero cuando tenemos
que hacer un pequeo
programa o escribir muchos comandos suele resultar ms til escribir un fichero con las
instrucciones
y luego hacer que matlab los ejecute. Estos son los ficheros .m que no son ms que ficheros
de texto
a los que luego ponemos la extensin .m . Matlab lleva incorporado un editor que podemos
usar para
este propsito. Buscamos en File -> New -> M-file y escribimos en el editor que aparece

format long
primero=2.1;
segundo=2.1
for n=1:40
tercero=4*primero-3*segundo
primero=segundo;
segundo=tercero;
end
que luego guardamos en matlab con el nombre diferencias.m , ya que lo que hace este
programita es
calcular los sucesivos trminos de la sucesin a
n+2
=4 a
n
3 a
n+1
empezando con a
1
=2.1 y
a
2
=2.1
En este caso, como no hemos puesto punto y coma despus de la lnea de tercero, los
resultados
se irn escribiendo en la pantalla, unos debajo de otros a medida que se van calculando.

2.10000000000000
2.10000000000000
2.10000000000000
2.09999999999999
2.10000000000002
2.09999999999991
2.10000000000036
2.09999999999854
2.10000000000582
2.09999999997672
2.10000000009313
2.09999999962747
2.10000000149012
2.09999999403954
2.10000002384186
2.09999990463257
2.10000038146973
2.09999847412109
2.10000610351563
2.09997558593750
2.10009765625000
2.09960937500000
2.10156250000000
2.09375000000000
2.12500000000000
2
2.50000000000000
0.50000000000000
8.50000000000000
-23.50000000000000
1.045000000000000e+00
2
-
4.075000000000000e+00
2
1.640500000000000e+00
3
-
6.551500000000000e+00
3
2.621650000000000e+00
4
-
1.048555000000000e+00
5
4.194325000000000e+00
5
-
1.677719500000000e+00
6
6.710888500000000e+00
El resultado es sorprendente !!
Esperaramos ver que a
n
=2.1, para todo n. Por qu aparece
este extrao
comportamiento?
En realidad la ecuacin en diferencias a
n+2
=4 a
n
3 a
n+1
tiene
por solucin

donde
siendo C
1
y C
2
dos constantes cualesquiera. Las condiciones
iniciales a
1
=a
2
=2.1
determinan la solucin con constantes C
1
=1, C
2
=0. Pero debido
a que 2.1 en
base dos tiene una fraccin peridica que se repite
indefinidamente, ya que

al calcular
tercero=tercero=4*primero-3*segundo,
resulta que si eps es un nmero muy pequeo comparable al
epsilon mquina
a
3
=tercero=2.1+eps
al iterar ahora de nuevo con
a
2
=2.1, a
3
=2.1+eps,
como nuevas condiciones iniciales, resulta que la constante C
2

ya no es 0.
Lo que hace que la solucin errnea aumente exponencialmente
y enmascare
completamente la solucin prevista. Es un claro ejemplo de
inestabilidad
numrica.
6
-
2.684354350000000e+00
7
1.073741845000000e+00
8
!No te fes de los
ordenadores!


Comentarios al programa:

- 1) Si aadimos la instruccin fprintf(' %16.7f\n ',segundo);
aparecer una pantalla ms ordenada con los resultados en columna.
- 2)

format long
primero=2.1;
segundo=2.1;
fi=fopen('resultados.txt','w');
for n=1:40
tercero=4*primero-3*segundo;
primero=segundo;
segundo=tercero;

fprintf(fi,'%16.7f\n',segundo);
end
fclose(fi)
Este programa abre un fichero de texto
llamado resultados.txt donde se
escribirn
los clculos en columna.
Buscar en
>> help fprintf
para ms informacin sobre este y otros
comandos parecidos.
- 3)
a(1)=2.1;
a(2)=2.1;
for n=1:18
a(n+2)=4*a(n+1)-
3*a(n);
end
Este otro programa tiene una estructura ms
apropiada para
Matlab ya que va incrementando las componentes de
un
vector a.
Que luego se puede usar , por ejemplo, para
representar
grficamente como
>>plot(a)
Ver
>>whos
para observar
las variables que estn en memoria y como van
cambiando.
En matlab hay unos aadidos llamados Toolboxes que incorporan ms funciones y
posibilidades.
Una de ellas, que se incorpora en todas las versiones de Matlab para estudiantes, se llama
Symbolic Toolbox. Con ella podemos trabajar con el nmero de dgitos de mantisa que
deseemos, esta funcin es
vpa. Buscar en help vpa. El ejemplo siguiente nos da los 800 primeros dgitos de pi:

>> vpa(pi,800)
ans =
3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803
48253
4211706798214808651328230664709384460955058223172535940812848111745028410270193852110555
96446
2294895493038196442881097566593344612847564823378678316527120190914564856692346034861045
43266
4821339360726024914127372458700660631558817488152092096282925409171536436789259036001133
05305
4882046652138414695194151160943305727036575959195309218611738193261179310511854807446237
99627
4956735188575272489122793818301194912983367336244065664308602139494639522473719070217986
09437
0277053921717629317675238467481846766940513200056812714526356082778577134275778960917363
71787
2146844090122495343014654958537105079227968925892354201995611212902196086403441815981362
97747
713099605187072113499999983729780499510597317328160963186
Como otro ejemplo, calculemos con mantisa 3 la suma de los primeros 20 trminos
de la serie armnica, esto es

clear all
suma=1
for n=2:20
suma=vpa(vpa(suma,3)+vpa(1/n,3),3)
end
El resultado que obtenemos es suma =3.60. De no haber calculado con esta
mantisa obtendramos
>> suma =3.59773965714368
suma=0;
tic
for m=1:20
for
n=1:1000*m

suma=suma+1/n
;
end
t(m)=toc;
end
plot(t)

El programita de aqu arriba utiliza una grfica para representar el tiempo que ha tardado
Matlab en sumar distintas sumas
parciales de esta serie armnica. Cul es la suma de la serie armnica infinita? Todos
sabemos que diverge, esto es, que si vamos sumando ms y ms trminos las sumas
parciales se hacen tan grandes como queramos. Hay una manera divertida de pensar en la
suma de los trminos de una serie. Se puede pensar que tenemos una pulguita que va dando
saltitos, cada vez, en este caso, primero
de un metro, luego de medio, luego de una tercera parte, y as sucesivamente. Esto es que
en el salto n avanzara una distancia 1/n.
Que esta serie diverge significa que si el nmero de saltos es suficientemente grande
nuestra amiga llegara de la Autnoma
a Madrid, a la Luna, ... llegara tan lejos como queramos. !!Pero si la calculamos con el
ordenador esta suma sera finita !!
Has pensado en cul sera la suma?

Tal como hemos dicho Matlab est muy adaptado al clculo con vectores y matrices, por
ejemplo en las
siguientes instrucciones
>> x=[0 : 0.1 : 1]
significa que x es un vector cuyas componentes empiezan en 0, se van incrementando de
0.1 en 0.1
y terminan en 1. Luego
>>y=sin(x)
es un vector cuyas componentes son los senos de las anteriores,
>>disp([x' y' z'])
muestra los traspuestos de estos vectores. El resultado se puede ver como sigue:

>> x=[0:0.1:1]; y=sin(x); z=cos(x);
>> '-------------------------------------------------------
'
>> ' x seno(x)
cos(x) ', disp([x' y' z'])
ans =
x seno(x) cos(x)
----------------------------------------------------------
0 0 1.00000000000000
0.10000000000000 0.09983341664683 0.99500416527803
0.20000000000000 0.19866933079506 0.98006657784124
0.30000000000000 0.29552020666134 0.95533648912561
0.40000000000000 0.38941834230865 0.92106099400289
0.50000000000000 0.47942553860420 0.87758256189037
0.60000000000000 0.56464247339504 0.82533561490968
0.70000000000000 0.64421768723769 0.76484218728449
0.80000000000000 0.71735609089952 0.69670670934717
0.90000000000000 0.78332690962748 0.62160996827066
1.00000000000000 0.84147098480790 0.54030230586814
En Matlab podemos escribir un conjunto de instrucciones que forman un fichero.m, pero
tambin podemos
utilizar una function. Hay una diferencia entre ambos ya que en un fichero.m los datos y las
variables son como
si las hubirmos escrito desde la consola. En una funcin las variables son internas, no
cambian ni afectan las
externas. Por cierto que conviene muchas veces limpiar las variables externas con la
instruccin
>>clear all
si no queremos tener clculos confusos. Para limpiar la pantalla usaremos
>>clc
Un ejemplo de funcin sera el programita siguiente, que calcula los 20 primeros
trminos de la serie exponencial


function [s]=serie(x)
term=1; suma=1;
for n=1:20
term=term*x/n;
suma=suma+term;
end
s=suma
La funcin se llama desde la consola como
>>serie(x),
Por ejemplo:

>>serie(1)
suma=2.71828182845905
Resultado que ya da todas las cifras decimales correctas del numero e hasta la precisin
de Matlat, como se puede
comprobar fcilmente. Con esta funcin podemos comprobar por ejemplo que al sumar una
suma alternada afecta
en mucho el error de redondeo, ya que

>> exp(-8)-serie(-8)
ans = -0.13229825662640
Mientras que

>> 1/serie(8)-exp(-8)
ans =3.152568231321777e-008

Grficos con Matlab
Pueden verse en los siguientes ejemplos:
Un comando til en matlab es ginput. Ver >>help gineput (tambin gtext). Abajo el
pequeo
programita dibuja y=x(x-1)sin x, luego sobre la figura, permite tomar 6 puntos con el ratn,
que
al final muestra en la consola.

>> f='x*(x-1)*sin(x)'; ezplot(f);[x,y]=ginput(6);
[x,y]
>> help plot
Various line types, plot symbols and colors may be obtained
with
PLOT(X,Y,S) where S is a character string made from one
element
from any or all the following 3 colunms:
y yellow . point - solid
m magenta o circle : dotted
c cyan x x-mark -. dashdot
r red + plus -- dashed
g green * star
b blue s square
w white d diamond
k black v triangle (down)
^ triangle (up)
< triangle (left)
> triangle (right)
p pentagram
h hexagram
Otros ejemplos:







Ventana de comandos de matlab



close all
u=-8:0.5:8; v=u;
[U,V]=meshgrid(u,v)
;
R=sqrt(U.*U+V.*V)+e
ps;
W=sin(R)./R;
mesh(W)




x=[-3:0.4:3];
y=x;
close
subplot(2,2,1)
figure(gcf), fi=[-
6*pi:pi/20:6*pi];
plot3(fi.*cos(fi),fi.*sin(f
i),fi,'r')
[X,Y]=meshgrid(x,y);
Z=superficie(X,Y);
subplot(2,2,2)
mesh(Z)
subplot(2,2,3)
surf(Z)
subplot(2,2,4)
contour3(Z,16)


>>[x y z]=peaks;
>>contour(x,y,z,'k')
>>pcolor(x,y,z)
>>shading interp
>>Z=peaks;
>> figure (2); [C,h]=contour(Z,10);
>> clabel(C,h)
produce las siguientes figuras:





>> help elfun
Trigonometric.
sin - Sine.
sinh - Hyperbolic sine.
asin - Inverse sine.
asinh - Inverse hyperbolic
sine.
cos - Cosine.
cosh - Hyperbolic cosine.
acos - Inverse cosine.
acosh - Inverse hyperbolic
cosine.
tan - Tangent.
tanh - Hyperbolic tangent.
atan - Inverse tangent.
atan2 - Four quadrant
inverse tangent.
atanh - Inverse hyperbolic
tangent.
sec - Secant.
sech - Hyperbolic secant.
asec - Inverse secant.
asech - Inverse hyperbolic
secant.
csc - Cosecant.
Exponential.
exp - Exponential.
log - Natural logarithm.
log10 - Common (base 10) logarithm.
log2 - Base 2 logarithm and dissect floating
point number.
pow2 - Base 2 power and scale floating
point number.
sqrt - Square root.
nextpow2 - Next higher power of 2.
Complex.
abs - Absolute value.
angle - Phase angle.
complex - Construct complex data from real
and imaginary parts.
conj - Complex conjugate.
imag - Complex imaginary part.
real - Complex real part.
unwrap - Unwrap phase angle.
isreal - True for real array.
cplxpair - Sort numbers into complex
csch - Hyperbolic
cosecant.
acsc - Inverse cosecant.
acsch - Inverse hyperbolic
cosecant.
cot - Cotangent.
coth - Hyperbolic
cotangent.
acot - Inverse cotangent.
acoth - Inverse hyperbolic
cotangent.
conjugate pairs.
Rounding and remainder.
fix - Round towards zero.
floor - Round towards minus infinity.
ceil - Round towards plus infinity.
round - Round towards nearest integer.
mod - Modulus (signed remainder after
division).
rem - Remainder after division.
sign - Signum.
Ver tambin
>>help specfun (Bessel , gamma, Airy).
>>help mfun
>>mfunlist (Zeta de Riemann, Polinomios ortogonales)

cardioide:
>>ezpolar('1+cos(t)')
Otros comandos tiles de matlab:

>> date
>> calendar
>> clear x, clear all limpia la variable x, limpia todas las variables
>> close , close all cierra la figura actual, cierra todas las figuras
>> axis([minx maxx miny maxy]) encuadra figura en este marco
>> break sale de dentro de un if o de un while
>> clc limpia la pantalla
Control C ( Control Z) acaba con la ejecucin de
un clculo de matlab (en caso necesario).
Un juego: Vamos a mandar mensajes secretos
Julio Csar se comunicaba con sus gobernadoresy generales con mensajes codificados.
Haca corresponder a cada
letra del abecedario la tercera siguiente. El mensaje pareca una sopa de letras ininteligible.
Para decodificar no haba
ms que proceder al revs. Aqu tenemos en cuenta que las letras y smbolos del teclado
tienen asignados nmeros
enteros del 0 al 127, cdigo ASCII. El comando char asigna este nmero a las letras
mientras que rem (p,q) es el
resto de dividir p entre q (clase de restos). El resultado es el siguiente:

texto='Me encanta este curso'
texto =
Me encanta este curso
secreto=char(rem(texto+3,128))
secreto =
Ph#hqfdqwd#hvwh#fxuvr
decodifica=char(rem(secreto-3,128))
decodifica =
Me encanta este curso
Un programita de regalo: tetris.m

Refencias: http://www.glue.umd.edu/~nsw/ench250/primer.htm

Tomeu Barcel / Departamento de Matemticas / Universidad Autnoma de Madrid