Curso Iniciacion Matlab

Centro Universitario de Formación e Innovación Educativa (CUFIE),
Universidade da Coruña
Curso de iniciación
a MATLAB
Material de apoyo
Mª Cristina Naya Riveiro

22/01/2019
La información recogida en estos apuntes ha sido elaborada y adaptada de
otras fuentes bibliográficas.
Curso de iniciación a MATLAB
CONTENIDO
1. Interfaz de usuario de MATLAB ................................................................................................ 7
1.1 Introducción ......................................................................................................................... 7
1.1.1 ¿Qué es MATLAB? ....................................................................................................... 7
1.1.2 Desarrollo de algoritmos y aplicaciones ..................................................................... 10
1.1.3 Análisis y acceso de datos .......................................................................................... 12
1.1.4 Visualización de datos ................................................................................................ 13
1.1.5 Cálculo Numérico ........................................................................................................ 15
1.1.6 Publicación de resultados y distribución de aplicaciones ........................................... 16
1.1.7 El programa MATLAB ................................................................................................. 18
1.1.8 Uso del Help ................................................................................................................ 20
1.2 El entorno de trabajo de MATLAB ..................................................................................... 25
1.2.1 El escritorio de MATLAB (MATLAB DESKTOP) ......................................................... 25
1.2.2 Command window....................................................................................................... 27
1.2.3 Command history browser .......................................................................................... 28
1.2.4 Current DIRECTORY BROWSER .............................................................................. 29
1.2.5 Path de matlab: establecer el camino de búsqueda (SEARCH PATH) ...................... 29
1.2.6 Workspace browser y array editor .............................................................................. 32
1.2.7 El editor DEBUGGER ................................................................................................. 33
1.2.8 El profiler ..................................................................................................................... 36
Apps de MATLAB ................................................................................................................. 36
1.3 Preferencias: formatos de salida y de otras opciones de MATLAB .................................. 36
1.4 Ficheros matlabrc.m, startup.m y finish.m ......................................................................... 38
1.5 Guardar variables y estados de una sesión: comandos save y load ................................ 39
1.6 Guardar sesión y copiar salidas: comando diary .............................................................. 40
1.7 Líneas de comentarios ...................................................................................................... 40
1.8 Medida de tiempos y de esfuerzo de cálculo .................................................................... 41
2. Ejecución de comandos y creación de variables .................................................................... 42
Mª Cristina Naya Riveiro 2

2.1 Operaciones aritméticas. Uso del MATLAB como calculadora ......................................... 42
2.1.1 Constantes .................................................................................................................. 42
2.1.2 Operaciones ................................................................................................................ 42
2.1.3 Variables y expresiones .............................................................................................. 43
2.1.4 Funciones intrínsicas de MATLAB .............................................................................. 48
2.2 Límites, sucesiones, derivadas E integrales ..................................................................... 49
2.2.1 Límites ......................................................................................................................... 49
2.2.2 Sucesiones .................................................................................................................. 49
2.2.3 Derivadas .................................................................................................................... 50
2.2.4 Integrales .................................................................................................................... 50
3. Análisis de vectores, matrices, polinomios y sistemas de ecuaciones lineales. Otros tipos de

datos. ........................................................................................................................................... 52
3.1 Vectores ............................................................................................................................. 52
3.1.1 Vectores fila ................................................................................................................ 52
3.1.1 Vectores columna ....................................................................................................... 53
3.1.3 Operaciones entre vector y escalar ............................................................................ 54
3.1.4 Operaciones entre vectores ........................................................................................ 55
3.1.5 Operaciones con componentes. ................................................................................. 55
3.1.6 Expresiones más complicadas. .................................................................................. 55
3.1.7 Funciones de MATLAB específicas para vectores ..................................................... 56
3.2 Matrices ............................................................................................................................. 58
3.2.1 Definición de matrices ................................................................................................. 58
3.2.2 Operaciones con matrices .......................................................................................... 59
3.2.3 Funciones específicas para matrices.......................................................................... 59
3.2.4 Matrices dispersas o huecas ...................................................................................... 60
3.3 Polinomios ......................................................................................................................... 62
3.4 Sistemas de Ecuaciones lineales ...................................................................................... 63
3.5 Otros tipos de datos........................................................................................................... 64
3.5.1 Cadenas de caracteres ............................................................................................... 64
3.5.2 Hipermatrices .............................................................................................................. 67

3.5.3 Estructuras .................................................................................................................. 69
3.5.4. Vectores o matrices de celdas (Cell Arrays) .............................................................. 72
4. Gráficos con MATLAB ............................................................................................................. 74
4.1 Representación gráfica de funciones definidas por una fórmula ...................................... 74
4.1.1 Curvas planas ............................................................................................................. 74
4.1.2 Curvas en el espacio................................................................................................... 76
4.1.3 Superficies .................................................................................................................. 76
4.2 Ventana gráfica de MATLAB ............................................................................................. 78
4.3 Algunos comandos gráficos auxiliares .............................................................................. 78
4.4 Los comandos básicos de dibujo 2D Y 3D ........................................................................ 82
5. Introducción a la programación en MATLAB. ......................................................................... 87
5.1 Sintaxis general ................................................................................................................. 87
5.2 Ejecución de las funciones y scripts .................................................................................. 87
5.3 Bifurcaciones y bucles ....................................................................................................... 88
5.3.1 Sentencia IF ................................................................................................................ 89
5.3.2 Sentencia SWITCH ..................................................................................................... 90
5.3.3 Sentencia FOR............................................................................................................ 90
5.3.4 Sentencia WHILE ........................................................................................................ 91
5.3.5 Sentencia BREAK ....................................................................................................... 91
5.3.6 Sentencia CONTINUE ................................................................................................ 91
5.3.7 Sentencias TRY...CATCH...END ................................................................................ 91
5.4 Operadores relacionales.................................................................................................... 91
5.5 Operadores lógicos............................................................................................................ 92
5.6 Lectura y escritura interactiva de variables ....................................................................... 92
5.6.1 Función INPUT............................................................................................................ 93
5.6.2 Función DISP .............................................................................................................. 93
5.7 Ficheros *.m ....................................................................................................................... 93
5.7.1 Ficheros de comandos (scripts) .................................................................................. 94
5.7.2 Definición de funciones ............................................................................................... 94
5.7.3 Sentencia RETURN .................................................................................................... 95

5.7.4 Funciones con número variable de argumentos ......................................................... 95
5.7.4 HELP para las funciones de usuario........................................................................... 96
5.7.5 HELP de directorios .................................................................................................... 96
5.7.6 Subfunciones .............................................................................................................. 97
5.7.6 Funciones privadas ..................................................................................................... 97
5.7.7 Funciones *.p .............................................................................................................. 97
5.7.8 Variables persistentes ................................................................................................. 97
5.7.9 Variables globales ....................................................................................................... 98
5.8 Entrada y salida de datos .................................................................................................. 98
5.8.1 Importar datos de otras aplicaciones .......................................................................... 98
5.8.2 Exportar datos a otras aplicaciones ............................................................................ 99
5.9 Lectura y escritura de ficheros .......................................................................................... 99
5.9.1 Funciones FOPEN Y FCLOSE ................................................................................... 99
5.9.2 Funciones FSCANF, SSCANF, FPRINTF Y SPRINTF .............................................. 99
5.9.3 Funciones FREAD Y FWRITE .................................................................................. 100
5.9.4 Ficheros de acceso directo ....................................................................................... 100
5.10 Recomendaciones generales de programación ............................................................ 100
5.11 Acelerador JIT (Just In Time) en MATLAB .................................................................... 102
5.12 Llamada a comandos del sistema operativo y a otras funciones externas ................... 103
5.13 Distribución del esfuerzo de cálculo: Profiler................................................................. 103
6. Introducción al análisis de datos ........................................................................................... 106
6.1 Cálculo del mínimo, máximo, media y mediana .............................................................. 106
6.2 Desviación típica .............................................................................................................. 110
6.3 Coeficientes de correlación y matriz de covarianza ........................................................ 110
6.4 Gráficos estadísticos ....................................................................................................... 111
6.5 Curvas de regresión ........................................................................................................ 114
6.6 Interpolación uni y bidimensional .................................................................................... 115
7. Introducción al uso de interfaces gráficas de usuario (GUI) con MATLAB. .......................... 118
7.1 Uso de guide .................................................................................................................... 119
7.1.1 Controles de la GUI................................................................................................... 121

7.1.2 Fichero .m de guide .................................................................................................. 124
7.1.3 Manejo de datos y algunas funciones....................................................................... 126
Bibliografía................................................................................................................................. 127

1. INTERFAZ DE USUARIO DE MATLAB
1.1 INTRODUCCIÓN
1.1.1 ¿QUÉ ES MATLAB?
MATLAB® es un lenguaje de alto nivel y un entorno interactivo para el cálculo numérico, la

visualización y la programación. Mediante MATLAB, es posible analizar datos, desarrollar
algoritmos y crear modelos o aplicaciones. El lenguaje, las herramientas y las funciones
matemáticas incorporadas permiten explorar diversos enfoques y llegar a una solución antes
que con hojas de cálculo o lenguajes de programación tradicionales, como pueden ser C/C++ o
Java™.
Es ampliamente usado por ingenieros y, científicos de todo el mundo para una gran variedad
de aplicaciones, tales como análisis y visualización de datos, modelización matemática,
desarrollo de algoritmos, procesamiento de señales y comunicaciones, procesamiento de
imagen y vídeo, sistemas de control, pruebas y medidas, finanzas computacionales, biología
computacional, posee además una extraordinaria versatilidad y capacidad para resolver
problemas en matemática aplicada, física, química, ingeniería, finanzas y muchas otras
aplicaciones. Está basado en un sofisticado software de matrices para el análisis de sistemas
de ecuaciones. Permite resolver complicados problemas numéricos sin necesidad de escribir
un programa. Por este motivo es usado en empresas líderes de ingeniería y ciencia, así como
el software estándar en más de 5000 universidades de todo el mundo.
MATLAB es un entorno de computación y desarrollo de aplicaciones totalmente integrado

orientado para llevar a cabo proyectos en donde se encuentren implicados elevados cálculos
matemáticos y la visualización gráfica de los mismos.
MATLAB integra análisis numérico, cálculo matricial, proceso de señal y visualización gráfica
en un entorno completo donde los problemas y sus soluciones son expresados del mismo
modo en que se escribirían tradicionalmente, sin necesidad de hacer uso de la programación
tradicional.
MATLAB es el nombre abreviado de “MATrix LABoratory”. MATLAB es un programa para

realizar cálculos numéricos con vectores y matrices. Como caso particular puede también
trabajar con números escalares −tanto reales como complejos−, con cadenas de caracteres y
con otras estructuras de información más complejas. Una de las capacidades más atractivas es
la de realizar una amplia variedad de gráficos en dos y tres dimensiones. MATLAB tiene
también un lenguaje de programación propio. MATLAB fue inicialmente concebido para
proporcionar fácil acceso a las librerías LINPACK y EISPACK, las cuales representan hoy en
día dos de las librerías más importantes en computación y cálculo matricial.
MATLAB es un sistema de trabajo interactivo cuyo elemento básico de trabajo son las matrices.
El programa permite realizar de un modo rápido la resolución numérica de problemas en un
tiempo mucho menor que si se quisiesen resolver estos mismos problemas con lenguajes de
programación tradicionales como pueden ser los lenguajes Fortran, Basic o C. En cualquier
caso, el lenguaje de programación de MATLAB siempre es una magnífica herramienta de alto
nivel para desarrollar aplicaciones técnicas, fácil de utilizar y que, como ya se ha dicho,
aumenta significativamente la productividad de los programadores respecto a otros entornos de
desarrollo.
MATLAB goza en la actualidad de un alto nivel de implantación en escuelas y centros

universitarios, así como en departamentos de investigación y desarrollo de muchas compañías

industriales nacionales e internacionales. En entornos universitarios, por ejemplo, MATLAB se
ha convertido en una herramienta básica, tanto para los profesionales e investigadores de
centros docentes, como una importante herramienta para la impartición de cursos
universitarios, tales como sistemas e ingeniería de control, álgebra lineal, proceso digital de
imagen, señal, etc. En el mundo industrial, MATLAB está siendo utilizado como herramienta de
investigación para la resolución de complejos problemas planteados en la realización y
aplicación de modelos matemáticos en ingeniería. Los usos más característicos de la
herramienta los encontramos en áreas de computación y cálculo numérico tradicional,
prototipaje algorítmico, teoría de control automático, estadística, análisis de series temporales
para el proceso digital de señal.
MATLAB dispone de un código básico y también en la actualidad, de un amplio abanico de

programas de apoyo especializado, es decir, de varias librerías especializadas denominadas
Toolboxes, que extienden significativamente el número de funciones incorporadas en el
programa principal y que están disponibles por separado. Estos Toolboxes cubren en la
actualidad prácticamente casi todas las áreas principales en el mundo de la ingeniería y la
simulación, destacando entre ellos el 'toolbox' de proceso de imágenes, señal, control robusto,
estadística, análisis financiero, matemáticas simbólicas, redes neurales, lógica difusa,
identificación de sistemas, simulación de sistemas dinámicos, etc. Además, también se dispone
del programa Simulink que es un entorno gráfico interactivo con el que se puede analizar,
modelizar y simular la dinámica de sistemas no lineales.
Son características importantes de MATLAB las siguientes:
 Lenguaje de alto nivel para cálculos de ingeniería y científicos (particularmente cálculo

numérico, la visualización y el desarrollo de aplicaciones).
 Entorno de escritorio afinado para la exploración, el diseño y la solución de problemas
de manera iterativa.
 Funciones matemáticas para álgebra lineal, estadística, análisis de Fourier, filtrado,
optimización, integración numérica y resolución de ecuaciones diferenciales ordinarias.
 Gráficos integrados para visualizar datos y herramientas para crear gráficos
personalizados.
 Apps para ajustar curvas, clasificar datos, analizar señales y muchas otras tareas
relacionadas con dominios concretos.
 Herramientas de desarrollo para mejorar la calidad y el mantenimiento del código, así
como para maximizar el rendimiento.
 Herramientas para crear aplicaciones con interfaces de usuario personalizadas.
 Funciones para integrar algoritmos basados en MATLAB con aplicaciones y lenguajes
externos tales como C, Java, .NET y Microsoft® Excel®.
 Entorno de desarrollo para la gestión de código, archivos y datos.
 Toolboxes complementarias para una amplia variedad de aplicaciones de ingeniería y
científicas.
 Opciones de despliegue sin coste en concepto de derechos de licencia para compartir
programas de MATLAB con los usuarios finales.
 Interfaces para C/C++, Java®, .NET, Python®, SQL, Hadoop® y Microsoft® Excel®.
 Soporte de comunicaciones móviles 5G y LTE.
En estos apuntes se hará referencia exclusiva al código básico, donde todos los conceptos
estudiados y funciones dadas serán válidos para la gran mayoría de las versiones de
MATLAB.

1.1.1.1 USO DE MATRICES
MATLAB emplea matrices porque con ellas se puede describir infinidad de cosas de una forma
altamente flexible y matemáticamente eficiente. Una matriz de pixeles puede ser una imagen o
una película. Una matriz de fluctuaciones de una señal puede ser un sonido o una voz humana.
Y tal vez más significativamente, una matriz puede describir una relación lineal entre los
componentes de un modelo matemático. En este último sentido, una matriz puede describir el
comportamiento de un sistema extremadamente complejo. Por ejemplo, una matriz puede
representar el vuelo de un avión a 40.000 pies de altura, o un filtro digital de procesamiento de
señales.
1.1.1.2 ORIGEN DE MATLAB
MATLAB fue originalmente desarrollado en lenguaje FORTRAN para ser usado en

computadoras mainframe1. Fue el resultado de los proyectos Linpack y Eispack desarrollados
en el Argonne National Laboratory. Su nombre proviene de MATrix LABoratory. Al pasar los
años fue complementado y reimplementado en lenguaje C. Actualmente la licencia de MATLAB
es propiedad de MathWorks Inc. (Web http://www.mathworks.es).
1.1.1.3 PLATAFORMAS
MATLAB está disponible para un amplio número de plataformas: estaciones de trabajo SUN,
Apollo, VAXstation y HP, VAX, MicroVAX, Gould, Apple Macintosh y PC AT compatibles 80386
o superiores. Opera bajo sistemas operativos UNIX, Macintosh y Windows.
También está disponible una plataforma móvil, MATLAB Mobile, que ofrece un escritorio ligero
para iPhone, iPad o dispositivos Android. Esta aplicación permite conectarse a una sesión de
MATLAB que se ejecuta en la nube MathWorks o en un ordenador, y desde la cual se pueden
ejecutar scripts, crear y manipular figuras, y ver los resultados con teclados personalizados
para el iOS y Android, lo que facilita la entrada fácil de la sintaxis de MATLAB.
Recientemente se pueden encontrar soluciones para implementar aplicaciones con MATLAB y

Simulink en hardware de bajo coste como Arduino y Raspberry Pi.
1.1.1.4 PRODUCTOS
La empresa MathWorks ofrece MATLAB como su principal producto para computación

numérica, análisis y visualización de datos. También ofrece Simulink como un anexo a
MATLAB y que interactúa con él en lenguaje de MATLAB y lenguaje de bajo nivel C. Simulink
es usado para simulación modelado no lineal avanzado. Se ofrecen además numerosas
herramientas especiales en "Toolboxes" para resolver problemas de aplicaciones específicas,
por ejemplo control, procesamiento de señales, redes neurales, etc. Estas herramientas son
colecciones de rutinas escritas en MATLAB.
MATLAB dispone de una versión para estudiantes MATLAB and Simulink Student Versión que
incluye la versión R2015b, y es compatible con Windows, Mac, y Linux. Esta versión estudiante
R2015b incluye además soporte integrado para prototipado, pruebas y ejecución de modelos
en plataformas hardware de bajo coste, tales como, Arduino, LEGO MINDSTORMS NXT,
1
Una computadora central o mainframe es una computadora grande, potente y costosa usada
principalmente por una gran compañía para el procesamiento de una gran cantidad de datos;
por ejemplo, para el procesamiento de transacciones bancarias.

PandaBoard, Rasperry Pi, Gumstix Overo y BeagleBoard. Además de soporte de hardware

para sensores de iOS, Raspberry PiTM 2 y BeagleBone Black.
1.1.2 DESARROLLO DE ALGORITMOS Y APLICACIONES
MATLAB proporciona un lenguaje de alto nivel y herramientas de desarrollo que permiten

desarrollar y analizar algoritmos y aplicaciones con rapidez.
El lenguaje MATLAB incluye operaciones vectoriales y matriciales que son fundamentales para
resolver problemas de ingeniería y científicos. Agiliza, tanto el desarrollo, como la ejecución.
Con el lenguaje de MATLAB, se pueden escribir programas y desarrollar algoritmos de manera

más rápida que con los lenguajes tradicionales, ya que no es necesario realizar tareas
administrativas de bajo nivel tales como declarar variables, especificar tipos de datos y asignar
memoria. En muchos casos, el soporte para las operaciones de vectores y matrices elimina la
necesidad de bucles For. Como resultado, con frecuencia una línea de código de MATLAB
puede reemplazar varias líneas de código C o C++.
Al mismo tiempo, MATLAB ofrece todas las características de los lenguajes de programación
tradicionales, que incluyen operadores aritméticos, control de flujo, estructuras de datos, tipos
de datos, gestión de errores y programación orientada a objetos (OOP).
Un algoritmo de comunicaciones que genera 1024 bits aleatorios, convierte el vector en una
señal transmitida, añade ruido gaussiano complejo y representa el resultado gráficamente, se
integra en MATLAB en sólo nueve líneas de código:
Figura 1
MATLAB posibilita ejecutar comandos o grupos de comandos de forma interactiva uno tras
otro, sin compilar ni enlazar, y repetir su ejecución hasta lograr la solución óptima
Para ejecutar rápidamente cálculos matriciales y vectoriales complejos, MATLAB utiliza

bibliotecas optimizadas para el procesador. Para cálculos escalares de aplicación general,

MATLAB, genera instrucciones en código máquina utilizando su tecnología JIT (Just In Time).
Gracias a esta tecnología, que está disponible para la mayoría de las plataformas, las
velocidades de ejecución son mucho más rápidas que las de los lenguajes de programación
tradicionales.
MATLAB incluye herramientas de desarrollo que ayudan a implementar algoritmos

eficientemente. Las siguientes son algunas de ellas:
 Ventana de comandos: permite introducir datos, ejecutar comandos o programas y

mostrar los resultados de forma interactiva.
 MATLAB Editor: ofrece características de edición y depuración, tales como establecer
puntos de interrupción y avanzar paso a paso por líneas de código individuales.
 M-Lint Code Checker (analizador de código): comprueba el código automáticamente en
busca de problemas y recomienda modificaciones para maximizar el rendimiento y el
mantenimiento.
 MATLAB Profiler: registra el tiempo que tarda en ejecutarse cada línea de código, es
decir, mide el rendimiento de los programas de MATLAB e identifica áreas de código
que se pueden modificar para mejorarlas.
 Directory Reports: explora todos los archivos de un directorio y crea informes sobre la
eficiencia del código, las diferencias entre los archivos, las dependencias de los
archivos y la cobertura del código.
También se puede usar la herramienta interactiva GUIDE (Graphical User Interface

Development Environment) para diseñar y editar interfaces de usuario. Esta herramienta
permite incluir listas de selección, menús desplegables, botones de controles ActiveX. También
se pueden crear interfaces gráficas de usuario por medio de programación usando las
funciones de MATLAB.
Figura 2
Imagen de las diferentes opciones que podemos generar con la interface de usuario de MATLAB. Imagen
obtenida de:
http://www.google.es/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&docid=jH89yKGaoJSxuM&tbni

d=INf4JG_GjBk6LM:&ved=0CAQQjB0&url=http%3A%2F%2Flims.mech.northwestern.edu%2Fprojects%2Ffrictio
ninducedforcefields%2F&ei=xrFZUe3fAaGI0AXD4YHwAg&bvm=bv.44442042,d.ZGU&psig=AFQjCNF1-
x43Pez6t3eGR6WDFIXkpkU-Pw&ust=1364919092339419
1.1.3 ANÁLISIS Y ACCESO DE DATOS
MATLAB soporta el proceso completo de acceso a datos desde la adquisición de datos de

dispositivos externos y bases de datos, pasando por el preprocesado, visualización y el análisis
numérico, hasta la producción de resultados con calidad de presentación.
MATLAB permite gestionar, filtrar y preprocesar los datos como ya se ha comentado, pero
además es posible realizar análisis de datos exploratorios a fin de descubrir tendencias, probar
suposiciones y elaborar modelos descriptivos. MATLAB proporciona funciones para filtrado y
suavizado, interpolación, convolución y transformadas rápidas de Fourier (FFT). Los productos
complementarios proporcionan capacidades para ajuste de curvas o de superficies, estadística
multivariante, análisis espectral, análisis de imágenes, identificación de sistemas y otras tareas
de análisis. En resumen, MATLAB proporciona herramientas interactivas y funciones en línea
de comandos para operaciones de análisis de datos incluyendo:
• interpolación,
• extracción de secciones de datos, escalado y promediación,
• umbralación y suavizamiento,
• correlación, análisis de Fourier y filtraje,
• búsqueda de picos unidimensionales y ceros,
• estadística básica y ajuste de curvas,
• análisis matricial, etc.
En la Figura 3 se observa un diagrama en el que se muestra una curva ajustada a las

diferencias de presión atmosférica promediadas entre Easter Island y Darwin en Australia.
Figura 3: Ejemplo de una ventana gráfica de MATLAB.

En cuanto a acceso a datos, MATLAB es una plataforma eficiente para acceder a datos desde
archivos, otras aplicaciones, bases de datos y dispositivos externos. Puede leer datos desde
los formatos más populares como Microsoft Excel, Texto ASCII o archivos binarios, imágenes,
archivos de sonido y video o archivos cintíficos tales como netCDF y HDF. Las funciones de
entrada y salida de bajo nivel para archivos binarios permiten trabajar con datos en cualquier
formato. Las funciones adicionales permiten leer datos desde páginas web y XML. Es decir, las
funciones de entrada/salida de archivos permiten trabajar con archivos de datos de cualquier
formato.
Puede llamar otras aplicaciones y lenguajes como C, C++, objetos COM, DLLs, Java, Fortran y
Microsoft Excel y acceder a sitios ftp y servicios Web. Usando el Database Toolbox, incluso
puede acceder a bases de datos ODBC/JDBC.
Puede adquirir datos desde dispositivos de hardware, como el puerto serial de las
computadoras o la tarjeta de sonido, o bien recurrir al streaming de los datos dinámicos
medidos directamente a MATLAB para su análisis y visualización También es posible
comunicarse con instrumentos tales como osciloscopios, generadores de funciones y
analizadores de señales.
Usando Data Acquisition Toolbox, puede medir datos directamente en MATLAB para análisis y
visualización. Instrument Control Toolbox permite la comunicación con hardware GPIB y VXI.
Figura 4: ventana de importación de datos.
1.1.4 VISUALIZACIÓN DE DATOS
Todas las características gráficas que son requeridas para visualizar datos de ingeniería y
científicos están disponibles en MATLAB. Esto incluye funciones de representación de
diagramas bidimensionales y tridimensionales, visualización de volúmenes, herramientas para
crear graficas interactivamente y la posibilidad de exportar los resultados a todos los formatos
de gráficos más conocidos y usuales. Es posible personalizar las gráficas añadiendo múltiples
ejes, cambiando los colores de las líneas y marcadores, añadir anotaciones, ecuaciones en
LaTEX, leyendas y trazando formas.

Se pueden visualizar vectores de datos con funciones

de representación de diagramas bidimensionales para
crear:
• Líneas, áreas, barras y gráficas de pastel.

• Gráficas de Dirección y Velocidad.
• Histogramas.
• Polígonos y superficies.
• Gráficas Dispersas y de Burbujas.
• Animaciones.
Figura 5
La Figura 5 muestra los diagramas lineales de los resultados de varias pruebas de emisión de
un motor, con una curva ajustada a los datos.
MATLAB también proporciona funciones para visualizar matrices bidimensionales, datos

escalares tridimensionales y datos vectoriales tridimensionales. Es posible usar estas funciones
para visualizar y comprender grandes cantidades de datos multidimensionales, generalmente
complejos. También es posible definir las características de los diagramas, tales como el
ángulo de la orientación de la cámara, la perspectiva, el efecto de iluminación, la ubicación de
la fuente de luz y la transparencia. Las funciones de creación de diagramas tridimensionales
incluyen:
• Superficies, contornos y mallas

• Graficar imágenes
• Cono, sección, cascadas e isosuperficies
En la Figura 6 se observa un diagrama tridimensional de isosuperficie que revela la estructura

geodésica abovedada de una molécula de fullerene carbono-60.
Figura 6
MATLAB proporciona herramientas interactivas para el diseño y la modificación de gráficas.

Desde una figura o diagrama de MATLAB se puede desarrollar las siguientes tareas:
• Colocar nuevos datos en las gráficas arrastrándolos.

• Cambiar las propiedades de cualquier objeto en la figura.
• Acercar, rotar, deslizar y cambiar el ángulo de la cámara y de la luz.
• Añadir anotaciones y etiquetas de datos.
• Trazar formas.

• Generar una función de código M para reutilizarla con datos diferentes.
En la Figura 7 se observa una colección de gráficos, creada interactivamente arrastrando

conjuntos de datos a la ventana de diagramas, creando nuevos subdiagramas, cambiando las
propiedades tales como colores y tipos de letra y añadiendo anotaciones.
Figura 7
MATLAB permite leer y escribir en diversos formatos de archivos de datos y de gráficos, como
GIF, JPEG, BMP, EPS, TIFF, PNG, HDF, AVI y PCX. Como resultado, puede exportar las
gráficas de MATLAB a otras aplicaciones como Microsoft Word® y Microsoft PowerPoint®, o
software de autoedición. Antes de exportar, puede crear y aplicar plantillas de estilo, que
contengan el diseño, los tipos de letra, la definición del grosor de las líneas, el fondo y la
escala, etc., necesarios para cumplir con las especificaciones para su publicación.
La galería de gráficos de MATLAB ofrece multitud de ejemplos para mostrar los datos de forma
gráfica en MATLAB. En cada ejemplo podrá ver y descargar el código fuente a fin de emplearlo
en su aplicación de MATLAB.
1.1.5 CÁLCULO NUMÉRICO
MATLAB contiene funciones matemáticas, estadísticas y de ingeniería que soportan las

operaciones más comunes a realizar en estos campos. Estas funciones, desarrolladas por
expertos en matemáticas, son la base del lenguaje de MATLAB. En núcleo de funciones
matemáticas usan las bibliotecas de algebra lineal de LAPACK y BLAS y la biblioteca de la
transformada de Fourier de FFTW. Debido a que el procesador depende de las bibliotecas,
éstas se optimizan en las diferentes plataformas que MATLAB soporta, con lo que se ejecutan
más rápido que su equivalente en C o C++.
Por citar algunos ejemplos, MATLAB proporciona los siguientes tipos de funciones para
desarrollar las operaciones matemáticas y de análisis de datos:
• Manipulación de matrices y algebra lineal.

• Polinomios e interpolación y regresión.
• Diferenciación e integración.

• Análisis de Fourier y filtrado.

• Valores propios y valores singulares.
• Análisis de Datos y Estadística.
• Optimización e integración numérica.
• Ecuaciones Diferenciales Ordinarias (ODEs).
• Ecuaciones Diferenciales Parciales (PDEs).
• Operaciones de Matrices Dispersas.
1.1.6 PUBLICACIÓN DE RESULTADOS Y DISTRIBUCIÓN DE

APLICACIONES
MATLAB contiene una serie de funciones para documentar y compartir su trabajo. Puede
integrar su código en otros lenguajes y aplicaciones, desplegar algoritmos y aplicaciones de
MATLAB como programas independientes o módulos de software.
MATLAB permite exportar los resultados como gráficas o como informes completos. Puede
exportar las figuras a todos los formatos de gráficos más usados y conocidos para luego
importarlos a otros paquetes, como Microsoft Word o Microsoft PowerPoint. Usando el Editor
de MATLAB se puede, automáticamente, publicar el código MATLAB en HTML, Word, LaTEX y
otros formatos. Por ejemplo, en la Figura 8 se observa un programa de código M (izquierda)
publicado en HTML (derecha) usando MATLAB Editor. Los resultados, que se envían a la
ventana de comandos o a diagramas, se capturan e incluyen en el documento y los
comentarios se convierten en títulos y texto en HTML.
Figura 8: Programa de MATLAB (izquierda) publicado como HTML (derecha) mediante MATLAB Editor. Los
resultados que se muestran en la ventana de comandos o en forma de gráficos se capturan y se incluyen,
mientras que los comentarios sobre el código se convierten en títulos de sección y cuerpo de texto en HTML.
Extraída de: http://es.mathworks.com/products/matlab/features.html
Es posible crear informes más complejos, tales como ejecuciones simuladas y varias pruebas

de parámetros, utilizando MATLAB Report Generator™ disponible por separado. El informe

contiene el código, los comentarios y los resultados del programa, incluidos los gráficos. Los
informes se pueden publicar en diversos formatos, tales como HTML, PDF, Word o LaTeX.
En cuanto a la integración del código MATLAB con otros lenguajes y aplicaciones, MATLAB
proporciona funciones para integrar código C y C++, Fortran, Objetos COM y código de Java
con sus aplicaciones y .NET. Puede llamar a DLLs, clases de Java y Controles Active X.
Usando las bibliotecas de MATLAB, se puede también llamar a MATLAB desde su código C,
C++ y Fortran.
En cuanto a distribución de aplicaciones, puede crearse algoritmos en MATLAB y distribuirlos a

otros usuarios de MATLAB como código de MATLAB que se puede empaquetar a modo de
aplicación de MATLAB, lo cual genera un archivo único para la distribución. Las aplicaciones se
instalan automáticamente en la galería de aplicaciones de MATLAB para que resulte fácil
acceder a ellas.
Si desea compartir aplicaciones con personas que no disponen de MATLAB, puede utilizar
productos de distribución de aplicaciones. Estos productos complementarios generan de forma
automática aplicaciones autónomas, librerías compartidas y componentes de software para su
integración en entornos de C, C++, Java, .NET y Excel. Los ejecutables y los componentes se
pueden distribuir de forma gratuita usando el MATLAB Compiler™ (disponible por separado).
Figura 9
MATLAB Coder™ (disponible por separado) se puede emplear para generar código C
independiente a partir del código de MATLAB. MATLAB Coder admite un subconjunto del
lenguaje de MATLAB que suelen emplear los ingenieros de diseño para desarrollar algoritmos
a modo de componentes de sistemas más amplios. Este código se puede utilizar para la
ejecución autónoma, para la integración con otras aplicaciones de software o como parte de

una aplicación embebida.
1.1.7 EL PROGRAMA MATLAB
MATLAB se puede arrancar como cualquier otra aplicación de Windows, clicando dos veces en
el icono correspondiente en el escritorio o por medio del menú Inicio. Al arrancar MATLAB se
abre una ventana similar a la mostrada en la Figura 10: escritorio de MATLAB.
Con el fin de ayudar a los usuarios, ya sean nuevos o experimentados, a navegar por las
capacidades en continua expansión de MATLAB, MathWorks ha actualizado el escritorio de
MATLAB desde la versión 2012b con dos mejoras principales:
 La cinta de herramientas (toolstrip) de MATLAB que sustituye a los menús y a las

barras de herramientas, cuenta con iconos para las características de MATLAB más
utilizadas, como seleccionar el mejor tipo de gráfico para los datos.
 La galería de aplicaciones (Apps) ofrece aplicaciones de la familia de productos
MATLAB con las que los usuarios pueden llevar a cabo tareas frecuentes sin
necesidad de escribir código.
 Visualización de varias páginas de documentación a la vez gracias a la navegación con
pestañas.
 Sugerencias de corrección para funciones y variables mal escritas en la ventana de
comandos.
Otras características nuevas ayudan a los usuarios a empaquetar aplicaciones de MATLAB

para incluirlas en la galería, importar datos desde archivos de texto tanto de ancho fijo como
delimitados mediante la herramienta de importación, y corregir funciones o variables mal
escritas en la ventana de comandos.
Ésta es la vista que se obtiene eligiendo la opción Desktop Layout/Default, en el menú View en
versiones anteriores a 2012b, pero en el nuevo escritorio con vistas de pestañas, se va a la
pestaña de HOME, en el icono de Layout y Default. Como esta configuración puede ser
cambiada fácilmente por el usuario, es posible que en muchos casos concretos lo que
aparezca sea muy diferente.
La parte más importante de la ventana inicial es la Command Window o Ventana de comandos,

que aparece en la parte derecha. En esta subventana es donde se ejecutan los comandos de
MATLAB, a continuación del prompt (aviso) característico (>>), que indica que el programa
está preparado para recibir instrucciones.
En la parte superior izquierda de la pantalla (ver Figura 10) aparecen dos ventanas también
muy útiles: en la parte superior aparece la ventana Current Directory, que se puede alternar
con Workspace clicando en la pestaña correspondiente. La ventana Current Directory muestra
los ficheros del directorio activo o actual. El directorio activo se puede cambiar desde la
Command Window, o desde la propia ventana (o desde la barra de herramientas, debajo de la
barra de menús) con los métodos de navegación de directorios propios de Windows. Clicando
dos veces sobre alguno de los ficheros *.m del directorio activo se abre el editor de ficheros de
MATLAB, herramienta fundamental para la programación sobre la que se volverá en las
próximas páginas. El Workspace contiene información sobre todas las variables que se hayan
definido en esta sesión y permite ver y modificar las matrices con las que se esté trabajando.
En la parte inferior derecha (ver figura 10) aparece la ventana Command History que muestra
los últimos comandos ejecutados en la Command Window. Estos comandos se pueden volver
a ejecutar haciendo doble clic sobre ellos. Clicando sobre un comando con el botón derecho

del ratón se muestra un menú contextual con las posibilidades disponibles en ese momento.
Para editar uno de estos comandos hay que copiarlo antes a la Command Window.
Figura 10: escritorio de MATLAB, la primera con la versión actual y la segunda con la versión anterior a la
2012b
En versiones anterores a la 2012b, en la parte inferior izquierda de la pantalla aparece el botón

Start, con una función análoga a la del botón Inicio de Windows. Start da acceso inmediato a
ciertas capacidades del programa. La Figura 12 muestra las posibilidades de Start/MATLAB,

mientras que la Figura 11 muestra las opciones de Start/Desktop Tools, que permiten el acceso
a las principales componentes o módulos de MATLAB. El menú Desktop realiza un papel
análogo al botón Start, dando acceso a los módulos o componentes de MATLAB que se tengan
instalados.
Estas funciones en la nueva versión se pueden obtener a partir de los iconos de la cinta de
herramientas en las distintas pestañas.
Figura 12: Menu Start/MATLAB Figura 11: Menú Start/Desktop Tools
Puede hacerse que al arrancar MATLAB se ejecute automáticamente un fichero, de modo que
aparezca por ejemplo un saludo inicial personalizado. Esto se hace mediante un fichero de
comandos que se ejecuta de modo automático cada vez que se entra en el programa (el
fichero startup.m, que debe de estar en un fichero determinado, por ejemplo
C:\Matlal701\Work).
Con la Command History, es posible recuperar comandos anteriores de MATLAB y moverse

por dichos comandos con el ratón y con las teclas-flechas ↑ y ↓. Al pulsar la primera de dichas
flechas aparecerá el comando que se había introducido inmediatamente antes. De modo
análogo es posible moverse sobre la línea de comandos con las teclas ← y →, ir al principio de
la línea con la tecla Inicio, al final de la línea con Fin, y borrar toda la línea con Esc.
Recuérdese que sólo hay una línea activa (la última).
Para borrar todas las salidas anteriores de MATLAB y dejar limpia la Command Window se
pueden utilizar las funciones clc y home. La función clc (clear console) elimina todas las salidas
anteriores, mientras que home las mantiene, pero lleva el prompt (>> ) a la primera línea de la
ventana.
En la nueva versión de MATLAB las propias ventanas ya tiene un menú desplegable indicado
con que permite utilizar todas las opciones de cada ventana comentadas anteriormente.
Si se desea salir de MATLAB basta teclear los comandos quit o exit, elegir Exit MATLAB en el
menú File o utilizar cualquiera de los medios de terminar una aplicación en Windows.
Veremos todas estas características con más detalle, en una próxima sección.
1.1.8 USO DEL HELP
MATLAB dispone de un excelente Help con el que se puede encontrar la información que se
desee. Se puede obtener ayuda a través del botón Ayuda de la barra de iconos o a través de la
opción Help de la barra de menús, y a través de comandos implementados como objetos de
MATLAB. La Figura 13, muestra las distintas opciones que aparecen en el menú Help de la
ventana principal de la aplicación.

Figura 13 Menú Help de MATLAB, la primera de las versiones anteriores a 2012b y la segunda de la actual.
1. Full Product Family Help o Product Help, Se abre la ventana de la Figura 15, en la
que se puede buscar información general sobre MATLAB o sobre otros productos de la
familia a los que se tenga acceso. La forma de la ventana de ayuda es típica y común
con otros niveles de ayuda. La mayor parte de las páginas de ayuda están en formato
HTML.

Figura 15: Ventana inicial de Help Full Product Family Figura 14a: Ventana inicial de MATLAB Help
2. MATLAB Help o Function Browser. Se abre la ventana de la Figura 14a o de la

Figura 14b, en la que se puede buscar ayuda general sobre MATLAB o sobre la
función o el concepto que se desee. La portada de esta ayuda tiene siete capítulos
principales: Functions, que contiene información de referencia sobre las funciones por
orden alfabético o por categorías; Handle Graphics, que permite acceder a información
concreta sobre las distintas propiedades de los objetos gráficos; Documentation Set,
que da acceso a versiones completas de los manuales del programa en formato de
pantalla fácilmente navegable (con apartados de Getting Started, User Guides,
Programming Tips y Examples in Documentation), Product Demos (con una colección
de ejemplos programados que se pueden ejecutar y cuyo código se puede examinar
para ver cómo están programados), What's New (con las novedades de esta versión
respecto a la anterior), Printing the Documentation Set (que permite abrir documentos
PDF (Portable Document Format), que se corrresponden con las versiones en papel de
los manuales del programa, y que precisan del programa Adobe Acrobat Reader 5.0 o
superior) y un apartado final sobre The MathWorks Web Site Resources (que permite
acceder a una amplísima colección de informaciones adicionales disponibles en la web
de la empresa que ha desarrollado MATLAB). En la parte izquierda de la ventana,
cuando está seleccionada la pestaña Contents, aparece un índice temático
estructurado en forma de árbol que puede ser desplegado y recorrido con gran
facilidad. Las restantes pestañas de esta ventana dan acceso a un índice por palabras
(Index), a un formulario de búsqueda (Search) y a la colección de ejemplos ya
programados antes citada (Demos).

