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
Introducción a MATLAB 2012
Robótica Industrial 2 Práctica 1
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.
Introducción a MATLAB 2012
Robótica Industrial 3 Práctica 1
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.
Introducción a MATLAB 2012
Robótica Industrial 4 Práctica 1
“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.
Introducción a MATLAB 2012
Robótica Industrial 5 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 6 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 7 Práctica 1
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.
Introducción a MATLAB 2012
Robótica Industrial 8 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 9 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 10 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 11 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 12 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 13 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 14 Práctica 1
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:
Introducción a MATLAB 2012
Robótica Industrial 15 Práctica 1
>> 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
Introducción a MATLAB 2012
Robótica Industrial 16 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 17 Práctica 1
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 =
Introducción a MATLAB 2012
Robótica Industrial 18 Práctica 1
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.
Introducción a MATLAB 2012
Robótica Industrial 19 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 20 Práctica 1
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')
Introducción a MATLAB 2012
Robótica Industrial 21 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 22 Práctica 1
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');
xlabel('angulo'); ylabel('seno')
subplot(1,3,3); plot(angulo,seno,'g--'); title('figura 3');
xlabel('angulo'); ylabel('seno')
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
Introducción a MATLAB 2012
Robótica Industrial 23 Práctica 1
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);
plot(exp(i*(0:pi/20:2*pi)));
axis square;
title('axis square')
subplot(1,3,3);
plot(exp(i*(0:pi/20:2*pi)));
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
Introducción a MATLAB 2012
Robótica Industrial 24 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 25 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 26 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 27 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 28 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 29 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 30 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 31 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 32 Práctica 1
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
Introducción a MATLAB 2012
Robótica Industrial 33 Práctica 1
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.
Introducción a MATLAB 2012
Robótica Industrial 34 Práctica 1
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 =
posicion: [71x3 double]
velocidad: [71x3 double]
aceleracion: [71x3 double]
tiempo: [71x1 double]
visualizacion: '3D'
experimento: [1x1 struct]
particula.experimento
ans =
Introducción a MATLAB 2012
Robótica Industrial 35 Práctica 1
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 =
posicion: [71x3 double]
velocidad: [71x3 double]
aceleracion: [71x3 double]
tiempo: [71x1 double]
visualizacion: '3D'
experimento: [1x1 struct]
ans =
posicion: [71x3 double]
velocidad: [71x3 double]
aceleracion: [71x3 double]
tiempo: [71x1 double]
visualizacion: []
experimento: [1x1 struct]
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:
Introducción a MATLAB 2012
Robótica Industrial 36 Práctica 1
[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']
Introducción a MATLAB 2012
Robótica Industrial 37 Práctica 1
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'
Introducción a MATLAB 2012
Robótica Industrial 38 Práctica 1
'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
Introducción a MATLAB 2012
Robótica Industrial 39 Práctica 1
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:
Introducción a MATLAB 2012
Robótica Industrial 40 Práctica 1
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
stdev = sqrt(sum((x-mean).^2/n));
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
Introducción a MATLAB 2012
Robótica Industrial 41 Práctica 1
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
stdev = sqrt(sum((x-mean).^2/n));
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