Introducción a la Programación en MATLAB (C2)

Mauricio Tejada

ILADES - Universidad Alberto Hurtado

Agosto 2017

2. Primeros Pasos en Matlab

Matlab (abreviatura de MATrix LABoratory, "laboratorio de matrices") es uno de los paquetes más populares para realizar análisis numérico.

Ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de programación propio (lenguaje M).

El lenguaje M es un lenguaje de alto nivel (high level):

  • Simple de aprender y usar.
  • El costo está en los tiempos de ejecución.
  • Si bien las computadoras que tenemos hacen que dicho costo se haya reducido, éste lamentablemente no se ha eliminado y depende del problema que tengamos.

Un lenguaje de programación de alto nivel se caracteriza por expresar el algoritmo de una manera adecuada a la capacidad cognitiva humana, en lugar de la capacidad ejecutora de las máquinas.

Un lenguaje de programación de bajo nivel es aquel en el que sus instrucciones ejercen un control directo sobre el hardware y están condicionados por la estructura física de las computadoras que lo soportan.

El uso de la palabra bajo nivel no implica que el lenguaje sea menos potente que un lenguaje de alto nivel, sino que se refiere a la reducida abstracción entre el lenguaje y el hardware

Wikipedia

2.1 Menú, Ventanas y Directorios

Interfaz gráfica del usuario (versión 2015b):

Photo

Matlab almacena todo en la memoria RAM del computador. Para liberar la memoria se usan los siguientes comandos:

  • La memoria se limpia con el comando clear
  • La pantalla se limpia con el comando clc.

Matlab usa el espacio de un directorio como área de trabajo. Dicho directorio se denomina directorio de trabajo y todos los archivos (que no formen parte del paquete) deber estar en dicho directorio.

  • Usar pwd para conocer el directorio de trabajo actual.
  • Usar cd('directorio') para cambiar el directorio de trabajo.
In [1]:
clear all;
In [2]:
pwd
ans =

    '/Users/mauriciotejada/Dropbox/MT/Teaching/MAE - Matlab/Nootebooks'
In [3]:
cd('/Users/mauriciotejada/Dropbox/');
pwd
ans =

    '/Users/mauriciotejada/Dropbox'
In [4]:
cd('/Users/mauriciotejada/Dropbox/MT/Teaching/MAE - Matlab/Nootebooks');
  • Los usuarios de windows deben usar las rutas en formato C:\Dir\Subdir\

Existen ocasiones en que podemos tener algún procedimiento que usamos regularmente. Para usarlo en cada proyecto tendríamos que copiarlo en cada carpeta de trabajo. No parece eficiente ya que estaríamos duplicando archivos. Un mejor enfoque es llamar el directorio de procedimientos cada vez que los necesitemos.

  • Usar addpath('directorio') adicionar temporalmente un directorio en el path de búsqueda de Matlab.

2.2 Ayuda

Más allá de este curso introductorio, la mejor forma de aprender Matlab es a través de la experimentación. Las dos fuentes más importantes para referencia:

  1. Documentación de Matlab (que es clara, extensa y amigable).
  2. Google (existen literalmente millones de códigos en la web que resuelven distintos problemas).

Existen distintas formas de acceder a la documentación de Matlab.

  • Ayuda: help
  • Ayuda sobre un comando o procedimiento particular: help comando
  • Buscar ayuda usando una palabra clave: lookfor('palabra clave')
In [5]:
help mean
MEAN   Average or mean value.
    S = MEAN(X) is the mean value of the elements in X if X is a vector. 
    For matrices, S is a row vector containing the mean value of each 
    column. 
    For N-D arrays, S is the mean value of the elements along the first 
    array dimension whose size does not equal 1.
 
    MEAN(X,DIM) takes the mean along the dimension DIM of X.
 
    S = MEAN(...,TYPE) specifies the type in which the mean is performed, 
    and the type of S. Available options are:
 
    'double'    -  S has class double for any input X
    'native'    -  S has the same class as X
    'default'   -  If X is floating point, that is double or single,
                   S has the same class as X. If X is not floating point, 
                   S has class double.
 
    S = MEAN(...,NANFLAG) specifies how NaN (Not-A-Number) values are 
    treated. The default is 'includenan':
 
    'includenan' - the mean of a vector containing NaN values is also NaN.
    'omitnan'    - the mean of a vector containing NaN values is the mean 
                   of all its non-NaN elements. If all elements are NaN,
                   the result is NaN.
 
    Example:
        X = [1 2 3; 3 3 6; 4 6 8; 4 7 7]
        mean(X,1)
        mean(X,2)
 
    Class support for input X:
       float: double, single
       integer: uint8, int8, uint16, int16, uint32,
                int32, uint64, int64
 
    See also MEDIAN, STD, MIN, MAX, VAR, COV, MODE.

    Reference page in Doc Center
       doc mean

    Other functions named mean

       codistributed/mean    fints/mean                tall/mean
       datetime/mean         gpuArray/mean             timeseries/mean
       duration/mean         ProbDistUnivParam/mean