Figura 14b: Menú del Function Browser.
3. Using the Desktop. Se abre una ventana de ayuda con un formato similar a las de las
figuras anteriores con información detallada sobre cómo utilizar y configurar el entorno
de desarrollo o Desktop. Las distintas herramientas disponibles se describen
sucesivamente. Cada página dispone de flechas y enlaces que permiten ir a la página
siguiente o volver a la anterior. Es posible también imprimir aquellas páginas que se
desee consultar o archivar sobre papel. Una característica muy importante es la
posibilidad de organizar las ventanas con gran flexibilidad, agrupándolas o
independizándolas según los propios gustos o deseos.
4. Using the Command Window. Esta opción del menú Help da acceso a la información
necesaria para aprovechar las capacidades de la Command Window, que es el
corazón de MATLAB.
5. Web Resources. Muestra algunas direcciones de Internet con información interesante
sobre MATLAB. Todas ellas corresponden a distintas secciones de la web de The
Mathworks (la empresa que desarrolla y comercializa MATLAB), cuya página de inicio
se muestra en primer lugar. Además, en las últimas versiones ofrece Training de
ofertas de cursos de formación en MATLAB (ver Figura 16 o 13).
Figura 16: Algunas páginas web sobre MATLAB
6. Check for Updates. MATLAB se conecta con The Mathworks y comprueba si hay
versiones más recientes de los productos instalados. Si se es un usuario registrado, es
posible descargar las versiones más actuales.
7. Licesing. Acceso a todo lo relacionado con la licencia del producto, actualizaciones,
activación/desactivación de software, etc.

8. Demos. Se abre una ventana como la mostrada en la ¡Error! No se encuentra el o

rigen de la referencia.Figura 17 que da acceso a un buen número de ejemplos
resueltos con MATLAB, cuyos resultados se presentan gráficamente de diversas
formas. Es muy interesante recorrer estos ejemplos para hacerse idea de las
posibilidades del programa, tanto en cálculo como en gráficos. Es asimismo muy
instructivo analizar los ficheros *.m de los ejemplos de características similares a las de
la aplicación que se desea desarrollar.
Figura 17: Demos disponibles en Matlab.
Además, de una forma muy inmediata, es posible también recurrir al Help desde la línea de
comandos de la Command Window. Se aconseja practicar un poco al respecto. Por ejemplo,
obsérvese la respuesta a los siguientes usos del comando help:
>> help
>> help lang
Como se puede comprobar el comando help ofrece ayuda general sobre todos los comandos
de MATLAB. Haciendo clic sobre cualquiera de ellos, se obtiene su ayuda particular. Se pide
ayuda sobre un comando específico o sobre cualquier tema del contenido utilizando el
comando help comando o help tema.
El comando lookfor secuencia permite encontrar todas aquellas funciones o comandos de

MATLAB que se refieren a dicha secuencia o la contienen. Este comando es muy útil, bien
cuando no se dispone de ayuda directa para la secuencia especificada, o bien para ver la
ayuda de todos los comandos que contienen la secuencia. Por ejemplo, si buscamos ayuda
para todos los comandos que contienen la secuencia inv, podemos usar el comando lookfor
inv.
El comando helpwin seguido de un nombre de comando o de función muestra la información

correspondiente a ese comando en la ventana Help (ver Figura 17). En la parte superior de la

ventana que se abre se muestra una barra de menús, donde en la opción View, y luego Code
for …, permite acceder al código fuente si está disponible; con la opción Go to online doc for ...
se accede a una información más completa que puede incluir ejemplos y comandos similares
sobre los que también se ofrece ayuda. En la parte inferior de la página aparece una lista de
enlaces See Also a funciones relacionadas.
El comando doc tecleado en la línea de comandos equivale a Help/Full Product Family Help; si
va seguido de un nombre de comando o función se muestra la información detallada
correspondiente a ese comando de modo similar a Go to online doc for... en el párrafo anterior.
En resumen, MATLAB dispone de una ayuda muy completa y accesible, estructurada en varios
niveles (línea de comandos en la Command Window, ventana Help, y manuales en formato
PDF), con la que es muy importante estar familiarizado, porque hasta los más expertos
programadores tienen que acudir a ella con una cierta frecuencia.
1.2 EL ENTORNO DE TRABAJO DE MATLAB
El entorno de trabajo de MATLAB es muy gráfico e intuitivo, similar al de otras aplicaciones

profesionales de Windows. En la introducción a MATLAB realizada en el apartado anterior, ya
se han citado algunas de las componentes más importantes de este entorno de trabajo o de
desarrollo. Ahora se explicarán estas componentes con un poco más de detalle.
Las componentes más importantes del entorno de trabajo de MATLAB son las siguientes:
1. El Escritorio de MATLAB (MATLAB Desktop), que es la ventana o contenedor de

máximo nivel en la que se pueden situar las demás componentes, y es la pantalla de
entrada al programa, que constituye el entorno de trabajo primario de MATLAB.
2. Las componentes individuales, orientadas a tareas concretas, entre las que se puede
citar:
a. la ventana de comandos (Command Window),
b. la ventana histórica de comandos (Command History),
c. el espacio de trabajo (Workspace),
d. la plataforma de lanzamiento (Launch Pad),
e. el directorio actual (Current Directory),
f. la ventana de ayuda (Help)
g. el editor de ficheros y depurador de errores (Editor&Debugger),
h. el editor de vectores y matrices (Array Editor).
i. la ventana que permite estudiar cómo se emplea el tiempo de ejecución
(Profiler).
A continuación, se describen brevemente estas componentes. Téngase en cuenta que utilizar

MATLAB y desarrollar programas para MATLAB es mucho más fácil si se conoce bien este
entorno de trabajo.
1.2.1 EL ESCRITORIO DE MATLAB (MATLAB DESKTOP)
El MATLAB Desktop es la ventana más general de la aplicación. El resto de las ventanas o

componentes citadas pueden alojarse en la MATLAB Desktop o ejecutarse como ventanas
independientes. A su vez, los componentes alojados en el MATLAB Desktop pueden aparecer
como subventanas independientes o como pestañas dentro de una de las subventanas.
MATLAB ofrece una gran flexibilidad al respecto y es cada usuario quien decide en qué forma
desea utilizar la aplicación.

Cuando se arranca MATLAB por primera vez o cuando se ejecuta el comando View/Desktop
Layout/ Default aparece una ventana como la mostrada en la Figura 10. Aunque dividida en
tres zonas, en realidad aparecen cuatro componentes, pues la subventana superior izquierda
contiene dos componentes superpuestas que se permutan por medio de la pestaña
correspondiente.
La Figura 19a muestra un detalle del menú Desktop, desde el que se controlan las
componentes visibles y la forma en que se visualizan. Por ejemplo, como en la Figura 19a la
ventana activa es la Command Window (resalta en azul), en el menú de la Figura 19b aparece
la opción de dejar de alojar dicha ventana en el MATLAB Desktop (Undock Command
Window). Dicho menú permite también eliminar del Desktop alguna de las componentes
visibles o visualizar el Help (que no está visible). Con los submenús de Desktop Layout se
pueden adoptar algunas configuraciones predefinidas, como la configuración por defecto
(Default) o incluir sólo la Command Window. La configuración adoptada por el usuario se
mantendrá la siguiente vez que arranque el programa. Es posible también guardar distintas
configuraciones con distintos nombres, para su uso posterior.
Figura 18: Distintas configuraciones del MATLAB DESKTOP (a,b,c,d)
Además del menú mostrado en la Figura 18b, que cambia en algunos detalles según cual sea
la ventana activa, el usuario puede configurar el MATLAB Desktop por medio del ratón
mediante algunas operaciones como las siguientes:
1. Colocando el ratón sobre los bordes intermedios de las subventanas y arrastrando

puede modificar su tamaño en la forma que desee.
2. Clicando sobre la barra de título de la subventana activa y arrastrando (Figura 18c) se
puede llevar a otra parte del Desktop, obteniéndose el resultado mostrado en la Figura

18d.
3. Si todas las ventanas se van seleccionando sucesivamente y se elige la
correspondiente opción Undock... en el menú View, se podría obtener una
configuración como la mostrada en la Figura 19a, en la que todas las ventanas son
independientes y aparecen separadas en la barra de tareas.
4. Finalmente, si se parte de la configuración por defecto y cada uno de los componentes
se arrastra sobre la Command Window se puede obtener una configuración como la
mostrada en la Figura 19b, en la que todos los componentes abiertos aparecen como
pestañas alternativas en una ventana única.
Figura 19: Otras configuraciones del MATLAB DESKTOP (a,b)
La variedad de configuraciones mostradas en las figuras precedentes da una idea de las

posibilidades de adaptación a las preferencias del usuario que tiene MATLAB. Otros
componentes como el Help Browser podrían añadirse a esta ventana de forma análoga. En los
apartados siguientes se analizan algunas de las posibilidades de cada componente.
1.2.2 COMMAND WINDOW
Ésta es la ventana en la que se ejecutan interactivamente las instrucciones de MATLAB y en

donde se muestran los resultados correspondientes, si es el caso. En cierta forma es la
ventana más importante y la única que existía en las primeras versiones de la aplicación.
Algunas características que nos permiten hacer el programa sobre esta ventana son:
1. Cualquier entrada a ejecutar en MATLAB se escribe a la derecha del input del usuario
encabezado con el prompt “>>”·obteniéndose la respuesta en las líneas
inmediatamente inferiores. Después de la salida vuelve a aparecer el input de usuario
para introducir más entradas.
2. Cuando en la entrada (input de usuario) que se le proponga a MATLAB en la venta de
comandos no se cita una variable para recoger el resultado, devuelve la respuesta
utilizando la expresión ans=. Pero si definimos una variable que recoja los resultados,
posteriormente podremos utilizar esa variable como argumento de entradas
posteriores.
3. Para que MATLAB ejecute una entrada, basta con pulsar Enter una vez escrita la
misma. Si al final de la entrada colocamos un punto y coma, el programa ejecuta los
cálculos y los guarda en la memoria (Workspace), pero no muestra el resultado en la
pantalla. Aparece el prompt de input “>>” para indicar que se puede introducir una
nueva entrada.
4. Al igual que el lenguaje C de programación, MATLAB es sensible a la diferencia entre

mayúsculas y minúsculas.
5. Los nombres de todas las funciones incorporadas empiezan con minúscula.
6. No debe haber espacios en los nombres de las órdenes, en símbolos de más de una
letra ni en los nombres de las funciones. En los demás casos, los espacios no se tienen
en cuenta. Se pueden poner algunos para hacer más legibles su input.
7. Se pueden realizar varias entradas en la misma línea de la ventana de comandos
separándolas por comas y pulsando Enter al final de la última entrada. En caso de
utilizar un punto y coma al final de una de las entradas de la línea, se omite su
correspondiente salida.
8. Es posible introducir comentarios descriptivos en una línea de entrada de la ventana de
comandos iniciándolos con el signo “%”. Al ejecutar la entrada, MATLAB ignora la zona
de comentario y procesa el resto.
9. Para simplificar el proceso de introducción de comandos para ser evaluados por el
intérprete de MATLAB, se pueden utilizar una serie de teclas con las siguientes
funciones:
Flecha hacia arriba (Ctrl-P) Recupera la entrada anterior a la actual.
Flecha hacia abajo (Ctrl-N) Recupera la entrada siguiente a la actual.
Flecha hacia la izquierda (Ctrl-B) Lleva el cursor un carácter a la izquierda.
Flecha hacia la derecha (Ctrl-F) Lleva el cursor un carácter a la derecha.
Ctrl-Flecha a la izquierda Lleva el cursor una palabra a la izquierda.
Ctrl-Flecha a la derecha Lleva el cursor una palabra a la derecha.
Inicio (Ctrl-A) Lleva el cursor al comienzo de la línea.
Fin (Ctrl-E) Lleva el cursor al final de la línea actual.
Escape Borra la línea de comandos.
Supr (Ctrl-D) Borra el carácter indicado por el cursor.
Backspace Borra el carácter a la izquierda del cursor.
Ctrl-k Borra toda la línea actual.
10. El comando clc borra la ventana de comandos, pero no borra su contenido del área de
trabajo (el contenido permanece en memoria).
11. Escribir líneas de comandos muy largas que automáticamente siguen en la línea
siguiente al llegar al margen derecho de la ventana. Para ello hay que activar la opción
Wrap Lines, en el menú File/Preferences/Command Window.
12. Clicando con el botón derecho sobre el nombre de una función que aparezca en esta
ventana se tiene acceso a la página del Help sobre dicha función. Si el código fuente
(fichero *.m) está disponible, también se puede acceder al fichero correspondiente por
medio del Editor/ Debugger.
13. Comenzando a teclear el nombre de una función y pulsando la tecla Tab, MATLAB
completa automáticamente el nombre de la función, o bien muestra en la línea
siguiente todas las funciones disponibles que comienzan con las letras tecleadas por el
usuario.
14. Cuando al ejecutar un fichero *.m se produce un error y se obtiene el correspondiente
mensaje en la Command Window, MATLAB muestra mediante un subrayado un enlace
a la línea del fichero fuente en la que se ha producido el error. Clicando en ese enlace
se va a la línea correspondiente del fichero por medio del Editor/Debugger.
1.2.3 COMMAND HISTORY BROWSER
La ventana Command History ofrece acceso a las sentencias que se han ejecutado
anteriormente en la Command Window. Estas sentencias están también accesibles por medio
de las teclas ↑ y ↓ como se ha comentado anteriormente, pero esta ventana facilita mucho el
tener una visión más general de lo hecho anteriormente y seleccionar lo que realmente se

desea repetir.
Las sentencias ejecutadas anteriormente se pueden volver a ejecutar mediante un doble clic o
por medio del menú contextual que se abre al clicar sobre ellas con el botón derecho. También
se pueden copiar y volcar sobre la línea de comandos, pero se ha de copiar toda la línea, sin
que se admita la copia de un fragmento de la sentencia. Existen opciones para borrar algunas
o todas las líneas de esta ventana. Se puede también hacer un profile (evaluar la eficiencia
relativa) de una sentencia o de un grupo de sentencias.
1.2.4 CURRENT DIRECTORY BROWSER
El concepto de directorio activo o directorio actual es muy importante en MATLAB. Los

programas de MATLAB se encuentran en ficheros con la extensión *.m. Estos ficheros se
ejecutan tecleando su nombre en la línea de comandos (sin la extensión), seguido de los
argumentos entre paréntesis, si se trata de funciones. No todos los ficheros *.m que se
encuentren en el disco duro o en otras unidades lógicas montadas en una red local son
accesibles sin más. Para que un fichero *.m se pueda ejecutar es necesario que se cumpla una
de las dos condiciones siguientes:
1. Que esté en el directorio actual. MATLAB mantiene en todo momento un único

directorio con esta condición. Este directorio es el primer sitio en el que MATLAB busca
cuando desde la línea de comandos se le pide que ejecute un fichero.
2. Que esté en uno de los directorios indicados en el Path de MATLAB. El Path es una
lista ordenada de directorios en los que el programa busca los ficheros o las funciones
que ha de ejecutar. Muchos de los directorios del Path son propios de MATLAB, pero
los usuarios también pueden añadir sus propios directorios, normalmente al principio o
al final de la lista. En un próximo apartado se verá cómo se controla el Path.
El comando pwd (de print working directory) permite saber cuál es el directorio actual. Para
cambiar de directorio actual se puede utilizar el comando cd (de change directory) en la línea
de comandos, seguido del nombre del directorio, para el cual se puede utilizar un path absoluto
(por ejemplo cd C:\MATLAB\Ejemplos) o relativo (cd Ejemplos). Para subir un nivel en la
jerarquía de directorios se utiliza el comando cd .., y cd ../.. para subir dos niveles. Éste es el
mismo sistema que se sigue para cambiar de directorio en las ventanas de MS-DOS. MATLAB
permite utilizar la barra normal (/) y la barra invertida (\), indistintamente.
La ventana Current Directory permite explorar los directorios del ordenador en forma análoga a
la del Explorador u otras aplicaciones de Windows. Cuando se llega al directorio deseado se
muestran los ficheros allí contenidos. La ventana Current Directory permite ordenarlos por
fecha, tamaño, nombre, etc. El directorio actual cambia automáticamente en función del
directorio seleccionado con este explorador, y también se puede cambiar desde la propia barra
de herramientas del MATLAB Desktop. Los ficheros *.m mostrados en la ventana Current
Directory se pueden abrir con el Editor/Debugger mediante un doble clic.
A partir del menú contextual que se abre clicando con el botón derecho en cualquier parte de la
ventana Current Directory se tiene la posibilidad de añadir ese directorio al Path de MATLAB.
1.2.5 PATH DE MATLAB: ESTABLECER EL CAMINO DE BÚSQUEDA

(SEARCH PATH)
MATLAB puede llamar a una gran variedad de funciones, tanto propias como programadas por
los usuarios. Puede incluso haber funciones distintas con el mismo nombre. Interesa saber
cuáles son las reglas que determinan qué función o qué fichero *.m es el que se va a ejecutar

cuando su nombre aparezca en una línea de comandos del programa. Esto queda determinado
por el camino de búsqueda (search path) que el programa utiliza cuando encuentra el nombre
de una función.
El search path de MATLAB es una lista de directorios que se puede ver y modificar a partir de
la línea de comandos, o utilizando el cuadro de diálogo Set Path, del menú File. El comando
path hace que se escriba el search path de MATLAB (el resultado depende de en qué directorio
esté instalado MATLAB; se muestran sólo unas pocas líneas de la respuesta real del
programa):
>> path
>> path
MATLABPATH
C:\MATLAB701\toolbox\MATLAB\general
C:\MATLAB701\toolbox\MATLAB\ops
C:\MATLAB701\toolbox\MATLAB\lang
C:\MATLAB701\toolbox\MATLAB\elmat
...
C:\MATLAB701\toolbox\MATLAB\helptools
C:\MATLAB701\toolbox\MATLAB\winfun
C:\MATLAB701\toolbox\MATLAB\demos
C:\MATLAB701\toolbox\local
Para ver cómo se utiliza el search path supóngase que se utiliza la palabra nombre1 en un
comando. El proceso que sigue el programa para tratar de conocer qué es nombre1 es el
siguiente:
1. Comprueba si nombre1 es una variable previamente definida por el usuario.

2. Comprueba si nombre1 es una función interna o intrínseca de MATLAB.
3. Comprueba si nombre1 es una sub-función o una función privada del usuario.
4. Comprueba si hay un fichero llamado nombre1.mex, nombre1.dll o nombre1.m en el
directorio actual, cuyo contenido se obtiene con el comando dir. Ya se ha visto cómo se
cambiaba el directorio actual.
5. Comprueba si hay ficheros llamados nombre1.mex, nombre1.dll o nombre1.m en los
directorios incluidos en el search path de MATLAB.
Estos pasos se realizan por el orden indicado. En cuanto se encuentra lo que se está buscando
se detiene la búsqueda y se utiliza el fichero que se ha encontrado. Conviene saber que, a
igualdad de nombre, los ficheros *.mex tienen precedencia sobre los ficheros *.m que están en
el mismo directorio.

