Introducción al Matlab

    El propósito de estas notas es hacer una rápida introducción al matlab. Son sólo unas pequeñas
muestras para dar idea de como funciona este programa. Para un estudio más serio deben
consultarse otras referencias. En particular las que damos al final de esta página.

    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 orígenes, a los que se han ido incorporando sucesivamente
más capacidades, sobretodo gráficas.

    Matlab es una potente calculadora, por ejemplo calcula la suma de dos números
 
>> 2+2
ans =
       4

    Aunque el ejemplo es sencillo ya vemos como actua matlab, se escriben las instrucciones en
la línea de comandos >>  y  después de pulsar la tecla Intro aparece el resultado más 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 expresión veremos el resultado. Para
escribirla de nuevo podemos usar la flecha hacia arriba del teclado, que nos recupera
los comandos escritos anteriormente en la sesión.
 
>> 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

    Obsérvese la rapidez con que se han calculado estas matrices A=rand(6) encuentra una matriz 6x6 de
números aleatorios (cada uno entre 0 y 1), inv(A) calcula su inversa y luego comprobamos que B*A
es la matriz identidad. Los números negativos que aparecen son debido al redondeo (en este caso
serían números muy pequeños, pero negativos).

    Veamos como maneja matab los números:
 
>> pi
ans =
    3.1416
>> format long
>> pi
ans =
   3.14159265358979

    Aunque nos da el valor de pi con distinto número de decimales en realidad matlab trabaja internamente
con doble presición, 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 número se guarda en memoria como un vector de 8 bytes, lo que da una mantisa de unos 15 ó 16
dígitos 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 número 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 número x será por tanto

      x= signo x mantisa x 10E
    Los 211=2048 posibles exponentes E se distribuyen entre -1023 £ E £  1024, siendo el número más
grande posible del orden de (2-eps)*21023 @ 1,7977 x 10308 y el número más pequeño del orden de
2-1022 @ 2,25 x10-308 . La mantisa de 52 bits nos da un epsilon máquina del orden de eps=2-52@ 2,22 x10-16.
    Recordenmos que el epsilon máquina eps se define como el número más grande eps tal que la máquina no
distingue entre 1 y 1+eps.

    El número real más grande, más pequeño y epsilon máquina respectivamente, se obtienen con
 
>>realmin
>>realmax
>>eps


    Con matlab podemos ir escribiendo los comandos uno tras otro, pero cuando tenemos que hacer un pequeño
programa o escribir muchos comandos suele resultar más útil escribir un fichero con las instrucciones
y luego hacer que matlab los ejecute. Estos son los ficheros .m que no son más que ficheros de texto
a los que luego ponemos la extensión .m . Matlab lleva incorporado un editor que podemos usar para
este propósito. 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 términos de la sucesión  an+2=4 an-3 an+1 empezando con a1=2.1 y  a2=2.1
En este caso, como no hemos puesto punto y coma después de la línea de tercero, los resultados
se irán 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+002
-4.075000000000000e+002
1.640500000000000e+003
-6.551500000000000e+003
2.621650000000000e+004
-1.048555000000000e+005
4.194325000000000e+005
-1.677719500000000e+006
6.710888500000000e+006
-2.684354350000000e+007
1.073741845000000e+008
  El resultado es sorprendente !! 

  Esperaríamos ver que  an=2.1, para todo n. ¿Por qué aparece este extraño
comportamiento?
  En realidad la ecuación en diferencias  an+2=4 an-3 an+1  tiene por solución
  donde 
siendo C1 y C2 dos constantes cualesquiera. Las condiciones iniciales a1=a2=2.1
determinan la solución con constantes C1=1, C2=0. Pero debido a que 2.1 en
base dos tiene una fracción periódica que se repite indefinidamente, ya que 

  al calcular 

     tercero=tercero=4*primero-3*segundo,

resulta que si eps es un número muy pequeño comparable al epsilon máquina

     a3=tercero=2.1+eps

al iterar ahora de nuevo con 

     a2=2.1,   a3=2.1+eps, 
como nuevas condiciones iniciales, resulta que la constante C2 ya no es 0. 
Lo que hace que la solución errónea aumente exponencialmente y enmascare 
completamente la solución  prevista. Es un claro ejemplo de inestabilidad 
numérica. 

    !No te fíes de los 
     ordenadores!
 

 

Comentarios al programa:
 

    aparecerá una pantalla más ordenada con los resultados en columna.     En matlab hay unos añadidos llamados Toolboxes que incorporan más 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 número de dígitos de mantisa que deseemos, esta función es
vpa. Buscar en help vpa. El ejemplo siguiente nos da los 800 primeros dígitos de pi:
 
>> vpa(pi,800)
ans =
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253
421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446
229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266
482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305
488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627
495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437
027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787
214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747
713099605187072113499999983729780499510597317328160963186

    Como otro ejemplo, calculemos con mantisa 3  la suma de los primeros 20 términos
de la serie armónica, 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 obtendríamos
>> 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 gráfica para representar el tiempo que ha tardado Matlab en sumar distintas sumas
parciales de esta serie armónica. ¿Cuál es la suma de la serie armónica infinita? Todos sabemos que diverge, esto es, que si vamos sumando más y más términos las sumas parciales se hacen tan grandes como queramos. Hay una manera divertida de pensar en la
suma de los términos 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 avanzaría una distancia 1/n.
Que esta serie diverge significa que si el número de saltos es suficientemente grande nuestra amiga llegaría de la Autónoma
a Madrid, a la Luna, ... llegaría tan lejos como queramos. !!Pero si la calculamos con el ordenador esta suma sería finita !!

¿Has pensado en cuál sería la suma?


    Tal como hemos dicho Matlab está muy adaptado al cálculo 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 también podemos
utilizar una function. Hay una diferencia entre ambos ya que en un fichero.m los datos y las variables son como
si las hubiérmos escrito desde la consola. En una función las variables son internas, no cambian ni afectan las
externas. Por cierto que conviene muchas veces limpiar las variables externas con  la instrucción

>>clear all
si no queremos tener cálculos confusos. Para limpiar la pantalla usaremos
>>clc
    Un ejemplo de función sería el programita siguiente, que calcula los 20 primeros términos 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 función 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 precisión de Matlat, como se puede
comprobar fácilmente. Con esta función 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


Gráficos con Matlab

Pueden verse en los siguientes ejemplos:

    Un comando útil en matlab es ginput. Ver >>help gineput (también gtext). Abajo el pequeño
programita dibuja y=x(x-1)sin x, luego sobre la figura, permite tomar 6 puntos con el ratón, 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.
    csch        - Hyperbolic cosecant.
    acsc        - Inverse cosecant.
    acsch       - Inverse hyperbolic cosecant.
    cot         - Cotangent.
    coth        - Hyperbolic cotangent.
    acot        - Inverse cotangent.
    acoth       - Inverse hyperbolic cotangent.
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.

  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 también

>>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 ejecución de 
 un cálculo de matlab (en caso necesario).

Un juego: Vamos a mandar mensajes secretos

    Julio César se comunicaba con sus gobernadoresy generales con mensajes codificados. Hacía corresponder a cada
letra del abecedario la tercera siguiente. El mensaje parecía una sopa de letras ininteligible. Para decodificar no había
más que proceder al revés. Aquí tenemos en cuenta que las letras y símbolos del teclado tienen asignados números
enteros del 0 al 127, código ASCII. El comando char asigna este número 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 Matemáticas / Universidad Autónoma de Madrid