In [6]:
lookfor('standard deviation')
movstd                         - Moving standard deviation value.
std                            - Standard deviation.
corr2cov                       - Converts standard deviation and correlation to covariance.
cov2corr                       - Converts covariance to standard deviation and correlation coefficient.
std2                           - Standard deviation of matrix elements.
stdfilt                        - Local standard deviation of image.
stdm                           - Standard deviation for geographic points
prestd                         - Preprocesses the data so that the mean is 0 and the standard deviation is 1.
trastd                         - Preprocesses data using a precalculated mean and standard deviation.
dspblkstd2                     - DSP System Toolbox Standard deviation block helper function.
nanstd                         - Standard deviation, ignoring NaNs.
schart                         - S chart for monitoring the standard deviation.
  • Para conocer las funciones elementales de Matlab usamos help elfun.
In [7]:
help elfun
Elementary math functions.
 
  Trigonometric.
    sin         - Sine.
    sind        - Sine of argument in degrees.
    sinh        - Hyperbolic sine.
    asin        - Inverse sine.
    asind       - Inverse sine, result in degrees.
    asinh       - Inverse hyperbolic sine.
    cos         - Cosine.
    cosd        - Cosine of argument in degrees.
    cosh        - Hyperbolic cosine.
    acos        - Inverse cosine.
    acosd       - Inverse cosine, result in degrees.
    acosh       - Inverse hyperbolic cosine.
    tan         - Tangent.
    tand        - Tangent of argument in degrees.
    tanh        - Hyperbolic tangent.
    atan        - Inverse tangent.
    atand       - Inverse tangent, result in degrees.
    atan2       - Four quadrant inverse tangent.
    atan2d      - Four quadrant inverse tangent, result in degrees.
    atanh       - Inverse hyperbolic tangent.
    sec         - Secant.
    secd        - Secant of argument in degrees.
    sech        - Hyperbolic secant.
    asec        - Inverse secant.
    asecd       - Inverse secant, result in degrees.
    asech       - Inverse hyperbolic secant.
    csc         - Cosecant.
    cscd        - Cosecant of argument in degrees.
    csch        - Hyperbolic cosecant.
    acsc        - Inverse cosecant.
    acscd       - Inverse cosecant, result in degrees.
    acsch       - Inverse hyperbolic cosecant.
    cot         - Cotangent.
    cotd        - Cotangent of argument in degrees.
    coth        - Hyperbolic cotangent.
    acot        - Inverse cotangent.
    acotd       - Inverse cotangent, result in degrees.
    acoth       - Inverse hyperbolic cotangent.
    hypot       - Square root of sum of squares.
    deg2rad     - Convert angles from degrees to radians.
    rad2deg     - Convert angles from radians to degrees.
 
  Exponential.
    exp         - Exponential.
    expm1       - Compute exp(x)-1 accurately.
    log         - Natural logarithm.
    log1p       - Compute log(1+x) accurately.
    log10       - Common (base 10) logarithm.
    log2        - Base 2 logarithm and dissect floating point number.
    pow2        - Base 2 power and scale floating point number.
    realpow     - Power that will error out on complex result.
    reallog     - Natural logarithm of real number.
    realsqrt    - Square root of number greater than or equal to zero.
    sqrt        - Square root.
    nthroot     - Real n-th root of real numbers.
    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.

2.3 Variables

Matlab es un lenguaje basado en expresiones.

Las expresiones que introducimos mediante el teclado son interpretadas y evaluadas.

Cada expresión genera algún tipo de output que puede ser asignado en una variable. La asignación se realiza de la siguiente forma:

nombrevariable = expresión

