Introducción a MATLABisa.uniovi.es/~jalvarez/Buzon/tutoriales/matlab/Intro-MATLAB.pdf · 1.1...

2012

Ingeniería de Sistemas y Automática

Universidad de Oviedo

25/01/2012

Introducción a MATLAB

Introducción a MATLAB 2012

Robótica Industrial 1 Práctica 1

0 Contenido 0 Contenido .............................................................................................................................. 1

1 ¿Qué es MATLAB? ................................................................................................................. 2

1.1 Componentes de MATLAB ............................................................................................ 3

1.2 Documentación y ayuda ................................................................................................ 4

2 Primeros pasos con MATLAB................................................................................................. 5

2.1 Iniciando y finalizando MATLAB .................................................................................... 5

2.1.1 Acceso a la documentación ................................................................................... 6

3 MATLAB como calculadora científica .................................................................................... 7

3.1 Operaciones básicas y precedencia de operadores ...................................................... 7

3.2 Operaciones lógicas....................................................................................................... 7

3.3 Variables ........................................................................................................................ 7

3.4 Aritmética compleja ...................................................................................................... 8

3.5 Supresión de eco en pantalla ........................................................................................ 8

4 Matrices y arrays ................................................................................................................... 8

4.1 Introducir matrices ........................................................................................................ 8

4.1.1 Creación directa de matrices ................................................................................. 8

4.1.2 Creación de matrices a partir de funciones .......................................................... 9

4.1.3 Cargar matrices desde un fichero de datos ........................................................ 10

4.1.4 Concatenación ..................................................................................................... 10

4.2 Acceso a los elementos de una matriz ........................................................................ 11

4.2.1 Acceso básico ...................................................................................................... 11

4.2.2 El operador dos puntos (:) ................................................................................... 12

4.2.3 Indexación mediante vectores de booleanos ..................................................... 14

4.2.4 Modificación de elementos ................................................................................. 14

4.3 Operaciones con matrices ........................................................................................... 15

4.3.1 Traspuesta ........................................................................................................... 15

4.3.2 Operaciones aritméticas ..................................................................................... 16

4.3.3 División (multiplicación por la inversa) ............................................................... 16

4.3.4 Funciones ............................................................................................................ 16

4.4 Operaciones con arrays ............................................................................................... 16

4.4.1 Uso de funciones con arrays ............................................................................... 17

4.4.2 Funciones básicas para el análisis de datos ........................................................ 18

5 Polinomios ........................................................................................................................... 19



6 Funciones gráficas básicas .................................................................................................. 20

6.1 Creación de una figura con plot .................................................................................. 20

6.2 Creación de varios gráficos en una misma ventana .................................................... 21

6.2.1 Ventanas gráficas ................................................................................................ 21

6.2.2 Subplot ................................................................................................................ 21

6.2.3 Control de los ejes ............................................................................................... 22

6.2.4 Introducción a los gráficos 3D ............................................................................. 24

7 Un pequeño ejemplo ........................................................................................................... 25

8 Programación ...................................................................................................................... 28

8.1 Control de flujo............................................................................................................ 28

8.1.1 Control de flujo condicional: if, else, y switch ..................................................... 28

8.1.2 Bucles: for, while, continue y break .................................................................... 31

8.2 Otros tipos de datos .................................................................................................... 34

8.2.1 Estructuras .......................................................................................................... 34

8.2.2 Cadenas y texto ................................................................................................... 36

8.2.3 Cell arrays ............................................................................................................ 37

8.2.4 Arrays multidimensionales .................................................................................. 38

8.3 Funciones y scripts ...................................................................................................... 38

8.3.1 Scripts .................................................................................................................. 38

8.3.2 Funciones ............................................................................................................ 38

8.4 Reservar espacio para los arrays ................................................................................. 41

1 ¿Qué es MATLAB? MATLAB es un potente entorno para la realización de los cálculos necesarios para resolver

problemas científicos y de ingeniería. El nombre es la abreviación de MATrix LABoratory,

porque el sistema se diseñó para hacer especialmente fáciles los cálculos con matrices. Sus

características lo hacen muy efectivo en el desarrollo de algoritmos, visualización de datos,

análisis de datos y cálculo numérico de una manera mucho más rápida que con lenguajes de

programación tradicionales como C, C++ o Fortran.

Algunas características de MATLAB:

Es un sistema interactivo.

MATLAB soluciona los problemas asociados con tareas de la resolución numérica de

los cálculos, lo que facilita centrarse en la búsqueda de soluciones al problema que se

desea resolver.



MATLAB implementa algoritmos plenamente probados, lo que nos permite estar

seguros de los resultados que proporcionan sus funciones.

Permite hacer cálculos complejos con muy pocos comandos.

Permite desarrollar nuestras propias funciones para aplicaciones particulares.

Tiene una gran capacidad gráfica en 2 y 3D, con una gran capacidad de interacción con

los gráficos. Además éstos pueden ser fácilmente exportados a otros programas.

Es muy útil para el trabajo con grandes conjuntos de datos, ya que permite trabajar

con ellos de forma paralela en base a su representación en forma de matrices.

Desarrollo de aplicaciones con interfaces gráficas de usuario.

El entorno integrado permite el desarrollo y depuración de nuestras propias funciones

sin necesidad de recurrir a herramientas externas.

Algunos campos de aplicación de MATLAB en ingeniería son: procesamiento digital de señal,

procesamiento de imagen, diseño de sistemas de control, modelado de sistemas, desarrollo de

aplicaciones de test y medida, prototipado de sistemas en tiempo real. Para ello se basa en las

denominadas Toolboxes, que consisten en colecciones de funciones de propósito especial

orientadas a la solución de problemas específicos en ingeniería. Estas Toolboxes pueden ser

comerciales, gratuitas o desarrolladas por el propio usuario. En este curso, emplearemos la

toolbox de robótica creada por el profesor Peter Corke para el análisis y la solución de

problemas en el campo de la robótica industrial.

MATLAB también proporciona herramientas para documentar y compartir el trabajo, como

por ejemplo generar una página web con los resultados de nuestros cálculos. También permite

la integración del código desarrollado en MATLAB con otros lenguajes (C, C++, Fortran),

aplicaciones (EXCEL, Bases de Datos, …) o hardware (Tarjetas de Adquisición, puerto serie,

cámaras, …).

1.1 Componentes de MATLAB MATLAB está integrado por los siguientes elementos fundamentales:

Herramientas de escritorio y Entorno de desarrollo : Están formadas por el

Escritorio y la ventana de comandos, un editor y depurador integrados, un analizador de

código, y herramientas para visualizar la ayuda, el espacio de trabajo, las carpetas o el historial

de comandos.

Librería de funciones matemáticas : Es una amplia colección de algoritmos

computacionales que cubren desde funciones elementales como la suma, seno, coseno y la

aritmética de complejos, a funciones matemáticas de alto nivel como el cálculo de la inversa

de una matriz, cálculo de valores propios o transformadas de Fourier.

Lenguaje: Es un lenguaje de alto nivel para operaciones con matrices / arrays, con

instrucciones de control de flujo, funciones, estructuras de datos, entrada/salida de datos, e

incluso características de programación orientada a objetos. Permite tanto:

“programar lo pequeño” para desarrollar rápidamente funciones y programas que no

están pensados para ser reutilizados.



“programar lo grande” para desarrollar aplicaciones completas o nuevas toolboxes,

que pueden alcanzar alto nivel de complejidad, y que están pensadas para ser

reutilizadas.

Gráficos: MATLAB incluye muchas herramientas para visualizar vectores y matrices como

gráficos, así como su anotación (títulos, leyenda, etiquetas, textos) y su impresión/exportación

a otros formatos o aplicaciones. Incluye funciones tanto para la creación de gráficos 2D como

3D, visualización de imágenes, animaciones o gráficos para presentaciones. También incluye la

posibilidad de acceder a bajo nivel a dichos gráficos con fin de personalizarlos o llegar a

desarrollar aplicaciones completas con interfaces gráficas.

Interfaces externas : Permiten la interacción entre MATLAB y programas desarrollados en

otros lenguajes, o para la exportación / importación de datos.

1.2 Documentación y ayuda Una ventaja importante de MATLAB es su amplia documentación, accesible desde el propio

entorno. La documentación está disponible en formato HTML y PDF. El punto de inicio para un

nuevo usuario es la guía “Getting Started”, que cubre de forma sencilla las características

fundamentales de MATLAB, con muchos ejemplos que pueden ser copiados y ejecutados

fácilmente en la ventana de comandos. La documentación de MATLAB está organizada en los

siguientes puntos:

Desktop Tools and Development Environment : Ayuda sobre la forma de

uso de las diferentes herramientas que constituyen el entorno

Data Import and Export : Entrada y salida de datos con MATLAB.

Mathematics : Librería de funciones matemáticas disponibles

Data Analysis : Herramientas disponibles para el análisis de datos, como por

ejemplo: ajuste de datos, análisis de Fourier o herramientas para el análisis de series

temporales.

Programming Fundamentals : Cubre el lenguaje de programación de MATLAB y

los fundamentos sobre cómo desarrollar aplicaciones con MATLAB.

Object-Oriented Programming : Documentación sobre las características