Figura 20: Ventanas del Path (a,b)
El cuadro de diálogo que se abre con el comando File/Set Path ayuda a definir la lista de
directorios donde MATLAB debe buscar los ficheros de comandos y las funciones, tanto del
sistema como de usuario. Al ejecutar dicho comando aparece el cuadro de diálogo de la Figura
191a, en el cual se muestra la lista de directorios en la que MATLAB buscará. Para añadir (o
quitar) un directorio a esta lista se debe clicar sobre los botones Add Folder o Add with
Subfolders, con lo cual aparece un nuevo cuadro de diálogo, mostrado en la Figura 20b, que
ayuda a elegir el directorio deseado. El nuevo directorio se añade al comienzo de la lista, pero
desde esa posición puede desplazarse hacia abajo o hasta el final con los botones Move Down
o Move to Botton, respectivamente. Como ya se ha dicho el orden de la lista es muy
importante, porque refleja el orden de la búsqueda: si dos funciones con el mismo nombre
están en dos directorios diferentes, se utilizará la que primero se encuentre. El cuadro de
diálogo Set Path contiene los botones necesarios para realizar todas las operaciones que el
usuario desee.
Para incluir desde la línea de comandos de MATLAB un directorio nuevo al comienzo del Path
sin utilizar el cuadro de diálogo Set Path, se puede utilizar también el comando path, que
concatena dos listas de directorios (sólo se deben utilizar directorios que realmente existan en
el PC), como, por ejemplo:
>> path('c:\mat\MATLAB', path)2
mientras que para añadir el nuevo directorio al final de la lista, se utilizaría el comando:
>> path(path, 'c:\mat\practicas')
El comando addpath permite añadir uno o más directorios al Path. Su forma general puede
verse en los siguientes ejemplos:
>> addpath 'c:\MATLAB' 'c:\Temp' -end
>> addpath 'c:\MATLAB\Pruebas' 'c:\Temp\Pruebas' -begin
donde la opción por defecto (cuando no se pone ni –begin ni –end) es añadir al comienzo de la
lista. Después de ejecutar estos comandos conviene comprobar cómo ha quedado modificado
el search path (recuérdese que los directorios deben existir en realidad).
2
El comando path dentro del paréntesis de la función devuelve la lista de directorios anterior.

No es difícil borrar las líneas que se han introducido en el Path: por una parte, los cambios no
son permanentes y dejarán de surtir efecto al salir de MATLAB y volver a entrar (salvo que se
guarden como opciones estables). También, se puede utilizar el comando rmpath (de remove
path), al que se le pasan la lista de directorios a eliminar del Path. Por ejemplo, el comando:
>> rmpath 'c:\MATLAB' 'c:\Temp'
borra del Path los dos directorios indicados.
1.2.6 WORKSPACE BROWSER Y ARRAY EDITOR
El espacio de trabajo de MATLAB (Workspace) es el conjunto de variables y de funciones de

usuario que en un determinado momento están definidas en la memoria del programa o de la
función que se está ejecutando. Para obtener información sobre el Workspace desde la línea
de comandos se pueden utilizar los comandos who y whos. El segundo proporciona una
información más detallada que el primero. Por ejemplo, una salida típica del comando whos es
la siguiente:
>> whos
Name Size Bytes Class
A 3x3 72 double array
B 3x3 72 double array
C 3x3 72 double array
D 3x3 72 double array
Grand total is 36 elements using 288 bytes.
Éstas son las variables del espacio de trabajo base (el de la línea de comandos de MATLAB).
Más adelante se verá que cada función tiene su propio espacio de trabajo, con variables cuyos
nombres no interfieren con las variables de los otros espacios de trabajo.
La ventana Workspace constituye un entorno gráfico para ver las variables definidas en el
espacio de trabajo. Se activa con el comando View/Workspace. La Figura 21a muestra el
aspecto inicial de la ventana Workspace cuando se abre desde un determinado programa.
Haciendo doble clic por ejemplo sobre la matriz BARS aparece una nueva ventana (o pestaña,
si la ventana ya existía) del Array Editor, en la que se muestran y pueden ser modificados los
elementos de dicha matriz (ver Figura 21b).
Es importante insistir en que cada una de las funciones de MATLAB tiene su propio espacio de
trabajo, al que en principio sólo pertenecen las variables recibidas como argumentos o
definidas dentro de la propia función. En la barra de herramientas de la ventana Workspace
aparece una lista desplegable llamada Stack, con los espacios de trabajo del programa actual.
Hay que tener en cuenta que cuando se termina de ejecutar una función y se devuelve el
control al programa que la había llamado, las variables definidas en la función dejan de existir
(salvo que se hayan declarado como persistentes) y también deja de existir su espacio de
trabajo.

Figura 21: Ventanas del Workspace y de su editor (a,b).
Si se desean examinar otras matrices y/o vectores, al hacer doble clic sobre ellas el Array
Editor las muestra en la misma ventana como subventanas con una pestaña diferente.
Clicando con el botón derecho sobre alguna de las variables del Workspace Browser se abre
un menú contextual que ofrece algunas posibilidades interesantes, como por ejemplo la de
representar gráficamente dicha variable.
El Array Editor no sólo permite ver los valores de los elementos de cualquier matriz o vector
definido en el programa: es también posible modificar estos valores clicando sobre la celda
correspondiente. La ventana del Array Editor incluye una lista desplegable en la que se puede
elegir el formato en el que se desea ver los datos.
El Array Editor es muy útil también para entender bien ciertos algoritmos, ejecutando paso a
paso un programa y viendo cómo cambian los valores de las distintas variables. Es posible
aparcar o situar las ventanas o pestañas del Array Editor en la misma ventana del
Editor/Debugger, que se va a ver a continuación.
1.2.7 EL EDITOR DEBUGGER
En MATLAB tienen particular importancia los ya citados ficheros-M (o M-files). Son ficheros de
texto ASCII, con la extensión *.m, que contienen conjuntos de comandos o definición de
funciones (estos últimos son un poco más complicados y se verán más adelante). La
importancia de estos ficheros-M es que al teclear su nombre en la línea de comandos y pulsar
Intro, se ejecutan uno tras otro todos los comandos contenidos en dicho fichero. El poder
guardar instrucciones y grandes matrices en un fichero permite ahorrar mucho trabajo de
tecleado.
Aunque los ficheros *.m se pueden crear con cualquier editor de ficheros ASCII tal como
Notepad, MATLAB dispone de un editor que permite tanto crear y modificar estos ficheros,
como ejecutarlos paso a paso para ver si contienen errores (proceso de Debug o depuración).
La Figura 22 muestra la ventana principal del Editor/Debugger, en la que se ha tecleado un
fichero-M llamado Prueba1.m, que contiene un comentario y seis sentencias:

Figura 22: Ventana Editor/Debugger.
clear all;
A=rand(3,3);
B=A';
C=inv(A);
D=C*A; disp('Ya he terminado');
El Editor muestra con diferentes colores los diferentes tipos o elementos constitutivos de los
comandos (en verde los comentarios, en violeta las cadenas de caracteres, etc.). El Editor se
preocupa también de que las comillas o paréntesis que se abren, no se queden sin el
correspondiente elemento de cierre. Colocando el cursor antes o después de una apertura o
cierre de corchete o paréntesis y pulsando las teclas (←) o (→), el Editor muestra con qué
cierre o apertura de corchete o paréntesis se empareja el elemento considerado; si no se
empareja con ninguno, aparece con una rayita de tachado.
Seleccionando varias líneas y clicando con el botón derecho aparece un menú contextual cuya
sentencia Comment permite entre otras cosas comentar con el carácter % todas las líneas
seleccionadas. Estos comentarios pueden volver a su condición de código ejecutable
seleccionándolos y ejecutando Uncomment en el menú contextual. Otra opción muy útil de ese
menú contextual es Smart Indent, que organiza el sangrado de los bucles y bifurcaciones de
las sentencias seleccionadas.
La Figura 22 corresponde a una ejecución de este fichero de comandos controlada con el

Debugger. Dicha ejecución se comienza eligiendo el comando Run en el menú Debug,
pulsando la tecla F5, clicando en el botón Run and Advance de la barra de herramientas del
Editor o tecleando el nombre del fichero en la línea de comandos de la Command Window. Los
puntos rojos que aparecen en el margen izquierdo son breakpoints (puntos en los que se
detiene la ejecución de programa); cuando el cursor se coloca sobre una variable (en este caso
sobre A) aparece una pequeña ventana con los valores numéricos de esa variable.
En la Figura 22 puede apreciarse también que están activados los botones que corresponden
al Debugger. El significado de estos botones, que aparece al colocar sobre ellos el cursor, es el
siguiente:
 Set/Clear Breakpoint. Coloca o borra un breakpoint en la línea en que está el cursor.
 Clear All Breakpoints. Elimina todos los breakpoints que haya en el fichero.
 Step. Avanzar un paso sin entrar en las funciones de usuario llamadas en esa línea.
 Step In. Avanzar un paso, y si en ese paso hay una llamada a una función cuyo fichero
*.m está accesible, entra en dicha función.

 Step Out. Salir de la función que se está ejecutando en ese momento.
 Continue. Continuar la ejecución hasta el siguiente breakpoint.
 Quit Debugging. Terminar la ejecución del Debugger.
 Function Call Stack. En la parte derecha de la barra de herramientas aparece esta lista
desplegable (visible en la Figura 22 con las letras Prueba1) mediante la cual se puede
elegir el contexto, es decir el espacio de trabajo o el ámbito de las variables que se
quieren examinar. Ya se ha comentado que el espacio de trabajo base (el de las
variables creadas desde la línea de comandos) y el espacio de trabajo de cada función
son diferentes.
El Debugger es un programa que hay que conocer muy bien, pues es muy útil para detectar y
corregir errores. Es también enormemente útil para aprender métodos numéricos y técnicas de
programación. Para aprender a manejar el Debugger lo mejor es practicar.
Cuando se está ejecutando un programa con el Debugger, en cualquier momento se puede ir a

la línea de comandos de MATLAB y teclear una expresión para ver su resultado. También se
puede seleccionar con el ratón una sub-expresión en cualquier línea vista en el
Editor/Debugger, clicar con el botón derecho y en el menú contextual que se abre elegir
Evaluate Selection. El resultado de evaluar esa sub-expresión aparece en la línea de
comandos de MATLAB.
Al realizar operaciones con el Debugger gráfico van apareciendo las correspondientes

instrucciones en la línea de comandos de MATLAB. Para más información sobre los comandos
del Debugger alfanumérico, buscar en la sección “Editing and Debugging M-Files” en
Help/MATLAB/Desktop Tools and Development Environment.
Seleccionando el nombre de una función o de un fichero de comandos en el código mostrado

en la ventana del Editor/Debugger y abriendo con el botón derecho el menú contextual
correspondiente, se ofrecen las tres posibilidades Evaluate Selection, Open Selection y Help on
Selection, que son muy útiles para comprobar, ver o recibir ayuda sobre la función
seleccionada.
MATLAB permite también introducir breakpoints condicionales (indicados con un punto

amarillo, en vez de rojo), en los que el programa se para sólo si se cumple una determinada
condición. Para introducir un breakpoint condicional basta clicar con el botón derecho en la
correspondiente línea del código en la ventana del Editor/Debugger y elegir en el menú
contextual que resulta Set/Modify Conditional Breakpoint. Se abre una ventana como la
mostrada en la Figura 23 en la que se escribe la condición que debe cumplirse para que el
programa se detenga en dicho punto.

Figura 23
1.2.8 EL PROFILER
El profiler es un programa de utilidad que permite saber cómo se ha empleado el tiempo de la

CPU en la ejecución de un determinado programa. El profiler es una herramienta muy útil para
determinar los cuellos de botella de un programa, es decir las funciones y las líneas de código
que más veces se llaman y que se llevan la mayor parte del tiempo de ejecución. Por ejemplo,
es obvio que si se trata de mejorar la eficiencia de un programa, sería más importante mejorar
una función que se llevase el 60% del tiempo total que otra que sólo se llevase el 2%. Dentro
de la función más llamada, el profiler proporciona información sobre el tiempo que se lleva cada
sentencia, y da también algunas orientaciones
sobre las posibilidades de mejorarla.
En esta nueva versión tenemos directamente

un botón Run and Time que nos facilita esta
información.
APPS DE MATLAB
Las Apps de MATLAB® son Apps interactivas

escritas para realizar tareas de cálculo técnico.
Diversos productos de MATLAB incluyen Apps.
La pestaña Apps de la barra de herramientas
de MATLAB muestra las Apps que hay
instaladas en la actualidad.
Existen varias formas de obtener más Apps: en

la sección de intercambio de archivos de
MATLAB, mediante otros productos de
MATLAB y creando Apps propias. A partir de
MATLAB R2012b, es posible crear Apps y
compartirlas con los miembros de la
comunidad de MATLAB. Ejemplo de iconos de Apps.
1.3 PREFERENCIAS: FORMATOS DE SALIDA Y DE OTRAS OPCIONES

DE MATLAB
MATLAB dispone de un cuadro de diálogo desde el que se establecen casi todas las opciones
que el usuario puede determinar por su cuenta. Este cuadro de diálogo se abre con el icono
Preferences del menú mostrando todas las posibilidades que ofrece en el menú de la izquierda:

en total son 24 cuadros de diálogo diferentes. La Figura 24b muestra el que permite elegir los
colores generales del código.
Figura 24: Ventana Preferences/General (a,b)
El cuadro de diálogo Command Window/Fonts ofrece la posibilidad de elegir el tipo de letra –

así como el tamaño y el color, tanto de las letras como del fondo– con la que se escribe en la
ventana de comandos de MATLAB. Es muy importante utilizar tipos de letra de tamaño
constante (por ejemplo, Courier New, Lucida Console o Monospaced), para que las filas de las
matrices se alineen bien en la pantalla.
Respecto a los formatos numéricos con que MATLAB muestra los resultados (recuérdese que
siempre calcula con doble precisión, es decir con unas 16 cifras decimales equivalentes), las
posibilidades existentes se muestran en la lista desplegable de la Figura 25a y son las
siguientes:
 short coma fija con 4 decimales (defecto)

 long coma fija con 15 decimales
 hex cifras hexadecimales
 bank números con dos cifras decimales
 short e notación científica con 4 decimales
 short g notación científica o decimal, dependiendo del valor
 long e notación científica con 15 decimales
 long g notación científica o decimal, dependiendo del valor
 rational expresa los números racionales como cocientes de enteros
Estos formatos se pueden cambiar también desde la línea de comandos anteponiendo la

palabra format. Por ejemplo, para ver las matrices en formato long habrá que ejecutar el
comando:
>> format long
Por otra parte, el formato loose introduce algunas líneas en blanco en la salida (opción por
defecto), mientras que el formato compact elimina las líneas en blanco citadas. Estas opciones
están disponibles en el cuadro de diálogo de la Figura 25a y se pueden también establecer
desde la línea de comandos en la forma:

>> format compact
El cuadro de diálogo de la Figura 25b permite elegir un editor de programas distinto del que
trae MATLAB (built-in editor), así como obligar a que los ficheros se abran de modo automático
al ejecutarlos con el Debugger.
Figura 25: Ventana Preferencias (a,b)
MATLAB aplica un factor de escala general a las matrices cuando los elementos no enteros
más grandes o más pequeños son superiores o inferiores a una determinada cantidad (103 y
10–3, respectivamente).
Hay que añadir que MATLAB trata de mantener el formato de los números que han sido
definidos como enteros (sin punto decimal). Si se elige la opción format rational el programa
trata de expresar los números racionales como cocientes de enteros.
1.4 FICHEROS MATLABRC.M, STARTUP.M Y FINISH.M
El search path inicial o por defecto de MATLAB está definido en un fichero llamado
MATLABrc.m, en el subdirectorio toolbox\local. Este fichero contiene también otros parámetros
de inicialización y es, por ejemplo, el responsable de los mensajes que aparecen al arrancar el
programa. Este fichero se ejecuta automáticamente al arrancar MATLAB.
En las instalaciones de MATLAB en red, MATLABrc.m es un fichero controlado por el

administrador del sistema. Una de las cosas que hace este fichero es ver si en algún directorio
del search path existe otro fichero llamado startup.m, y en caso de que exista lo ejecuta. Esto
abre la posibilidad de que cada usuario arranque MATLAB de una forma personalizada. Si en
el search path de MATLAB se coloca un fichero creado por el usuario llamado startup.m las
instrucciones contenidas en dicho fichero se ejecutarán automáticamente cada vez que
arranque MATLAB.
Un posible contenido de este fichero puede ser el siguiente (crearlo con el Editor/Debugger):
>> format compact
>> addpath 'c:\MATLAB\Practicas' -end
>> disp('¡Hola!')

Se puede crear el fichero startup.m en el directorio indicado y probar a arrancar MATLAB. Si el

saludo ¡Hola! se sustituye por un saludo más personal (por ejemplo, incluyendo el propio
nombre), se comprobará lo explicado previamente. Es muy aconsejable crear este fichero si
MATLAB se utiliza en un ordenador de uso personal.
De forma análoga, al abandonar la ejecución de MATLAB con el comando quit se ejecuta

automáticamente el fichero finish.m, siempre que se encuentre en alguno de los directorios del
search path. Este fichero se puede utilizar por ejemplo para guardar el espacio de trabajo de
MATLAB y poder continuar en otro momento a partir del punto en el que se abandonó el
trabajo, por ejemplo, al cerrar el programa.
1.5 GUARDAR VARIABLES Y ESTADOS DE UNA SESIÓN: COMANDOS

SAVE Y LOAD
En muchas ocasiones puede resultar interesante interrumpir el trabajo con MATLAB y poderlo
recuperar más tarde en el mismo punto en el que se dejó (con las mismas variables definidas,
con los mismos resultados intermedios, etc.). Hay que tener en cuenta que al salir del
programa todo el contenido de la memoria se borra automáticamente.
Para guardar el estado de una sesión de trabajo existe el comando save. Si se teclea:
>> save
antes de abandonar el programa, se crea en el directorio actual un fichero binario llamado

MATLAB.mat (o MATLAB) con el estado de la sesión (excepto los gráficos, que por ocupar
mucha memoria hay que guardar aparte). Dicho estado puede recuperarse la siguiente vez que
se arranque el programa con el comando:
>> load
Esta es la forma más básica de los comandos save y load. Se pueden guardar también
matrices y vectores de forma selectiva y en ficheros con nombre especificado por el usuario.
Por ejemplo, el comando (sin comas entre los nombres de variables):
>> save filename A x y
guarda las variables A, x e y en un fichero binario llamado filename.mat (o filename). Para

recuperarlas en otra sesión basta teclear:
>> load filename
Si no se indica ninguna variable, se guardan todas las variables creadas en esa sesión.
El comando save permite guardar el estado de la sesión en formato ASCII utilizándolo de la

siguiente forma (lo que va detrás del carácter (%) es un comentario que es ignorado por
MATLAB):
>> save -ascii % almacena 8 cifras decimales
>> save -ascii -double % almacena 16 cifras decimales
>> save -ascii -double -tab % almacena 16 cifras separadas por tabs
aunque en formato ASCII sólo se guardan los valores y no otra información tal como los
nombres de las matrices y/o vectores. Cuando se recuperan estos ficheros con load -ascii toda

la información se guarda en una única matriz con el nombre del fichero. Esto produce un error
cuando no todas las filas tienen el mismo número de elementos.
Con la opción -append en el comando save la información se guarda a continuación de lo que

hubiera en el fichero.
El comando load admite las opciones -ascii y -mat, para obligarle a leer en formato ASCII o
binario, respectivamente.
1.6 GUARDAR SESIÓN Y COPIAR SALIDAS: COMANDO DIARY
Los comandos save y load crean ficheros binarios o ASCII con el estado de la sesión. Existe
otra forma más sencilla de almacenar en un fichero un texto que describa lo que el programa
va haciendo (la entrada y salida de los comandos utilizados). Esto se hace con el comando
diary en la forma siguiente:
>> diary filename.txt
...
>> diary off
...
>> diary on
...
El comando diary off suspende la ejecución de diary y diary on la reanuda. El simple comando
diary pasa de on a off y viceversa. Para poder acceder al fichero filename.txt con Notepad o
Word es necesario que diary esté en off. Si en el comando diary no se incluye el nombre del
fichero se utiliza por defecto un fichero llamado diary (sin extensión).
1.7 LÍNEAS DE COMENTARIOS
Ya se ha indicado que para MATLAB el carácter tanto por ciento (%) indica comienzo de
comentario. Cuando aparece en una línea de comandos, el programa supone que todo lo que
va desde ese carácter hasta el fin de la línea es un comentario.
Más adelante se verá que los comentarios de los ficheros *.m tienen algunas peculiaridades
importantes, pues pueden servir para definir help's personalizados de las funciones que el
usuario vaya creando.
MATLAB permite comentar bloques de sentencias, es decir, muchas sentencias contiguas de

una vez. Una forma de hacerlo es seleccionar las sentencias que se desea comentar, clicar con
el botón derecho, y elegir la opción Comment en el menú que se abre; las sentencias
seleccionadas se comentan individualmente con el carácter %. De forma similar se pueden
eliminar los comentarios.
Otra forma de comentar bloques de sentencias (similar a la utilizada en C/C++ con /* y */) es
encerrar las líneas que se desea inutilizar entre los caracteres %{ y %}. Los bloques
comentados pueden incluirse dentro de otros bloques comentados más amplios (bloques
anidados).

1.8 MEDIDA DE TIEMPOS Y DE ESFUERZO DE CÁLCULO
MATLAB dispone de funciones que permiten calcular el tiempo empleado en las operaciones
matemáticas realizadas. Algunas de estas funciones son las siguientes:
cputime devuelve el tiempo de CPU (con precisión de centésimas de segundo) desde

que el programa arrancó. Llamando antes y después de realizar una operación
y restando los valores devueltos, se puede saber el tiempo de CPU empleado
en esa operación. Este tiempo sigue corriendo, aunque MATLAB esté inactivo.
etime(t2, t1) tiempo transcurrido entre los vectores t1 y t2 (¡atención al orden!), obtenidos
como respuesta al comando clock.
tic ops toc imprime el tiempo en segundos requerido por ops. El comando tic pone el reloj
a cero y toc obtiene el tiempo transcurrido.
A modo de ejemplo, el siguiente código mide de varias formas el tiempo necesario para
resolver un sistema de 1000 ecuaciones con 1000 incógnitas. Téngase en cuenta que los
tiempos pequeños (del orden de las décimas o centésimas de segundo), no se pueden medir
con gran precisión.
>> n=1000; A=rand(n); b=rand(n,1); x=zeros(n,1);
>> tiempoIni=clock; x=A\b; tiempo=etime(clock, tiempoIni)
>> time=cputime; x=A\b; time=cputime-time
>> tic; x=A\b; toc
donde se han puesto varias sentencias en la misma línea para que se ejecuten todas sin
tiempos muertos al pulsar intro. Esto es especialmente importante en la línea de comandos en
la que se quiere medir los tiempos. Todas las sentencias de cálculos matriciales van seguidas
de punto y coma (;) con objeto de evitar la impresión de resultados. Conviene ejecutar dos o
tres veces cada sentencia para obtener tiempos óptimos, ya que la primera vez que se
ejecutan se emplea un cierto tiempo en cargar las funciones a memoria.
Práctica:
1. Modifica el entorno original para que aparezca:

a. Únicamente la ventana de comandos.
b. La Ventana de comandos y los comandos ejecutados en sesiones anteriores.
c. La ventana de comandos y el directorio de trabajo.
d. Prueba otras posibilidades y escoge la que más se adecúe a tu forma de
trabajo.
2. Crea un directorio de trabajo con tu nombre.
>> diary primera_sesion.dia
Al final de la sesión de trabajo y, antes de salir de MatLab, bastará teclear
>> diary off
Para comprobar que ha sido grabado podemos escribir
>>dir (viendo que existe en el listado de ficheros)
Visualizar su contenido:
>>type primera_sesion.dia

2. EJECUCIÓN DE COMANDOS Y CREACIÓN DE VARIABLES
2.1 OPERACIONES ARITMÉTICAS. USO DEL MATLAB COMO

CALCULADORA
La utilización más básica de MATLAB es su uso como calculadora, que funciona de una forma
similar que una calculadora programable, aunque bastante más versátil.
Los elementos básicos del MATLAB, como en cualquier otro lenguaje de programación son:
constantes, operaciones, variables, expresiones y funciones.
2.1.1 CONSTANTES
Una constante numérica es cualquier número que se utiliza en un cálculo sin que experimente
variación durante una sesión de trabajo. Al igual que en cálculo elemental tendremos tres tipos
de números y, por lo tanto, tres tipos de constantes:
1. Números enteros: 2 58 39 479 -98 … (números escritos sin punto decimal).

2. Números reales: 23. -95.9 1.2 (con punto decimal, es obligatorio el uso de punto y no
de la coma). Pueden escribirse de la siguiente manera:
 Con un máximo de 16 cifras significativas y el punto decimal en cualquier
posición.
i. Ejemplos válidos: 5693.258 25.9
ii. Ejemplos no válidos: 12,87 pues no se admite la “,” en la definición de
una constante.
 Utilizando la letra E (tanto en mayúsculas como en minúscula e) a continuación
de un número con punto decimal, seguida de un número positivo o negativo de
3 cifras, que indicará la potencia de 10 por la que debe multiplicarse el número
que le precede. Esta posibilidad permite simplificar la escritura de constantes
reales muy grandes o muy pequeñas.
i. Ejemplos válidos: 85.E4 (= 85. x 104), 0.587E-02 (=0.587x10-2).
ii. Ejemplos no válidos: 96,E1 pues no se admite la “,”, 5E1.6 pues el
exponente debe ser un número entero.
Esta forma de representar los números reales se conoce como notación

exponencial o científica.
3. Números complejos: 3+4i, 3.-8.i, 3+4*j, …, donde i,j= √−1.
En MATLAB las variables i y j están predefinidas como √−1. Como veremos el signo de
la multiplicación en MATLAB es *; sin embargo, en la escritura de los números
complejos no es preciso poner este signo antes del complejo i.
Cualquier constante que no vaya precedida de signo se considera positiva.
2.1.2 OPERACIONES
En la tabla siguiente se ilustran las operaciones aritméticas elementales, el símbolo que

emplea MATLAB y un ejemplo.

Operación Símbolo Ejemplo

Suma + 9.3+7
Resta - 9-12
Multiplicación * 9*53
División / 7/9
División inversa (produce el inverso de la división a\b=b/a) \ 5\50
Exponenciación ^ 6^2
El orden en que estas operaciones se evalúan en una expresión está dado por la siguiente ley
de precedencia:
Las expresiones se evalúan de izquierda a derecha, con la operación de potencia o de

exponenciación teniendo el orden de precedencia más alto, seguido por multiplicación y
división que tienen ambas igual precedencia y seguidas finalmente, por suma y resta que
tienen igual precedencia.
Se pueden usar paréntesis para alterar esta usual ordenación, en cuyo caso la evaluación se
inicia dentro del paréntesis más interno y se procede hacia fuera.
Ejercicio:
Para observar cómo funcionan estas operaciones en MATLAB, resolver:
i. 3^2+1-2/2*4
ii. (3^2+1-2)/2*4
iii. 3^(2+1)-2/(2*4)
2.1.3 VARIABLES Y EXPRESIONES
Una variable es la etiqueta que identifica una porción de memoria; en ella podemos guardar
datos de un mismo tipo, números o caracteres, recuperables y modificables durante la vida de
la variable en la sesión de trabajo, sin más que hacer referencia a su nombre. Es decir, es un
nombre que se le da a una entidad numérica o carácter, que puede ser una matriz, un vector o
un escalar. El valor de esa variable, e incluso el tipo de entidad numérica o carácter que
representa, puede cambiar a lo largo de una sesión de MATLAB o a lo largo de la ejecución de
un programa. La forma más normal de cambiar el valor de una variable es colocándola a la
izquierda del operador de asignación (=). Por ejemplo:
>> a=4/3;
>> b=11;
>> volumen=2;
>> temperatura=33.5;
>> nombre='Javier'
nombre =
Javier
Como se muestra el ejemplo, MATLAB puede definir variables que contengan cadenas de
caracteres. Las cadenas de texto van entre apóstrofos o comillas simples s = 'cadena de
caracteres'.
A partir de expresiones aritméticas también podemos definir variables. Por ejemplo:

>> c=a*(b-1)
c=
13.3333
Las expresiones numéricas son un conjunto de números, funciones y variables previamente

definidas, relacionados todos ellos por operadores aritméticos. Se permite utilizar espacios en
blanco para separar las unidades básicas de la expresión, mejorando su presentación y lectura
posterior.
Una expresión de MATLAB puede tener las dos formas siguientes: primero, asignando su
resultado a una variable,
variable = expresión
y segundo evaluando simplemente el resultado del siguiente modo,
expresión
en cuyo caso el resultado se asigna automáticamente a una variable interna de MATLAB

llamada ans (de answer) que almacena el último resultado obtenido.
>> 4*a-6/b+c
ans =
18.1212
Se considera por defecto que una expresión termina cuando se pulsa intro. Si se desea que
una expresión continúe en la línea siguiente, por ejemplo si es demasiado larga, hay que
introducir tres puntos (...) antes de pulsar intro (para evitar que pueda confundirse el primer
punto de este comando con el punto decimal, es conveniente dejar un espacio en blanco antes
de escribirlo).
>> s=1+2+3+4+5+6+7+8+9...
+10+11
s=
66
También se pueden incluir varias expresiones en una misma línea separándolas por comas (,)
o puntos y comas (;).
La ventaja de usar variables en las expresiones es que permite guardar todas las cifras
significativas de los cálculos intermedios, teniendo por tanto una mayor precisión en el
resultado final y una mayor comodidad.
Si una expresión termina en punto y coma (;) su resultado se calcula, pero no se escribe en
pantalla. Esta posibilidad es muy interesante, tanto para evitar la escritura de resultados
intermedios, como para evitar la impresión de grandes cantidades de números cuando se
trabaja con matrices de gran tamaño.
MATLAB distingue entre mayúsculas y minúsculas en los nombres de variables, es decir la

variable AB y la variable ab son distintas.
Los nombres de variables deben empezar siempre por una letra y pueden constar de hasta
63 caracteres, que pueden ser letras y números. No pueden utilizarse para nombrar variables
los caracteres especiales siguientes:

+, -,=,*, <, >, ^, …
El carácter guion bajo (_) se considera como una letra. La función namelengthmax permite
preguntar al programa por este número máximo de caracteres. A diferencia de otros lenguajes
de programación, MATLAB no requiere ningún tipo de declaración de las variables que se
vayan a utilizar. Esto hace que se deba tener especial cuidado con no utilizar nombres
erróneos en las variables, porque no se recibirá ningún aviso del ordenador.
Cuando se quiere tener una relación de las variables que se han utilizado en una sesión de
trabajo se puede utilizar el comando who.
>> who
Your variables are:
a c temperatura
b nombre volumen
Existe otro comando llamado whos que proporciona además información sobre el tamaño o
dimensión, la cantidad de memoria ocupada y el carácter real o complejo de cada variable.
>> whos
Name Size Bytes Class
a 1x1 8 double array

b 1x1 8 double array
c 1x1 8 double array
nombre 1x6 12 char array
temperatura 1x1 8 double array
volumen 1x1 8 double array
Grand total is 11 elements using 52 bytes
Se sugiere utilizar de vez en cuando estos comandos en la sesión de MATLAB que se tiene
abierta. Esta misma información se puede obtener gráficamente con el Workspace Browser, que
aparece con el comando View/Workspace o activando la ventana correspondiente si estaba
abierto.
Si en algún momento de la sesión de MATLAB deseamos eliminar una variable se utiliza el

comando clear, que tiene tiene varias formas posibles:
 clear sin argumentos, clear elimina todas las variables creadas previamente (excepto
las variables globales).
 clear A, b borra las variables indicadas.
 clear global borra las variables globales.
 clear functions borra las funciones.
 clear all borra todas las variables, incluyendo las globales, y las funciones.
Este comando es muy interesante, pues permite que la variable tenga un tiempo de vida
limitado durante una sesión de trabajo y, así, optimizar los recursos de la memoria.
La ejecución de una sentencia puede abortarse pulsando simultáneamente las teclas Control y
C.
Cualquier comentario que desee introducirse para facilitar posteriores lecturas de los comandos
ejecutados, puede incluirse en una línea suelta, o a continuación de una expresión; tan sólo
debe ir precedido por “%”. Por ejemplo:

>> %Definimos, a continuación, la temperatura:
>> temp= 48; % temp toma el valor inicial 48
>> %cualquier otro comentario puede ir aquí.
MATLAB tiene predefinidas una serie de variables y constantes especiales, que son variables
permanentes, es decir, son aquellas con significado especial, y que no se pueden eliminar:
 ans: variable utilizada por defecto para almacenar el resultado de evaluar expresiones
aritméticas, que contiene la respuesta (answer) del ´ultimo comando ejecutado, cuando
el resultado de dicho comando no se asigna explíıcitamente a ninguna variable.
 eps: número más pequeño que, añadido a otro, crea un nuevo número en coma
flotante3 sobre el ordenador.
>> eps
ans =
2.2204e-016
 pi: π.
 i, j: √−1 Constante imaginaria.
 inf: ∞. Se trata de un valor excesivamente grande para ser almacenado.
>> 1/0
Warning: Divide by zero.
ans =
Inf
 NaN: Not a number. Es el resultado que se proporciona si durante una operación se
0 ∞
produce una indeterminación, del tipo 0·∞, , , etc.
0 ∞
>> b=inf/inf
b=
NaN
Con respecto a estas dos últimas variables es necesario subrayar que el usuario debe
extremar las precauciones en el uso del paquete pues, por ejemplo, si a lo largo de un
programa se realiza el cáculo 3/Inf (que matemáticamente carece de sentido) el
programa se sigue ejecutando tomando para tal expresión el valor cero y dificultando
posteriormente la identificación del error correspondiente.
 date: toma el valor de la fecha actual.
 clock: da un vector de 6 elementos que contiene como coordenadas el año, el mes, el
día, la hora, el minuto y los segundos.
CLOCK = [year month day hour minute seconds]
>> clock
ans =
1.0e+003 *
2.0120 0.0050 0.0240 0.0170 0.0570 0.0126.
 rand: genera de forma aleatoria un número entre 0 y 1.
3
La representación de coma flotante, es una forma de notación científica usada en los CPU,
GPU, FPU, etc, con la cual se pueden representar números reales extremadamente grandes y
pequeños de una manera muy eficiente y compacta, y con la que se pueden realizar
operaciones aritméticas.

>> rand
ans =
0.9501
>> rand
ans =
0.2311
 realmin: el menor número positivo utilizable.
 realmax: el mayor número positivo utilizable.
>> realmin
ans =
2.2251e-308
>> realmax
ans =
1.7977e+308
 flops: número de operaciones en punto flotante realizadas hasta el momento.
Por defecto, si solicitamos el valor de una variable sólo se nos informa de cinco cifras
significativas, correspondientes a la visualización en formato corto. Para cambiar este número
tecleamos el comando:
>> format long
Que nos ofrece 14 cifras significativas. Para volver al formato corte es preciso teclear:
>> format
o bien:
>> format short
Si deseamos que nos exprese en formato corto y en notación exponencial el valor de las
variables, debemos usar el comando:
>> format short e
De la misma forma,
>> format long e
Permite expresar en formato largo y en notación exponencial el valor de las variables. El

formato:
>> format rat
Nos da una aproximación racional, es decir en forma de fracción, del valor de las variables que
se soliciten a continuación.
Cuando se sale de MATLAB, se pierden todas las variables. Para evitarlo se puede utilizar la
instrucción save antes de salir. Esto hace que las variables se almacenen en el archivo de
disco matllab.mat. Al ingresar nuevamente a MATLAB se pueden recuperar todas las variables
con la instrucción load.
En resumen, en MATLAB podemos encontrar variables unidimensionales, vectoriales,

matriciales y las denominadas variables simbólicas. Son aquellas que nos permitirán trabajar
con el cálculo matemático simbólico, manipular con facilidad y rapidez las fórmulas y

expresiones algebraicas y realizar la mayoría de las operaciones con las mismas.
Sin embargo, para realizar estas tareas es necesario disponer del módulo MATLAB Symbolic
Math Toolbox. Para que una variable o expresión algebraica sea simbólica, previamente hay
que declararla como tal con el comando syms, con el comando sym o introduciéndola entre
comillas. Ejemplo:
>> syms x y
>> x+x-6*y
ans =
2*x-5*y
>> y=sym(‘x’)
2.1.4 FUNCIONES INTRÍNSICAS DE MATLAB
Una función tiene la forma:
nombre(argumento)
donde nombre identifica la función a utilizar y argumento el punto donde queremos evaluarla.
Existen numerosas funciones intrínsecas ya definidas en MATLAB, y es precisamente aquí
donde radica la gran potencia de este problema. En su nombre sólo intervienen letras
minúsculas. Enumeramos a continuación algunas de ellas:
 sqrt(x): calcula la raíz cuadrada de x. El argumento puede ser real o complejo.

 abs(x): calcula el módulo del número x, sea real o complejo.
 conj(z): calcula el conjugado del número comlejo z.
 real(x), imag(z): calcula la parte real e imaginaria del número complejo z.
 exp(x): calcula ex, siendo x un número real o complejo.
 sin(x): función seno de x
 asin(x): función arcoseno de x con valores de –π/2 a π/2.
 cos(x): función seno de x
 acos(x): función arcoseno de x con valores de –π/2 a π/2.
 tan(x): función tangentede x.
 atan(x): función arcotantgente de x con valores de –π/2 a π/2.
 angle(z): calcula el argumento del número complejo z.
 log(x): función logaritmo natural en base e del número x.
 log10(x): función logaritmo decimal del número x
 rats(x): aproxima el argumento por una fracción, es decir, por un número racional.
 rem(x,y): calcula el resto de dividir x por y.
 round(x): redondea el valor de x por el entero más próximo.
 sign(x): calcula el signo de x. Para una cantidad positiva el signo es 1, para una
negativa el signo es -1, y para el cero el signo es 0.
En todas las funciones intrínsecas, el argumento debe ir entre paréntesis y puede ser una
constante, una variable ya definida anteriormente o una expresión.
En las funciones trigonométricas el ángulo debe darse en radianes. Por tanto, si conocemos el
ángulo en grados debe convertirse previamente a radianes. MATLAB no proporciona función
alguna que transforme grados a radianes.

2.2 LÍMITES, SUCESIONES, DERIVADAS E INTEGRALES
MATLAB incorpora funciones que permiten trabajar con límites, sucesiones, derivadas o
integrales. Veremos unos ejemplos sencillos para trabajar estos conceptos matemáticos.
2.2.1 LÍMITES
MATLAB contiene funciones que permiten trabajar con límites y límites laterales de una manera
muy simple. Esto posibilita el análisis del estudio de la continuidad y derivabilidad de funciones,
así como analizar el carácter de las series numéricas y de las series de potencias. Algunos
ejemplos son:
 limit(función o sucesión, variable, valor, ‘left o right’): calcula el límite de la función o

sucesión de su primer argumento, indicada por su expresión analítica o su término
general, respectivamente cuando la variable tiende hacia el valor por la derecha o
izquierda.
>> syms x
>> limit(exp(1/x),x,0,'left')
ans =0
>> limit(exp(1/x),x,0,'right')
ans =Inf
>> syms n
>> limit((3+n)/(2+6*n),inf)
ans =1/6
2.2.2 SUCESIONES
MATLAB permite trabajar con series numéricas, tanto de términos positivos como alternados.
Algunos ejemplos son:
 symsum(S,v,a,b): suma la serie S para la variable v variando entre a y b.

>> syms x
>> syms k
>> symsum(x^k/sym('k!'),k,0,inf)
ans =exp(x)
 taylor(f,a): realiza el desarrollo de McLaurin de orden n para la función f siendo n un
número natural.
 taylor(f,n,v,a): realiza el desarrollo de Taylor de orden n-1 para la función f en la
variable v en un entorno del punto a.
>> syms x
f=exp(x^2);
>> pretty(taylor(f))

4 2
x/2 + x + 1
>> pretty(taylor(f,3,x,2))
exp(4) + 4 exp(4) (x - 2) + 9 exp(4) (x - 2)
La función pretty(s) imprime la expresión s en un formato que se asemeja al usado en

Matemáticas.
2.2.3 DERIVADAS
MATLAB permite trabajar con derivadas a través de un grupo de comandos que habilita
especialmente para esta tarea. Algunos ejemplos son:
 diff(f,x,n): halla la función derivada enésima de f respecto a x.

 R=jacobian(w,v): halla la matriz jacobiana de w respecto de v.
>> syms x
>> diff (sin(x^2),x,2)
ans =2*cos(x^2) - 4*x^2*sin(x^2)
>> syms x y z
>> jacobian([x*y*z; y; x+z],[x y z])
ans =
[ y*z, x*z, x*y]
[ 0, 1, 0]
[ 1, 0, 1]
2.2.4 INTEGRALES
MATLAB trata integrales de una o varias variables a través de un conjunto de funciones

intrínsecas específicas para ello. Algunos ejemplos son:
 int(f(x),x): calcula la integral indefinida ∫ 𝑓(𝑥)𝑑𝑥.

 int(int(f(x,y),x),y): calcula la integral doble ∬ 𝑓(𝑥, 𝑦)𝑑𝑥𝑑𝑦
𝑏
 int(f(x),x,a,b): calcula la integral definida ∫𝑎 𝑓(𝑥) 𝑑𝑥.
>> syms x y z
>> int(tan(x),x)
ans =-log(cos(x))
>> int(int(int(sin(x+y+z),x),y),z)
ans =cos(x + y + z)
>> int((cos(x))^2,x,-pi,pi)
ans =pi

Práctica:

3. ANÁLISIS DE VECTORES, MATRICES, POLINOMIOS Y SISTEMAS DE

ECUACIONES LINEALES. OTROS TIPOS DE DATOS.
Ya se ha comentado que MATLAB es fundamentalmente un programa para cálculo matricial.

Inicialmente se utilizará MATLAB como programa interactivo, en el que se irán definiendo los
vectores, las matrices, los polinomios, los sistemas de ecuaciones lineales y las expresiones
que los combinan. Además, uno de los aspectos más notables de MATLAB lo constituye la
forma en que permite manipular y operar con vectores y matrices.
3.1 VECTORES
El tratamiento que el paquete MATLAB hace de los vectores, también llamados arrays,
simplifica considerablemente la resolución de problemas básicos como pueden ser la
representación gráfica de funciones, el tratamiento estadístico de datos, etc.
Al igual que en cálculo elemental, distinguiremos entre vectores fila y vectores columna.
3.1.1 VECTORES FILA
En general, se introducen escribiendo entre corchetes cada una de sus componentes

separadas por un espacio o una coma; la diferencia con respecto a su escritura tradicional
estriba en que en vez de utilizar paréntesis para delimitar sus componentes debemos utilizar
corchetes. Por ejemplo:
>> v=[4 -6 5]
v=
4 -6 5
>> v=[4, -6, 5]
v=
4 -6 5
También se pueden introducir especificando el valor de cada componente en el orden que

desee:
>> w(2)=-6, w(1)=4, w(3)=5
w=
0 -6
w=
4 -6
w=
4 -6 5
Las componentes de un vector pueden ser constantes, variables o expresiones aritméticas y

serán identificadas por su índice: la variable w(2) representa la segunda componente de w. Los

índices serán secuencias de números naturales empezando por el 1.
También podremos acceder a un bloque de componentes a la vez, tecleando:
subvector_w=w(i:j)
que identifica todas las componentes de w comprendidas entre la i-ésima componente y la j-

ésima componente, guardándolas en la variable subvector w.
Otras órdenes para casos particulares:
 v=[a:h:b] Define un vector “fila” cuyo primer elemento es a y los demás elementos
aumentan de h en h sin superar b .
 v=[a:b] Define un vector “fila” cuyo primer elemento es a y los demás elementos
aumentan de 1 en 1 sin superar b .
 v=linspace(a,b,n) Define un vector “fila” de n componentes, cuyo primer elemento es a
y cuyo último elemento es b, con diferencia constante entre componentes consecutivas
k=(b-a)/(n-1).
 v=logspace(a,b,n) Genera un vector fila de n puntos logarítmicamente espaciados entre
10a y 10b. Si se omite el valor de n, se toma 50.
Por ejemplo,
>> u=linspace(-4,7,6)
u=
-4.0000 -1.8000 0.4000 2.6000 4.8000 7.0000
>> v=[-4:2:7], w=[-4:7]
v=
-4 -2 0 2 4 6
w=
-4 -3 -2 -1 0 1 2 3 4 5 6 7
>> v=-4:2:7, w=-4:7; % se puede escribir sin los corchetes
La longitud de un vector se obtiene utilizando el comando
>> length(nombre_vector)
La dimensión de un vector se obtiene utilizando el comando
>> size(nombre_vector)
3.1.1 VECTORES COLUMNA
En general, se introducen como los vectores “fila”, separando las filas por un punto y coma:
>> b=[0;1;-5]
b=

-5
v’ transpone el vector v (el transpuesto de un vector fila es un vector columna).
3.1.3 OPERACIONES ENTRE VECTOR Y ESCALAR
Las operaciones entre escalares y vectores son directas. Desde el punto de vista teórico, no se
puede sumar un escalar a un vector. Sin embargo, MATLAB si lo permite. Por ejemplo, si y es
un vector, el comando y+2 añadirá 2 a cada componente del vector.
Es decir, dado un vector v y un número real k:
 v+k: suma k a cada componente de v.

 v-k: resta k a cada componente de v.
 v*k o k*v: multiplica por k cada componente de v.
 v/k: divide por k cada componente de v.
 k./v: divide k por cada componente de v.
 v.^k es un nuevo vector donde cada componente se obtiene al elevar a k la
correspondiente de v.
 k.^v: es un vector cuya componente i-ésima se obtiene al elevar k a la i-ésima
componente de v.
El “.” Indica que trabajaremos con los vectores componente a componente, no en el sentido
usual del álgebra lineal.
Estúdiense las salidas de los siguientes comandos.
>> y=1:5
>> y+2
>> y-2
>> 2*y
>> y/2
Por supuesto, estas operaciones son igualmente válidas para vectores columna.
>> w=(1:3:20)’
>> w+3
>> w-11
>> .1*w
>> w/10

3.1.4 OPERACIONES ENTRE VECTORES
En primer lugar, considérense los siguientes vectores.
>> a=1:3
>> b=4:6
La adición y sustracción de vectores es natural y fácil. Introdúzcanse los siguientes comandos.
>> a,b,a+b
>> a,b,a-b
De nuevo, estas operaciones son válidas para vectores columna.
>> a=(1:3)’,b=(4:6)’
>> a+b,a-b
Producto escalar de vectores “*”: si v es un vector fila, w un vector columna y ambos tienen la
misma dimensión, entonces admiten el comando v*w que calcula el producto escalar de
ambos.
3.1.5 OPERACIONES CON COMPONENTES.
Para multiplicar los vectores a y b componente a componente, ejecútese el siguiente comando

de MATLAB.
>> a=(1:3)’,b=(4:6)’
>> a,b,a.*b
El símbolo .* es el operador de MATLAB para la multiplicación elemento a elemento. La salida

se calcula multiplicando las primeras componentes de los vectores a y b, a continuación, las
segundas componentes, etc. El operador de MATLAB para la división componente a
componente es ./
>> a,b,a./b
Para elevar cada componente de un vector a una potencia, úsese .^
>> a,a.^2
3.1.6 EXPRESIONES MÁS COMPLICADAS.
Con un poco de práctica se aprenderá como evaluar expresiones más complejas.

Supongamos, por ejemplo, para evaluar la expresión x2 − 2x − 3 para valores de x entre 1 y 10,
con incremento de 1 escríbase
>> x=1:10
>> y=x.^2-2*x-3
Supóngase ahora que se quiere evaluar la expresión sen(x)/x para valores de x entre −1 y 1

con incrementos de 0,1 unidades se haría:
>> x=-1:.1:1
>> y=sin(x)./x
Los operadores por componentes también funcionan con vectores columna.
>> xdata=(1:10)’
>> xdata.^2
3.1.7 FUNCIONES DE MATLAB ESPECÍFICAS PARA VECTORES

Las funciones matemáticas elementales admiten vectores como argumentos y se interpretan
componente a componente.
Algunas funciones específicas para vectores son:
 sum(v) suma de las componentes del vector v,

 prod(v) producto de las componentes del vector v,
 dot(v,w) producto escalar de dos vectores del mismo tipo y las mismas dimensiones,
 cross(v,w) producto vectorial de dos vectores del mismo tipo y dimensión,
 max(v) máximo de las componentes del vector v (atención: sin valor absoluto),
 norm(v) norma euclídea del vector v,
 norm(v,p) norma-p del vector v: sum(abs(v).^p)^(1/p),
 norm(v,inf) norma infinito del vector v.
Las funciones MATLAB pueden devolver un número variable de resultados. Cuando una
función tiene, en su definición, más de un argumento de salida, puede ser utilizada de varias
formas. La función max nos proporciona un ejemplo:
- si, simplemente, utilizamos la función en la forma:
>> max(v)
MATLAB nos devolverá el máximo valor de entre las componentes del vector v
- si la utilizamos en la forma:
>> [m,k]=max(v)
utilizando dos variables para almacenar la salida, en la variable m quedará almacenado el

máximo de las componentes, y en la variable k se guardará el valor del subíndice de la
componente que produce el máximo.
Hay otras funciones que también pueden tener un número variable de argumentos de entrada:
por ejemplo la función norm tiene distinto comportamiento según la llamemos con un solo
argumento (norm(v)) o con dos argumentos (norm(v,p)).
Si v es un vector fila (respectivamente columna) de componentes vi, entonces exp(v) es otro

vector fila (resp. columna) de componentes exp(vi).
>> v=[1,2,4,-5,0,-1];
>> sum(v)

ans =1
>> max(v)
ans =4
>> [m,k]=max(abs(v))
m =5
k =4
>> sqrt(sum(v.^2))
ans =6.8557
Práctica:
1. Dadas las variables vectoriales a=(π,2π,3π,4π,5π) y b=(e,2e,3e,4e,5e) calcular
c=sen a+b, d=cosh a, e=ln b, f=c*d, g=c/d, h=d2
Cálculo de errores relativos
2. Supongamos que para resolver una ecuación diferencial ordinaria hemos

utilizado:
 Un método analítico mediante el cual sabemos que su solución en el
intervalo [0,1] es y(x)=x2+cos(x).
 Un método numérico para aproximar la solución en el intervalo [0,1] con
parámetro de discretización 0.2, obteniendo la siguiente tabla de soluciones
aproximadas:
Calcular el máximo error relativo.

3.2 MATRICES
3.2.1 DEFINICIÓN DE MATRICES
Las matrices se definen de forma similar a los vectores, introduciendo sus filas como vectores
fila y separando unas filas de otras mediante punto y coma o saltos de línea.
>> A=[1,2,3 ; 4,5,6 ; 7,8,9]
A=
123
456
789
Las componentes de una matriz se designan mediante los números de sus subíndices.
Un vector fila de dimensión n es en realidad una matriz de dimensión 1xn.
Un vector columna de dimensión m es en realidad una matriz de dimensión mx1.
>> A=[1,2,3 ; 4,5,6 ; 7,8,9];
>> A(1,3)
ans =
>> A(1,:) % primera fila de A
ans =
123
>> A(:,2) % segunda columna de A
ans =
>> A(1:2;2:3) % submatriz de A
ans =
23
56

3.2.2 OPERACIONES CON MATRICES
 A+B suma de matrices

 A-B diferencia de matrices
 A*B producto de matrices (habitual)
 A^2 producto de la matriz A por si misma
 A\B A-1 B
 A/B A B-1
 A.*B producto componente a componente (aij bij)
 A.^2 cuadrado componente a componente (aij ^2)
 A./B división componente a componente (aij / bij)
 A’ transpuesta de A (la adjunta si A es compleja)
3.2.3 FUNCIONES ESPECÍFICAS PARA MATRICES
Las matrices pueden también utilizarse como argumento de las funciones intrínsecas. Algunas
funciones específicas para manejo de matrices son:
 diag(A) vector conteniendo la diagonal principal de la matriz A

 diag(A,k) k-ésima sub o super diagonal de A (según sea k>0, k=0, k<0)
 max(A) Vector conteniendo el valor máximo de las componentes de cada columna.
[y,k]=max(A) nos da, además, la fila en la que se produce el máximo de cada columna
 zeros(n,m) matriz nxm con todas sus componentes iguales a cero
 zeros(n) ídem nxn
 ones(n,m) matriz nxm con todas sus componentes iguales a uno
 ones(n) ídem nxn
 eye(n,m) matriz unidad: matriz nxm con diagonal principal =1 y el resto de las
componentes =0
 diag(v) (donde v es un vector) matriz con la diagonal principal = v y ceros en el resto
 diag(v,k) (donde v es un vector) ídem con la k-ésima diagonal=v y ceros en el resto
(Obsérvese la diferencia de comportamiento de la función diag, en función de que el

argumento de entrada sea una matriz o un vector). Por ejemplo:
>> diag([1,2,3,1])
ans =
1000
0200
0030
0001
>> eye(3,3)+diag([-1,-1],1)
ans =
1 -1 0
0 1 -1

001
También se pueden definir matrices por bloques:
 [A,B] es la matriz (A B)
 [A;B] es la matriz (A B) transpuesta (columna)
 [ ] representa la matriz “vacía” (0x0)
 A(:,3)=[] elimina la tercera columna de la matriz A
 A(1,:)=[] elimina la primera fila de A
Ejemplo
>> A=diag([1,2,3,4]); A(:,3)=[];
>> A
A=
100
020
000
004
>> A(1,:)=[]
A=
020
000
004
3.2.4 MATRICES DISPERSAS O HUECAS
Las matrices que tienen un gran número de elementos nulos se conocen como matrices
dispersas o huecas. MATLAB dispone de un sistema especial de almacenamiento y
manipulación de matrices huecas.
La función
>> sparse(i,j,c,m,n)
dónde:
 i , j son vectores de subíndices, de la misma longitud

 c es un vector de la misma longitud que los anteriores
 n , m son números naturales.
Esta función genera una matriz hueca de dimensión nxm, cuyos únicos elementos no nulos
son los de subíndices (i(k),j(k)), de valor c(k)
Por ejemplo:

>> fil=[1,1,2,3,4];
>> col=[1,3,2,4,1];
>> val=[1,2,-1,3,4];
>> C=sparse(fil,col,val,4,4)
C=
(1,1) 1
(1,3) 2
(2,2) -1
(3,4) 3
(4,1) 4
 full(A) Si A es una matriz en forma hueca, devuelve su forma estándar

 [i,j,c]=find(A) Si A es una matriz (en forma hueca o no), devuelve los vectores i, j y c
correspondientes a su almacenamiento sparse.
 sparse(A) Si A es una matriz en forma estándar, devuelve su forma esparse.
Las operaciones entre matrices pueden también realizarse entre matrices huecas.
Aquí C es la matriz del ejemplo anterior:
>> CS=full(C)
CS =
1020
0 -1 0 0
0003
4000
>> [i,j,c]=find(C)
i=
11234
j=
13241
c=
1 2 -1 3 4
>> sparse(CS)
ans=

(1,1) 1
(1,3) 2
(2,2) -1
(3,4) 3
(4,1) 4
Práctica:
Para un laboratorio se compran los materiales especificados en la tabla siguiente.
Utilizar matrices y el producto de vectores para calcular el coste de cada producto y el