Si se introduce alguna expresión pero no se define un nombre para la variable, Matlab asigna la expresión a una variable auxiliar temporal denominada ans.

Todas las variables son almacenadas en la memoria RAM del computador por lo que se pierden en cuanto uno sale y apaga Matlab.

Es posible limpiar la memoria usando:

clear nombrevariable1 nombrevariable1 ...

Algunas reglas al elegir los nombres de las variables:

  • Los nombres deben empezar con una letra y pueden contener letras, números y _.
  • Matlab es sensible a mayúsculas y minúsculas (x es diferente de X).

Tipos básicos de variables:

  • Numéricas (precisión doble - 64 bits, max $3.4x10^{38}$ y min $-3.4x10^{38}$). Reales o Imaginarias.
  • Textos (vectores en lo que cada celda tiene un código Unicode de 0 a 65536).
  • Estructura (tipo de dato que agrupa información contenida en celdas, numéricas o de texto)

Asignación de variables numéricas:

In [8]:
x  = 2.5
y  = 4
X  = 5
NombreLargo = 4
vaim = 2+5i
x =

    2.5000


y =

     4


X =

     5


NombreLargo =

     4


vaim =

   2.0000 + 5.0000i

Las de tipo texto se asignan usando '':

In [9]:
Y_1 = 'Texto'
VaxTexto = 'Pueden incluirse Espacios'
Y_1 =

    'Texto'


VaxTexto =

    'Pueden incluirse Espacios'

Las estructura se crean definiendo un nombre para la estructura seguido de un punto y a continuación el nombre de la celda: NombreEstrutura.NombreCelda = expresion:

In [10]:
NombreEst.x = x+y;
NombreEst.y = 'Otro Texto';
NombreEst.X = 20;

NombreEst

NombreEst.X
NombreEst = 

  struct with fields:

    x: 6.5000
    y: 'Otro Texto'
    X: 20


ans =

    20

Adicionalmente se puede crear una variable vacía. El objetivo es reservar espacio en la memoria.

In [11]:
VarVacia = []
VarVacia =

     []

Para saber qué objetos se han creado se usan los comandos who y whos. El primero muestra los nombres de todas las variables mientras que el segundo además da información detallada del tipo y el tamaño.

In [12]:
who
Your variables are:

NombreEst    VarVacia     X            ans          x            
NombreLargo  VaxTexto     Y_1          vaim         y
In [13]:
whos
Name             Size            Bytes  Class     Attributes

  NombreEst        1x1               564  struct              
  NombreLargo      1x1                 8  double              
  VarVacia         0x0                 0  double              
  VaxTexto         1x25               50  char                
  X                1x1                 8  double              
  Y_1              1x5                10  char                
  ans              1x1                 8  double              
  vaim             1x1                16  double    complex   
  x                1x1                 8  double              
  y                1x1                 8  double

Además las variables puedes ser locales o globales.

  • Las variables serán locales si su valor queda en memoria sólo para la sesión o procedimiento con que se esté trabajando.
  • En el caso de las variables globales, su valor se mantiene para otras sesiones o procedimientos.

Por definición todas las variables que están dentro una función son locales (más adelante quedará más claro).

Para declarar una variable como global se usa:

global NombreVariable1 NombreVAriable2 ...
In [14]:
global x y;
whos;
[Warning: The value of local variables may have been changed to match the
globals.  Future versions of MATLAB will require that you declare a variable to
be global before you use that variable.] 
[> In pymat_eval (line 31)
  In matlabserver (line 24)] 
[Warning: The value of local variables may have been changed to match the
globals.  Future versions of MATLAB will require that you declare a variable to
be global before you use that variable.] 
[> In pymat_eval (line 31)
  In matlabserver (line 24)] 
  Name             Size            Bytes  Class     Attributes

  NombreEst        1x1               564  struct              
  NombreLargo      1x1                 8  double              
  VarVacia         0x0                 0  double              
  VaxTexto         1x25               50  char                
  X                1x1                 8  double              
  Y_1              1x5                10  char                
  ans              1x1                 8  double              
  vaim             1x1                16  double    complex   
  x                1x1                 8  double    global    
  y                1x1                 8  double    global

2.4 Imprimir Resultados en Pantalla

Para mostrar el valor de las variables en pantalla usamos disp() y para imprimirlos en pantalla con un formato determinado usamos fprintf().