orientadas a objeto de MATLAB.

Graphics : Información sobre las herramientas para la creación de gráficos

proporcionadas por MATLAB

3-D Visualization : Herramientas para la visualización de datos 3D.

Creating Graphical User Interfaces : Herramientas para la creación de

interfases gráficas de usuario (GUI).

External Interfaces : Documentación sobre las interfases externas de MATLAB

(MEX-files, MATLAB engine, Java, Microsoft® .NET Framework, COM, servicios Web y el

puerto serie)

Incluye también la documentación de referencia para todas las funciones de MATLAB:

Function Reference : Lista todas las funciones de MATLAB por categorías o

alfabéticamente.



Handle Graphics Property Browser : Documentación sobre las propiedades

de los objetos gráficos.

C/C++ and Fortran API Reference : Documentación sobre las funciones

usadas por las interfaces externas de MATLAB.

La documentación de MATLAB también incluye un relación indexada de los ejemplos incluidos

en la documentación para poder acceder directamente a los mismos, unas notas sobre la

versión y enlaces a la documentación imprimible en PDF (descargable desde la página web de

Mathworks).

Los demás productos que se integran en MATLAB (Simulink, Toolboxes, etc) tienen una

estructura similar para su documentación, encontrándose accesible dicha información una vez

que se instalan dichas herramientas.

2 Primeros pasos con MATLAB

2.1 Iniciando y finalizando MATLAB En sistemas Windows podemos arrancar MATLAB haciendo un doble click sobre el icono de la

aplicación que aparece en el escritorio, o bien seleccionando MATLAB en el menú de inicio. Al

arrancarlo nos aparecerá la ventana principal del entorno de MATLAB:

Figura 1 El entorno de MATLAB



Disponemos de varias herramientas que nos permiten navegar por el directorio actual,

introducir comandos, ver las variables que se han ido creando o tener acceso al historial con

los comandos ejecutados.

Para terminar la sesión podemos elegir la opción del menú File > Exit MATLAB, o bien

podemos teclear el comando exit en la línea de comandos.

2.1.1 Acceso a la documentación

Para... Intenta esto Más información

Buscar guías de inicio, código de ejemplos y demos.

En el panel Contents de la ventana de ayuda, expande el árbol correspondiente al producto de interés.

Para abrir la ventana de ayuda: Selecciona Help > Product Help en el menú. En la ventana de comandos ejecuta el comando doc.

Buscar información sobre un tema.

En el campo de búsqueda de la ventana de ayuda, teclea los terminos sobre los que deseas buscar ayuda. Después presiona Enter.

Ver la ayuda sobre una función o un bloque.

En la línea de comandos, ejecuta doc nombre_función para abrir la página deseada en la ventana de ayuda. Para ver la ayuda en línea dentro de la ventana de commandos, ejecuta el comando help

nombre_función. En ocasiones, el texto

muestra los nombres de las funciones todo en mayúsculas para facilitar que se distinga de otros textos. Cuando se llame a la función no se debe usar el nombre todo en mayúsculas.

Páginas de ayuda de los commandos:

doc

help

Buscar una función y visualizar su ayuda.

Seleccionar Help > Function Browser en el menu y luego buscar el nombre de la función de interés.

Obtener pistas sobre la sintaxis y los parámetros de funciones mientras se usa la ventana de comandos o el editor.

En el editor, se usan colores y otras pistas para determinar si la sintaxis es correcta. Mientras se introduce una función, hacer una pausa después de teclear el paréntesis izquierdo y antes de empezar a introducir los parámetros. Un resumen de las opciones de sintaxis aparece en una ventana temporal. Para autocompletar el nombre de una función o variable, pulsar la tecla tabulador tras introducir una parte del nombre, en una ventana temporal se muestras las funciones y variables que comienzan por el texto tecleado.

Obtener ayuda específica mientras se usa una herramienta.

Algunas herramientas ofrecen ayuda sensible al contexto. Accede a la ayuda usando los botones de ayuda o los menús contextuales.

Ver la ayuda específica de cada herramienta para saber si incluye ayudas contextuales.

Verificar el código y obtener recomendaciones sobre cómo mejorarlo.

En el editor, ver los mensajes de la herramienta M-Lint



3 MATLAB como calculadora científica

3.1 Operaciones básicas y precedencia de operadores MATLAB puede usarse como una potente calculadora científica en la que los las expresiones a

evaluar se introducen por teclado. Los operadores aritméticos básicos son +, -, *, / y ^

(operador elevado a), que pueden usarse junto con los paréntesis para alterar la precedencia

de los mismos. El orden de precedencia es:

1. Cantidades entre paréntesis: (2+3)*5 5 * 5 25

2. Potencias (^): 2 + 3^2 2 + 9 11

3. *, /, que se ejecutan de izquierda a derecha: 2 * 6 / 4 12 / 4 3

4. +, -, que se ejecutan de izquierda a derecha: 2 + 3 – 7 5 – 7 -2

3.2 Operaciones lógicas MATLAB también permite incluir operaciones lógicas. Sigue el criterio habitual de interpretar 0

como falso y distinto de cero como cierto. Los operadores lógicos y de comparación son: ==

(comparación igual), ~= (distinto), < (menor), > (mayor), <= (menor o igual), >= (mayor o igual),

~ (negación), & (y lógico), | (o lógico), && (short circuit AND), || (short circuit OR).

Las operaciones && y || se diferencian de & y de | en que la parte a la derecha del operador

sólo se evalúa si el valor de la parte izquierda no es suficiente para determinar el resultado de

la operación.

Las operaciones lógicas y de comparación tienen el menor nivel de precedencia. Por ejemplo:

2 + 3 < 4 5 < 4 0

3.3 Variables MATLAB permite la creación de variables y la asignación a las mismas de un valor. A diferencia

de otros lenguajes de programación, MATLAB no exige la declaración de tipos para las

variables, sino que el tipo se determina dinámicamente en tiempo de ejecución.

Un nombre de variable empieza siempre con una letra, seguida por un número de letras,

dígitos o underscores (‘_’). Los nombres son sensibles a mayúsculas y minúsculas, de modo

que A y a son dos variables distintas. Los sombres de las variables no pueden coincidir con los

nombres de palabras reservadas de MATLAB como if o end. El comando iskeyword devuelve

una lista completa de las palabras reservadas).

Se debe evitar crear variables con los mismos nombres que una función (como por ejemplo i, j,

mode, chark, size o path). Los nombres de las variables tienen precedencia sobre los nombres

de las funciones, por lo que al crear variables cuyo nombre coincida con el de una función,

pueden obtenerse resultados inesperados. Para saber si un nombre ya existe como nombre de

función, podemos usar la función exist. Para eliminar una variable de la memoria (workspace)

podemos usar la función clear.

Para asignar un valor a una variable se utiliza el operador =, con la sintaxis var_name =

expresión. Por ejemplo x=(5+3*7), que asignaría a la variable x el valor 26.



MATLAB usa los caracteres i y j para representar la unidad imaginaria, por ello debe evitarse el

uso de i y j como nombres de variables, en especial si va a usar aritmética compleja.

3.4 Aritmética compleja MATLAB permite operar directamente con valores complejos. Como se indicó en el apartado

anterior, i y j se utilizar para representar la unidad imaginaria (i=j=sqrt(-1)). Si queremos

obtener la parte real o la parte imaginaria de una cantidad compleja, podemos usar las

funciones real y imag respectivamente. Las funciones abs y angle permiten calcular el módulo

y la fase de un valor complejo.

3.5 Supresión de eco en pantalla MATLAB muestra en pantalla el resultado de la expresión introducida desde la línea de

comandos. Si queremos evitar dicho eco por pantalla, basta con terminar las expresiones con

el carácter punto y coma (;).

4 Matrices y arrays Como ya se indicó al introducir MATLAB, éste surgió inicialmente para facilitar la realización de

cálculos con matrices. Como aproximación inicial podemos decir que en MATLAB todo son

matrices. Una matriz es cualquier array rectangular de números (reales o complejos). En ese

sentido, un escalar se representa en MATLAB como una matriz de dimensión 1x1, y un vector

es una matriz que tiene una única fila (vector fila) o una única columna (vector columna).

4.1 Introducir matrices Podemos introducir matrices de varias formas:

1. Introducir una lista explícita de elementos.

2. Crear matrices a partir de funciones.

3. Cargar matrices a partir de ficheros externos de datos.

4. Mediante concatenación de otras matrices.

4.1.1 Creación directa de matrices

Para crear una matriz directamente en MATLAB debemos seguir las siguientes reglas:

1. Separar los elementos de una fila mediante espacios en blanco o comas.

2. Utilizar el carácter punto y coma (;) para indicar el final de cada fila.

3. Encerrar toda la lista de elementos entre corchetes.

4. La matriz vacía (sin elementos) se representa con [], es decir sin introducir ningún

elemento entre los corchetes.

Por ejemplo:

A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]

a lo que MATLAB responderá con el resultado:

A =

16 3 2 13



5 10 11 8

9 6 7 12

4 15 14 1

En el espacio de trabajo (workspace) veremos la variable A. Podremos referirnos a esta matriz

utilizando el nombre de la variable en la que la hemos almacenado.

4.1.2 Creación de matrices a partir de funciones