total a pagar (la tabla de precios no incluye IVA, debiendo por tanto aplicarse un 21%
de incremento.
3.3 POLINOMIOS
Un polinomio de grado n se representa en MATLAB por un vector fila de dimensión n+1, cuya
componente i-ésima es el coeficiente de xn-i+1; es decir, el vector se forma con los coeficientes
del polinomio ordenados en orden decreciente de la potencia de la variable. Todos los
coeficientes intermedios que sean nulos deben incluirse. Es decir, en MATLAB los polinomios
se identifican con el vector fila de sus coeficientes:
p=[3,5,0,1,2] representa el polinomio 3x4+5x3+x+2
 roots(p) Calcula las raíces del polinomio p (es un vector columna y, en general, calcula
aproximaciones).
 poly(raices) Si raices es un vector columna, devuelve el polinomio que tiene dichas
raíces. Se obtiene normalizado y puede ser de coeficientes complejos.
 poly(A) Si A es una matriz cuadrada, es el polinomio característico.
 polyval(p,x) Calcula el valor del polinomio p en el punto x (x puede ser un vector.
 conv(p1,p2) Producto de los polinomios p1 y p2.
 deconv(p1,p2) División de polinomios.
 polyder(p) Derivada del polinomio p.
 polyfit(x,y,n) calcula los coeficientes de un polinomio p(x) de grado n que se ajusta a
los datos p(x(i)) ~= y(i), en el sentido de mínimo error cuadrático medio.

Ejemplo:
>> p=[3,5,0,1,2];polival(p,0)
ans =
>> raices=roots(p)
raices =
-1.6394
0.3716 + 0.6243 i
0.3716 - 0.6243 i
-0.7704
>> poly(CS) % CS es la del ejemplo de la página anterior
ans=
1 0 -1 -24 -24
>> polyder(p)
ans =
12 15 0 1
Práctica:
x3  x 2  1
Descomponer en fracciones simples el cociente
x 3  3x 2  4
x3  x 2  1 35 13 1
   1
x  3x  4 9( x  2) 3( x  2) 9( x  1)
3 2 2
3.4 SISTEMAS DE ECUACIONES LINEALES
Dado un sistema algebraico de ecuaciones lineales de la forma Ax=b, lo resolveremos

utilizando métodos clásicos, y también, funciones propias de MATLAB. De este modo
enumeramos a continuación algunas funciones de MATLAB cuyo argumento son matrices, que
simplifican considerablemente la resolución analítica de sistemas lineales y de ecuaciones
diferenciales ordinarias con coeficientes constantes:
 det(A) Calcula el determinante de la matriz A.

 inv(A) Calcula la inversa de la matriz cuadrada A.
 rank(A) Calcula el rango de la matriz A.

En particular, si deseamos saber si un sistema Ax=b es compatible podemos

comprobar si el rango de la matriz de coeficientes y el de la ampliada coinciden; para
ello ejecutamos las sentencias
>>rank(A)-rank([A,b])
 cond(A) Número de condición de la matriz A. Este número indica cuán sensible es la
solución de un problema respecto de pequeños cambios relativos en los datos de
entrada. Si el número de condición está próximo a la unidad, la matriz se dice bien
condicionada; en este caso pequeñas perturbaciones en los datos, o lo que es lo
mismo en el segundo miembro del sistema, sólo ocasionarán pequeñas modificaciones
en la solución. En cambio, si el número de condición es grande, entonces A es mal
condicionada y cualquier solución numérica del sistema Ax=b debe examinarse con
precaución.
 A\b Calcula la solución del sistema lineal Ax=b. Previamente a los cálculos, MATLAB
realiza un análisis de la matriz A para decidir cuál es el método más adecuado:
triangular, Cholesky, LU, QR, Gauss, etc., y además lleva a cabo un pre-ordenamiento
si A es hueca.
 eig(A) calcula los autovalores o valores propios de una matriz cuadrada A, cuyo
resultado se almacena en un vector columna.
 [V,D]=eig(A) almacena en cada columna de la matriz V los autovectores de la matriz A,
los autovalores se guardan en la matriz diagonal D.
Práctica:
6 18 2 
1. Se considera la matriz A=  7 
 2  4

 4 10  6 
 
2. Calcular el determinante de la matriz A. Resolver el sistema siendo b un vector

columna igual a (1 2 3).
3. Ver qué ocurre cuando se cambia el elemento a13 por -10.
3.5 OTROS TIPOS DE DATOS
MATLAB puede también trabajar con otros tipos de datos:
1. Conjuntos o cadenas de caracteres, fundamentales en cualquier lenguaje de

programación.
2. Hipermatrices, o matrices de más de dos dimensiones.
3. Estructuras, o agrupaciones bajo un mismo nombre de datos de naturaleza
diferente.
4. Vectores o matrices de celdas (cell arrays), que son vectores o matrices cuyos
elementos pueden ser cualquier otro tipo de dato.
3.5.1 CADENAS DE CARACTERES
Los caracteres de una cadena se almacenan en un vector, con un carácter por elemento. Cada
carácter ocupa dos bytes. Las cadenas de caracteres van entre apóstrofos o comillas simples,
como, por ejemplo: 'cadena'. Si la cadena debe contener comillas, éstas se representan por un

doble carácter comilla, de modo que se pueden distinguir fácilmente del principio y final de la
cadena. Por ejemplo, para escribir la cadena ‘ni idea' se escribiría “ni idea”.
Una matriz de caracteres es una matriz cuyos elementos son caracteres, o bien una matriz
cuyas filas son cadenas de caracteres. Todas las filas de una matriz de caracteres deben tener
el mismo número de elementos. Si es preciso, las cadenas (filas) más cortas se completan con
blancos.
A continuación, se pueden ver algunos ejemplos y practicar con ellos:
>> c='cadena'
c=
cadena
>> size(c) % dimensiones del array
ans =
1 6
>> double(c) % convierte en números ASCII cada carácter
ans =
99 97 100 101 110 97
>> char(abs(c)) % convierte números ASCII en caracteres
ans =
cadena
>> cc=char('más','madera') % convierte dos cadenas en una matriz
cc =
más
madera
>> size(cc) % se han añadido tres espacios a 'más'
ans =
2 6
Las funciones más importantes para manejo de cadenas de caracteres son las siguientes:
 double(c) convierte en números ASCII cada carácter,

 char(v) convierte un vector de números v en una cadena de caracteres,
 char(c1,c2) crea una matriz de caracteres, completando con blancos las cadenas más
cortas,
 deblank(c) elimina los blancos al final de una cadena de caracteres,
 disp(c) imprime el texto contenido en la variable c,
 ischar(c) detecta si una variable es una cadena de caracteres,

 isletter() detecta si un carácter es una letra del alfabeto. Si se le pasa un vector o matriz
 de caracteres devuelve un vector o matriz de unos y ceros,
 isspace() detecta si un carácter es un espacio en blanco. Si se le pasa un vector o
matriz de caracteres devuelve un vector o matriz de unos y ceros,
 strcmp(c1,c2) comparación de cadenas. Si las cadenas son iguales devuelve un uno, y
si no lo son, devuelve un cero,
 strcmpi(c1,c2) igual que strcmp(c1,c2), pero ignorando la diferencia entre mayúsculas y
minúsculas,
 strncmp(c1,c2,n) compara los n primeros caracteres de dos cadenas c1==c2 compara
dos cadenas carácter a carácter. Devuelve un vector o matriz de unos y ceros,
 s=[s,' y más'] concatena cadenas, añadiendo la segunda a continuación de la primera,
 findstr(c1,c2) devuelve un vector con las posiciones iniciales de todas las veces en que
la cadena más corta aparece en la más larga,
 strmatch(cc,c) devuelve los índices de todos los elementos de la matriz de caracteres
(o vector de celdas) cc, que empiezan por la cadena c,
 strrep(c1,c2,c3) sustituye la cadena c2 por c3, cada vez que c2 es encontrada en c1
 [p,r]=strtok(t) separa las palabras de una cadena de caracteres t. Devuelve la primera
palabra p y el resto de la cadena r,
 int2str(v) convierte un número entero en cadena de caracteres,
 num2str(x,n) convierte un número real x en su expresión por medio de una cadena de
caracteres, con cuatro cifras decimales por defecto (pueden especificarse más cifras,
con un argumento opcional n),
 str2double(str) convierte una cadena de caracteres representando un número real en el
número real correspondiente,
 vc=cellstr(cc) convierte una matriz de caracteres cc en un vector de celdas vc,
eliminando los blancos adicionales al final de cada cadena. La función char() realiza las
conversiones opuestas,
 sprintf convierte valores numéricos en cadenas de caracteres.
Con las funciones anteriores se dispone en MATLAB de una amplia gama de posibilidades
para trabajar con cadenas de caracteres.
A continuación se pueden ver algunos ejemplos:
>> num2str(pi) % el resultado es una cadena de caracteres, no un número
ans =3.142
>> num2str(pi,8)
ans =3.1415927
Es habitual convertir los valores numéricos en cadenas de caracteres para poder imprimirlos
como títulos en los dibujos o gráficos. Véase el siguiente ejemplo:
>> fahr=70; grd=(fahr-32)/1.8;
>> title(['Temperatura ambiente: ',num2str(grd),' grados centígrados'])

3.5.2 HIPERMATRICES
Son arrays de más de dos dimensiones, es decir con matrices de más de dos dimensiones (por
ejemplo, ver en la figura una hipermatriz de tres dimensiones).
Una posible aplicación es almacenar con un único nombre distintas matrices del mismo tamaño
(resulta una hipermatriz de 3 dimensiones). Los elementos de una hipermatriz pueden ser
números, caracteres, estructuras, y vectores o matrices de celdas. El tercer subíndice
representa la tercera dimensión: la “profundidad” de la hipermatriz.
3.5.2.1 DEFINICIÓN DE HIPERMATRICES
Las funciones para trabajar con estas hipermatrices están en el subdirectorio

toolbox\MATLAB\datatypes. Las funciones que operan con matrices de más de dos
dimensiones son análogas a las funciones vistas previamente, aunque con algunas diferencias.
Por ejemplo, las siguientes sentencias generan, en dos pasos, una matriz de 2×3×2:
>> AA(:,:,1)=[1 2 3; 4 5 6] % matriz inicial
AA =
123
456
>> AA(:,:,2)=[2 3 4; 5 6 7] % se añade una segunda matriz
AA(:,:,1) =
123
456
AA(:,:,2) =
234

567
3.5.2.2 FUNCIONES QUE TRABAJAN CON HIPERMATRICES
Algunas funciones de MATLAB para generar matrices admiten más de dos subíndices y
pueden ser utilizadas para generar hipermatrices. Entre ellas están rand(), randn(), zeros() y
ones(). Por ejemplo, véase la siguiente sentencia y su resultado:
>> BB=randn(2,3,2)
BB(:,:,1) =
-0.4326 0.1253 -1.1465
-1.6656 0.2877 1.1909
BB(:,:,2) =
1.1892 0.3273 -0.1867
-0.0376 0.1746 0.7258
La función cat() permite concatenar matrices según las distintas “dimensiones”, como puede
verse en el siguiente ejemplo:
>> A=zeros(2,3); B=ones(2,3);
A(i,j,k)
>> cat(1,A,B)
ans =
000
000
111
111
>> cat(2,A,B)
ans =
000111
000111
>> cat(3,A,B)

ans(:,:,1) =
000
000
ans(:,:,2) =
111
111
Las siguientes funciones de MATLAB se pueden emplear también con hipermatrices:
 size() devuelve tres o más valores (el nº de elementos en cada dimensión),

 ndims() devuelve el número de dimensiones,
 squeeze() elimina las dimensiones que son igual a uno,
 reshape() distribuye el mismo número de elementos en una matriz con distinta forma o
con distintas dimensiones,
 permute(A,v) permuta las dimensiones de A según los índices del vector v,
 ipermute(A,v) realiza la permutación inversa.
Respecto al resto de las funciones de MATLAB, se pueden establecer las siguientes reglas
para su aplicación a hipermatrices:
1. Todas las funciones de MATLAB que operan sobre escalares (sin(), cos(), etc.) se
aplican sobre hipermatrices elemento a elemento (igual que sobre vectores y matrices).
Las operaciones con escalares también se aplican de la misma manera.
2. Las funciones que operan sobre vectores (sum(), max(), etc.) se aplican a matrices e
hipermatrices según la primera dimensión, resultando un array de una dimensión
inferior.
3. Las funciones matriciales propias del Álgebra Lineal (det(), inv(), etc.) no se pueden
aplicar a hipermatrices. Para poderlas aplicar hay que extraer primero las matrices
correspondientes (por ejemplo, con el operador dos puntos (:)).
3.5.3 ESTRUCTURAS
Una estructura (struct) es una agrupación de datos de tipo diferente bajo un mismo nombre.
Estos datos se llaman miembros (members) o campos (fields). Una estructura es un nuevo tipo
de dato, del que luego se pueden crear muchas variables (objetos o instances). Por ejemplo, la
estructura alumno puede contener los campos nombre (una cadena de caracteres) y carnet (un
número).
3.5.3.1 CREACIÓN DE ESTRUCTURAS
En MATLAB la estructura alumno se crea creando un objeto de dicha estructura. A diferencia

de otros lenguajes de programación, no hace falta definir previamente el modelo o patrón de la
estructura.
Una posible forma de hacerlo es crear uno a uno los distintos campos, como en el ejemplo
siguiente:

>> alu.nombre='Miguel'
alu =
nombre: 'Miguel'
>> alu.carnet=75482
alu =
nombre: 'Miguel'
carnet: 75482
>> alu
alu =
nombre: 'Miguel'
carnet: 75482
Se accede a los miembros o campos de una estructura por medio del operador punto (.), que
une el nombre de la estructura y el nombre del campo (por ejemplo: alu.nombre).
También puede crearse la estructura por medio de la función struct(), como por ejemplo,
>> al = struct('nombre', 'Ignacio', 'carnet', 76589)
al =
nombre: 'Ignacio'
carnet: 76589
Los nombres de los campos se pasan a la función struct() entre apóstrofos ('), seguidos del
valor que se les quiere dar. Este valor puede ser la cadena vacía ('') o la matriz vacía ([]).
Pueden crearse vectores y matrices (e hipermatrices) de estructuras. Por ejemplo, la sentencia,

>> alum(10) = struct('nombre', 'Ignacio', 'carnet', 76589)
crea un vector de 10 elementos cada uno de los cuales es una estructura tipo alumno. Sólo el
elemento 10 del vector es inicializado con los argumentos de la función struct(); el resto de los
campos se inicializan con una cadena vacía o una matriz vacía4. Para dar valor a los campos
de los elementos restantes se puede utilizar un bucle for con sentencias del tipo:
>> alum(i).nombre='Noelia', alum(i).carnet=77524;
MATLAB permite añadir un nuevo campo a una estructura en cualquier momento. La siguiente
sentencia añade el campo edad a todos los elementos del vector alum, aunque sólo se da valor
al campo del elemento 5:
>> alum(5).edad=18;
Para ver el campo edad en los 10 elementos del vector puede teclearse el comando:
4
Esta forma de crear arrays de estructuras da error si la estructura ha sido previamente
declarada global.

>> alum.edad
3.5.3.2. FUNCIONES PARA OPERAR CON ESTRUCTURAS
Las estructuras de MATLAB disponen de funciones que facilitan su uso. Algunas de estas
funciones son las siguientes:
 fieldnames() devuelve un vector de celdas con cadenas de caracteres que recogen los
nombres de los campos de una estructura,
 isfield(ST,s) permite saber si la cadena s es un campo de una estructura ST,
 isstruct(ST) permite saber si ST es o no una estructura,
 rmfield(ST,s) elimina el campo s de la estructura ST,
 getfield(ST,s) devuelve el valor del campo especificado. Si la estructura es un array hay
que pasarle los índices como cell array (entre llaves {}) como segundo argumento,
 setfield(ST,s,v) da el valor v al campo s de la estructura ST. Si la estructura es un
array, hay que pasarle los índices como cell array (entre llaves {}) como segundo
argumento.
MATLAB permite definir estructuras anidadas, es decir una estructura con campos que sean
otras estructuras. Para acceder a los campos de la estructura más interna se utiliza dos veces
el operado punto (.), como puede verse en el siguiente ejemplo, en el que la estructura clase
contiene un campo que es un vector alum de alumnos:
>> clase=struct('curso','primero','grupo','A', ...
'alum', struct('nombre','Juan', 'edad', 19))
clase =
curso: 'primero'
grupo: 'A'
alum: [1x1 struct]
>> clase.alum(2).nombre='María';
>> clase.alum(2).edad=17;
>> clase.alum(2)
ans =
nombre: 'María'
edad: 17
>> clase.alum(1)
ans =
nombre: 'Juan'
edad: 19

Las estructuras se generalizan con las clases y los objetos, que no se verán en este manual.
3.5.4. VECTORES O MATRICES DE CELDAS (CELL ARRAYS)
Un vector (matriz o hipermatriz) de celdas es un vector (matriz o hipermatriz) cuyos elementos

son cada uno de ellos una variable de tipo cualquiera. En un array ordinario todos sus
elementos son números o cadenas de caracteres. Sin embargo, en un array de celdas, el
primer elemento puede ser un número; el segundo una matriz; el tercero una cadena de
caracteres; el cuarto una estructura, etc.
3.5.4.1 CREACIÓN DE VECTORES Y MATRICES DE CELDAS
Obsérvese por ejemplo cómo se crea, utilizando llaves {}, el siguiente vector de celdas,
>> vc(1)={[1 2 3]}
vc =
[1x3 double]
>> vc(2)={'mi nombre'}
vc =
[1x3 double] 'mi nombre'
>> vc(3)={rand(3,3)}
vc =
[1x3 double] 'mi nombre' [3x3 double]
Es importante que el nombre del vector de celdas vc no haya sido utilizado previamente para
otra variable (si así fuera, se obtendría un error). Si es preciso se utiliza el comando clear.
Obsérvese que para crear un vector de celdas los valores asignados a cada elemento se han
definido entre llaves {...}.
Otra nomenclatura alternativa y similar, que también utiliza llaves, es la que se muestra a
continuación:
>> vb{1}=[1 2 3]
vb =
[1x3 double]
>> vb{2}='mi nombre'
vb =
[1x3 double] 'mi nombre'
>> vb{3}=rand(3,3)
vb =

y también es posible crear el vector de celdas en una sola operación en la forma:
vcc = {[1 2 3], 'mi nombre', rand(3,3)}
3.5.4.2 FUNCIONES PARA TRABAJAR CON VECTORES Y MATRICES DE

CELDAS
MATLAB dispone de las siguientes funciones para trabajar con cell arrays:
 cell(m,n) crea un cell array vacío de m filas y n columnas,

 celldisp(ca) muestra el contenido de todas las celdas de ca,
 cellplot(ca) muestra una representación gráfica de las distintas celdas,
 iscell(ca) indica si ca es un vector de celdas,
 num2cell() convierte un array numérico en un cell array,
 cell2struct() convierte un cell array en una estructura,
 struct2cell() convierte una estructura en un cell array.
3.5.4.3 CONVERSIÓN ENTRE ESTRUCTURAS Y VECTORES DE CELDAS
El siguiente ejemplo convierte el cell array vcc creado previamente en una estructura ST cuyos
campos se pasan como argumentos a la función cell2struct(). El tercer argumento (un 2) indica
que es la segunda dimensión del cell array (las columnas) la que va a dar origen a los campos
de la estructura.
Con posterioridad la estructura ST se convierte en un nuevo cell array llamado vbb,
>> ST=cell2struct(vb,{'vector','cadena','matriz'},2)
ST =
vector: [1 2 3]
cadena: 'mi nombre'
matriz: [3x3 double]
>> vbb = struct2cell(ST)' % hay que transponer para obtener una fila
vbb =
La gran ventaja de las estructuras y los arrays de celdas es que proporcionan una gran
flexibilidad para el almacenamiento de los más diversos tipos de información. El inconveniente
es que se pierde parte de la eficiencia que MATLAB tiene trabajando con vectores y matrices.

4. GRÁFICOS CON MATLAB
4.1 REPRESENTACIÓN GRÁFICA DE FUNCIONES DEFINIDAS POR UNA

FÓRMULA
Los comandos que se presentan en este apartado son funciones MATLAB “fáciles de usar”
(easy-touse) para representar gráficamente, de forma rápida, funciones definidas por una
expresión matemática. Tienen sólo un pequeño número de parámetros que se pueden
especificar. Todas ellas hacen uso de otras funciones MATLAB que disponen de un número
superior de opciones y parámetros que podemos modificar. Cuando se necesite hacer gráficas
de funciones que no vienen definidas por una fórmula (definidas a trozos, definidas a través de
programas o por sus valores en un número finito de puntos, …) habrá que recurrir a dichas
funciones más generales.
4.1.1 CURVAS PLANAS
El comando más fácil de usar de que dispone MATLAB para dibujar curvas planas definidas
por una fórmula matemática (no por un conjunto de valores) es el comando ezplot, que puede
ser usado de varias formas.
 ezplot(f) donde f es una cadena de caracteres

conteniendo la expresión de una función y=f(x) dibuja
la función y=f(x) para x en el intervalo [-2π,2π]
Ejemplo:
>> ezplot('2*sin(x/2)*cos(3*x)')
También puede utilizarse el comando fplot(‘funcion’,

[xo,x1], ’opción’), que representa la función dada en el
intervalo [xo,x1], con la opción elegida. Además
también actúa sobre una función f definida en un fichero m-fichero. Si queremos
representar la función definida en sol.m, escribimos:
>>f=’sol’;
>>fplot(f,[0 2*pi], ‘--’)
Y se obtiene la gráfica de la función definida en sol.m en el intervalo [0,2π], con trazo

discontinuo.
Podemos construir un único polígono dando los vértices y usando el comando

fill(x,y.’opción’), que lo colorea según se
especifique en opción. Construir varios polígonos:
fill(x1,y1.’opción1’, x2,y2.’opción2’, …),
 ezplot(f,[a,b]) lo mismo que la anterior para x

variando en el intervalo [a,b]
Ejemplo:
>> ezplot('2*sin(x/2)*cos(3*x)',[0,pi/2])

 ezplot(f), ezplot(f,[a,b]) si f es una expresión de

(x,y), dibuja la curva implícitamente definida por
f(x,y)=0, para x e y variando en el intervalo [-
2π,2π] en el primer caso y para x e y variando en
el intervalo [a,b] en el segundo caso.
Ejemplo:
>> ezplot('x^2*y-1')
 ezplot(x,y), ezplot(x,y,[a,b]) donde x e y son dos

cadenas de caracteres conteniendo las
expresiones de dos funciones x(t) e y(t) dibuja la
curva de ecuaciones paramétricas x=x(t) y=y(t)
para t en el intervalo [0,2π], en el primer caso y
para t en el intervalo [a,b] en el segundo
Ejemplo:
>> ezplot('sin(3*t)','cos(t)')
 ezpolar(f), ezpolar(f,[a,b]) donde f es una cadena

de caracteres conteniendo la expresión de una
función f(θ) dibuja la curva definida en
coordenadas polares por ρ= f(θ) para θ variando
en el intervalo [0,2π], en el primer caso y en el
intervalo [a,b] en el segundo
Ejemplo:
>> ezpolar('sin(2*t)*cos(3*t)',[0,pi])
Práctica:
Representar las funciones:
y1= sin(3 π x)/ex
y2=cos(3π x)/ex
con x variando entre 0 y 3

π,obteniendo una única figura con
la forma que muestra la imagen:

4.1.2 CURVAS EN EL ESPACIO
Para dibujar curvas en el espacio tridimensional, MATLAB dispone del comando ezplot3:
ezplot3(x,y,z), ezplot3(x,y,z,[a,b]) donde x , y , z son tres cadenas de caracteres conteniendo
las expresiones de tres funciones x(t) , y(t) , z(t) dibuja la curva de ecuaciones paramétricas
x=x(t) y=y(t) z=z(t) para t en el intervalo [0,2π], en el
primer caso y para t en el intervalo [a,b] en el segundo
caso.
Ejemplo:
>> ezplot3('3*cos(t)','t*sin(t^2)','sqrt(t)')
4.1.3 SUPERFICIES
 ezmesh(f), ezmesh(f,[a,b]), ezmesh(f,[a,b,c,d]) donde f

es una expresión de dos variables dibuja la superficie
z=f(x,y) para (x,y) variando en el cuadrado [-π,π]x[-π,π]
en el primer caso, en el cuadrado [a,b]x[a,b] en el
segundo, y en el rectángulo [a,b]x[c,d] en el tercer caso.
El método de dibujo es una malla con segmentos
coloreados, en función de los valores en los extremos.
Ejemplo:
>> ezmesh('x*exp(-x^2 - y^2)')
 ezmesh(x,y,z), ezmesh(x,y,z,[a,b]),
ezmesh(x,y,z,[a,b,c,d]) donde x, y, z son expresiones de
funciones de dos variables dibuja la superficie de
coordenadas paramétricas x=x(s,t) y=y(s,t) z=z(s,t)
para (s,t) variando en el cuadrado [-2π,2π]x[-2π,2π] en
el primer caso, en el cuadrado [a,b]x[a,b] en el
segundo, y en el rectángulo [a,b]x[c,d] en el tercer caso
Ejemplo:
>> ezmesh('s*cos(t)','s*sin(t)','t',[- pi,pi])
 ezmesh(... , ‘circ’) en cualquiera de los usos anteriores,

dibuja la función correspondiente sobre un círculo
centrado en el origen.
Ejemplo:
>> ezmesh('x*exp(-x^2 - y^2)','circ')
 ezcontour(f), ezcontour(f,[a,b]), ezcontour(f,[a,b,c,d])

dibuja las líneas de nivel (isovalores) de la función

z=f(x,y).
Ejemplo:
>> ezcontour('x*exp(-x^2 - y^2)')
 ezcontourf(. . . ) hace lo mismo que ezcontour, pero

rellenando con un color sólido las distintas zonas
determinadas por las líneas de nivel.
Ejemplo:
>> ezcontourf('x*exp(-x^2 - y^2)')
 ezmeshc(f) con los mismos argumentos que ezmesh,

dibuja simultáneamente las líneas de nivel y la superficie.
Ejemplo:
>> ezmeshc('sin(u/2)*sin(v/2)')
 ezsurf(f) dibuja una superficie coloreada z=f(x,y). Sus

argumentos son como en ezmesh.
Ejemplo:
>> ezsurf('sin(sqrt(x^2+y^2))/sqrt(x^2+y^2)')

 ezsurfc(f) como la anterior pero, además, dibuja las

líneas de nivel.
Ejemplo:
>>ezsurfc('sin(sqrt(x^2+y^2))/sqrt(x^2+y^2)')
4.2 VENTANA GRÁFICA DE MATLAB
4.3 ALGUNOS COMANDOS GRÁFICOS AUXILIARES
Vamos a ver algunos comandos que modifican el aspecto de un gráfico. Veremos su efecto
sobre la gráfica. No se exponen todas las posibilidades de estos comandos. Utilizando el help
de MATLAB, se pueden ver el resto de las opciones.
Dado el gráfico siguiente, veremos cómo varía según las diferentes opciones que añadamos:

 grid on / grid off añade / elimina las cuadrículas sobre los ejes actuales.
 xlabel(‘texto para el eje x’)

 ylabel(‘texto para el eje y’)
 zlabel(‘texto para el eje z’)
 title(‘Título de la gráfica’)
 axis on / axis off: activa / desactiva todos los etiquetados de los ejes.
 axis([x1,x2,y1,y2,z1,z2]) determina los límites de la gráfica. En gráficos bidimensionales

no se incluyen z1, z2.
 axis auto impone los límites establecidos por defecto por MATLAB ([-10,10,-10,10,-
0.5,1])
Ejemplo:
axis([-10,10,-10,10,0,4])

 axis equal determina los mismos factores de escala para todos los ejes
 view(r,e) en las gráficas tridimensionales permite cambiar el punto de observación del

objeto representado. Los valores por defecto son r=-37.5, e=30.
>> view(10,50)
 shading determina la forma de utilizar los colores de las superficies coloreadas.

 shading flat la función color es constante a trozos (en cada segmento o panel).
 shading interp la función color es bilineal a trozos (en cada segmento o panel).
 shading faceted (es la opción por defecto) la función color es constante a trozos (como
en flat), pero además se superpone el dibujo de la malla con los segmentos en negro.
 hold on

...
hold off
Todas las órdenes de dibujo entre ambos comandos se ejecutan sobre la misma
ventana gráfica, sin borrar lo anterior.
 figure
figure(h)
Crea una nueva ventana gráfica, la activa y la trae al frente, delante de todas las
ventanas abiertas.
En el primer caso le asigna un número de forma automática.
En el segundo caso le asigna el número h, es decir, el nombre “Figure No. h”
 gcf Devuelve el número de la ventana gráfica activa en ese momento.

 shg Trae la ventana gráfica activa al frente de todas.
 clf Borra la figura de la ventana gráfica activa. No cierra la ventana; sólo borra su
contenido.
 close
close(h)
Cierra la ventana gráfica activa, en el primer caso, o la de número h, en el segundo.
 subplot(m,n,p) Este comando permite dividir la ventana gráfica en una matriz mxn de
subventanas gráficas, activando para dibujar la p-ésima de ellas. Ver ejemplo siguiente:
>> subplot(2,2,1); ezcontour('x*exp(-x^2 - y^2)');
>> subplot(2,2,2); ezmeshc('sin(u/2)*sin(v/2)');
>> subplot(2,2,3); ezmesh('x*exp(-x^2 - y^2)');

>> subplot(2,2,4); ezplot('sin(3*x)');
4.4 LOS COMANDOS BÁSICOS DE DIBUJO 2D Y 3D
Vemos aquí los comandos más completos de que dispone MATLAB para dibujar curvas planas
y en el espacio, superficies, líneas de nivel, etc.
plot(x,y) Si x e y son dos vectores de la misma dimensión, n, dibuja una curva (lineal a trozos)
que pasa por los puntos (xi , yi), i=1,… n. Es decir, reproduce la gráfica de las componentes de
un vector frente a las componentes de otro vector, y para ello ambos vectores deben tener la
misma dimensión.
Ejemplo:
>> x=0:pi/100:4*pi; y=sin(x).*cos(x/3);
>> plot(x,y)
plot(x1,y1,x2,y2) Dibuja las dos curvas (x1i , y1i), i=1,… n1 y (x2i , y2i), i=1,… n2 en la misma
ventana y en los mismos ejes.
Ejemplo:
>> x=0:pi/100:4*pi;
>> y=sin(x).*cos(x/3); z=sin(x).*cos(x/2);
>> plot(x,y,x,z)
plot(x,A) donde x es un vector columna (resp. fila) y A es una matriz, dibuja tantas curvas (xi ,
Aij), i=1,… n (como columnas (resp. filas) tenga la matriz A.
Ejemplo:
>> x=0:pi/100:4*pi;
>> A=[sin(x);sin(x/2);sin(x/3);sin(x/4)];

>> plot(x,A)
El comando plot asigna, por defecto, determinados colores a las gráficas. Estos colores, así
como el tipo de línea a utilizar para dibujar (continua, de puntos, con marcadores, etc.) se
pueden modificar.
plot(x,y,param) donde param es una cadena de caracteres como máximo, cada uno a elegir de
una de las columnas siguientes:
 b amarillo. asteriscos - línea sólida,
 b azul. puntos - línea sólida,
 g verde o círculo : linea de puntos,
 r rojo x aspas -. punto-guión,
 c cyan + cruces – guiones,
 m magenta * asteriscos,
 y amarillos s square,
 k negro d diamantes,
 v triángulo,s
 etc. (para más información se puede consultar help plot).
Ejemplo:
>> x=0:pi/100:4*pi; y=sin(x).*cos(x/3);
>> plot(x,y,’r*’)
plot3(x,y,z), plot3(x,y,z,param). Si x , y , z son tres vectores de la misma dimensión, n, dibuja

una curva tridimensional (lineal a trozos) que pasa por los puntos (xi , yi , zi), i=1,… n.
Ejemplo:
>> alpha=0:pi/80:8*pi; z=alpha/8;
>> x=z/(8*pi)+z.*cos(alpha);
>> y=z/(8*pi)+z.*sin(alpha);

>> plot3(x,y,z)
meshgrid(xp,yp), mesh(x,y,z), meshc(x,y,z) Representa una superficie z=f(x,y) sobre una malla
rectangular. Los argumentos x , y , z son matrices de la misma dimensión conteniendo,
respectivamente, las coordenadas x , y , z de los nodos de la malla. Los segmentos de la malla
se colorean según los valores de la función (coordenada z).
La función meshc hace lo mismo, pero dibujando además las líneas de nivel en el plano XY.
La funcion meshgrid sirve para construir la malla de base, en el plano XY.
Si xp es una partición del intervalo [x0,x1] e yp es una partición del intervalo [y0,y1], entonces
>> [x,y]=meshgrid(xp,yp)
construye dos matrices, x e y, que definen una malla del rectángulo [x0,x1]x[y0,y1]. . La matriz
x contiene las coordenadas X de los puntos de la malla y la matriz y sus coordenadas Y.
Ejemplo:
>> xp=linspace(pi/4,2*pi,50);
>> [x,y]=meshgrid(xp,xp);
>> z=(cos(x)./x).*(sin(y)./sqrt(y));
>> mesh(x,y,z)
surf(x,y,z) / surfc(x,y,z) / surfl(x,y,z) La función surf hace lo mismo que mesh, pero dibujando
los segmentos de la malla en color negro y rellenando los “rectángulos” de la malla de color,
según los valores de la función.
La función surfc hace lo mismo, pero dibujando además las líneas de nivel en el plano XY.
La funcion surfl hace lo mismo que surf, pero además añade una fuente de luz lateral

contour(x,y,z,n)
contour3(x,y,z,n)
La función contour dibuja las proyecciones sobre el plano XY de las líneas de nivel
(isovalores)
La función contour3 dibuja las líneas de nivel sobre la misma superficie. En ambos casos n es
el número de líneas a dibujar. Se puede usar la función colorbar para añadir a la gráfica una
barra con la graduación de colores y la correspondencia con los valores de la función
representada. (Esta función puede ser usada con cualquier otra función gráfica que utilice
colores).
colormap(m) permite cambiar el mapa de colores que se utiliza en la representación. En

general, m es una matriz con tres columnas, de modo que la i-ésima fila determina las
proporciones en la escala RGB, del i-ésimo color utilizado.
Para más comodidad, MATLAB dispone de una serie de mapas de colores predefinidos, que se
pueden imponer mediante colormap(mapa), mapa puede tomar uno de los valores siguientes:
 hsv - la escala por defecto (hue-saturation-value).
 cool - Gama de colores entre cyan y magenta.
 hot - Gama de colores entre rojo oscuro y amarillo.
 gray - Gama de colores grises.
 copper - Gama de colores cobrizos.
 pink - Gama de colores rosados.
 flag - Alterna rojo – blanco – azul - negro.
 colorcube - Contraste de colores.
 autumn - Colores entre el rojo y el amarillo.
 spring - Colores entre el magenta y el amarillo.
 winter - Colores entre el azul y el verde.
 summer - Colores entre el verde y el amarillo.
 ...
para obtener más información consultar help graph3d.

Práctica:
Ejecuta estos comandos y observa sus figuras.

5. INTRODUCCIÓN A LA PROGRAMACIÓN EN MATLAB.
Los programas o funciones de MATLAB se guardan en ficheros de nombre ****.m. Por esto nos
referimos a ellos como m-ficheros o ficheros-m. Son ficheros ASCII (de texto) que contienen
secuencias de comandos de MATLAB.
Para crear y modificar estos ficheros, la versión para Windows de MATLAB dispone de su
propio EDITOR (aunque puede usarse cualquier otro editor ASCII).
Existen dos tipos de ficheros ****.m :
 los ficheros de comandos o scripts son ficheros que contienen un conjunto de

comandos que se ejecutan sucesivamente cuando se teclea el nombre del fichero en la
línea de comandos.
 las funciones. Son ficheros con una estructura especial, que definen funciones
análogas a las de MATLAB. Con carácter general, una función recibe unos DATOS DE
ENTRADA, ejecuta unas ÓRDENES y produce unos DATOS DE SALIDA.
La primera línea de un fichero nombre.m que define una función debe tener la forma
function [variables de salida]=nombre(argumentos de entrada)
Los argumentos de entrada y las variables de salida, cuando hay varios, se separan por
comas. Puede no haber unos y otros. Si no hay argumentos de entrada, no es necesario poner
los paréntesis. Si no hay variables de salida, no es necesario poner los corchetes ni el signo =
Si sólo hay una variable de salida, no es necesario poner los corchetes.
5.1 SINTAXIS GENERAL
Las líneas que comienzan por el carácter % son líneas de comentario, es decir, son ignoradas
al ejecutar la función o script.
Las primeras líneas de comentario de un fichero ****.m pueden utilizarse para construir un help
del programa.
Si una expresión es demasiado larga, se puede continuar en la línea siguiente, indicándolo por
“tres puntos”: ...
En los scripts y funciones conviene terminar cada línea por “punto y coma”, ya que sino
aparecerá un exceso de información en el terminal.
5.2 EJECUCIÓN DE LAS FUNCIONES Y SCRIPTS
Las funciones y los scripts pueden ser “llamados” desde la línea de comandos y desde otro
fichero *.m.
Para ejecutar un script llamado program.m basta con teclear su nombre program (sin el punto
ni la m), siempre y cuando su localización forme parte del search path. La ejecución del
programa termina cuando se llega a su última sentencia ejecutable. En cualquier punto del

programa se puede forzar el fin de la ejecución mediante la instrucción return.
El número de argumentos de salida de una función no tiene que ser fijo. Puede depender de
cómo se “llame” a la función
Una función llamada funcionita.m se llama como el resto de funciones MATLAB: por su
nombre (sin el punto ni la m) y proporcionando los datos de entrada necesarios, a través de
variables o de constantes.
Observación: en un fichero *.m que contenga una función pueden incluirse subfunciones.
Son funciones con nombre diferente del nombre del fichero (y por tanto de la función principal),
y que sólo son “visibles” para las funciones del mismo fichero.
Se comenzará viendo las bifurcaciones y bucles, y la lectura y escritura interactiva de variables,

que son los elementos básicos de cualquier programa de una cierta complejidad.
5.3 BIFURCACIONES Y BUCLES
MATLAB posee un lenguaje de programación que –como cualquier otro lenguaje– dispone de
sentencias para realizar bifurcaciones o estructuras de control condicionadas y bucles.
Las bifurcaciones o estructuras de control condicionadas permiten realizar una u otra

operación según se cumpla o no una determinada condición. Es decir, permiten controlar
mediante una condición si una parte de un programa se ejecuta o no.
Una condición es una expresión que puede incluir operaciones aritméticas, relacionales y
lógicas, y cuyo resultado es un verdadero o falso lógico. Un ejemplo sencillo sería 2*a+1>0.
Para su evaluación, se calcula el valor de 2*a+1; si es estrictamente positivo la condición es

verdadera, en caso contrario la condición es falsa. El estudio detallado de los operadores
relacionales y lógicos que pueden intervenir en la definición de una condición será objeto del
siguiente apartado. La Figura 26 muestra tres posibles formas de bifurcación.
Figura 26

Los bucles permiten repetir las mismas o análogas operaciones sobre datos distintos. En
MATLAB el cuerpo de estas sentencias de determina mediante la palabra end.
Figura 27
La Figura 27 muestra dos posibles formas de bucle, con el control situado al principio o al final
del mismo. Si el control está situado al comienzo del bucle es posible que las sentencias no se
ejecuten ninguna vez, por no haberse cumplido la condición cuando se llega al bucle por
primera vez. Sin embargo, si la condición está al final del bucle las sentencias se ejecutarán
por lo menos una vez, aunque la condición no se cumpla. Muchos lenguajes de programación
disponen de bucles con control al principio (for y while en C/C++/Java) y al final (do … while
en C/C++/Java). En MATLAB no hay bucles con control al final del bucle, es decir, no existe
construcción análoga a do ... while.
Las bifurcaciones y bucles no sólo son útiles en la preparación de programas o de ficheros *.m.
También se aplican con frecuencia en el uso interactivo de MATLAB.
5.3.1 SENTENCIA IF
En su forma más simple, la sentencia if se escribe en la forma siguiente:
if condicion
sentencias
end
Si la condición es:
 verdadera se ejecutan los comandos entre if y end.
 falsa se pasa el control de la ejecución a la sentencia siguiente a la end.
Existe también la bifurcación múltiple, en la que pueden concatenarse tantas condiciones como
se desee, y que tiene la forma:
if condicion1
bloque1
elseif condicion2
bloque2
elseif condicion3
bloque3
else % opción por defecto para cuando no se cumplan las condiciones 1,2,3
bloque4
end
donde la opción por defecto else puede ser omitida: si no está presente no se hace nada en
caso de que no se cumpla ninguna de las condiciones que se han chequeado.
Una observación muy importante: la condición del if puede ser una condición matricial, del tipo
A==B, donde A y B son matrices del mismo tamaño. Para que se considere que la condición
se cumple, es necesario que sean iguales dos a dos todos los elementos de las matrices A y B
(aij=bij, 1≤i≤m, 1≤j≤n). Basta que haya dos elementos aij y bij diferentes para que las matrices ya

no sean iguales, y por tanto las sentencias del if no se ejecuten. Análogamente, una condición
en la forma A∼=B exige que todos los elementos sean diferentes dos a dos (aij≠bij, 1≤i≤m,
1≤j≤n). Bastaría que hubiera dos elementos aij y bij iguales para que la condición no se
cumpliese. En resumen:
 if A==B exige que todos los elementos sean iguales dos a dos
 if A∼=B exige que todos los elementos sean diferentes dos a dos
Como se ha dicho, MATLAB dispone de funciones especiales para ayudar en el chequeo de
condiciones matriciales. Por ejemplo, la función isequal(A, B) devuelve un uno si las dos
matrices son idénticas y un cero en caso de que difieran en algo.
5.3.2 SENTENCIA SWITCH

La sentencia switch realiza una función análoga a un conjunto de if...elseif concatenados.
Permite realizar bifurcaciones en un programa atendiendo al resultado de una expresión. Su
forma general es la siguiente:
switch switch_expresion
case case_expr1,
bloque1
case {case_expr2, case_expr3, case_expr4,...}
bloque2
...
otherwise, % opción por defecto
bloque3
end
Al principio se evalúa la switch_expresion, cuyo resultado debe ser un número escalar o una
cadena de caracteres. Este resultado se compara con las case_expr, y se ejecuta el bloque de
sentencias que corresponda con ese resultado. Si ninguno es igual a switch_expresion se
ejecutan las sentencias correspondientes a otherwise. Según puede verse en el ejemplo
anterior, es posible agrupar varias condiciones dentro de unas llaves (constituyendo lo que se
llama un cell array o vector de celdas); basta la igualdad con cualquier elemento del cell array
para que se ejecute ese bloque de sentencias. La “igualdad” debe entenderse en el sentido del
operador de igualdad (==) para escalares y la función strcmp() para cadenas de caracteres).
5.3.3 SENTENCIA FOR

La sentencia for repite un conjunto de sentencias un número predeterminado de veces. La
estructura más simple de los bucles tiene la siguiente estructura y la siguiente construcción
ejecuta sentencias con valores de i de 1 a n, variando de uno en uno:
for i=1:n
sentencias
end
o bien,
for i=vectorValores
sentencias
end
donde vectorValores es un vector con los distintos valores que tomará la variable i.
En el siguiente ejemplo se presenta el caso más general para la variable del bucle
(valor_inicial: incremento: valor_final); el bucle se ejecuta por primera vez con i=n, y luego i se
va reduciendo de 0.2 en 0.2 hasta que llega a ser menor que 1, en cuyo caso el bucle se
termina:
for i=n:-0.2:1
sentencias
end
En el siguiente ejemplo se presenta una estructura correspondiente a dos bucles anidados. La
variable j es la que varía más rápidamente (por cada valor de i, j toma todos sus posibles
valores):
for i=1:m
for j=1:n
sentencias
end

end
Una última forma de interés del bucle for es la siguiente (A es una matriz):
for i=A
sentencias
end
La variable i es un vector que va tomando en cada iteración el valor de una de las columnas de
A. Cuando se introducen interactivamente en la línea de comandos, los bucles for se ejecutan
sólo después de introducir la sentencia end que los completa.
5.3.4 SENTENCIA WHILE

La estructura del bucle while es la siguiente:
while condicion
sentencias
end
donde condicion puede ser una expresión vectorial o matricial. Las sentencias se siguen
ejecutando mientras haya elementos distintos de cero en condicion, es decir, mientras haya
algún o algunos elementos true. El bucle se termina cuando todos los elementos de condicion
son false (es decir, cero).
5.3.5 SENTENCIA BREAK

La sentencia break hace que se termine la ejecución del bucle for y/o while más interno de los
que comprenden a dicha sentencia.
5.3.6 SENTENCIA CONTINUE

La sentencia continue hace que se pase inmediatamente a la siguiente iteración del bucle for
o while, saltando todas las sentencias que hay entre el continue y el fin del bucle en la
iteración actual.
5.3.7 SENTENCIAS TRY...CATCH...END

La construcción try...catch...end permite gestionar los errores que se pueden producir en
tiempo de ejecución. Su forma es la siguiente:
try
sentencias1
catch
sentencias2
end
En el caso de que durante la ejecución del bloque sentencias1 se produzca un error, el control
de la ejecución se transfiere al bloque sentencias2. Si la ejecución transcurriera normalmente,
sentencias2 no se ejecutaría nunca. MATLAB dispone de una función lasterr que devuelve
una cadena de caracteres con el mensaje correspondiente al último error que se ha producido.
En la forma lasterr('') pone a cero este contador de errores, y hace que la función lasterr
devuelva la matriz vacía [] hasta que se produzca un nuevo error.
5.4 OPERADORES RELACIONALES

El lenguaje de programación de MATLAB dispone de los siguientes operadores relacionales:
< menor que
> mayor que
<= menor o igual que
>= mayor o igual que
== igual que
~= distinto que5
Obsérvese que, salvo el último de ellos, coinciden con los correspondientes operadores
relacionales de C. Sin embargo, ésta es una coincidencia más bien formal. En MATLAB los
5
El carácter (~) se obtiene en los PCs pulsando sucesivamente las teclas 1, 2 y 6 manteniendo
Alt pulsada.

operadores relacionales pueden aplicarse a vectores y matrices, y eso hace que tengan un
significado especial.
Si una comparación se cumple el resultado es 1 (true), mientras que si no se cumple es 0
(false). Recíprocamente, cualquier valor distinto de cero es considerado como true y el
cero equivale a false. Cuando los operadores relacionales de MATLAB se aplican a dos
matrices o vectores del mismo tamaño, la comparación se realiza elemento a elemento, y el
resultado es otra matriz de unos y ceros del mismo tamaño, que recoge el resultado de
cada comparación entre elementos. Considérese el siguiente ejemplo como ilustración de lo
que se acaba de decir:
>> A=[1 2;0 3]; B=[4 2;1 5];
>> A==B
ans =
01
00
>> A~=B
ans =
10
11
5.5 OPERADORES LÓGICOS

Los operadores lógicos de MATLAB son los siguientes:
 & and (función equivalente: and(A,B)). Se evalúan siempre ambos operandos, y el
resultado es true sólo si ambos son true.
 && and breve: si el primer operando es false ya no se evalúa el segundo, pues el
resultado final ya no puede ser más que false.
 | or (función equivalente: or(A,B)). Se evalúan siempre ambos operandos, y el
resultado es false sólo si ambos son false.
 || or breve: si el primer operando es true ya no se evalúa el segundo, pues el resultado
final no puede ser más que true.
 ~ negación lógica (función equivalente: not(A)).
Los operadores lógicos se combinan con los relacionales para poder comprobar el
cumplimiento de condiciones múltiples.
Los operadores lógicos breves (&&) y (||) se utilizan para simplificar las operaciones de
comparación evitando operaciones innecesarias, pero también para evitar ciertos errores que
se producirían en caso de evaluar incondicionalmente el segundo argumento. Considérese por
ejemplo la siguiente sentencia, que evita una división por cero:
r = (b~=0) && (a/b>0);
Además de los operadores básicos, comunes a cualquier lenguaje de programación avanzado,

MATLAB aporta las siguientes funciones lógicas o relacionales:
 xor(A,B) realiza un "or exclusivo", es decir, devuelve 0 en el caso en que ambos sean
no cero o ambos sean 0, y 1 cuando ni A ni B, pero no ambos son no nulos.
 any(x) si el argumento es un vector, devuelve un 1 si alguna de las componentes de x
son no nulas. Si el argumento es una matriz, devuelve un vector fila, con un 1 para
cada columna de la matriz x que tiene alguna de sus filas no nulas, y 0 en otro caso.
 all(x) si el argumento es un vector, devuelve un 1 si todas las componentes de x son no
nulas. Si el argumento es una matriz, devuelve un vector fila con un 1 para cada
columna de la matriz x que tiene todas sus filas no nulas, y 0 en otro caso.
 isempty(x) devuelve un 1 si la matriz x es vacía y 0 en caso contrario.
 isequal(x1,x2,…,xn) devuelve un 1 si todas las matrices son idénticas y un 0 en caso
contrario.
Otros comandos de estas características sería isreal, isnan, isfinite, isinf, …
5.6 LECTURA Y ESCRITURA INTERACTIVA DE VARIABLES

Todos los m-ficheros admiten sentencias que permiten mantener una comunicación con el
usuario sobre la ventana de comandos. Para ellos, se verá a continuación una forma sencilla
de leer variables desde teclado y escribir mensajes en la pantalla del PC.

5.6.1 FUNCIÓN INPUT

La función input permite la introducción de datos por pantalla, es decir, permite imprimir un
mensaje en la línea de comandos de MATLAB y recuperar como valor de retorno un valor
numérico o el resultado de una expresión tecleada por el usuario.
Después de imprimir el mensaje, el programa espera que el usuario teclee el valor numérico o
la expresión. Cualquier expresión válida de MATLAB es aceptada por este comando. El usuario
puede teclear simplemente un vector o una matriz. En cualquier caso, la expresión introducida
es evaluada con los valores actuales de las variables de MATLAB y el resultado se devuelve
como valor de retorno. Véase un ejemplo de uso de esta función:
>> n = input('Teclee el número de ecuaciones')
Otra posible forma de esta función es la siguiente (obsérvese el parámetro 's'):
>> nombre = input('¿Cómo te llamas?','s')
En este caso el texto tecleado como respuesta se lee y se devuelve sin evaluar, con lo que se
almacena en la cadena nombre. Así pues, en este caso, si se teclea una fórmula, se almacena
como texto sin evaluarse.
5.6.2 FUNCIÓN DISP

La función disp permite imprimir en pantalla un mensaje de texto o el valor de una matriz, pero
sin imprimir su nombre. En realidad, disp siempre imprime vectores y/o matrices: las cadenas
de caracteres son un caso particular de vectores. Considérense los siguientes ejemplos de
cómo se utiliza:
>> disp('El programa ha terminado')
>> A=rand(4,4)
>> disp(A)
Ejecútense las sentencias anteriores en MATLAB y obsérvese la diferencia entre las dos
formas de imprimir la matriz A.
5.7 FICHEROS *.M

Los ficheros con extensión (.m) son ficheros de texto sin formato (ficheros ASCII) que
constituyen el centro de la programación en MATLAB. Ya se han utilizado en varias ocasiones.
Estos ficheros se crean y modifican con un editor de textos cualquiera. En el caso de MATLAB
ejecutado en un PC bajo Windows, lo mejor es utilizar su propio editor de textos, que es
también Debugger.
Existen dos tipos de ficheros *.m, los ficheros de comandos (llamados scripts en inglés) y las
funciones.
Los primeros contienen simplemente un conjunto de comandos que se ejecutan sucesivamente
cuando se teclea el nombre del fichero en la línea de comandos de MATLAB o se incluye dicho
nombre en otro fichero *.m. Un fichero de comandos puede llamar a otros ficheros de
comandos.
Si un fichero de comandos se llama desde de la línea de comandos de MATLAB, las variables
que crea pertenecen al espacio de trabajo base de MATLAB, y permanecen en él cuando se
termina la ejecución de dicho fichero.
Las funciones permiten definir funciones enteramente análogas a las de MATLAB, con su
nombre, sus argumentos y sus valores de retorno. Los ficheros *.m que definen funciones
permiten extender las posibilidades de MATLAB; de hecho existen bibliotecas de ficheros *.m
que se venden (toolkits) o se distribuyen gratuitamente (a través de Internet). Las funciones
definidas en ficheros *.m se caracterizan porque la primera línea (que no sea un comentario)
comienza por la palabra function, seguida por los valores de retorno (entre corchetes [ ] y
separados por comas, si hay más de uno), el signo igual (=) y el nombre de la función, seguido
de los argumentos (entre paréntesis y separados por comas).
Recuérdese que un fichero *.m puede llamar a otros ficheros *.m, e incluso puede llamarse a sí
mismo de forma recursiva. Los ficheros de comandos se pueden llamar también desde
funciones, en cuyo caso las variables que se crean pertenecen al espacio de trabajo de la
función. El espacio de trabajo de una función es independiente del espacio de trabajo base y
del espacio de trabajo de las demás funciones. Esto implica por ejemplo que no puede haber
colisiones entre nombres de variables: aunque varias funciones tengan una variable llamada A,
en realidad se trata de variables completamente distintas (a no ser que A haya sido declarada
como variable global).

A continuación se verá con un poco más de detalle ambos tipos de ficheros *.m.
5.7.1 FICHEROS DE COMANDOS (SCRIPTS)

Como ya se ha dicho, los ficheros de comandos o scripts son ficheros con un nombre tal como
file1.m que contienen una sucesión de comandos análoga a la que se teclearía en el uso
interactivo del programa. Dichos comandos se ejecutan sucesivamente cuando se teclea el
nombre del fichero que los contiene (sin la extensión), es decir cuando se teclea file1 con el
ejemplo considerado.
Cuando se ejecuta desde la línea de comandos, las variables creadas por file1 pertenecen al
espacio de trabajo base de MATLAB. Por el contrario, si se ejecuta desde una función, las
variables que crea pertenecen al espacio de trabajo de la función.
En los ficheros de comandos conviene poner los puntos y coma (;) al final de cada sentencia,
para evitar una salida de resultados demasiado cuantiosa. Un fichero *.m puede llamar a otros
ficheros *.m, e incluso se puede llamar a sí mismo de modo recursivo. Sin embargo, no se
puede hacer profile de un fichero de comandos: sólo se puede hacer de las funciones.
Las variables definidas por los ficheros de comandos son variables del espacio de trabajo
desde el que se ejecuta el fichero, esto es, variables con el mismo carácter que las que se
crean interactivamente en MATLAB si el fichero se ha ejecutado desde la línea de comandos.
Al terminar la ejecución del script, dichas variables permanecen en memoria.
El comando echo hace que se impriman los comandos que están en un script a medida que
van siendo ejecutados. Este comando tiene varias formas:
 echo on activa el echo en todos los ficheros script,
 echo off desactiva el echo,
 echo file on donde 'file' es el nombre de un fichero de función, activa el echo en esa
función,
 echo file off desactiva el echo en la función,
 echo file pasa de on a off y viceversa,
 echo on all activa el echo en todas las funciones,
 echo off all desactiva el echo de todas las funciones.
Mención especial merece el fichero de comandos startup.m. Este fichero se ejecuta cada vez
que se entra en MATLAB. En él puede introducir todos aquellos comandos que le interesa se
ejecuten siempre al iniciar la sesión, por ejemplo format compact y los comandos necesarios
para modificar el path.
5.7.2 DEFINICIÓN DE FUNCIONES

La primera línea de un fichero llamado name.m que define una función tiene la forma:
function [lista de valores de retorno] = name(lista de argumentos)
donde name es el nombre de la función. Entre corchetes y separados por comas van los
valores de retorno (siempre que haya más de uno), y entre paréntesis también separados por
comas los argumentos.
Puede haber funciones sin valor de retorno y también sin argumentos. Recuérdese que los
argumentos son los datos de la función y los valores de retorno sus resultados. Si no hay
valores de retorno se omiten los corchetes y el signo igual (=); si sólo hay un valor de retorno
no hace falta poner corchetes. Tampoco hace falta poner paréntesis si no hay argumentos.
En MATLAB una función no puede modificar nunca los argumentos que recibe, de cara al
entorno que ha realizado la llamada. Los resultados de una función de MATLAB se obtienen
siempre a través de los valores de retorno, que pueden ser múltiples y matriciales. Tanto el
número de argumentos como el de valores de retorno no tienen que ser fijos, dependiendo de
cómo el usuario llama a la función6.
Las variables definidas dentro de una función son variables locales, en el sentido de que son
inaccesibles desde otras partes del programa y en el de que no interfieren con variables del
mismo nombre definidas en otras funciones o partes del programa. Se puede decir que
pertenecen al propio espacio de trabajo de la función y no son vistas desde otros espacios de
6
Es un concepto distinto del de funciones sobrecargadas (funciones distintas con el mismo
nombre y distintos argumentos), utilizadas en C/C++/Java. En MATLAB una misma función
puede ser llamada con más o menos argumentos y valores de retorno. También en C/C++ es
posible tener un número variable de argumentos, aunque no de valores de retorno.

trabajo. Para que la función tenga acceso a variables que no han sido pasadas como
argumentos es necesario declarar dichas variables como variables globales, tanto en el
programa principal como en las distintas funciones que deben acceder a su valor. Es frecuente
utilizar el convenio de usar para las variables globales nombres largos (más de 5 letras) y con
mayúsculas.
Por razones de eficiencia, los argumentos que recibe una función de MATLAB no se copian a
variables locales si no son modificados por dicha función. Esto tiene importantes
consecuencias en términos de eficiencia y ahorro de tiempo de cálculo. Sin embargo, si dentro
de la función se realizan modificaciones sobre los argumentos recibidos, antes se sacan copias
de dichos argumentos a variables locales y se modifican las copias. .
Dentro de la función, los valores de retorno deben ser calculados en algún momento.De todas
formas, no hace falta calcular siempre todos los posibles valores de retorno de la función, sino
sólo los que el usuario espera obtener en la sentencia de llamada a la función. En cualquier
función existen dos variables definidas de modo automático, llamadas nargin y nargout, que
representan respectivamente el número de argumentos y el número de valores de retorno con
los que la función ha sido llamada. Dentro de la función, estas variables pueden ser utilizadas
como el programador desee.
La ejecución de una función termina cuando se llega a su última sentencia ejecutable. Si se
quiere forzar el que una función termine de ejecutarse se puede utilizar la sentencia return,
que devuelve inmediatamente el control al entorno de llamada.
5.7.3 SENTENCIA RETURN

De ordinario las funciones devuelven el control después de que se ejecute la última de sus
sentencias.
La sentencia return, incluida dentro del código de una función, hace que se devuelva
inmediatamente el control al programa que realizó la llamada.
5.7.4 FUNCIONES CON NÚMERO VARIABLE DE ARGUMENTOS

Desde la versión 5.0, MATLAB dispone de una nueva forma de pasar a una función un número
variable de argumentos por medio de la variable varargin, que es un vector de celdas que
contiene tantos elementos como sean necesarios para poder recoger en dichos elementos
todos los argumentos que se hayan pasado en la llamada. No es necesario que varargin sea
el único argumento, pero sí debe ser el último de los que haya, pues recoge todos los
argumentos a partir de una determinada posición. Recuérdese que a los elementos de un cell
array se accede utilizando llaves {}, en lugar de paréntesis ().
De forma análoga, una función puede tener un número indeterminado de valores de retorno
utilizando varargout, que es también un cell array que agrupa los últimos valores de retorno
de la función.
Puede haber otros valores de retorno, pero varargout debe ser el último. El cell array
varargout se debe crear dentro de la función y hay que dar valor a sus elementos antes de
salir de la función.
Recuérdese también que las variables nargin y nargout indican el número de argumentos y de
valores de retorno con que ha sido llamada la función. A continuación se presenta un ejemplo
sencillo: obsérvese el código de la siguiente función atan3:
function varargout=atan3(varargin)
if nargin==1
rad = atan(varargin{1});
elseif nargin==2
rad = atan2(varargin{1},varargin{2});
else
disp('Error: más de dos argumentos')
return
end
varargout{1}=rad;
if nargout>1
varargout{2}=rad*180/pi;
end
MATLAB (y muchos otros lenguajes de programación) dispone de dos funciones, llamadas

atan y atan2, para calcular el arco cuya tangente tiene un determinado valor. El resultado de
dichas funciones está expresado en radianes. La función atan recibe un único argumento, con
lo cual el arco que devuelve está comprendido entre –π/2 y +π/2 (entre –90º y 90º), porque por
ejemplo un arco de 45º es indistinguible de otro de –135º, si sólo se conoce la tangente. La
función atan2 recibe dos argumentos, uno proporcional al seno del ángulo y otro al coseno. En
este caso ya se pueden distinguir los ángulos en los cuatro cuadrantes, entre –π y π (entre –
180º y 180º).
La función atan3 definida anteriormente puede recibir uno o dos argumentos: si recibe uno
llama a atan y si recibe dos llama a atan2 (si recibe más da un mensaje de error). Además,
atan3 puede devolver uno o dos valores de retorno. Por ejemplo, si el usuario la llama en la
forma:
>> a = atan3(1);
devuelve un valor de retorno que es el ángulo en radianes, pero si se llama en la forma:
>> [a, b] = atan3(1,-1);
devuelve dos valores de retorno, uno con el ángulo en radianes y otro en grados. Obsérvese
cómo la función atan3 utiliza los vectores de celdas varargin y varargout, así como el número
actual de argumentos nargin con los que ha sido llamada.
5.7.4 HELP PARA LAS FUNCIONES DE USUARIO

También las funciones creadas por el usuario pueden tener su help, análogo al que tienen las
propias funciones de MATLAB. Esto se consigue de la siguiente forma: las primeras líneas de
comentarios de cada fichero de función son muy importantes, pues permiten construir un help
sobre esa función. En otras palabras, cuando se teclea en la ventana de comandos de
MATLAB:
>> help mi_func
el programa responde escribiendo las primeras líneas del fichero mi_func.m que comienzan
por el carácter (%), es decir, que son comentarios.
De estas líneas, tiene una importancia particular la primera línea de comentarios (llamada en
ocasiones línea H1). En ella hay que intentar poner la información más relevante sobre esa
función. La razón es que la función, llamada lookfor busca una determinada palabra en cada
primera línea de comentario de todas las funciones *.m.
5.7.5 HELP DE DIRECTORIOS

MATLAB permite que los usuarios creen una ayuda general para todas las funciones que están
en un determinado directorio. Para ello se debe crear en dicho directorio un fichero llamado
contents.m. A continuación, se muestra un fichero típico contents.m correspondiente al
directorio toolbox\local de MATLAB:
% Preferences.
%
% Saved preferences files.
% startup - User startup M-file.
% finish - User finish M-file.
% MATLABrc - Master startup M-file.
% pathdef - Search path defaults.
% docopt - Web browser defaults.
% printopt - Printer defaults.
%
% Preference commands.
% cedit - Set command line editor keys.
% terminal - Set graphics terminal type.
%
% Configuration information.
% hostid - MATLAB server host identification number.
% license - License number.
% version - MATLAB version number.
% Utilities.
% userpath - User environment path.
% Copyright 1984-2002 The MathWorks, Inc.

% $Revision: 1.14 $ $Date: 2002/06/07 21:45:05 $

Compruébese que la información anterior es exactamente la que se imprime con el comando
>> help local
Si el fichero contents.m no existe, se listan las primeras líneas de comentarios (líneas H1) de
todas las funciones que haya en ese directorio. Para que el Help de directorios funcione
correctamente hace falta que ese directorio esté en el search path de MATLAB o que sea el
directorio actual.
5.7.6 SUBFUNCIONES
Tradicionalmente MATLAB obligaba a crear un fichero *.m diferente por cada función. El
nombre de la función debía coincidir con el nombre del fichero. A partir de la versión 5.0 se
introdujeron las subfunciones, que son funciones adicionales definidas en un mismo fichero
*.m, con nombres diferentes del nombre del fichero (y del nombre de la función principal) y que
las subfunciones sólo pueden ser llamadas por las funciones contenidas en ese fichero,
resultando “invisibles” para otras funciones externas.
En lo siguiente, se muestra un ejemplo contenido en un fichero llamado mi_fun.m:
function y=mi_fun(a,b)
y=subfun1(a,b);
function x=subfun1(y,z)
x=subfun2(y,z);
function x=subfun2(y,z)
x=y+z+2;
5.7.6 FUNCIONES PRIVADAS

Las funciones privadas (private) son funciones que no se pueden llamar desde cualquier otra
función, aunque se encuentren en el path o en el directorio actual. Sólo ciertas funciones
están autorizadas a utilizarlas. Las funciones privadas se definen en subdirectorios que se
llaman private y sólo pueden ser llamadas por funciones definidas en el directorio padre del
subdirectorio private.
En la búsqueda de nombres que hace MATLAB cuando encuentra un nombre en una
expresión, las funciones privadas se buscan inmediatamente después de las subfunciones, y
antes que las funciones de tipo general.
5.7.7 FUNCIONES *.P

Las funciones *.p son funciones *.m pre-compiladas con la función pcode. Por defecto el
resultado del comando pcode func.m es un fichero func.p en el directorio actual (el fichero
func.m puede estar en cualquier directorio del search path). El comando pcode -inplace
func.m crea el fichero func.p en el mismo directorio donde encuentra el fichero func.m.
Pueden pasarse varios ficheros *.m al comando pcode de una sola vez.
Los ficheros *.p se ejecutan algo más rápidamente que los *.m y permiten ocultar el código de
los ficheros ASCII correspondientes a las funciones *.m de MATLAB.
5.7.8 VARIABLES PERSISTENTES

Las variables persistentes son variables locales de las funciones (pertenecen al espacio de
trabajo de la función y sólo son visibles en dicho espacio de trabajo), que conservan su valor
entre distintas llamadas a la función. Por defecto, las variables locales de una función se crean
y destruyen cada vez que se ejecuta la función. Las variables persistentes se pueden definir en
funciones, pero no en ficheros de comandos. Es habitual utilizar para ellas letras mayúsculas.
Las variables se declaran como persistentes utilizando la palabra persistent seguida de los
nombres separados por blancos, como, por ejemplo:
>> persistent VELOCIDAD TIEMPO
Las variables persistent se inicializan a la matriz vacía [] y permanecen en memoria hasta que
se hace clear de la función o cuando se modifica el fichero-M. Para evitar que un fichero-M se
modifique se puede utilizar el comando mlock file.m, que impide la modificación del fichero. El
comando munlock desbloquea el fichero mientras que la función mislocked permite saber si
está bloqueado o no.

5.7.9 VARIABLES GLOBALES

Las variables globales son visibles en todas las funciones (y en el espacio de trabajo base o
general) que las declaran como tales. Dichas variables se declaran precedidas por la palabra
global y separadas por blancos, en la forma:
global VARIABLE1 VARIABLE2
Como ya se ha apuntado, estas variables sólo son visibles en los espacios de trabajo de las
funciones que las declaran como tales (y en el propio espacio de trabajo base, si también ahí
han sido declaradas como globales). Ya se ha dicho también que se suele recurrir al criterio de
utilizar nombres largos y con mayúsculas, para distinguirlas fácilmente de las demás variables.
Práctica:
 Crear una función que reciba un vector u y devuelva un 1 si todos los elementos del
vector son estrictamente positivos y 0 en caso contrario.
Por ejemplo, si v=(7,4,0,2), la función devolverá 0, y si u=(7,4,7,2), la función devolverá 1.
Posible solución:
function flag=ftodospos(u)
flag=1;
i=1;
while i<=length(u)
if u(i)<=0
flag=0;
break;
end
i=i+1;
end
5.8 ENTRADA Y SALIDA DE DATOS

Ya se ha visto una forma de realizar la entrada interactiva de datos por medio de la función
input y de imprimir resultados por medio de la función disp. Ahora se van a ver otras formas de
intercambiar datos con otras aplicaciones.
5.8.1 IMPORTAR DATOS DE OTRAS APLICACIONES

Hay varias formas de pasar datos de otras aplicaciones –por ejemplo de Excel– a MATLAB. Se
pueden enumerar las siguientes:
– se puede utilizar el Copy y Paste para copiar datos de la aplicación original y
depositarlos entre los corchetes de una matriz o vector, en una línea de comandos de
MATLAB. Tiene el inconveniente de que estos datos no se pueden editar.
– se puede crear un fichero *.m con un editor de textos, con lo cual no existen problemas
de edición.
– es posible leer un flat file escrito con caracteres ASCII. Un flat file es un fichero con
filas de longitud constante separadas con Intro, y varios datos por fila separados por
blancos. Estos ficheros pueden ser leídos desde MATLAB con el comando load. Si se
ejecuta load datos.txt el contenido del flat file se deposita en una matriz con el
nombre datos. Por ejemplo, creando un fichero llamado flat.txt que contenga las
líneas:
23.456 56.032 67.802
3.749 -98.906 34.910
el comando A=load('flat.txt') leerá estos valores y los asignará a la matriz A. Para más
información utilizar help load.
– el comando textread permite leer datos de cualquier tipo de un fichero siempre que
estén convenientemente separados. Ver el Help para más información.
– se pueden leer datos de un fichero con las funciones fopen y fread.

– existen también otros métodos posibles: escribir funciones en C para traducir a formato
*.mat (y cargar después con load), crear un fichero ejecutable *.mex 7 que lea los
datos, etc.
5.8.2 EXPORTAR DATOS A OTRAS APLICACIONES

De forma análoga, también los resultados de MATLAB se pueden exportar a otras aplicaciones
como Word o Excel.
– utilizar el comando diary para datos de pequeño tamaño,
– utilizar el comando save con la opción –ascii,
– utilizar las funciones de bajo nivel fopen, fwrite y otras,
– otros métodos, por ejemplo: escribir subrutinas en C para traducir de formato *.mat
(guardando previamente con save), crear un fichero ejecutable *.mex que escriba los
datos, etc.
Hay que señalar que los ficheros binarios *.mat son trasportables entre versiones de MATLAB
en distintos tipos de computadores, porque contienen información sobre el tipo de máquina en
el header del fichero, y el programa realiza la transformación de modo automático. Los ficheros
*.m son de tipo ASCII, y por tanto pueden ser leídos por distintos computadores sin problemas
de ningún tipo.
5.9 LECTURA Y ESCRITURA DE FICHEROS

MATLAB dispone de funciones de lectura/escritura análogas a las del lenguaje C (en las que
están inspiradas), aunque con algunas diferencias. En general son versiones simplificadas –
con menos opciones y posibilidades– que las correspondientes funciones de C.
5.9.1 FUNCIONES FOPEN Y FCLOSE

Estas funciones sirven para abrir y cerrar ficheros, respectivamente. La función fopen tiene la
forma siguiente:
[fi,texto] = fopen('filename','c')
donde fi es un valor de retorno que sirve como identificador del fichero, texto es un mensaje
para caso de que se produzca un error, y c es un carácter (o dos) que indica el tipo de
operación que se desea realizar. Las opciones más importantes son las siguientes:
 'r' lectura (de read)
 'w' escritura reemplazando (de write)
 'a' escritura a continuación (de append)
 'r+' lectura y escritura
Cuando por alguna razón el fichero no puede ser abierto, se devuelve un (-1). En este caso el
valor de retorno texto puede proporcionar información sobre el tipo de error que se ha
producido (también existe una función llamada ferror que permite obtener información sobre
los errores. En el Help del programa se puede ver cómo utilizar esta función).
Después de realizar las operaciones de lectura y escritura deseadas, el fichero se puede cerrar
con la función close en la forma siguiente:
st = fclose(fi)
donde st es un valor de retorno para posibles condiciones de error. Si se quieren cerrar a la
vez todos los ficheros abiertos puede utilizarse el comando:
st = close('all')
5.9.2 FUNCIONES FSCANF, SSCANF, FPRINTF Y SPRINTF

Estas funciones permiten leer y escribir en ficheros ASCII, es decir, en ficheros formateados. La
forma general de la función fscanf es la siguiente:
[var1,var2,...] = fscanf(fi,'cadena de control',size)
donde fi es el identificador del fichero (devuelto por la función fopen), y size es un argumento
opcional que puede indicar el tamaño del vector o matriz a leer. Obsérvese otra diferencia con
C: las variables leídas se devuelven como valor de retorno y no como argumentos pasados por
referencia (precedidos por el carácter &). La cadena de control va encerrada entre apóstrofos
simples, y contiene los especificadores de formato para las variables:
7
Los archivos .mex son archivos Matlab ejecutables compilados a partir de Fortran o C.

 %s para cadenas de caracteres

 %d para variables enteras
 %f para variables de punto flotante
 %lf para variables de doble precisión
La función sscanf es similar a fscanf pero la entrada de caracteres no proviene de un fichero
sino de una cadena de caracteres.
Finalmente, la función fprintf dirige su salida formateada hacia el fichero indicado por el
identificador. Su forma general es:
fprintf(fi,'cadena de control',var1,var2,...)
Ésta es la función más parecida a su homóloga de C. La cadena de control contiene los
formatos de escritura, que son similares a los de C, como muestran los ejemplos siguientes:
fprintf(fi,'El número de ecuaciones es: %d\n',n)
fprintf(fi,'El determinante es: %lf10.4\n',n)
De forma análoga, la función sprintf convierte su resultado en una cadena de caracteres que
devuelve como valor de retorno, en vez de enviarlo a un fichero. Véase un ejemplo:
resultado = sprintf('El cuadrado de %f es %12.4f\n',n,n*n)
donde resultado es una cadena de caracteres. Esta función constituye el método más general
de convertir números en cadenas de caracteres, por ejemplo para ponerlos como títulos de
figuras.
5.9.3 FUNCIONES FREAD Y FWRITE

Estas funciones son análogas a fscanf y fprintf, pero en vez de leer o escribir en un fichero de
texto (ASCII), lo hacen en un fichero binario, no legible directamente por el usuario. Aunque
dichos ficheros no se pueden leer y/o modificar con un editor de textos, tienen la ventaja de que
las operaciones de lectura y escritura son mucho más rápidas, eficientes y precisas (no se
pierden decimales al escribir). Esto es particularmente significativo para grandes ficheros de
datos. Para más información sobre estas funciones se puede utilizar el help.
5.9.4 FICHEROS DE ACCESO DIRECTO

De ordinario los ficheros de disco se leen y escriben secuencialmente, es decir, de principio a
final, sin volver nunca hacia atrás ni realizar saltos. Sin embargo, a veces interesa acceder a un
fichero de un modo arbitrario, sin ningún orden preestablecido. Esto se puede conseguir con
las funciones ftell y fseek.
En cada momento, hay una especie de cursor que indica en qué parte del fichero se está
posicionado.
La función fseek permite mover este cursor hacia delante o hacia atrás, respecto a la posición
actual ('cof'), respecto al principio ('bof') o respecto al final del fichero ('eof'). La función ftell
indica en qué posición está el cursor. Si alguna vez se necesita utilizar este tipo de acceso a
disco, se puede buscar más información por medio del help.
5.10 RECOMENDACIONES GENERALES DE PROGRAMACIÓN

Las funciones vectoriales de MATLAB son mucho más rápidas que sus contrapartidas
escalares. En la medida de lo posible es muy interesante vectorizar los algoritmos de cálculo,
es decir, realizarlos con vectores y matrices, y no con variables escalares dentro de bucles.
Aunque los vectores y matrices pueden ir creciendo a medida que se necesita, es mucho más
rápido reservarles toda la memoria necesaria al comienzo del programa. Se puede utilizar para
ello la función zeros. Además de este modo la memoria reservada es contigua.
Es importante utilizar el profile para conocer en qué sentencias de cada función se gasta la
mayor parte del tiempo de cálculo. De esta forma se descubren “cuellos de botella” y se
pueden desarrollar aplicaciones mucho más eficientes.
Conviene desarrollar los programas incrementalmente, comprobando cada función o
componente que se añade. De esta forma siempre se construye sobre algo que ya ha sido
comprobado y que funciona: si aparece algún error, lo más probable es que se deba a lo último
que se ha añadido, y de esta manera la búsqueda de errores está acotada y es mucho más
sencilla. Recuérdese que de ordinario el tiempo de corrección de errores en un programa
puede ser 4 ó 5 veces superior al tiempo de programación. El debugger es una herramienta
muy útil a la hora de acortar ese tiempo de puesta a punto. En este mismo sentido, puede

decirse que pensar bien las cosas al programar (sobre una hoja de papel en blanco, mejor que
sobre la pantalla del PC) siempre es rentable, porque se disminuye más que proporcionalmente
el tiempo de depuración y eliminación de errores.
Otro objetivo de la programación debe ser mantener el código lo más sencillo y ordenado
posible. Al pensar en cómo hacer un programa o en cómo realizar determinada tarea es
conveniente pensar siempre primero en la solución más sencilla, y luego plantearse otras
cuestiones como la eficiencia.
Finalmente, el código debe ser escrito de una manera clara y ordenada, introduciendo
comentarios, utilizando líneas en blanco para separar las distintas partes del programa,
sangrando las líneas para ver claramente el rango de las bifurcaciones y bucles, utilizando
nombres de variables que recuerden al significado de la magnitud física correspondientes, etc.
En cualquier caso, la mejor forma (y la única) de aprender a programar es programando.
Práctica:
Supongamos que queremos leer los datos almacenados en un fichero, denominado datos.txt,
que contiene esta información:
Nombre Cálculo Álgebra Física Estadística

Fernando Gómez Pereira 3 6 5 7
Susana Rodríguez Pérez 7 4 3 1
Carlos Leis Álvarez 8 9 7 9
Arturo Gómez Álvarez 5 4 5 9
Silvia Tais Álvarez 10 9 10 9
Andrea Gallego Nimes 3 3 2 4
Alicia Caballero Leis 6 8 8 5
Antonio Fraga Gómez 5 7 6 5
Beatriz Machado Gómez 4 3 5 4
Laura Tobío Manzanal 7 8 5 9
Juan Rico Fraga 4 7 5 5
Andrés Pena Gómez 6 8 5 6
Luis Blanco Villa 8 6 6 4
Sandra Puentes Gallego 9 9 7 9
Isolina Prieto Gómez 5 5 6 6
Teresa Sieiro Gon 4 2 5 3
Ricardo López Amigo 8 6 2 9
Una forma posible de poder leer estos datos es mediante el fichero:

ident=fopen('datos.txt');% se abre el fichero

frewind(ident)% se situa el puntero al inicio del fichero
variables=[];%contiene el nombre de los distintos campos,
%es decir la primera línea del fichero
%La longitud de cada una se guarda en el vector long_v
for i=1:5
variable=fscanf(ident,'%s',1);
%se lee una variable caracter
long_v(i)=length(variables)+length(variable);
variables=[variables variable];
% Se imprime el nombre de cada valor leído
if(i==1)
fprintf(1,'\t%s\t\t',variable)
else
fprintf(1,'\t%s\t',variable)
end
end
%A continuación se leen las líneas restantes.
%La variable carácter nombres contiene los nombres y apellidos
%La variable numérica califica contendrá las calificaciones.
nombres=[];
califica=[];
for i=1:17
nombre=fscanf(ident,'%s,%c',1);
apellido1=fscanf(ident,'%s,%c',1);
apellido2=fscanf(ident,'%s,%c',1);
l=3*(i-1)
long_n(l+1)=length(nombres)+length(nombre);
long_n(l+2)=long_n(l+1)+length(apellido1);
long_n(l+3)=long_n(l+2)+length(apellido2);
nombres=[nombres nombre apellido1 apellido2];
califica=[califica; fscanf(ident,'%i',4)'];
fprintf(1,'\n%9s %s %9s',nombre, apellido1, apellido2)
fprintf(1,'\t%i\t\t%i\t\t%i\t\t%i',califica(i,:))
end
fclose(ident)%Se cierra el fichero
Analizar lo que hace este programa.
5.11 ACELERADOR JIT (JUST IN TIME) EN MATLAB

La versión 6.5 de MATLAB incorporó por primera vez un acelerador para los ficheros *.m, que
permite acercarse a las velocidades de otros lenguajes de programación como Fortran y /C++.
Es importante saber qué tipo de programas pueden ser acelerados y cuáles no lo son. En
principio MATLAB acelera los bucles de los ficheros *.m que no contienen cierto tipo de
sentencias. Más en concreto, se pueden ofrecer las siguientes recomendaciones prácticas:
1. No utilizar estructuras, vectores de celdas, clases ni llamadas a función por medio de
referencias.
2. No utilizar hipermatrices con más de tres dimensiones.
3. Utilizar sólo llamadas a funciones nativas de MATLAB (funciones compiladas, no
definidas por medio de ficheros *.m o ficheros MEX).
4. No utilizar variables que cambian de tipo a lo largo de la ejecución (por ejemplo, una
variable que primero es una cadena de caracteres y luego pasa a ser una matriz real).
5. No utilizar las variables i y/o j con números complejos como si fueran variables
normales (por ejemplo, no utilizar 3*i, sino 3i).
6. No utilizar vectores y/o matrices que crecen a lo largo de la ejecución del programa. Es
mucho mejor reservar previamente toda la memoria necesaria mediante la función
zeros, ones o equivalente.

5.12 LLAMADA A COMANDOS DEL SISTEMA OPERATIVO Y A OTRAS

FUNCIONES EXTERNAS
Estando en la ventana de comandos de MATLAB, se pueden ejecutar comandos de MS-DOS
precediéndolos por el carácter (!), por ejemplo:
>> !edit fichero1.m
Si el comando va seguido por el carácter ampersand (&) el comando se ejecuta en
“background”, es decir, se recupera el control del programa sin esperar que el comando
termine de ejecutarse. Por ejemplo, para arrancar Notepad en background,
>> !notepad &
Existe también la posibilidad de arrancar una aplicación y dejarla iconizada. Esto se hace
postponiendo el carácter barra vertical (|), como por ejemplo en el comando:
>> !notepad |
Algunos comandos de MATLAB realizan la misma función que los comandos análogos del
sistema operativo MS-DOS, con lo que se puede evitar utilizar el operador (!). Algunos de estos
comandos son los siguientes:
dir contenido del directorio actual
what ficheros *.m en el directorio actual
delete filename borra el fichero llamado filename
mkdir(nd) crea un subdirectorio con el nombre nd
copyfile(sc, dst) copia el fichero sc en el fichero dst
type file.txt imprime por la pantalla el contenido del fichero de texto file.txt
cd cambiar de directorio activo
pwd muestra el path del directorio actual
which func localiza una función llamada func
lookfor palabra busca palabra en todas las primeras líneas de los
ficheros *.m
5.13 DISTRIBUCIÓN DEL ESFUERZO DE CÁLCULO: PROFILER

El profiler es una utilidad que permite saber qué tiempo de cálculo se ha gastado en cada
línea de una función definida en un fichero *.m o en general de un programa de MATLAB. El
profiler también puede utilizarse con ficheros de comandos *.m, es decir con programas que
no sean funciones.
Permite asimismo determinar el número de llamadas a dicha función, las funciones que la han
llamado (parent functions), las funciones llamadas por ella (child functions), etc.
El profiler mejora la calidad de los programas, pues permite detectar los “cuellos de botella” de
una aplicación y concentrar en ellos los esfuerzos para mejorar su eficiencia. Por ejemplo,
sabiendo el número de veces que se llama a una función y el tiempo que cuesta cada llamada,
se puede decidir si es mejor emplear más memoria en guardar resultados intermedios para no
tener que calcular varias veces lo mismo.
El profiler ha sido mejorado en las distintas versiones de MATLAB, disponiendo de una
interface de usuario propia como muestran las siguientes figuras:

Figura 28 (a,b,c,d)
Con el profiler se puede medir el tiempo (en centésimas de segundo) empleado en cada línea
del fichero, en cada llamada a una función e incluso en cada operador del lenguaje.
Para arrancar la ventana del profiler se puede ejecutar el comando Profiler en el menú
Desktop, utilizar el menú Start/MATLAB o simplemente teclear profile viewer en la ventana
de comandos. El resultado será que se abre la ventana que se muestra en la Figura 28-a.
Ahora se debe introducir en la ventana Run this code el nombre de la función o fichero *.m
que se quiere analizar y después clicar en el botón Start Profiling. Inmediatamente el
programa empieza a ejecutarse bajo la supervisión del profiler, lo cual se sabe porque en la
parte superior derecha de la ventana aparece una marca verde y comienza a correr el tiempo.
Al acabar la ejecución se muestra el resumen de resultados (Profile Summary), que para el
programa tiroparMain4.m. En esta figura se muestra un informe del nº de veces que ha sido
llamada cada función y del tiempo total que se ha empleado en ella.
Clicando sobre el enlace a la función tiropar4salida se muestra la información de la Figura 28-
c y de la Figura 28-d. En la parte de arriba de la ventana (Figura 28-c) se muestra el número de
veces que ha sido llamada cada línea de código y el tiempo empleado en ella. En la parte
inferior de la ventana (Figura 28-d) aparece una información similar referida al código fuente del
fichero. Las sentencias que se han llevado más tiempo de CPU aparecen coloreadas en un
tono rosa de intensidad creciente.
Una información particularmente interesante es la proporcionada bajo el epígrafe M-Lint
results, (no mostrados en las figuras) que contiene sugerencias para mejorar la eficiencia del
programa. Por ejemplo, se avisa de la existencia de variables que se calculan, pero no se
utilizan posteriormente, de la existencia de alternativas más eficientes, etc.
El profiler proporciona también información sobre la función padre (la que la ha llamado) y las
funciones hijas de cada función.
Otra forma de llamar al profiler es por medio de la función profile, que se intercala en el

código fuente en la forma (se supone que estas líneas forman parte de un fichero *.m):
profile on -detail 'builtin';
sol=ode15s(@tiropar4,tspan2,y0,options,1,0.001);
profile viewer;
donde la primera línea activa el profiler a la vez que define el grado de detalle que se desea y
el tipo de tiempo que se desea medir. La segunda línea es una llamada a la función ode15s
que a su vez llama a muchas otras funciones y la tercera línea detiene el profiler y le pide un
informe con los resultados calculados. Los informes presentados por el Profiler son similares a
los de la Figura 29, aunque en este caso no se muestra un informe total sobre la función
tiroparMain4, sino sólo sobre la parte de código que está entre profile on y profile viewer.
Existen dos posibles grados de detalle respecto a la información que se le pide al profiler:
'mmex' determina el tiempo utilizado por funciones y subfunciones definidas en
ficheros *.m y *.mex. Ésta es la opción por defecto.
'builtin' como el anterior incluyendo las funciones intrínsecas de MATLAB.
Otros posibles comandos relacionados con el profiler de MATLAB son los siguientes:
– profile viewer abre la ventana del profiler mostrada en la Figura 29,
– profile on activa el profiler poniendo a cero los contadores,
– profile on –detail level como el anterior, pero con el grado de detalle indicado,
– profile on –history activa el profiler con información sobre el orden de las llamadas a
las funciones (puede registrar hasta 10000 llamadas),
– profile off desactiva el profiler sin poner a cero los contadores,
– profile resume vuelve a activar el profiler sin poner a cero los contadores,
– profile clear pone a cero los contadores,
– s = profile('status') muestra una estructura conteniendo los datos del profile,
– stats = profile('info') detiene el profiler y muestra una estructura con los resultados
(consultar el Help para más información sobre las variables miembro de estas
estructuras).
El profiler se puede aplicar a funciones y a ficheros de comandos. La ejecución de un
programa con el profiler puede ser bastante más lenta que sin él, por el trabajo extra que
conlleva.

6. INTRODUCCIÓN AL ANÁLISIS DE DATOS
Cuando se desea analizar el comportamiento de una o varias variables estadísticas, se

comienza por recopilar una gran cantidad de información numérica acerca de las variables en
cuestión. Para la presentación de estos datos en una forma útil y significativa, será necesario
reorganizar la información de forma adecuada para obtener una visión global del conjunto de
datos; a partir de esta agrupación será necesario, entre otras cosas:
– Calcular medias para deducir algo acerca del comportamiento específico del problema
en estudio.
– Describir la dispersión de los datos respecto de la media.
– Estudiar la relación que existe entre distintas variables medidas.
– Visualizar gráficamente los datos.
– Realizar distintas interpolaciones a partir de los datos medidos para deducir el
comportamiento en otros puntos no medidos.
En esta parte mostraremos las soluciones que MATLAB ofrece para cada uno de los puntos
anteriores.
Para analizar, con MATLAB, análisis estadísticos de un conjunto de datos, éstos deben ser
almacenados utilizando matrices: cada columna de la matriz representará una variable medida
y cada fila los valores que toman todas las variables consideradas en un determinado punto de
medida. Si el número de datos es pequeño, se puede introducir los datos a mano mediante una
matriz, sino recomendamos el uso de un fichero.
También podemos usar la función:
tblread(datos.txt)
que lee los datos almacenados en un fichero datos.txt interpretando los nombres de las
variables (primera fila) y los nombres de los individuos (primera columna). Permite distintos
caracteres como delimitadores de campos (espacios en blanco, coma, punto y coma, etc.)
Ej. [datos, nombresvariables, nombresindividuos] = tblread(’Demog.tex’);
datos, nombresvariables, nombresindividuos
Una vez realizada esta agrupación de los datos veremos en los apartados siguientes cómo
proceder a su análisis.
6.1 CÁLCULO DEL MÍNIMO, MÁXIMO, MEDIA Y MEDIANA
Como primer paso, supongamos que tenemos una sola variable cuyos valores medidos hemos
almacenado en un vector y de datos. Los comandos:
– min(y): calcula el valor mínimo.

– max(y): calcula el valor máximo.
– mean(y): calcula el valor medio.
– median(y): calcula la mediana de las componentes de y. Recordamos que la mediana
de un conjunto de números ordenados en magnitud es, o el valor central, o la media de
los dos valores centrales.
– tabulate(y): obtiene la tabla de distribución de frecuencias de x. El argumento x debe
ser un vector de números naturales.

– Ejemplo:
r = unidrnd(10,5,1)% deuelve un array aleatorio de valores comprendidos entre 1 y 10,

de dimensión 5x1.
r=
tabulate(r)
Value Count Percent
1 0 0.00%
2 0 0.00%
3 0 0.00%
4 2 40.00%
5 1 20.00%
6 0 0.00%
7 0 0.00%
8 1 20.00%
9 1 20.00%
Si los datos están almacenados en una matriz:
– nanmin(A), nanmax(A): Calculan, respectivamente, el mínimo y el máximo de los datos

que ocupan cada una de las columnas (variables) de la matriz A. Los datos “missing”
se omiten. Ej.:
r = unidrnd(10,5,2)
r=
98
9 10
17
88
94

nanmin(r),nanmax(r)
ans =
14
ans =
9 10
Podríamos también usar
[a,i]=min(A) almacena en el vector fila a el elemento más pequeño de cada

columna de A, y en i la fila en la que se encuentra este valor.
– range(A): Calcula el rango estadístico, es decir, la diferencia entre el valor máximo y el

mínimo, de los datos que ocupan cada una de las columnas (variables) de la matriz A.
Ej.:
r = unidrnd(10,5,2)
r=
13
35
49
92
46
range(r)
ans =
87
– median(A): Calcula la mediana de los datos que ocupan cada una de las columnas
(variables) de la matriz A. Ej.:
r = unidrnd(10,5,2)
r=
10 3
88
8 10
37
26
median(r)

ans =
87
– iqr(A): Calcula el rango intercuartílico de los datos que ocupan cada una de las
columnas (variables) de la matriz A. Ej.:
r = unidrnd(10,5,2)
r=
5 10
32
11
34
27
iqr(r)
ans =
1.7500 6.0000
– prdtile(A,p): Calcula los percentiles designados en p (en porcentaje) para cada una de
las columnas (variables) de A. El resultado es una matriz cuya fila i-ésima contiene los
percentiles del p(i), de cada una de las columnas de A. Ej.:
r = unidrnd(10,5,2)
r=
68
57
91
92
55
prctile(r,[25;50;75])
ans =
5.0000 1.7500
6.0000 5.0000
9.0000 7.2500
– nansum(A), nanmean(A), nanmedian(A), nanstd(A): Calculan, respectivamente, la

suma, la media aritmética, la mediana y la (cuasi) desviación estándar de los datos que
ocupan cada una de las columnas (variables) de la matriz A. Los datos “missing” se

omiten. Ej.:
r = unidrnd(10,5,2)
r=
92
45
11
85
10 9
nansum(r),nanmean(r),nanmedian(r),nanstd(r)
ans =
32 22
ans =
6.4000 4.4000
ans =
85
ans =
3.7815 3.1305
6.2 DESVIACIÓN TÍPICA
La dispersión o variación de los datos, para dar una idea de cuan esparcidos se encuentran,
puede medirse utilizando la desviación típica. Dado un vector y de datos, su desviación típica o
estándar se define por:
∑𝑖 (𝑦(𝑖) − 𝑦̅)2
𝑠𝑡𝑑(𝑦) = √
𝑁
siendo 𝑦̅ la media de los valores almacenados en y y N el número de datos, es decir, la

dimensión de y.
>>std(y)
El argumento de la función std también puede ser una matriz; en ese caso la desviación se
calculará para cada una de las columnas de la misma y se guardará en un vector fila.
6.3 COEFICIENTES DE CORRELACIÓN Y MATRIZ DE COVARIANZA
Dadas dos variables x e y, si deseamos expresar cuantitativamente hasta qué grado están
relacionadas, es necesario calcular la covarianza y el coeficiente de correlación de x e y. La

correlación se define como:
∑𝑁
𝑖=1 𝑥(𝑖)𝑦(𝑖)
𝑟=
√(∑𝑁 2 2 𝑁 2 2
𝑖=1 𝑥(𝑖) ) (∑𝑖=1 𝑦(𝑖) )
Si r toma un valor próximo a cero, significa que no hay apenas correlación entre las variables.
>>r=corrcoef([x,y])
donde suponemos que los valores de las variables x e y se guardan en los vectores columna
de nombre respectivo.
Dada una matriz A,
– corrcoef(A): Calcula la matriz de correlaciones asociada con las columnas (variables)

de A. Ej.:
X=unifrnd(2,10,1,100);Y=2.*X+normrnd(0,2,1,100);
corrcoef([X;Y]’)
ans =
1.0000 0.9371
0.9371 1.0000
El numerador de la formula anterior se denomina covarianza de x e y, y en MATLAB se

incorpora mediante el comando:
>> s=cov([x,y])
que calcula la estimación no sesgada de la covarianza entre ambas variables, es decir:
∑𝑁
𝑖=1 𝑥(𝑖)𝑦(𝑖)
𝑠=
𝑁−1
Si A es una matriz donde cada fila es una observación y cada columna una variable, el
comando
– cov(A): Calcula la matriz de covarianzas asociada con las columnas (variables) de A.

Ej.:
X=unifrnd(2,10,1,100);Y=normrnd(0,3,1,100);
cov([X;Y]’)
ans =
4.9814 -0.5150
-0.5150 11.6290
El vector diag(cov(A)) se llama vector de varianzas y es fácil comprobar que sus componentes
son las del vector de desviaciones típicas al cuadrado.
6.4 GRÁFICOS ESTADÍSTICOS

Supongamos que tenemos un fenómeno expresado en términos de una variable discreta y. Su

representación gráfica puede hacerse de las siguientes formas:
1. Histograma: es un gráfico para la distribución de una variable cuantitativa continua que

representa frecuencias mediante áreas. El histograma se construye colocando en el eje
de abscisas los intervalos de clase, como trozos de la recta real, y levantando sobre
ellos rectángulos con área proporcional a la frecuencia. Una vez más, aquí resulta
irrelevante trabajar con frecuencias absolutas o relativas.
Destacamos que es el área y no la altura de los rectángulos lo que debe ser
proporcional a la frecuencia. Así, el eje de ordenadas no refleja la frecuencia, sino que
la altura de cada rectángulo representa la densidad de frecuencia sobre ese intervalo,
definida como:
𝑓𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎
𝑑𝑒𝑛𝑠𝑖𝑑𝑎𝑑 𝑑𝑒 𝑓𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 =
𝑎𝑚𝑝𝑙𝑖𝑡𝑢𝑑
MATLAB ofrece el comando hist para construir la agrupación en intervalos de clase,

calcular las frecuencias y representarlas mediante un histograma. Presenta las
siguientes posibilidades:
– ni = hist(y): reparte la muestra contenida en el vector y en diez intervalos de
igual longitud y devuelve en el vector ni las frecuencias absolutas de cada
intervalo.
– ni = hist(y,m): utiliza m intervalos.
– ni = hist(y,x): utiliza las marcas de clase especificadas por el vector x.
Ilustración
Figura 29:1:ejemplo
Ejemplodedehistograma.
histograma.
– [ni, x] = hist(y): devuelve en x las marcas de clase.

– hist(y): sin argumentos de salida, produce la figura con el histograma. Ojo! las
alturas que representa son frecuencias absolutas.
2. Gráfico de barras: es un tipo de gráfico de variables cualitativas. De este modo, la

función bar(y) dibuja el gráfico de barras con los elementos de vector y; bar(x,y) realiza
un diagrama de barras que considera en el eje de abscisas los individuos especificados
en la variable x y en el de ordenadas la variable y. La dimensión de los vectores x e y
debe coincidir. Podemos influir en la anchura de los rectángulos representados. La
función stem(x,y) representa segmentos verticales rematados con una circunferencia

en su extremo superior, en las posiciones del eje de abscisas contenidas en el vector x

y cuyas alturas vienen dadas por el vector y.
Figura 30: ejemplo de un gráfico de barras.
3. Perfil de la muestra.
a. El comando stairs(y) es análogo al bar pero pintando únicamente el perfil de la
muestra.
b. stem(y) crea una gráfica con los datos dados en el vector y sobre el eje de
ordenadas, en el de abscisas se consideran trodos los puntos de la muestra y
para cada valor de la muestra se representa la línea paralela al eje oy que
conecta este punto del eje ox con la correspondiente ordenada.
>>stem(x,y)
representa la secuencia de datos de la variable y en los valores especificados
de la variable x. En resumen, el comando stem presenta también el perfil de la
muestra.
Con un “string” adicional se puede elegir el estilo de la línea:
>>stem(x,y,’option’)

donde la elección del trazo (no del color) se hace igual que con el comando
plot.
Figura 31: la función stem representa segmentos verticales.
4. Gráficos de errores
Dados tres vectores de la misma dimensión,
>>errorbar(x,y,e)
dibuja la gráfica del vector y frente al vector x con una barra vertical en cada punto
dado, que representa el error especificado en el vector e. Además, la barra csobre el
punto i-ésimo está centrada en el punto (x(i),y(i)) y su longitud es doble que la de la
componente i-ésima del vector e.
5. Histograma angular
El comando rose nos permite realizar un histograma angular. La utilización es similar al
comando hist, con la muestra y formada por ángulos en [0,2π]; para ello, en muchos
casos será necesaria una manipulación adecuada de los elementos de la muestra.
Todos estos comandos de dibujo pueden complementarse con los de etiquetado, definición de
ejes, … utilizados con plot.
6.5 CURVAS DE REGRESIÓN
Cuando se realizan experimentos, en muchas ocasiones encontramos que existen relaciones

entre varias variables que intervienen en el mismo; por ejemplo, la presión de una masa de gas
dada depende del volumen que ocupe y la temperatura a las que se encuentre. Una cuestión
de interés es encontrar una expresión matemática que indique la relación entre las variables

observadas.
Para ello, en primer lugar debemos recoger datos que muestren los valores correspondientes a
las variables x e y para las cuales se han realizado las medidas (𝑥𝑖)𝑚 𝑚
𝑖=1 e (𝑦𝑖)𝑖=1 ,
respectivamente. Si representamos los puntos medidos sobre un sistema de coordenadas
rectangulares obtendremos lo que se conoce como diagrama de dispersión.
En lo sigue, trataremos de resolver la siguiente cuestión: construir una curva que permita
obtener el valor de la variable y en puntos de la variable x distintos de los medidos, y así poder
expresar la ley de comportamiento que liga ambas variables. A esta pregunta se puede
responder de dos formas: calculando la curva de regresión o realizando interpolación.
Se construye la curva de ajuste de mínimos cuadrados o curva de regresión y se analiza la

bondad del ajuste realizado. Esta curva se caracteriza por ser una curva “suave” que minimiza
la suma de los cuadrados de las desviaciones desde la curva (valores estimados) a cada uno
de los valores medidos. El comando de MATLAB:
>>p=polyfit(x,y,n)
calcula el polinomio de regresión de grado n; es decir, el polinomio p de grado n que minimiza:

𝑚
∑(𝑝(𝑥𝑖 ) − 𝑦𝑖 )2 .
𝑖=1
Práctica:
La tabla siguiente recoge el peso de 30 estudiantes.
71 82 65 75 77 91 59 84 89 81
73 91 82 75 96 85 69 76 81 92
84 79 77 95 81 79 84 85 76 82
Construir sobre una misma ventana las 4 figuras siguientes:
1.-Un histograma de frecuencias con el ox peso y oy frecuencia de valores.
2.-El polígono de frecuencias, curva obtenida entre los puntos definidos por las marcas
de clase y la frecuencia.
3.-El perfil de muestra mediante stairs
4.-El perfil de muestra mediante stem.
5.-Calcular el máximo y mínimo peso y la media de pesos.
6.6 INTERPOLACIÓN UNI Y BIDIMENSIONAL
En este apartado aproximaremos los datos x e y por una curva que pasa por todos los puntos
medidos y que está formada por trozos de funciones polinómicas; en general, no será una
curva “regular”. Esta técnica se conoce con el nombre de interpolación. Dependiendo del grado
de las funciones consideradas tendremos interpolación lineal (grado 1), cúbica (grado 3), etc.

La interpolación lineal es el método utilizado, por ejemplo, por el comando plot para realizar la
representación gráfica.
El comando de MATLAB:
vector_y=interp1(x,y,vector_x,opción)
a partir de los valores medidos en las variables x e y, utiliza un método de interpolación para
calcular, en cada componente de la variable independiente vector_x el correspondiente valor
de la variable dependiente. Las componentes de vector_s deben estar en el rango
determinadao por los valores mínimo y máximo de las x; fuera de este rango el valor calculado
es NaN. El argumento opción es una variable carácter que indica el método a considerar:
– linear: interpolación lineal.

– cubic: interpolación cúbica.
– spline: interpolación spline cúbica.
La opción por defecto es la interpolación lineal.
El argumento de salida vector_y será un vector de la misma dimensión y tipo que el vector_x.
El comando de interpolación interp1 requiere que el vector x sea monótono y, además, si se

utiliza la opción spline, los puntos de interpolación deben estar igualmente espaciados.
Si no están igualmente espaciados, un comando de interpolación más rápido es:
interp1q(x,y,vector_x)
donde x e y deben ser vectores columna de la misma dimensión y, además, x debe ser
monótona creciente.
Si se desea hacer una interpolación bidimensional el comando es:
matriz_z=interp2(X;Y;Z;matriz_x,matriz_y,opción)
donde,
– X e Y son matrices que definen una malla sobre el plano XY de puntos de medida. Su
estructura debe ser similar a la obtenida con el comando meshgrid.
– Z contiene los valores medidos en las abscisas correspondientes de las matrices X e Y.
– matriz_x y matriz_y especifican los puntos donde se desea estimar el valor de la
variable Z.
– El argumento opción es una variable carácter que indica el método a considerar:
o linear: interpolación bilineal
o cubic: interpolación bicúbica.
Ambos métodos necesitan que las variables X e Y sean monótonos. Además, la
interpolación bicúbica necesita que los puntos estén igualmente espaciados.
– matriz_z alamacena los correspondientes valores estimados.
Práctica:
Se ha medido experimentalmente la conductividad eléctrica del acero a distintas temperaturas,

recogiéndose los siguientes valores:

Obtener los polinomios de regresión de primero y segundo grado. Calcular para los polinomios
obtenidos cuál sería el valor estimado de la conductividad eléctrica a los 600 y a los 1000ºC.

7. INTRODUCCIÓN AL USO DE INTERFACES GRÁFICAS DE USUARIO

(GUI) CON MATLAB.
Para que un lenguaje de programación revele todo su potencial debe permitir que los usuarios
puedan interaccionar con los programas de una forma cómoda. Para esto se desarrolló el
concepto de GUI.
Matlab Guide es un entorno de programación visual que ofrece Matlab para poder realizar y
ejecutar programas de simulación, tiene las características básicas de todos los programas
visuales como Visual Basic o Visual C++.
El lenguaje más habitual para crear GUI’s es Java, ya que tiene la enorme ventaja de funcionar
en cualquier máquina, sin embargo, Java resulta muy lento para hacer cálculos eficientes. En
comparación con Java, Matlab es más poderoso al realizar cálculos grandes.
En MATLAB podemos desarrollar las GUI de dos maneras. O bien desde cero, lo cual implica
tener que definir por texto cada uno de los elementos que configuran la GUI. O bien haciendo
uso de una utilidad que incorpora MATLAB llamada GUIDE.
Para construir una GUI con GUIDE desde esta generaremos una distribución de los elementos
que la componen (botones, textos, paneles, desplegables…), GUIDE compilará estos
elementos en un fichero con extensión .fig y creará un fichero .m que deberemos programar
para obtener las funcionalidades deseadas. Es decir, la GUI consta de dos archivos: uno .m
que contiene el código del programa, y otro .fig que es la parte gráfica. Las dos partes están
unidas a través de las subrutinas de llamada denominadas callback. La cadena de llamada es
una cadena que consiste en un comando, un conjunto de órdenes o una llamada de función.
En esta cadena se especifican todas las tareas de cómputo que deben ejecutarse al elegirse la
opción.
No siempre es necesario definir la propiedad callback, ya que algunos objetos no ejecutan

ningún comando de Matlab.
El archivo .m que se crea tiene una estructura predeterminada. Consta de un encabezado y el

código correspondiente a las subrutinas. Este archivo es construido automáticamente por
Matlab y las líneas de código que aparecen son las que crean la interfaz que aparece en el
archivo .fig. El archivo de inicialización define los parámetros básicos de la interfaz y crea un
conjunto de identificadores (handles) para cada uno de los objetos que vayan apareciendo
sobre la interfaz.
Cada uno de los objetos de Matlab tiene un identificador único. Algunos gráficos tienen muchos
objetos, por lo tanto tienen múltiples handles.
En una GUI, el flujo de datos está controlado por las acciones en la interfaz. Los comandos
para crear una interfaz con el usuario se escriben en un guión, la interfaz invoca el guión que
se ejecute, mientras la interfaz del usuario permanece en la pantalla aunque no se haya
completado la ejecución del guión.
Cuando se interactúa con un control, el programa registra el valor de esa opción y ejecuta los
comandos prescritos en la cadena de llamada o invocación. Al completarse la ejecución de las
instrucciones de la cadena de llamada, el control vuelve a la interfaz para que pueda elegirse
otra opción del menú. Este ciclo se repite hasta que se cierra la GUI.
El control guarda un string que describe la acción a realizar cuando se invoca, puede consistir

en un solo comando de Matlab o una secuencia de comandos, o en una llamada a una función.
7.1 USO DE GUIDE
Para inicializar GUIDE en MATLAB se puede realizar de varias maneras, ejecutando la

instrucción guide desde la línea de comandos, o haciendo click en NEW -> APP -> GUIDE:
Presentándose el siguiente cuadro de diálogo con las siguientes opciones:
a. Blank GUI (Default)

La opción de interfaz de usuario en blanco (opción que viene determinada) nos
presenta un formulario nuevo, en el cual podemos diseñar nuestro programa.
b. GUI with Uicontrols
Esta opción presenta un ejemplo en el cual se calcula la masa, dada la densidad y el
volumen, en alguno de los dos sitemas de unidades. Podemos ejecutar este ejemplo y
obtener resultados.
c. GUI with Axes and Menu
Esta opción es otro ejemplo el cual contiene el menú File con las opciones Open, Print
y Close. En el formulario tien un Popup menú, un push button y un objeto Axes,
podemos ejecutar el programa eligiendo alguna de las seis opciones que se
encuentran en el menú despegable y haciendo click en el botón de comando.
d. Modal Question Dialog
Con esta opción se muestra en la pantalla un cuadro de diálogo común el cual consta
de una pequeña imagen, una etiqueta y dos botones Yes y No dependiendo del botón
que se presione, el GUI retorna el texto seleccionado (la cadena de caracteres Yes o
No).

Elegimos la primera opción, Blank GUI y obtendremos una ventana como la de la
Figura 32.
Las Componentes principales de GUIDE son:
Barra de Menús
Barra de Herrameintas
Paleta de
componentes
Área de diseño
Figura 32: aplicación GUIDE
 Barra de Menús: Es donde se encuentran las funciones elementales de edición de

GUI’s.
 Paleta de Componentes: Contiene los controles (uicontrols) que se muestran en la GUI.
 Barra de Herramientas: Es donde se encuentran los siguientes botones:
o Alineación de Componentes (Alignment tool): esta opción permite alinear los

componentes que se encuentra en el área de trabajo (Layout Area) de manera
personalizada.
o Propiedades del Inspector (Property Inspector): Contiene todas las
propiedades de cada objeto en forma personalizada.
o Navegador de Objetos (Object Browser): Muestra todos los objetos que se
encuentran en la figura (en forma de árbol).
o Editor de Menús (Menu Editor): El redactor de Menú crea menús de ventana y
menús de contexto.
o Editor de orden (Tab Order Editor): Es para editar el orden de los objetos de la
GUI.
o Editor de archivos M (M-File Editor): Despliega en pantalla el archivo .m.
Para obtener la etiqueta de cada elemento de la paleta de componentes ejecutamos: File >>

Preferencias y Mostrar nombres en la paleta de componentes. Obteniendo la siguiente

presentación:
Esta ventana ofrece el objeto raíz (pantalla), que es siempre único y su identificador es el cero.
El identificador de las ventanas es un entero, que aparece en la barra de nombre de dicha
ventana. Los identificadores de otros elementos gráficos son números flotantes (float), que
pueden ser obtenidos como valor de retorno y almacenados en variables de Matlab.
El objeto más general de una GUI es la pantalla (screen). Este objeto es la raíz de todos los
demás objetos y sólo puede haber un objeto pantalla. Una pantalla puede contener una o más
ventanas (figures). A su vez cada una de las ventanas puede tener uno o más ejes de
coordenadas (axes).
Una ventana puede tener también controles (uicontrol) tales como botones, barras de
desplazamiento, botones de selección o de opción, etc.) y menús (uimenu).
Finalmente, los ejes pueden contener los seis tipos de elementos gráficos que permite Matlab:
líneas (line), rectángulos (rectangle), polígonos (patches), superficies (surface), imágenes
bitmap (image) y texto (text).
Cuando guardemos la GUI, GUIDE generará el fichero .m que deberemos programar.
Notemos que todos los elementos de la GUI son objetos del entorno de programación. Una vez
que ejecutemos la GUI tendremos unas instancias de estos que podremos manejar y editar
como tales.
Figura 33: Mini GUI con GUIDE
En la Figura 33 podemos observar cómo hemos creado un panel y un botón. En esencia esta
es la GUI más sencilla que podemos crear.
7.1.1 CONTROLES DE LA GUI

Los controles de la interfaz con el usuario en Matlab se especifican con la orden uicontrol, y se
localizan en la parte izquierda de la pantalla principal de la GUI, son los siguientes:
Figura 34: Controles de la GUI.
 Menú desplegable (Popup Menu). Provee una lista de opciones.

 Botones (Push Button). Invoca un evento inmediatamente.
 Caja de listas (List Box). Muestra una lista deslizable.
 Casilla de verificación (Check Box). Están diseñadas para realizar operaciones de
encendido/apagado. Indican el estado de una opción o atributo.
 Botón de radio (Radio Button). Indica una opción que puede ser seleccionada. Cuando sólo
se usa un botón de radio, no existe ninguna diferencia funcional con respecto a una casilla
de verificación. Los botones de radio en grupo son mutuamente exclusivos (es decir, si un
botón esta encendido, todos los demás botones se apagan), mientras que las casillas de
verificación son independientes entre sí.
 Texto estático (Static Text). Muestra un string de texto en una caja.
 Barra deslizadora (Slider). Usado para representar un rango de valores.
 Texto editable (Text Edit). Permite al usuario teclear una cadena de entrada.
 Panel de botones (Panel Button). Sirve para agrupar dispositivos.
 Botón de palanca (Toggle Button). Genera una acción que indica un estado binario.
(encendido o apagado).
 Grupo de botones (Button Group) Permite exclusividad de selección con los radio button.
 Active x. Permite crear aplicaciones exportables.
La siguiente tabla muestra una un breve resumen de la descripción de los componentes

anteriormente descritos:

Cada uno de los elementos de la GUI, tiene un conjunto de opciones que podemos acceder
con un click en el botón derecho.
Para modificar las características de los objetos (por ejemplo, color, etiqueta, valor, posición,
texto, etc.), es decir, personalizarlos, deberemos hacer uso del inspector de atributos al que se
accede con el menú contextual del botón derecho.
Para el botón este tiene el aspecto de la Figura 35. Como atributos más obvios, resaltado en
rojo, tenemos el ‘String’ que es el texto del botón (Push Button) o el ‘BackgroundColor’ (gris
medio). No obstante, los atributos más interesantes de cara a la programación son ‘Tag’ y
‘UserData’. El primero nos permite darle un nombre concreto y nos ayudará a encontrar el
objeto suministrándonos su handles. El segundo es un campo que nos permite almacenar
datos del tipo que queramos (números, textos…).

Figura 35: Atributos del botón pushbutton1.
7.1.2 FICHERO .M DE GUIDE
El aspecto del fichero .m generado por GUIDE es aproximadamente como el de la Figura 36.
En él se ha eliminado alguna información superflua, en forma de comentarios, que genera de
forma automática GUIDE.

Figura 36: Fichero .m de GUIDE
Hay que tener en cuenta que todos los valores de las propiedades de los elementos de Matlab
(ej. color, etiqueta, valor, posición, texto, etc.) y los valores de las variables del programa se
guardan en una estructura, los cuales son accedidos mediante un único y mismo puntero.
Una estructura (struct) es una agrupación de datos de tipo diferente bajo un mismo nombre,
como se ha estudiado anteriormente y estos datos se llaman miembros (members) o campos
(fields).
Hemos resaltado la función pushbutton1_Callback(). Esta la es la que se ejecutará cuando
pulsemos el botón, y se puede acceder a ella al hacer click en el elemento ubicado en el área
de diseño (en este caso es el botón) y tomando la opción de View Callback, la cual al ejecutarla

abre el archivo .m asociado a nuestro diseño y nos posiciona en la parte del programa que
corresponde a la subrutina que se ejecutará cuando se realice una determinada acción sobre el
elemento que estamos editando.
En este momento está vacía, pero podemos programarla para que haga cosas de nuestro
interés por ejemplo representar una gráfica, llamar a otra función, etc.
Para ejecutar una Interfaz Gráfica si la hemos etiquedatdo con el nombre curso.fig,
simplemente ejecutamos en la ventana de comandos >> curso o haciendo click derecho en el
m-file y seleccionando la opción RUN.
7.1.3 MANEJO DE DATOS Y ALGUNAS FUNCIONES
Todos los valores de las propiedades de los elementos (color, valor, posición, string, …) y los
valores de las variables transitorias del programa se almacenan en una estructura, los cuales
son accedidos mediante un único y mismo identificador para todos éstos. Tomando el
programa anteriormente presentado, el identificador se asigna en: handles.output=hObject.
handles, es nuestro identificador a los datos de la aplicación. Esta definición de identificador es
salvada con la siguiente instrucción: guidata (hObject, handles);
guidata es la sentencia para salvar los datos de la aplicación.
guidata es la función que guarda las variables y propiedades de los elementos en la estructura
de datos de la aplicación, por lo tanto, como regla general, en cada subrutina se debe escribir
en la última línea lo siguiente:
guidata(hObject,handles);
Esta sentencia nos garantiza que cualquier cambio o asignación de propiedades o variables
quede almacenado.
Por ejemplo, si dentro de una subrutina una operación dio como resultado una variable curso,
para poder utilizarla desde le programa u otra subrutina debemos slavarla de la siguiente
manera:
handles.curso=curso;
guidata(hObject,handles);
La primera línea crea la variable curso a la estructura de datos de la aplicación apuntada por
handles y la segunda graba el valor.
Para terminar, queremos mostrar cómo se accede a un objeto concreto y como se modifican
sus características. Esto se hace por medio de la función findobj(). Por ejemplo:
h_boton = findobj('Tag', 'pushbutton1');
Esta función nos devolverá la handles que apunta a la entidad cuya etiqueta (‘Tag’) es
‘pushbutton1’. Una vez que hemos encontrado el objeto podemos leer los valores de sus
atributos con funciones get() y modificarlos con set().
Por ejemplo, con las instrucciones:
color = get(h_boton, 'BackgroundColor');
set(h_boton, 'BackgroundColor', rand(1,3))
Obtendremos, por si tenemos interés en ello, el color del botón (get()) y lo modificaremos con el
color que queramos, en este caso con un color aleatorio suministrando un vector con 3 valores
elegidos al azar (set()).
Vemos pues que, en esencia, la interacción con la GUI a nivel de programación se realiza en
base a encontrar la handles del objeto, consultar sus propiedades, modificarlas y recuperarlas.
Esto aplica a cualquier elemento presente en una GUI: cajetines, botones de radio, gráficas…
Pero no sólo a estos, si no a otros objetos que conforman otros más complejos. En una gráfica
tenemos los ejes de coordenadas, los datos, la línea que representa los datos, las leyendas,
etc.

BIBLIOGRAFÍA
– Baillo Moreno, A., Grané Chávez, A. 100 Ejercicios resueltos de Estadística Multivariante
(Implementados en MATLAB). Madrid: Delta Publicaciones, 2008. (Ofrece ejercicios
estadísticos interesantes y es una buena opción para ver cómo trabaja MATLAB el análisis
estadístico).
– Carrera, A.R., Martínez, M. Introducción a MATLAB y a la creación de interfaces gráficas.
Servicio Editorial de la Universidad de País Vasco, 2004. (Muy buena ayuda para gráficos e
interfaces).
– Gilat, A. Una introducción con ejemplos prácticos. Editorial Reverté, S.A, 2006. (Contiene
cálculo simbólico).
– Higham, D.J., Higham, N.J. MATLAB guide. Society for Industrial and Applied Mathematics,
2000. (Un libro sobre MATLAB exhaustivo y con buenos ejemplos).
– Lara Sotelo, S.I. Apoyos didácticos para la clase de comunicaciones con MATLAB. Trabajo
de investigación de la Universidad Autónoma de Ciudad Juárez, 2010. (Contiene ejemplos
sencillos y básicos para trabajar distintas señales de comunicación).
– Merino, M., Vadillo, F. Matemática financiera con MATLAB©. Revista de Métodos
Cuantitativos para la Economía y la Empresa, 4 pp. 35-55, 2007.
– Moore, H. MATLAB for engineers. Editorial Pearson, 2015. (Lo hay en la Escuela
Politécnica Superior, y está muy bien enfocado para trabajar las matemáticas del
ingeniero).
– Ortega Ruiz, M. MATLAB aplicado a las telecomunicaciones. Barcelona: Editorial
Marcombo, 2015. (Ejemplos de cómo utilizar MATLAB para la teoría de la señal).
– Quintela Estévez, P. Matemáticas en ingeniería con MATLAB. Servicio de Publicacións da
Universidade de Santiago de Compostela, 2000. (Tiene ejemplos hechos en MATLAB y
además está en castellano).
– Souto, A., Bravo, J.L. Cantón, A., González, M. Curso básico de programación en Matlab®.
Editorial Tébar, S.L. 2013. (Muy fácil de leer y con multitud de ejemplos).
– Pérez, C. MATLAB a través de ejemplos. Garceta grupo editorial, 2011. (Con contenidos
matemáticos como derivadas, integrales, límites, etc.).
– The Math Works Inc. MATLAB, edición de estudiante: versión 4. Prentice Hall, cop. 1996.
(Es el manual del programa en una versión más antigua, pero más que suficiente).

Curso Iniciacion Matlab

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso Iniciacion Matlab

Cargado por

Copyright:

Formatos disponibles

Centro Universitario de Formación e Innovación Educativa (CUFIE),

Mª Cristina Naya Riveiro

1. Interfaz de usuario de MATLAB ................................................................................................ 7

1.1 Introducción ......................................................................................................................... 7

1.1.1 ¿Qué es MATLAB? ....................................................................................................... 7

1.1.2 Desarrollo de algoritmos y aplicaciones ..................................................................... 10

1.1.3 Análisis y acceso de datos .......................................................................................... 12

1.1.4 Visualización de datos ................................................................................................ 13

1.1.5 Cálculo Numérico ........................................................................................................ 15

1.1.6 Publicación de resultados y distribución de aplicaciones ........................................... 16

1.1.7 El programa MATLAB ................................................................................................. 18

1.1.8 Uso del Help ................................................................................................................ 20

1.2 El entorno de trabajo de MATLAB ..................................................................................... 25

1.2.1 El escritorio de MATLAB (MATLAB DESKTOP) ......................................................... 25

1.2.2 Command window....................................................................................................... 27

1.2.3 Command history browser .......................................................................................... 28

1.2.4 Current DIRECTORY BROWSER .............................................................................. 29

1.2.5 Path de matlab: establecer el camino de búsqueda (SEARCH PATH) ...................... 29

1.2.6 Workspace browser y array editor .............................................................................. 32

1.2.7 El editor DEBUGGER ................................................................................................. 33

1.2.8 El profiler ..................................................................................................................... 36

Apps de MATLAB ................................................................................................................. 36

1.3 Preferencias: formatos de salida y de otras opciones de MATLAB .................................. 36

1.4 Ficheros matlabrc.m, startup.m y finish.m ......................................................................... 38

1.6 Guardar sesión y copiar salidas: comando diary .............................................................. 40

1.7 Líneas de comentarios ...................................................................................................... 40

1.8 Medida de tiempos y de esfuerzo de cálculo .................................................................... 41

2. Ejecución de comandos y creación de variables .................................................................... 42

Mª Cristina Naya Riveiro 2

2.1 Operaciones aritméticas. Uso del MATLAB como calculadora ......................................... 42

2.1.1 Constantes .................................................................................................................. 42

2.1.2 Operaciones ................................................................................................................ 42

2.1.3 Variables y expresiones .............................................................................................. 43

2.1.4 Funciones intrínsicas de MATLAB .............................................................................. 48

2.2 Límites, sucesiones, derivadas E integrales ..................................................................... 49

2.2.1 Límites ......................................................................................................................... 49

2.2.2 Sucesiones .................................................................................................................. 49

2.2.3 Derivadas .................................................................................................................... 50

2.2.4 Integrales .................................................................................................................... 50

3. Análisis de vectores, matrices, polinomios y sistemas de ecuaciones lineales. Otros tipos de

3.1 Vectores ............................................................................................................................. 52

3.1.1 Vectores fila ................................................................................................................ 52

3.1.1 Vectores columna ....................................................................................................... 53

3.1.3 Operaciones entre vector y escalar ............................................................................ 54

3.1.4 Operaciones entre vectores ........................................................................................ 55

3.1.5 Operaciones con componentes. ................................................................................. 55

3.1.6 Expresiones más complicadas. .................................................................................. 55

3.1.7 Funciones de MATLAB específicas para vectores ..................................................... 56

3.2 Matrices ............................................................................................................................. 58

3.2.1 Definición de matrices ................................................................................................. 58

3.2.2 Operaciones con matrices .......................................................................................... 59

3.2.3 Funciones específicas para matrices.......................................................................... 59

3.2.4 Matrices dispersas o huecas ...................................................................................... 60

3.3 Polinomios ......................................................................................................................... 62

3.4 Sistemas de Ecuaciones lineales ...................................................................................... 63

3.5 Otros tipos de datos........................................................................................................... 64

3.5.1 Cadenas de caracteres ............................................................................................... 64

3.5.2 Hipermatrices .............................................................................................................. 67

Mª Cristina Naya Riveiro 3

3.5.3 Estructuras .................................................................................................................. 69

3.5.4. Vectores o matrices de celdas (Cell Arrays) .............................................................. 72

4. Gráficos con MATLAB ............................................................................................................. 74

4.1 Representación gráfica de funciones definidas por una fórmula ...................................... 74