El comando disp()muestra en pantalla el valor asignado a una variable (numérica o texto). Una alternativa es simplemente digitar el nombre de la variable sin el punto y coma.

Algunos ejemplos:

In [15]:
disp(NombreLargo);

disp(Y_1);
disp('*** Otra forma ***');   % Note que esta es una variable de texto 
                              % definida directamente para disp
disp('---------')
4

Texto
*** Otra forma ***
---------
In [16]:
h = 2.45986768768;
disp(h);
2.4599

El comando fprintf se usa también para mostrar en pantalla información sobre el valor asignado a determinadas variables, con la diferencia que éste comando permite dar formato a la visualización e introducir la misma en dentro un texto determinado.

La asignación dentro el texto se inicia con % (si bien este símbolo es también usado para comentarios en el código, aquí su uso es diferente).

Dentro un texto se necesitan introducir tantos signos % como valores de variables se quieran mostrar seguidos por un carácter que representa el tipo de valor a visualizar:

  • %s Imprime texto
  • %c Imprime un único carácter.
  • %d Imprime un número (completo).
  • %f Imprime un número con un número determinado de decimales (ejemplo %.2f imprime dos decimales)

Otras opciones de formato son:

  • \n Imprime una nueva línea (Enter)
  • \t Imprime una tabulación (Tab)
  • \\ Imprime \.
  • %% Imprime % (Un sólo % sirve para comentarios).

Algunos ejemplos:

In [17]:
prof_name = 'Mauricio Tejada';
prof_of = 211;
prof_email = '[email protected]';

fprintf('Mi nombre es %s\n', prof_name); 
fprintf('Mi oficina es la %d y mi email es %s\n', prof_of, prof_email);  % Note que % en este contexto no es nota.
Mi nombre es Mauricio Tejada
Mi oficina es la 211 y mi email es [email protected]

Ahora usando decimales:

In [18]:
N = 3.6245;
fprintf('Numero completo %d\n', N); 
fprintf('Numero con 2 decimales %.2f\n', N); 
fprintf('Numero con 3 decimales %.3f\n', N); 
fprintf('Numero sin decimales (entero) %.0f\n', N);
Numero completo 3.624500e+00
Numero con 2 decimales 3.62
Numero con 3 decimales 3.624
Numero sin decimales (entero) 4

2.5 Elementos Básicos para Graficar

Matlab es una herramienta poderosa y útil para presentar resultados de forma gráfica.

Los elementos básicos para graficar y dar formato a un gráfico son:

  • figure: Abre una ventana de gráficos.
  • plot: Graficar.
  • title: Título del gráfico.
  • xlabel: Etiqueta del eje x.
  • ylabel: Etiqueta del eje y.
  • legend: Manejo y definición de la leyenda del gráfico.
  • grid: Cuadrícula.

Nota: Sólo presentamos algunas características. Ver la documentación para mayor detalles.

Ejemplo 1:

In [19]:
x = 0:pi/100:2*pi;
y = sin(x);

% figure;
plot(x,y);
title('Función Seno');
xlabel('x');
ylabel('f(x)');

Ejemplo 2:

In [20]:
x = linspace(-2*pi,2*pi);
y1 = sin(x);
y2 = cos(x);

% figure;
plot(x,y1,x,y2)
title('Funciones Seno y Coseno');
xlabel('x');
ylabel('f(x)');
legend('sin(x)','cos(x)')

Existen muchas opciones para personalizar un gráfico:

Estilos:

  • - Línea sólida (por defecto)
  • -- Línea cortada.
  • : Línea punteada.
  • -. Línea cortada-puntada.

Colores:

  • y Amarillo.
  • m Magenta.
  • r Rojo.
  • g Verde.
  • b Azul.
  • w Blanco.
  • k Negro.

Marcadores principales:

  • o Circulo
  • + Signo de suma.
  • * Asterisco.
  • . Punto.
  • x Cruz.
  • s Cuadrado.
  • d Diamante.

Ejemplo 3:

In [21]:
x = linspace(-2*pi,2*pi);
y1 = sin(x);
y2 = cos(x);

% figure;
plot(x,y1,'-ro',x,y2,'-.b')
title('Funciones Seno y Coseno');
xlabel('x');
ylabel('f(x)');
legend('sin(x)','cos(x)')
grid('on');