MATLAB proporciona una serie de funciones que nos permiten crear tipos especiales de

matrices. Las funciones más básicas son:

Función Resultado

zeros Una matriz de las dimensiones indicadas con todos los elementos inicializados a cero

ones Una matriz de las dimensiones indicadas con todos los elementos inicializados a uno

eye La matriz unidad de las dimensiones indicadas diag Permite crear una matriz diagonal, en la que los elementos de la diagonal

son los valores del vector que se le pasa como parámetro. rand Una matriz de las dimensiones indicadas con elementos aleatorios tomados

de una distribución uniforme. randn Una matriz de las dimensiones indicadas con elementos aleatorios tomados

de una distribución normal de media 0 y desviación típica 1. linspace Devuelve un vector fila con un conjunt de valores equiespaciados. Es

necesario indicar el valor inicial, el final y el número total de elementos.

Algunos ejemplos son:

Z = zeros(2,4)

Z =

0 0 0 0

0 0 0 0

F = 5*ones(3,3)

F =

5 5 5

5 5 5

5 5 5

N = fix(10*rand(1,10))

N =

9 2 6 4 8 7 4 0 8 4

R = randn(4,4)

R =

0.6353 0.0860 -0.3210 -1.2316

-0.6014 -2.0046 1.2366 1.0556

0.5512 -0.4931 -0.6313 -0.1132

-1.0998 0.4620 -2.3252 0.3792



4.1.3 Cargar matrices desde un fichero de datos

La forma más simple de importar datos desde un fichero es utilizando la función load. Esta

función permite cargar varias variables diferentes, cada una con el mismo nombre con el que

se salvó, si se utilizan ficheros con el formato ‘.mat’. Como ejemplo, y suponiendo que hemos

creado las matrices de los ejemplos anteriores, podemos salvar dichas matrices en un fichero

con el comando save:

save mis_datos A Z F N

Con este comando salvamos en el fichero mis_datos.mat las variables A, Z, F y N. Si sólo

ponemos el nombre del fichero y no indicamos ningún nombre de variable, salvaríamos todas

las variables existentes en el workspace.

Para cargar al workspace el contenido de un fichero .mat, basta con hacer:

load mis_datos

si sólo queremos cargar parte de las variables, basta con indiquemos los nombres de las

mismas tras el nombre del fichero.

También podemos usar load para cargar matrices desde un fichero de texto que contenga

datos numéricos. El fichero debe estar organizado como una tabla de números, separados por

espacios (o tabuladores), con una fila de la matriz en cada fila del fichero, y un mismo número

de elementos en cada una de las filas. Por ejemplo supongamos que tenemos un fichero de

texto denominado datos.dat cuyo contenido es:

16 3 2 13

5.0 10.0 11 8.0

9.0 6.0 7 12.0

4.0 15.0 14.0 1.5

Con el comando:

load datos.dat

leeríamos el contenido del fichero y quedaría almacenado en la variable datos. Un fichero de

texto sólo puede contener una matriz. También podemos usar el comando save para guardar

una matriz en un fichero de texto. Para más información sobre todas las posibilidades que

ofrecen los comandos load y sabe, consultar la ayuda de MATLAB.

4.1.4 Concatenación

Es un proceso por el que podemos crear matrices a partir de la unión de otras matrices más

pequeñas. Una forma de ver esta idea es volver a lo ya enunciado de que para MATLAB

prácticamente todo es una matriz. En ese sentido, la introducción directa de una matriz

consistiría en la concatenación de un conjunto de matrices 1x1. Esta idea podemos ampliarla a

matrices de otros tamaños. Por ejemplo consideremos el caso de construir una matriz de

transformación homogénea, que es un tipo de matriz empleada en la representación de



transformaciones entre distintos sistemas de coordenadas. La estructura de este tipo de

matrices es:

1|0

|

|

31

1333

x

xx PR

T

Supongamos que:

R=[1 0 0; 0 0 -1; 0 1 0];

P=[1; 2; 3];

Entonces, construyendo T por filas:

T=[ R P; zeros(1,3) 1];

o bien, si lo hacemos por columnas:

T=[ [R; zeros(1,3)] [P; 1] ];

En cualquiera de los dos casos, lo que hay que tener en cuenta es que las dimensiones de los

bloques que formemos deben ser compatibles. En el primer caso, R y P son matrices de tres

filas y zeros(1,3) y 1 tienen una fila cada una. Además la suma del número de columnas de los

elementos que forman cada fila de T es la misma (4 columnas en total). En el segundo caso

estamos en una situación similar. Todos los elementos de la primera columna de la matriz T (R

y zeros(1,3)) tienen 3 columnas, mientras que para la segunda columna de T hemos usado

matrices de 1 columna. Respecto al número de filas, en ambos casos, cada columna de T tiene

un total de 4 filas.

4.2 Acceso a los elementos de una matriz

4.2.1 Acceso básico

Para acceder al elemento en la fila r y la columna c de la matriz A, se usa la notación A(r,c). En

el caso de trabajar con vectores fila (matrices 1xn) o vectores columna (matrices mx1) es

suficiente con emplear un único índice. Así, para acceder al elemento k del vector V

escribiremos V(k). A diferencia de otros lenguajes como C, los índices siempre comienzan con

el valor 1.

También podemos usar un único índice para referirnos a un elemento de una matriz

rectangular cualquiera. Para interpretar el resultado, es necesario tener en cuenta que

MATLAB almacena los valores de las matrices por columnas. Es decir, el primer elemento de la

matriz A será el A(1,1), el segundo el A(2,1) y así sucesivamente. Como ejemplo, si tenemos la

matriz:

A =

16 2 3 13

5 11 10 8



9 7 6 12

4 14 15 1

el elemento A(7) vale 7 (en la posición 3,2), y el elemento A(9) es el 3 (en la posición 1,3).

Si intentamos acceder a un elemento fuera de la matriz, obtendremos un error:

>> t=A(4,5)

??? Attempted to access A(4,5); index out of bounds because

size(A)=[4,4].

Podemos usar matrices para acceder simultáneamente a más de un elemento de una matriz.

Por ejemplo, si que queremos acceder a los elementos 1 y 3 de la fila 4 de la matriz A,

haremos:

>> A(4,[1 3])

ans =

4 15

La función size nos sirve para calcular el tamaño de una matriz. En su uso más común size(A),

nos devuelve un vector fila con el número de filas y columnas de la matriz:

>> size(A)

ans =

4 4

Podemos usar la función size para obtener sólo el número de filas o el número de columnas.

Para ello (consultar la ayuda: doc size), es necesario añadir un segundo parámetro como puede

observarse en el siguiente ejemplo:

>> B=[A A];

>> size(B,1)

ans =

4

>> size(B,2)

ans =

8

También disponemos de la función length, que devuelve el máximo entre el número de filas y

de columnas de una matriz. Es muy útil en el caso de manejar vectores.

4.2.2 El operador dos puntos (:)

El operador dos puntos, : , es uno de los más importantes en MATLAB y tiene varios usos. La

expresión:

>> 1:5

Produce como resultado un vector fila con los enteros entre 1 y 5:

ans =

1 2 3 4 5



Los valores a la izquierda y derecha del operador pueden ser cualquier expresión que devuelva

un escalar. Si queremos obtener un espaciado entre elementos no unitario, utilizaremos la

sintaxis:

>> 10:-3:1

ans =

10 7 4 1

Otro ejemplo puede ser:

>> 0:pi/4:pi

ans =

0 0.7854 1.5708 2.3562 3.1416

Este operador podemos usarlo para referirnos a rangos de filas o columnas en una matriz. Por

ejemplo, para referirnos a los elementos de las filas 1 a 3 de la cuarta columna de la matriz A,

escribiríamos:

A(1:3, 4)

Si queremos acceder a toda una fila (o una columna), podemos utilizar éste operador sin

necesidad de indicar un valor inicial y otro final. Así, para referirnos a la fila 3 de la matriz B,

escribiríamos:

B(3,:)

Podemos usar la palabra reservada end para referirnos a la última fila o columna de una

matriz. Por ejemplo para referirnos a los elementos a partir de la columna 2 de la penúltima

fila de la matriz B, podemos escribir:

B(end-1,2:end)

Un último caso que merece la pena destacar es el uso del operador : para convertir una matriz

en un vector columna. Para ello sólo es necesario referirse a todos los elementos de la matriz

utilizando un único índice. Por ejemplo:

>> A(:)

ans =

16

5

9

4

2

11

7

14



3

10

6

15

13

8

12

1

4.2.3 Indexación mediante vectores de booleanos

Podemos usar vectores de valores booleanos para acceder a los elementos de una matriz. La

mejor forma de ilustrar este caso es mediante un ejemplo. Supongamos que queremos

obtener los valores de la matriz A que son mayores que cinco. Para ello basta con indicar la

condición como índices de la matriz:

>> A(A>5)

ans =

16

9

11

7

14

10

6

15

13

8

12

Nótese que como el resultado no tiene porqué ajustarse a una determinada estructura

rectangular, el resultado es devuelto como un vector columna.

4.2.4 Modificación de elementos

Para modificar los elementos de una matriz o un array es suficiente con acceder a dichos

elementos y asignarles el nuevo valor. Por ejemplo:

A(1:4,3)=[0; 1; 2; 3]

Lo importante es que las expresiones a la izquierda y a la derecha de la asignación tengan las

mismas dimensiones.

Existen dos casos particulares:

Si se va a asignar a todos los elementos el mismo valor, es suficiente con indicar el

numero valor como un escalar

Si se desea eliminar filas o columnas de un array, o elementos de un vector, se les

asignará la matriz vacía. Por ejemplo:



>> B=rand(4,5)

B =

0.7449 0.2251 0.0513 0.1676 0.0471

0.8923 0.3500 0.5927 0.5022 0.2137

0.2426 0.2871 0.1629 0.9993 0.3978

0.1296 0.9275 0.8384 0.3554 0.3337

>> B(:,3)=[]

B =

0.7449 0.2251 0.1676 0.0471

0.8923 0.3500 0.5022 0.2137

0.2426 0.2871 0.9993 0.3978

0.1296 0.9275 0.3554 0.3337

>> v=rand(1,8)

v =

0.2296 0.9361 0.6832 0.9621 0.4380 0.9403

0.0058 0.6103

>> v(v>0.5)=[]

v =

0.2296 0.4380 0.0058

4.3 Operaciones con matrices Dado que MATLAB nació orientado a facilitar la solución de problemas de cálculo matricial, no

es de extrañar que soporte de forma nativa las operaciones fundamentales del algebra lineal.

4.3.1 Traspuesta

El operador apóstrofo (‘) permite calcular la conjugada de la traspuesta de una matriz. En el

caso de trabajar con matrices reales, el cálculo de la conjugada es irrelevante ya que la parte

imaginaria de un número real es siempre cero.

>> A'

ans =

16 5 9 4

2 11 7 14

3 10 6 15

13 8 12 1

En el caso de una matriz de números complejos tendríamos:

>> [1 3+i -i 5+5i]'

ans =

1.0000

3.0000 - 1.0000i

0 + 1.0000i

5.0000 - 5.0000i

Si queremos asegurarnos de que sólo se realiza la trasposición podemos usar el operardor

precedido de un punto, como por ejemplo:

>> [1 3+i -i 5+5i].'

ans =

1.0000

3.0000 + 1.0000i

0 - 1.0000i



5.0000 + 5.0000i

4.3.2 Operaciones aritméticas

Podemos usar los operadores +, - y * para realizar las operaciones aritméticas

correspondientes (suma, resta y multiplicación de matrices). En este tipo de operaciones

debemos tener en cuenta las reglas habituales aplicables sobre las dimensiones de las

matrices.

4.3.3 División (multiplicación por la inversa)

Aunque la división de matrices no está definida, MATLAB utiliza los operadores / y \ para

abreviar la forma de representar el producto por la inversa de una matriz. La razón por la que

existen los dos operadores es que el producto de matrices no es una operación conmutativa,

por lo que el resultado de multiplicar B-1*A es distinto del de multiplicar A*B-1.

En concreto, cuando queramos hacer la operación A*B-1 escribiremos A/B, mientras que en el

otro caso, escribiremos A\B.

4.3.4 Funciones

MATLAB ofrece un amplio conjunto de funciones para hacer cálculos con matrices. Entre otras

podemos destacar:

Función Calcula

inv Calcula la inversa de una matriz, si existe. det Calcula el determinante de una matriz norm Calcula la norma de un vector o una matriz eig Calcula los autovalores de una matriz

Para un listado completo de las funciones disponibles usar doc matfun o help matfun.

4.4 Operaciones con arrays Aunque frecuentemente se intercambia el uso de los términos matriz y array, en este caso nos

referiremos a operaciones a realizar con datos que están almacenados en una estructura de

tipo array. En estos casos, lo que nos interesa es realizar una misma operación sobre cada

elemento de un array o entre elementos equivalentes de diferentes arrays.

Supongamos que queremos generar una tabla con los valores de los cuadrados, la raíz

cuadrada y las potencias de dos de los números naturales de 0 a 10. Los datos deben quedar

almacenados en las diferentes columnas de la tabla. El primer paso sería crear un vector

columna con los números enteros entre 0 y 5:

n=(0:5)’;

el siguiente paso sería crear la tabla aplicando el método de concatenación:

tabla=[n n_al_cuadrado raiz_de_n dos_a_n];

El problema surge al querer calcular las tres últimas columnas. Aunque ya se ha explicado que

el operador ^ permite calcular potencias, si escribimos n^2 obtendremos un error

>> n^2

??? Error using ==> mpower



Inputs must be a scalar and a square matrix.

To compute elementwise POWER, use POWER (.^) instead.

Esto se debe a que MATLAB intenta calcular el product n*n, lo que no es posible si la matriz no

es cuadrada. Además, aunque n fuese una matriz cuadrada, el resultado no sería el deseado. El

propio mensaje de error nos da una idea de como solucionar el problema al sugerirnos el uso

del operador (.^). Este operador lo que hace es aplicar la operación ^ a cada elemento

individual del array. Este si es el resultado deseado. La solución a nuestro problema es:

tabla=[ n n.^2 n.^(1/2) 2.^n]

tabla =

0 0 0 1.0000

1.0000 1.0000 1.0000 2.0000

2.0000 4.0000 1.4142 4.0000

3.0000 9.0000 1.7321 8.0000

4.0000 16.0000 2.0000 16.0000

5.0000 25.0000 2.2361 32.0000

Esta opción de preceder el operador con un punto está disponible para todas aquellas

operaciones en las que las reglas propias del algebra lineal difieren del mero hecho de aplicar

la operación a los elementos equivalentes de dos arrays de datos. Así, la suma y la resta son

iguales que la suma y resta de matrices, pero para los demás casos disponemos de los

operadores:

.* Multiplicación elemento a elemento.

./ División elemento a elemento.

.\ División elemento a elemento por la izquierda.

.^ Elevar a un valor cada elemento.

Así por ejemplo, las expresiones:

n.^2

y

n.*n

producirían el mismo resultado.

4.4.1 Uso de funciones con arrays

En el apartado 4.3.4 se ha mencionado que MATLAB proporciona funciones que permiten

resolver cálculos de algebra linear con matrices. Sin embargo, al trabajar con arrays de datos

suele ser habitual que tengamos que aplicar algún tipo de función (seno, coseno, logaritmo,

raíz cuadrada, etc.) a cada elemento del array. MATLAB resuelve este problema de una manera

muy sencilla. Cuando a una de estas funciones aritméticas le pasamos como parámetro un

array, MATLAB aplica la función a cada elemento del array lo que evita tener que crear bucles

para realizar el cálculo. En cierto modo, lo que hacemos es paralelizar el cálculo sobre todo el

conjunto de valores. Por ejemplo:

[(0:pi/6:pi)' sin(0:pi/6:pi)' (0:pi/6:pi)'*180/pi]

ans =



0 0 0

0.5236 0.5000 30.0000

1.0472 0.8660 60.0000

1.5708 1.0000 90.0000

2.0944 0.8660 120.0000

2.6180 0.5000 150.0000

3.1416 0.0000 180.0000

Función Resultado

abs Valor absoluto de valores reales y módulo de valores complejos acos Arcocoseno angle Argumento de un número complejo asin Arcoseno atan Arcotangente atan2 Arcotangente en 4 cuadrantes ceil Redondeo hacia infinito conj Conjugado de un número complejo cos Coseno exp Exponencial fix Redondea hacia cero floor Redondea hacia menos infinito log Logaritmo neperiano log2 Logaritmo en base 2 log10 Logaritmo en mase 10 mod Modulo (resto con signo tras la división entera) rem Resto de la división round Redondea al entero más cercano sign Signo sin Seno sqrt Raíz cuadrada tan Tangente

Para un listado complete de las funciones disponibles usar doc elfun o help elfun

4.4.2 Funciones básicas para el análisis de datos

MATLAB incluye un conjunto básico de funciones para el análisis de datos. Para el uso de estas

funciones es fundamental recordar que MATLAB está orientado, por defecto, al procesamiento

por columnas. Algunas de las funciones incluidas en este bloque son:

Función Resultado

cumprod Devuelve un vector de la misma dimensión que el original, en el que cada elemento es el producto acumulado de los anteriores. En el caso de arrays, el cálculo se hace para cada columna.

cumsum Devuelve un vector de la misma dimensión que el original, en el que cada elemento es la suma acumulada de los elementos anteriores. En el caso de arrays, el cálculo se hace para cada columna.

cumtrapz Integración numérica acumulativa (desde el primer elemento hasta el actual) mediante el método de los trapecios.

inpolygon Detecta si un punto está dentro de una región poligonal. max Vector fila con los máximos de cada columna de un array. Puede devolver

también la posición en la que se encuentran dichos máximos. mean Vector fila con el valor medio de cada columna de un array.



median Vector fila con las medianas de cada columna de un array. min Vector fila con los mínimos de cada columna de un array. Puede devolver

también la posición en la que se encuentran dichos mínimos. prod Vector fila con el producto de los elementos de cada columna del array. En el

caso de vectores es el producto de todos los elementos. sort Ordena los elementos en orden ascendente sortrows Ordena las filas de un array en orden ascendente. std Vector fila con la desviación típica de cada columna de un array sum Vector fila con la suma de los elementos de cada columna del array. En el caso

de vectores es la suma de todos los elementos. trapz Vector fila con la integral numérica, por el método de los trapecios, de los

elementos de cada columna del array. var Vector fila con la varianza de cada columna de un array

5 Polinomios MATLAB permite trabajar con polinomios y para ello usa el convenio de representar los

polinomios mediante vectores fila que contienen los coeficientes del polinomio ordenados por

orden decreciente del exponente. Por ejemplo, el polinomio se

representa en MATLAB como el vector:

P=[1 0 -2 -5]:

Obsérvese que es necesario incluir el valor cero en la segunda posición para indicar que no

existe el término de segundo grado.

Podemos sumar y restar polinomios usando los operadores + y – sin más que tener en cuenta

que los polinomios que intervengan deben ser del mismo grado (representados con vectores

de la misma longitud). Para ello rellenaremos con ceros por la izquierda para poder completar

el orden del polinomio de menor grado. Por ejemplo si queremos sumar el polinomio

al polinomio anterior, deberemos hacer:

q=[0 5 3 0];

MATLAB también nos ofrece un conjunto de funciones para operar con polinomios, las más

básicas son:

Función Resultado

conv La operación de convolución de dos polinomios equivale a su multiplicación.

deconv La deconvolución de dos polinomios equivale a su división poly Devuelve el polinomio con la raices indicadas. polyder Calcula la derivada de un polinomio polyfit Ajusta un conjunto de datos a un polinomio del grado especificado. polyint Calcula el polinomio resultante de calcular la integral analítica. polyval Evalúa el polinomio en un conjunto de valores de la variable independiente roots Calcula las raíces de un polinomio



6 Funciones gráficas básicas

6.1 Creación de una figura con plot La función plot puede usarse de diferentes maneras en función de los parámetros que se le

pasen (ver doc plot). Si y es un vector, plot(y) produce una aproximación lineal a trozos de la

curva representada por los elementos de y frente al índice. Si se especifican dos vectores de

las mismas dimensiones, plot(x,y), se representan los valores de y frente a los de x. Por

ejemplo sin queremos hacer una representación del valor del seno en función del ángulo en el

rango [0, 2], lo primero que haremos es seleccionar un conjunto discreto de valores angulares

en dicho rango:

angulo=0:pi/100:2*pi;

después calcularemos el seno en cada una de esas posiciones angulares. No es necesario hacer

un bucle para recorrer cada elemento del array, ya que las propias funciones de MATLAB nos

permiten hacer el cálculo en una única instrucción:

seno=sin(angulo);

Por último dibujaremos la curva:

plot(angulo,seno)

Podemos añadir un título a la gráfica o etiquetar los ejes mediante las funciones title, xlabel e

ylabel:

xlabel('ángulo = 0:2pi')

ylabel('Seno(angulo)')

title('Gráfica de la función seno','FontSize',12)

Podemos superponer varias curvas en una misma figura utilizando el comando hold:

Hold on Hace que sucesivas llamadas a plot se superpongan sin borrar las

curvas anteriores.

Hold off (por defecto) Cada llamada a plot sustituye la curva anterior con la

nueva.

Hold Conmuta el estado entre on y off.

También es posible cambiar la forma en la que se representa la curva. Como ejemplo,

podemos añadir a la curva anterior los puntos reales que la componen y la aproximación

resultante si hubiésemos elegido una resolución 25 veces menor:

hold on

plot(angulo,seno,'rx',angulo(1:25:end),seno(1:25:end),'--g')



6.2 Creación de varios gráficos en una misma ventana

6.2.1 Ventanas gráficas

Las funciones gráficas crean automática una ventana para la figura si no hay ninguna

disponible. Si ya existe, se utiliza para enviar a ella la salida del comando gráfico. Como se

comentó en el apartado anterior, hold permite controlar si los nuevos gráficos sustituyen o se

añaden a los ya existentes. Podemos crear nuevas ventanas gráficas mediante la función

figure. Dicha función devuelve un handle de ventana que puede ser utilizado para seleccionar

dicha ventana antes de ejecutar la siguiente instrucción gráfica sin más que volver a llamar a la

función y pasarle como parámetro el handle de la ventana que queremos activar. Si no existe

una ventana con el handle indicado, se crea una ventana nueva con dicho handle.

Podemos utilizar las opciones que aparecen en los menús y las barras de botones para:

Editar la gráfica: colores, tipos de línea, ejes, etc.

Hacer zoom: puede ser de una zona o sólo en uno de los ejes en función de lo

seleccionado con los menús contextuales.

Podemos rotar la figura.

Ver el valor de cada punto y desplazarnos por los puntos que constituyen la gráfica.

Añadir una leyenda.

6.2.2 Subplot

El comando subplot nos permite mostrar varios gráficos independientes en una misma

ventana. Para ello, la función recibe tres parámetros:

0 1 2 3 4 5 6 7-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

ángulo = 0:2pi

Seno(a

ngulo

)

Gráfica de la función seno



subplot(m,n,p)

Con este comando dividimos la ventana gráfica en una retícula de m filas y n columnas, para

dejar activada la celda p. Las celdas se numeran por filas, empezando por la fila superior y

siguiendo de izquierda a derecha. Por ejemplo, para representar las curvas anteriores en tres

gráficos distintos:

figure(2)

subplot(1,3,1); plot(angulo,seno); title('figura 1');

xlabel('angulo'); ylabel('seno')

subplot(1,3,2); plot(angulo,seno,'+r'); title('figura 2');


subplot(1,3,3); plot(angulo,seno,'g--'); title('figura 3');


6.2.3 Control de los ejes

El comando axis nos permite modificar el rango, la orientación y el aspecto de los ejes de la

figura.

Por defecto, MATLAB busca el mínimo y el máximo de los datos a representar y elige

automáticamente un rango que cubra dichos valores. Usando el comando axis podemos

especificar dichos rangos de forma manual:

axis([xmin xmax ymin ymax])

En el caso de gráficos tridimensionales es necesario especificar los valores para los tres ejes:

0 5 10-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1figura 1

angulo

seno

0 5 10-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1figura 2

angulo

seno

0 5 10-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1figura 3

angulo

seno



axis([xmin xmax ymin ymax zmin zmax])

Podemos volver a los límites automáticos usando el comando:

axis auto

El comando axis también nos permite modificar la relación de aspecto de los ejes. Para ver el

efecto, veamos el aspecto que tendría una circunferencia unidad con las diferentes opciones

disponibles:

figure(3)

subplot(1,3,1);

plot(exp(i*(0:pi/20:2*pi)));

axis normal;

title('axis normal')

subplot(1,3,2);


axis square;

title('axis square')

subplot(1,3,3);


axis equal;

title('axis equal')

El comando grid nos permite controlar la visualización del grid de la figura:

grid on, activa la visualización del grid

grid off, desactiva la visualización (por defecto)

-1 0 1-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1axis normal

-1 0 1-1

-0.5

0

0.5

1axis square

-1 0 1

-2.5

-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

2.5

axis equal



grid, conmuta el estado de la visualización entre on y off.

6.2.4 Introducción a los gráficos 3D

MATLAB dispone de funciones que nos permiten dibujar curvas 3D o visualizar superficies. La

función básica para visualizar una curva en el espacio 3D es la función plot3, cuyo

funcionamiento es muy similar a plot, salvo que necesita los tres vectores correspondientes a

las coordenadas x, y, z de los puntos que constituyen la curva.

Supongamos que una partícula se mueve siguiendo una trayectoria helicoidad definida por:

ttttP )2cos()2sin()( ,

La velocidad con que se desplaza es la derivada de la posición respecto del tiempo, luego:

1)2sin(2)2cos(2)(

)( ttdt

tdPtV

Para representar la posición de la partícula entre t=0s y t=7s, podemos emplear el siguiente

código:

t=0:0.1:7;

x=sin(2*t); y=cos(2*t); z=t;

plot3(x,y,z,'k','LineWidth',2);

grid on;

xlabel('\bfX'); ylabel('\bfY'); zlabel('\bfZ');

Si queremos representar la posición de la particula tras cada segundo de movimiento:

hold on

plot3(x(1:10:end),y(1:10:end),z(1:10:end),'o',…

'MarkerFaceColor',[0 1 0])

Si queremos visualizar el vector velocidad en los puntos de la trayectoria, podemos usar el

comando quiver3

vx=2*cos(2*t); vy=-2*sin(2*t); vz=ones(size(t));

quiver3(x,y,z,vx,vy,vz,'b')

Posición de la particula

Posición y velocidad de la partícula

-1

-0.5

0

0.5

1

-1

-0.5

0

0.5

1

0

1

2

3

4

5

6

7

XY

Z

-1.5-1

-0.50

0.51

1.5

-1.5

-1

-0.5

0

0.5

1

1.5

0

1

2

3

4

5

6

7

8

XY

Z



Es posible cambiar el punto de vista desde el que se representa la figura con el comando view,

pasándole como parámetros la rotación horizontal y la elevación vertical en grados. Por

ejemplo:

View([-15 42])

7 Un pequeño ejemplo Supongamos que tenemos en un fichero una matriz con cuatro columnas que representan el

tiempo y las tres componentes de la velocidad instantánea de un objeto. Las mediciones han

sido realizadas con un periodo de muestreo de 10Hz:

0.0000000e+000 2.0000000e+000 -0.0000000e+000 1.0000000e+000

1.0000000e-001 1.9601332e+000 -3.9733866e-001 1.0000000e+000

. . . .

. . . .

. . . .

6.9000000e+000 6.6162976e-001 -1.8873913e+000 1.0000000e+000

7.0000000e+000 2.7347444e-001 -1.9812147e+000 1.0000000e+000

El objetivo es calcular la trayectoria seguida por el objeto.

Podemos cargar el fichero en un array y visualizar los datos

datos=load('velocidad.dat');

t=datos(:,1);

v=datos(:,2:end);

plot(t,v,'.-')

xlabel('tiempo (s)')

ylabel('velocidad (ms^{-1})');

title('datos de velocidad');

legend('v_x','v_y','v_z')

-1.5-1

-0.50

0.51

1.5

-1.5

-1

-0.5

0

0.5

1

1.5

0

2

4

6

8

X

Y

Z



p=cumtrapz(t,v);

plot(t,p)

title('datos de posición');

xlabel('tiempo (s)');

ylabel('posición (m)');

Podemos visualizar los datos en 3D y, al igual que antes, visualizar la posición del objeto cada

segundo:

plot3(p(:,1),p(:,2),p(:,3),'k','LineWidth',2)

grid on

xlabel('p(:,1)');

ylabel('p(:,2)');

zlabel('p(:,3)');

title('Trayectoria del objeto en el espacio');

0 1 2 3 4 5 6 7-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

tiempo (s)

velo

cid

ad (

ms-1

)

datos de velocidad

vx

vy

vz

0 1 2 3 4 5 6 7-2

-1

0

1

2

3

4

5

6

7

tiempo (s)

posic

ión (

m)

datos de posición



view([-15 42])

hold on

plot3(p(1:10:end,1),p(1:10:end,2),p(1:10:end,3),'o','MarkerFaceColor',

'g');

También podemos analizar la aceleración de la partícula. Para ello debemos aproximar

numéricamente la derivada de la velocidad utilizando la función gradient:

acc=[gradient(v(:,1),0.1) gradient(v(:,2),0.1) gradient(v(:,3),0.1)];

figure

plot(t,acc)

xlabel('tiempo (s)');

ylabel('aceleración (ms^{-2}');

title('acceleración aproximada');

-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1

-2

-1.5

-1

-0.5

0

0

1

2

3

4

5

6

7

p(:,1)

Trayectoria del objeto en el espacio

p(:,2)

p(:

,3)

0 1 2 3 4 5 6 7-4

-3

-2

-1

0

1

2

3

4

tiempo (s)

acele

ració

n (

ms

-2

acceleración aproximada



Los datos analizados coindicen con los del ejemplo analítico anterior, así que podemos saber

cuál sería la aceleración real del objeto, derivando la expresión analítica de la velocidad

respecto del tiempo. El resultado es:

0)2cos(4)2cos(4)(

)( ttdt

tdVtA

8 Programación

8.1 Control de flujo Gran parte de la potencia de MATLAB reside en la facilidad para trabajar con datos

organizados en forma de arrays (tanto en algebra como en aplicaciones de análisis de datos) y

en el amplio conjunto de funciones de que dispone. Estas facilidades hacen que con una única

instrucción podamos resolver problemas que con un lenguaje tradicional como C, requieren la

generación de un gran número de líneas de código con bucles, bifurcaciones, etc.

Sin embargo, no todo puede resolverse siempre con una línea de código. Por ello, MATLAB

incluye las instrucciones de control de flujo necesarias para poder implementar cualquier

algoritmo.

8.1.1 Control de flujo condicional: if, else, y switch

Este tipo de instrucciones permite seleccionar, en tiempo de ejecución, qué bloque de código

se va a ejecutar realmente. La instrucción más sencilla es if, que permite ejecutar un bloque de

código si una determinada expresión se evalúa como cierta.

SINTAXIS

if expresión

instrucciones

end

La instrucción if puede combinarse con la instrucción else, de modo que si la expresión es

cierta, se ejecuta bloque de código que sigue a if y si es falsa, se ejecuta el bloque de código

que sigue a else.

SINTAXIS

if expresión

instrucciones

else

instrucciones

end

También se admite la construcción elseif como una forma de encadenar sucesivas condiciones.

Hay que tener en cuenta que el caso de elseif sólo es necesario incluir una vez la palabra

reservada end para finalizar la instrucción. En el caso de utilizar else if debemos tener en



cuenta que este nuevo if se interpreta como una instrucción separada y, por tanto, deberá

llevar asociado un end al final.

SINTAXIS con elseif if expresión

instrucciones

elseif

instrucciones

else

instrucciones

end

SINTAXIS con else if if expresión

instrucciones

else

if

instrucciones

else

instrucciones

end

end Las expresiones utilizadas con la instrucción if pueden ser expresiones matriciales y conviene

tener en cuenta cómo son interpretadas. La forma normal de comparar la igualdad entre dos

variables es A==B, con lo que podemos escribir

if A==B, …

El código es correcto y funcionará como esperamos en el caso de que A y B sean escalares

(matrices 1x1). Sin embargo, si A y B son matrices, el operador == comprueba qué elementos

de ambas matrices son iguales por lo que el resultado es una matriz del mismo tamaño que A y

B con valores 0 y 1 que reflejan si los elementos son iguales o no. De hecho, si A y B tienen

distinta dimensión se producirá un error en tiempo de ejecución. Para resolver este caso

debemos utilizar la función isequal.

Otras funciones que nos pueden servir para resolver estos casos:

Función Resultado

isempty Cierto si el parámetro es una matriz vacía ([]) all Cierto si todos los elementos del vector son ciertos. En caso de arrays hace el

cálculo para cada columna. any Cierto si al menos un elemento del vector es cierto. En caso de array hace el

cálculo para cada columna.

En ocasiones lo que queremos hacer es ejecutar diferente código en función de una variable

que puede tomar una serie de valores conocidos. En este caso resulta más apropiado utilizar la

instrucción switch.

SINTAXIS

switch expresión_del_switch

case expresión_caso_1

instrucciones

case expresión_caso_2

instrucciones

case expresión_caso_n

instrucciones

otherwise

instrucciones

end



Cada posible opción de los valores de la expresión del switch es un caso diferente. Al ejecutar

la instrucción switch, se compara el resultado de la expresión del switch con el resultado de la

expresión de cada caso hasta encontrar una comparación que devuelva cierto. Un case es

cierto cuando:

Tipo de dato Condición

Números isequal(expresión_caso. expresión_del_switch) Cadenas strcmp(expresión_caso. expresión_del_switch) Cell array la expression del switch es un miembre de cell array que forma la

expresión del caso

Existen algunas diferencias con el lenguaje C que es importante destacar:

En MATLAB no se continúa la comprobación de casos, es decir, en MATLAB sólo se

ejecuta el grupo de instrucciones pertenecientes al primer caso que se evalúe a cierto.

Por eso no es necesario añadir una instrucción break al final del caso para evitar que la

ejecución continúe.

No es necesario incluir el carácter :

Para identificar el caso que se ejecuta si todos los demás son falsos, se utiliza la

palabra reservada otherwhile.

Algunos ejemplos de uso son:

a) Mostrar un texto en función del valor introducido por el usuario:

mynumber = input('Enter a number:');

switch mynumber

case -1

disp('negative one');

case 0

disp('zero');

case 1

disp('positive one');

otherwise

disp('other value');

end

b) Decidir qué gráfica representar en función del valor de una cadena:

x = [12, 64, 24];

plottype = 'pie3';

switch plottype

case 'bar'

bar(x)

title('Bar Graph')

case {'pie','pie3'}

pie3(x)

title('Pie Chart')

legend('First','Second','Third')

otherwise



warning('Unexpected plot type. No plot created.');

end

8.1.2 Bucles: for, while, continue y break

MATLAB incluye dos formas para permitir la ejecución repetida de un conjunto de

instrucciones. Una es la instrucción for. La principal característica de la instrucción for es que el

número de veces que se repite el código del bloque es conocido de antemano. Para delimitar

las instrucciones que forman el código del bucle, emplearemos la palabra reservada end.

SINTAXIS

for index_var = valores

instrucciones

end

En cada iteración, index_var toma un nuevo valor de los indicados en valores y se ejecuta el

conjunto de instrucciones que forman el bucle con el nuevo valor de index_var. El valor de

ixdex_var al finalizar el bucle es el último valor del conjunto de posibles valores.

Valores es una matriz, de forma que index_var toma como valores las distintas columnas de

dicha matriz:

Valores es un vector fila Valores es un vector columna

for k=1:3

k

end

k =

1

k =

2

k =

3

for k=[1; 2; 3]

k

end

k =

1

2

3

En el caso de la izquierda, k toma como valor cada uno de los tres elementos que forman el

vector fila (1:3) y por tanto se ejecuta 3 veces. En el caso de la derecha, el mecanismo se

repite, k toma como valor cada una de las columnas de la matriz y ejecuta las instrucciones del

