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.4159265358
9793
format short
e 3.1416e+001
format long
e 3.141592653589793e
+001
format short g 31.416
format long
g 31.4159265358979
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
format
hex 403f6a7a29553
85e
format bank 31.42
format
rat 3550/113
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.
Imag
inary 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,7977x 10
308
y el nmero ms
pequeo del orden de
2
-1022
~ 2,25x10
-308
. La mantisa de 52 bits nos da un epsilon mquina del
orden de eps=2
-52
~ 2,22x10
-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
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
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+0
02
-
4.075000000000000e+0
02
1.640500000000000e+0
03
-
6.551500000000000e+0
03
2.621650000000000e+0
04
-
1.048555000000000e+0
05
4.194325000000000e+0
05
-
1.677719500000000e+0
06
6.710888500000000e+0
06
-
2.684354350000000e+0
07
1.073741845000000e+0
08
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.
!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
Este programa abre un fichero de
texto
llamado resultados.txt donde se
escribirn
tercero=4*primero-3*segundo;
primero=segundo;
segundo=tercero;
fprintf(fi,'%16.7f\n',segundo);
end
fclose(fi)
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.14159265358979323846264338327950288419716939937510582097494459230781640628620899862
80348253
4211706798214808651328230664709384460955058223172535940812848111745028410270193852110
55596446
2294895493038196442881097566593344612847564823378678316527120190914564856692346034861
04543266
4821339360726024914127372458700660631558817488152092096282925409171536436789259036001
13305305
4882046652138414695194151160943305727036575959195309218611738193261179310511854807446
23799627
4956735188575272489122793818301194912983367336244065664308602139494639522473719070217
98609437
0277053921717629317675238467481846766940513200056812714526356082778577134275778960917
36371787
2146844090122495343014654958537105079227968925892354201995611212902196086403441815981
36297747
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)+
eps;
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(
fi),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
conjugate pairs.
csch - Hyperbolic
cosecant.
acsc - Inverse cosecant.
acsch - Inverse hyperbolic
cosecant.
cot - Cotangent.
coth - Hyperbolic
cotangent.
acot - Inverse cotangent.
acoth - Inverse hyperbolic
cotangent.
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