bucle. En este caso, cada columna tiene tres filas, por lo que en cada iteración k es un vector

columna con tres elementos. Como la matriz que indica los posibles valores sólo tiene 1

columna el bloque sólo se ejecuta 1 vez.

La insturcción while ejecuta las instrucciones del bucle un número indefinido de veces. La

finalización del bucle depende de que la expresión que acompaña a while se evalue como

cierta. Al igual que el caso anterior, el conjunto de instrucciones que se ejecutan en el bucle va

delimitado con la palabra reservada end.

SINTAXIS

while expresión



instrucciones

end

Como ejemplo, el siguiente código permite buscar la raíz de un polinomio por el método de la

bisección:

a = 0; fa = -Inf;

b = 3; fb = Inf;

while b-a > eps*b

x = (a+b)/2;

fx = x^3-2*x-5;

if sign(fx) == sign(fa)

a = x; fa = fx;

else

b = x; fb = fx;

end

end

Conviene tener en cuenta las mismas consideraciones hechas para la instrucción if en el caso

de que la expresión que controla la ejecución del bucle while incluya matrices.

A diferencia de otros lenguajes de programación, MATLAB no incluye la instrucción do … while

o repeat … until. Sin embargo esto no supone ningún problema dado que cualquiera de estos

bucles puede escribirse en función del bucle while como:

instrucciones

while expresión

instrucciones

end

En ocasiones puede ser necesario modificar la forma en la que se ejecutan las instrucciones

dentro de un bucle. Para ello disponemos de las instrucciones: continue y break.

La instrucción continue pasa inmediatamente a la siguiente iteración del bucle dentro del que

aparece, evitando así la ejecución de las instrucciones que aparezcan por debajo de ella en el

bucle. Por ejemplo, el siguiente código evita la visualización del valor de k cuando k es par y

menor o igual que cuatro, aunque el bucle se ha ejecutado 6 veces.

for k=1:6

disp(sprintf('iteracion %d\n',k))

if ~rem(k,2) & k<=4

continue

end

k

end

iteracion 1

k =

1

iteracion 2

iteracion 3

k =

3



iteracion 4

iteracion 5

k =

5

iteracion 6

k =

6

La instrucción break nos permite abandonar la ejecución de un bucle, pasando a ejecutar la

siguiente instrucción posterior al bucle. El siguiente ejemplo sirve para visualizar la diferencia

de funcionamiento con la instrucción continue:

for k=1:6

disp(sprintf('iteracion %d\n',k))

if ~rem(k,2) & k<=4

break

end

k

end

iteracion 1

k =

1

iteracion 2

En este caso, la ejecución del bucle se interrumpe totalmente al encontrar el primer valor que

cumple la condición de la instrucción if. Usando la instrucción break podemos mejorar la

eficiencia del algoritmo de la bisección mostrado anteriormente:

a = 0; fa = -Inf;

b = 3; fb = Inf;

while b-a > eps*b

x = (a+b)/2;

fx = x^3-2*x-5;

if fx == 0

break

elseif sign(fx) == sign(fa)

a = x; fa = fx;

else

b = x; fb = fx;

end

end

x

¿Funcionaría igual si utilizamos continue en lugar de break?

Si queremos finalizar la ejecución de un programa inmediatamente, podemos usar la

instrucción return.



8.2 Otros tipos de datos

8.2.1 Estructuras

Las estructuras son tipos de datos que permiten almacenar diferente información en un mismo

dato. Las diferentes unidades de información se denominan campos y se identifican por un

nombre que debe seguir las mismas reglas que los nombres de las variables. Por ejemplo,

podemos agrupar los datos de tiempo, posición, velocidad y aceleración de la partícula del

ejemplo anterior una única variable de tipo estructura que el ejemplo se llama partícula:

t=0:0.1:7;

p=[sin(2*t) cos(2*t) t];

t=(0:0.1:7)';

p=[sin(2*t) cos(2*t) t];

v=[2*cos(2*t) -2*sin(2*t) ones(size(t))];

a=[-4*sin(2*t) -4*cos(2*t) zeros(size(t))];

particula.posicion=p;

particula.velocidad=v;

particula.aceleracion=a;

particula.tiempo=t;

particula

particula =

posicion: [71x3 double]

velocidad: [71x3 double]

aceleracion: [71x3 double]

tiempo: [71x1 double]

Para acceder a los campos que forma una estructura, escribiremos el nombre de la variable

seguido de un punto (.), y a continuación se escribe el nombre del campo. Cada campo puede

ser de un tipo distinto. También es posible añadir campos dinámicamente. Por ejemplo para

añadir a la estructura anterior un campo con una cadena para poder identificar el tipo de

visualización que queremos, podríamos hacer:

particula.visualizacion='3D';

Los campos de una estructura puede ser también estructuras. Por ejemplo:

particula.experimento.fecha='30-01-2012';

particula.experimento.equipo='simulador 1';

particula

particula =





visualizacion: '3D'

experimento: [1x1 struct]

particula.experimento

ans =



fecha: '30-01-2012'

equipo: 'simulador 1'

Podemos formar arrays de estructuras. Así, si tuviésemos un segundo conjunto de datos,

podemos hacer:

particula(2).posicion=-p;

particula(2).tiempo=t;

particula(2).aceleracion=-a;

particula(2).velocidad=-v;

particula(2).experimento.equipo='simulador 2'

particula(1)

particula(2)

particula =

1x2 struct array with fields:

posicion

velocidad

aceleracion

tiempo

visualizacion

experimento

ans =





visualizacion: '3D'


ans =





visualizacion: []


Podemos comprobar que los campos que no hemos asignado en partícula 2 están inicializados

a la matriz vacía.

Hay varias formas de unir los valores de un mismo campo de diferentes elementos de un array

de estructuras. Por ejemplo si hacemos

particula.posicion

nos devuelve una lista separada por comas de elementos. Es lo mismo que escribir:

paticula(1).posicion, particula(2).posicion

Si encerramos dicha lista entre corchetes, la convertimos en un array en el que cada elemento

de la lista sería una columna del nuevo array:



[particula.posicion]

ans =

0 1.0000 0 0 -1.0000 0

0.1987 0.9801 0.1000 -0.1987 -0.9801 -0.1000

0.3894 0.9211 0.2000 -0.3894 -0.9211 -0.2000

0.5646 0.8253 0.3000 -0.5646 -0.8253 -0.3000

0.7174 0.6967 0.4000 -0.7174 -0.6967 -0.4000

... ... ... ... ... ...

... ... ... ... ... ...

0.7404 0.6722 6.7000 -0.7404 -0.6722 -6.7000

0.8592 0.5117 6.8000 -0.8592 -0.5117 -6.8000

0.9437 0.3308 6.9000 -0.9437 -0.3308 -6.9000

0.9906 0.1367 7.0000 -0.9906 -0.1367 -7.0000

El resultado es una matriz de seis columnas formadas por las tres columna de la posición de la

partícula 1 y las tres columnas de la posición de la partícula 2. Para poder hacer esto, en

número de filas de las matrices de posición tiene que ser el mismo.

Podemos asignar cada elemento de la lista a una variable diferente. Para ello podemos hacer:

[p1 p2]=particula.posicion

De esta manera, guardamos en p1 la posición de la primera partícula y en p2 la posición de la

segunda.

8.2.2 Cadenas y texto

Aunque ya hemos usado cadenas a lo largo de este documento, es hora de hacer algunos

comentarios sobre su uso en MATLAB. Para construir una cadena, simplemente encerraremos

el texto entre comillas simples:

S='Hola'

S es una array formado por cinco caracteres. Internamente, se almacena el valor numérico del

código correspondiente al carácter. Si ejecutamos la instrucción:

double(S)

obtenemos como resultado

ans =

104 111 108 97

Para volver a transformar el resultado en una cadena, podemos hacer:

char([104 111 108 97])

ans =

hola

Podemos unir cadenas por el mecanismo de concatenación de arrays. Por ejemplo:

h = [s, ' mundo']



Podemos hacer la concatenación en vertical si todas las cadenas tienen la misma longitud. Si

las cadenas tienen distinta longitud podemos usar el comando char:

S = char('Un','ejemplo','con','cadenas de','diferente','tamaño')

whos S

Name Size Bytes Class Attributes

S 6x10 120 char

8.2.3 Cell arrays

Un cell array es un array en el que sus elementos pueden ser tipos de datos diferentes. Para

distinguirlos de los arrays normales, se representan con llaves en lugar de con corchetes. Por

ejemplo:

A=rand(4)

C={A sum(A) prod(sum(A)) 'un ejemplo'}

A =

0.8147 0.6324 0.9575 0.9572

0.9058 0.0975 0.9649 0.4854

0.1270 0.2785 0.1576 0.8003

0.9134 0.5469 0.9706 0.1419

C =

[4x4 double] [1x4 double] [30.7593] 'un ejemplo'

Los dos primeros no se muestran porque ocuparían mucho espacio. Debemos recordar dos

puntos importantes:

Para recuperar el contenido de un elemento del cell array, usaremos las mismas reglas

que para un array normal, pero encerrando los índices entre llaves.

Si al crear un cell array utilizamos variables, en el elemento correspondiente queda

almacenada una copia del valor de la variable.

Por ejemplo, podemos emplear un cell array para almacenar una secuencia de matrices.

También podemos usarlos para agregar información de un campo de un array de estructuras

cuando no podemos asegurar que los datos almacenados en dicho campo tienen las

dimensiones adecuadas. Usando el ejemplo de la sección anterior, podríamos hacer:

{particula.posicion}

o para tener una lista de cadenas de diferente longitud:

{'Un';'ejemplo';'con';'cadenas de';'diferente';'tamaño'}

ans =

'Un'

'ejemplo'

'con'

'cadenas de'

'diferente'



'tamaño'

8.2.4 Arrays multidimensionales

Los arrays multidimensionales en MATLAB, son arrays con más de dos índices para acceder a

sus elementos. Pueden crearse con funciones como zeros, ones, rand o randn, simplemente

pasando como parámetros el valor correspondiente a cada dimensión. También pueden

generarse asignado valores a los diferentes elementos.

8.3 Funciones y scripts El lenguaje de MATLAB es interpretado, lo que nos permite introducir las distintas

instrucciones una a una en la línea de comandos y ver el resultado. Este método no es

apropiado cuando:

El programa es largo,

Incluye bucles, condicionales u otras sentencias de control de flujo,

Queremos desarrollar trozos de código que pueden ejecutase sobre datos de entrada

diferentes (funciones)

Para estos casos, podemos escribir el programa o la función en un fichero de texto al que

podremos llamar como a cualquier otra función de MATLAB. MATLAB permite desarrollar dos

tipos de programas:

SCRIPTS: No aceptan argumentos de entrada ni devuelven ningún resultado.

Interactúan directamente con el workspace. A todos los efectos es equivalente a

introducir todas las líneas de programa una a una por la línea de comandos.

FUNCIONES: que pueden aceptar argumentos de entrada y/o retornar uno o varios

resultados. No tienen acceso al workspace y las variables internas son locales a la

función, desapareciendo al final la ejecución de la misma. En MATLAB todos los

parámetros se pasan por valor, es decir, pasamos una copia del valor del parámetro en

el momento de la llamada.

Al comenzar a trabajar con MATLAB conviene crear los nuevos programas en el directorio

actual. A medida que vayamos cogiendo experiencia, podemos probar a organizar nuestros

programas en directorios, creando nuestras propias toolboxes y haciéndolas accesibles como

cualquier otra función sin más que añadirlas al camino de búsqueda (search path) de MATLAB.

Si duplicamos el nombre de una función se ejecutará la primera que se encuentre siguiendo el

orden definido en el path.

8.3.1 Scripts

Un script es una conjunto de instrucciones almacenadas en un fichero de texto cuya extensión

es ‘.m’. Los scripts tienen acceso al workspace, de manera que pueden acceder a variables ya

creadas o crear nuevas variables que permanecerán en el workspace una vez finalizada la

ejecución del script.

8.3.2 Funciones

Las funciones son programas que pueden aceptar uno o varios argumentos de entrada, y

devolver un o varios resultados. El nombre de la función debe ser el mismo que el del fichero

de texto en el que está almacenada, y la extensión del fichero debe ser también ‘.m’. Las



funciones tienen su propio ámbito para las variables, de modo que no es posible acceder

directamente a las variables del workspace y todas las variables creadas durante la ejecución

de la función desaparecen al finalizar la ejecución de la misma.

La función rank.m nos puede servir para ver la estructura básica de una función:

function r = rank(A,tol)

% RANK Matrix rank.

% RANK(A) provides an estimate of the number of linearly

% independent rows or columns of a matrix A.

% RANK(A,tol) is the number of singular values of A

% that are larger than tol.

% RANK(A) uses the default tol = max(size(A)) * norm(A) * eps.

s = svd(A);

if nargin==1

tol = max(size(A)') * max(s) * eps;

end

r = sum(s > tol);

La primera línea del fichero que contiene la función comienza con la palabra reservada

function. Esta línea sirve para definir el nombre de la función y el orden de los argumentos de

entrada y de salida. En este ejemplo hay un argumento de salida (r) y dos argumentos de

entrada (A y tol).

Las siguientes líneas que empiezan por el carácter % son comentarios. Estos comentarios no

sirven sólo como documentación interna de la función, sino que son la ayuda que

obtendremos al ejecutar el comando help rank.

El resto del fichero contiene el código necesario para calcular el valor de r en función de los

parámetros de entrada A y tol. Todas estas variables, así como la variable s son locales a la

función y no aparecerán el workspace. La función puede usarse de diferentes formas:

rank(diag([1 2 3])) o rank(B)

rank(A)

rank(B,1e-6)

Muchas funciones de MATLAB operan de esta forma. Si el resultado no se almacena en otra

variable o se usa como parte de una expresión, quedará almacenado en la variable ans. Si no

se suministra un valor para el segundo argumento, la función lo identifica y le asigna un valor

por defecto. Para ello, dentro del cuerpo de la función podemos acceder a dos variables

denominadas nargin y nargout que nos indican el número de argumentos de entrada y de

salida que ha recibido la función en una llamada concreta. Por ejemplo, al ejecutar rank(diag([1

2 3])), nargin toma el valor 1. El código de la función detecta este caso y le asigna un valor por

defecto a tol. En el último ejemplo, nargin toma el valor 2 por lo que se usa dicho valor sin

necesidad de tener que asignarle un valor por defecto.

Una función puede devolver más de un resultado. Para ello sólo es necesario escribir la lista de

resultados separada por comas y encerrada entre corchetes. La siguiente función es un

ejemplo de este comportamiento:



function [mean,stdev] = stat(x)

n = length(x);

mean = sum(x)/n;

stdev = sqrt(sum((x-mean).^2/n));

En este caso, definimos la función stat que calcula la media y la desviación típica de los datos

contenidos en el vector x:

Primero se calcula el número de elementos del vector y se almacena en n.

mean se calcula como la suma de los elementos del vector y se divide por el número

de elementos del mismo.

stdev se calcula como la raíz cuadrada del error cuadrático medio suma del cuadrado

de la diferencia entre el valor y la media, dividida por el número de elementos.

Obsérvese el uso del operador (.^) y que el hecho de dividir cada término por n no

afecta al resultado debido a las propiedades de la suma.

Es destacable que no es necesario utilizar ningún bucle para la realización de los cálculos.

También es interesante analizar cuál sería el resultado si x es un array. Un primer comentario

tiene que ver con la forma de calcular el valor de n. Tal y como está calculado, la función

retornará el valor correcto tanto si x es un vector fila como si es un vector columna ya que en

cualquier caso, tendremos un vector 1xn o nx1. El único problema que podríamos tener es si el

array tiene menos filas que columnas. En ese caso, se podría recurrir al uso de la función size.

Una posible solución sería:

[m, n]=size(x);

if n==1 % tenemos un vector columna

n=m;

end

Dado que sum opera sobre cada columna, no habría problema para calcular el valor de las

medias. El problema surge al calcular error dado que mean sería un vector fila con tantas

columnas como x por lo que no podemos hacer el cálculo de x – mean. Podemos comparar dos

posibles soluciones. La primera sería la aplicación directa de las técnicas de programación en

lenguajes como C, es decir, hacer un bucle que recorra cada fila de x y restarle a cada fila el

valor de la media:

if any(size(x)==1)

% se trata de un vector, usamos el código original


else

% se trata de un array

error=zeros(1,n);

for k=1:m

error=error+(x(k,:)-mean).^2;

end

stdev = sqrt(error/n);

end

La otra opción es convertir a mean en una matriz del mismo tamaño que x y de forma que

mean se repita en cada fila. Para lograrlo podemos multiplicar un vector columna con tantas



filas como x e inicializado a 1 por la el vector fila mean. La otra forma de hacerlo es utilizar la

función repmat y crear una matriz que sea la concatenación de copias de mean en un array de

m filas y una columna. Una vez que mean es del mismo tamaño que x, podemos usar el mismo

código para calcular stdev:

if all(size(x)>1)

mean=ones(m,1)*mean; % o repmat(mean,m,1);

end


Este tipo de solución resulta mucho más eficiente en MATLAB y el código es más fácil de

mantener al tener menos líneas.

8.4 Reservar espacio para los arrays En MATLAB podemos hacer los arrays en tiempo de ejecución. A continuación mostramos dos

ejemplos distintos:

x = 0;

for k = 2:1000

x(k) = x(k-1) + 5;

end

x = [];

for k = 2:1000

x = [x rand(3,1)+k];

end

Este tipo de solución es adecuada cuando no sabemos el tamaño final que va a tener la matriz

final pero tienen el problema de que la ejecución se hace más lenta. Por ello, si conocemos el

tamaño de la variable, es mejor reservarlo de antemano.

x = zeros(1,1000);

for k = 2:1000

x(k) = x(k-1) + 5;

end

x = zeros(1,1000);

for k = 2:1000

x(:,k) = rand(3,1)+k;

end

Introducción a MATLABisa.uniovi.es/~jalvarez/Buzon/tutoriales/matlab/Intro-MATLAB.pdf · 1.1...

Documents

Transcript of Introducción a MATLABisa.uniovi.es/~jalvarez/Buzon/tutoriales/matlab/Intro-MATLAB.pdf · 1.1...