Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
http://iimyo.forja.rediris.es/
18 de mayo de 2008 Guillem Borrell i Nogueras
2
Este documento est publicado segn la siguiente licencia:
sfxX WUVEVRETWIEQTPTEQ
Matlab R y MathWorks R son nombres registrados por MathWorks Revisin 48 Pendientes de ampliacin las secciones marcadas con (+)
A Typeset by L T X E Escrito en Kubuntu GNU/Linux y Gentoo GNU/Linux. No ha sido necesaria ninguna herramienta comercial para preparar este texto, sirva como demostracin que el software no por ser ms caro debe ser mejor. Este es un proyecto de documentacin libre. La fuente del documento junto con el cdigo necesario para generarlo se encuentra en Guillem Borrell Introduccin Informal a Matlab y Octave
NDICE GENERAL
15
17
17 17 18 21 21 21 23 23 24 24 24 25 25 25
Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . El entorno de desarrollo Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . El ciclo de desarrollo clsico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rapid Application Development o RAD . . . . . . . . . . . . . . . . . . . . . . . . . . Otros lenguajes orientados a RAD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Errores tpicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Los proyectos de software y los lenguajes de programacin . . . . . . . . . . . . . . . . . . . .
Una visin contempornea del desarrollo de aplicaciones de simulacin . . . . . . . . . . . . . Cul es entonces el espacio de Matlab? . . . . . . . . . . . . . . . . . . . . . . . . . . Y el espacio de Octave? Los lenguajes pegamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. MATLAB
2.1. 2.2. El lenguaje y las bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Convenciones 2.2.1. 2.2.2. 2.3. 2.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operaciones elementales con Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algunas palabras clave y atajos de teclado.
27
27 28 28 29 29 30 30 30 31 31 32 32 32 35 35 36 36 37 37 37 37 39 40
La Ayuda(I) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de archivos en Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1. 2.4.2. 2.4.3. 2.4.4. 2.4.5. Funciones(I) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nuestra primera funcin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nuestro primer script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Una gran diferencia entre Matlab y Octave
2.5.
Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1.1. 2.5.2.1. Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Submatrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nmeros Complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cadenas de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Argumentos lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operadores aritmticos
2.6.
Operadores de comparacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.6.3. 2.6.4. 2.7. 2.7.1. 2.7.2. 2.7.3.
NDICE GENERAL
Operadores lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operadores de comparacin por bits en enteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Acceso a las variables: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funciones dedicadas a variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.3.1. 2.7.3.2. 2.7.3.3. 2.8. 2.8.1. 2.8.2. 2.8.3. 2.8.4. 2.8.5. 2.8.6. 2.9. 2.9.1. 2.9.2. 2.9.3. 2.9.4. 2.9.5. Estructuras de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 40 41 41 43 43 44 44 46 47 47 48 49 50 51 51 51 52 52 52 53 54 55 56 57 57 58 59 59 60 60 60 61 62 62 63 63 63 63 64
Variables
Cell Arrays.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sentencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
if . . . . . . . . . . swith. . . . . . . . Las sentencias for y while . . . 2.8.3.1. Mal uso de while . . . La sentencia doEuntil . . . . . . Las sentencias rek y ontinue La sentencia try . . . . . . . . .
La sentencia La sentencia Funciones matemticas bsicas La Ayuda(II) Argumentos de entrada y salida.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funciones (II) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
inline
2.9.5.1. 2.9.5.2. 2.9.5.3.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funciones annimas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funciones como argumentos de funciones. . . . . . . . . . . . . . . . . . . . . Acceso a las variables desde las funciones annimas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Function handles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funciones recursivas
Encapsulado de funciones
2.10. Entrada/Salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.10.1. E/S bsica por pantalla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.10.2. E/S bsica con archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11. Anlisis crtico del lenguaje Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11.1. Parntesis y corchetes. Tuples y celdas . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11.2. La notacin del punto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11.3. Versatilidad o por qu preero el intrprete Octave.
2.11.4. La orientacin a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11.5. Mdulos y funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11.6. Matlab 2 y otros lenguajes de programacin . . . . . . . . . . . . . . . . . . . . . . . .
II La biblioteca de funciones
3. Matrices y lgebra lineal
3.1. 3.2. 3.3. Rutinas de creacin de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1. 3.2.1. 3.3.1. 3.3.2. 3.3.3. 3.3.4. Tipos de argumentos matriciales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creacin directa de matrices de dimensin mayor que 2. . . . . . . . . . . . . . . . . . Matrices cuadradas regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodos directos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodos iterativos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Matrices sparse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.4.1. 3.3.4.2. 3.3.4.3. 3.3.4.4. 3.3.5. Anlisis de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Almacenamiento de matrices sparse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creacin de matrices sparse . . . . . . . . . . . . . . . . . . . . . . . . . . . . Manipulacin y operaciones con matrices sparse Rutinas de manipulacin de forma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sistemas de ecuaciones lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
67
67 68 69 70 71 73 73 74 74 74 74 76 76 77
NDICE GENERAL
3.3.6. Matrices no regulares. 3.3.6.1. 3.3.6.2. 3.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
77 77 78 78
Autovalores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Grcos
4.1. 4.2. 4.3. 4.4. 4.5.
79
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . y
text.
79 80 82 84 84 84 84 85 85
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Grcas estadsticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Un error bastante comn. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La funcin que tenemos que utilizar Las funciones que no tenemos que utilizar . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.
Las funciones
get
set
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Clculo y Anlisis.
5.1. 5.2. 5.3. 5.4. 5.5. Funciones elementales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Polinomios Derivadas Integrales 5.4.1. 5.5.1. 5.5.2. 5.5.3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
87 87 88 88 89 89 90 91 92 92 93 94 96 96 97 97
Integracin en dos dimensiones. Diferencias entre Matlab y Octave . . . . . . . . . . . Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Matlab 5.5.3.1. 5.5.3.2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Integracin del problema no sti (vdpI) . . . . . . . . . . . . . . . . . . . . . Solucin de la ecuacin de Van der Pol . . . . . . . . . . . . . . . . . . . . . . . . . . . Integracin del problema sti (vdpIHHH) . . . . . . . . . . . . . . . . . . . . .
Inestabilidades y caos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Denicin de variables y funciones simblicas . . . . . . . . . . . . . . . . . . . . . . . Funciones simblicas elementales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operaciones simblicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Clculo simblico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6. Toolkits
6.1. Estadstica descriptiva y anlisis de datos 6.1.1. 6.2. 6.1.1.1. 6.2.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ajuste de curvas por mnimos cuadrados. Qu calcula el ajuste polinmico por mnimos cuadrados?
99
99 99 . . . . . . . . . . 100
Interpolacin y aproximacin de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Interpolacin polinmica a trozos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.2.1.1. 6.2.1.2. 6.2.2. 6.2.3. Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 . . . . . . . . . . . . . . 102 Regeneracin de funciones mediante datos discretos
6.3.
Resolucin de ecuaciones no lineales y optimizacin. 6.3.1. 6.3.2. 6.3.3. 6.3.4. 6.3.1.1. 6.3.2.1.
Resolucin de ecuaciones no lineales. Root nding. . . . . . . . . . . . . . . . . . . . . 106 Ms incompatibilidades entre Matlab y Octave. Bsqueda de soluciones de sistemas de ecuaciones no lineales. . . . . . . . . . . . . . . 108 Algunas de las cosas que pueden salir mal . . . . . . . . . . . . . . . . . . . . 108 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Minimizacin de funciones.(+) Minimizacin de funcionales.(+)
7. Temas avanzados
7.1. 7.1.1. 7.1.1.1. 7.1.1.2. 7.1.2. 7.1.3.
111
El truco ms importante de la programacin en Matlab . . . . . . . . . . . . 112 Por qu son tan lentos los bucles? . . . . . . . . . . . . . . . . . . . . . . . . 112 . . . . . . . . . . . . . . 113 . . . . . 113
Aumentar la calidad del cdigo escrito en Matlab . . . . . . . . . . . . . . . . . . . . . . . . . 111 Vectorizar, la clave para aumentar la velocidad . . . . . . . . . . . . . . . . . . . . . . 111
6
7.2. 7.3. 7.4. 7.5. Array Masking
NDICE GENERAL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Polinomios de Chebyshev. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 La representacin del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Diagramas de Bloques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 7.5.2.1. 7.5.3.1. Ejemplo de aplicacin. Un sistema realimentado simple . . . . . . . . . . . . 124 Anlisis en frecuencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
7.6.
Anlisis Numrico de Ecuaciones en Derivadas Parciales . . . . . . . . . . . . . . . . . . . . . 127 7.6.1. Resolucin de la ecuacin del calor con simetra axial por volmenes nitos en un cilindro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
131
Una advertencia antes de empezar a programar. . . . . . . . . . . . . . . . . . . . . . . . . . . 131 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 . . . . . . . . . . . . . . . . . . . . . . . . . 136 Llamar funciones desde C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Por qu Fortran? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Llamar una funcin de C desde Fortran o la manera ms difcil de sumar 2+2 . . . . . 138 Punteros y arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 Escritura de wrappers para funciones en Fortran. . . . . . . . . . . . . . . . . . . . . . 139 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Extender C++ con Octave MEX (+) 8.5.1. 8.5.2. 8.5.3. El tipo mxArray
III Ejercicios
9. Ejercicios resueltos
9.1. 9.1.1. 9.1.2. 9.2. 9.2.1. 9.2.2. 9.3. 9.3.1. 9.3.2. Gua para la resolucin del ejercicio
147
149
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Ejercicio. Clculo de un gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 Solucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Gua para la resolucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Ejercicio. Diseo de una tobera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Solucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Gua para la resolucin del Ejercicio 9.3.2.1. 9.3.2.2. 9.3.2.3. 9.3.2.4. 9.3.2.5. 9.3.2.6. Octave
Solucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 Octave no sti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 Octave y C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Octave y C++ no sti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Octave, C++ y Fortran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
9.4.
Solucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Gua para la resolucin del ejercicio 9.5.2.1. 9.5.2.2. 9.5.2.3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
9.5.
Ejercicio. Resolucin de la ecuacin de Laplace en un dominio bidimensional . . . . . . . . . . 155 9.5.1. 9.5.2. Solucin del ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Mejorar la solucin. Clculo de tiempos. . . . . . . . . . . . . . . . . . . . . . 158 Resolucin del problema mediante matrices sparse(+) . . . . . . . . . . . . . 159 Resolucin del problema con un mtodo iterativo. . . . . . . . . . . . . . . . 159
9.6.
NDICE GENERAL
9.6.1. 9.6.2. 9.6.3. 9.6.4. 9.7. 9.7.1. 9.7.2. Gua para la resolucin del ejercicio Solucin del ejercicio (Octave) Solucin del ejercicio (Matlab)
7
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Comprobacin de la evolucin temporal Introduccin Algoritmo. 9.7.2.1. 9.7.2.2. 9.7.2.3. 9.7.2.4. 9.7.2.5.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Operador Operador
c . xx
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Los operadores
x6 y x2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
El operador Residuo.
9.7.3. 9.7.4.
10.Ejercicios propuestos
171
10.1. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 10.2. Programacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 10.3. lgebra lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 10.4. Clculo y Ecuaciones Diferenciales Ordinarias. . . . . . . . . . . . . . . . . . . . . . . . . . . 174 10.5. Estadstica y anlisis de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 10.6. Control automtico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
IV Apndices
A. Gua de estilo. Los 10 mandamientos A B. Pequea introduccin a TEX y L TEX
B.1. Tabla con algunos caracteres T X. E
177
179 183 185 187 187
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
C. Software y formatos libres. D. GNU Free Documentation License GNU Free Documentation License
1. APPLICABILITY AND DEFINITIONS 2. VERBATIM COPYING 4. MODIFICATIONS 3. COPYING IN QUANTITY 5. COMBINING DOCUMENTS
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
6. COLLECTIONS OF DOCUMENTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 7. AGGREGATION WITH INDEPENDENT WORKS 8. TRANSLATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 9. TERMINATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 10. FUTURE REVISIONS OF THIS LICENSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 ADDENDUM: How to use this License for your documents . . . . . . . . . . . . . . . . . . . . . . 191
NDICE GENERAL
NDICE DE FIGURAS
1.1. 1.2. 1.3. 1.4. 1.5. 2.1. 2.2. 2.3. 2.4. 2.5. 3.1. 4.1. 4.2. 4.3. 4.4. 4.5. 4.6. 4.7. 5.1. 5.2. 5.3. 5.4. 6.1. 6.2. 6.3. 6.4. 6.5. 7.1. 7.2. 7.3. 7.4. 9.1. 9.2. 9.3. 9.4.
Esta es una consola Linux, mucho ms til que el Command Prompt de Windows Ventana principal de Matlab El editor de Matlab
. . . . . .
18 19 20 20 22 29 32 42 42 43 76 80 81 82 82 83 85 85 93 94 95 95
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Navegador de ayuda de Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Emacs editando un archivo matlab, uno en C++ y debugeando simultneamente. . . . . . . . Tab completion en Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Comparacin del desarrollo de Taylor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Comportamiento normal de una variable llamada por una funcin
Propiedades de una variable persistente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Elementos no nulos de una matriz sparse creada con Ejemplo de uso de
sprnd
. . . . . . . . . . . . . . . . . . .
suplot text
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Insercin de nombres en las guras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Insercin de caracteres griegos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ejemplo de uso de Estilos de lnea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
peks.
. . . . . . . . . . . . . . . . . . . . . . . .
Introduccin de curvas de nivel personalizadas. Solucin de la ecuacin de Van der Pol con Solucin de la ecuacin de Van der Pol con Solucin del dipolo de Rikitake Curva solucin del dipolo de Rikitake
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
=1 . . = 1000
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ajuste por mnimos cuadrados de una serie de puntos Demostracin del fenmeno de Runge
. . . . . . . . . . . . . . . . . . . . . . 100
Comparacin de los mtodos de interpolacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Uso de los nodos ptimos de Chebyshev para reducir el error de interpolacin . . . . . . . . . 105 Representacin de las funciones a resolver. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Diagrama de bloques del sistema ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Diagrama de bloques resuelto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Diagrama de Nyquist del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Grca bode del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Resultado del script Resultado del script Supercie solucin Supercie solucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
10
9.5. 9.6. 9.7. Patrn de elementos no nulos de la matriz del sistema Evolucin del perl de temperaturas
NDICE DE FIGURAS
. . . . . . . . . . . . . . . . . . . . . . 159
Unas palabras
Los libros envejecen como el tema del que tratan. Si un libro habla sobre la vida, el amor, o poltica probablemente mantenga su vigencia durante siglos. Por desgracia el software es un mundo en constante cambio y este libro empezaba a notar el paso del tiempo de forma peligrosa. Octave ha cambiado; tambin lo ha hecho Matlab, sin duda para mejorar. Era consciente de este peligro mientras lo escriba pero an ms durante el ao y medio en el que no he hecho ningn cambio por falta de tiempo e inters. Las circunstancias que me llevaron a tomarme el tiempo necesario para sentarme a escribir han pasado; vuelvo a ser el to siempre ocupado con mil cosas distintas en la cabeza. No puedo vivir sin algn desafo intelecutal, no por instinto de superacin sino por puro entretenimiento. Mi profesin es la Ingeniera Aeronutica y Octave me mantuvo ocupado cuando me vi obligado a aparcarla durante un tiempo. He vuelto a mi carrera, he encontrado otras preocupaciones y Octave ha sido el primer damnicado. Es por este motivo que he decidido liberarlo con la esperanza que a su alrededor se forme una pequea comunidad entusiasta. No tiene ningn sentido que siga en mis manos donde no tiene futuro alguno. Seguro que en algn lado hay alguien que puede dedicarle el tiempo del que ahora carezco. No tengo la sensacin de haber completado el texto. Obviando las erratas y los posibles errores no he ni mucho menos terminado el que creo que es el captulo ms importante: el uso de Octave en aplicaciones multilenguaje. Tampoco he podido dedicarle el tiempo necesario a describir las funciones de representacin grca, estadstica y matrices sparse. Adems creo que el libro requiere un giro en su planteamiento. Muchas de las explicaciones matemticas son prescindibles porque este no es un libro de texto ni pretende ensear Clculo Numrico. Lo abandono con la sensacin de dejar mucho por hacer pero tambin con la satisfaccin del trabajo bien hecho. No me gustara terminar sin dar mi agradecimiento a todos los que me han demostrado su apoyo en una etapa bastante difcil de mi vida. A mis compaeros de departamento Oscar, Mark, Juan Carlos, Miguel, Sergio, lvaro, Leo, Isabel, Samuel, Jorge, Mario y Yoshi. A Javier Jimnez por conar en m sin darle motivos para ello, a Rafa por darme trabajo y a Vassilis por aguantarme. A Juanjo por invitarme a la Universidad de La Rioja, a la Delegacin de Alumnos de Aeronuticos por su conanza y a Nico (en paz descanse) por ser el nico profesor de mi escuela en felicitarme por el libro. Tampoco quiero olvidarme de Pedro, Virginia, Jose, Miguel, Juan Pedro y Alberto; compaeros a los que aprecio tantsimo. Por ltimo y los ms importantes: mis padres, mi abuela, mi hermana y Jaime; ojal mi sobrina Sara pueda leer este libro y pueda sentirse orgullosa del trabajo que un da su to empez.
11
12
NDICE DE FIGURAS
Hay muchos libros de Matlab, algunos muy buenos, pero en ninguno es tratado como un lenguaje de programacin. El enfoque habitual es pensar en Matlab como programa, como un entorno de desarrollo completo. No se habla nunca del intrprete Octave ni a las ventajas y defectos respecto a otros lenguajes de programacin. No son libros, son manuales. Creo que es muy importante aplicar el sentido crtico a cualquier herramienta y todo lo editado hasta a hora no es de gran ayuda. Octave es un programa magnco, lo he usado durante aos. No llega a la magnitud de Matlab pero debe ser tenido en cuenta. Estos apuntes empezaron como material adicional mal escrito para un curso de seis horas; con tiempo y dedicacin han crecido hasta lo que son ahora. Escribir sobre un lenguaje de programacin es largo, difcil y laborioso; nunca sabes si el lector va entender los conceptos que plasmas sobre el papel. Esto requiere el esfuerzo extra de reducir las ideas a lo ms bsico. Es una experiencia graticante, sobre todo cuando uno mismo tiene que reformular conceptos que ya crea asimilados. Uno aprende a escribir, a explicarse y a tener paciencia. Es un curso informal, pretende ser cercano y ameno incluso cuando se tratan conceptos complejos o abstractos. Este libro es libre y abierto; quera que fuera as desde un principio. Todo el que quiera participar en l puede hacerlo sin ninguna restriccin. Su nica nalidad es ayudar a los dems. Espero que quien lo sostenga en sus manos aprecie esta pequea muestra de altruismo y decida colaborar; estar siempre abierto a sugerencias y correcciones. Incluso si alguien propone una reescritura o la inclusin de un captulo no tengo ningn reparo en otorgarle la coautora.
13
14
NDICE DE FIGURAS
Parte I
15
CAPTULO 1
Introduccin
1.1. Lenguajes interpretados o de scripting
Un script o guin es una serie de rdenes que se pasan a un intrprete para que las ejecute. No cumplen la denicin de programa porque no son ejecutables por ellos mismos. Un programa se comunica directamente sistema operativo. En este proceso de comunicacin el programa no es el script, el archivo de cdigo, sino el intrprete que lee lnea por lnea el cdigo y que no ejecuta la siguiente orden hasta que no ha terminado con la anterior. Esta es la diferencia entre los lenguajes basados en cdigo fuente de los lenguajes de scripting. Los primeros son C, C++, Fortran, Ada, Cobol, Pascal... El cdigo fuente escrito es transformado por un compilador en un archivo ejecutable binario que slo es capaz de entender el ordenador. Los lenguajes de scripting ms conocidos son, en el caso de los lenguajes de uso general, Java, Python y Ruby. La popularidad de Java se debe a su naturaleza de producto comercial muy sencillo de administrar mientras que Python y Ruby son Software Libre; de igual o ms calidad pero sin publicidad. Python es un lenguaje basado en la consistencia que ofrece una gran productividad y versatilidad. Ruby es uno de los lenguajes ms recientes, su popularidad est aumentando gracias a la aplicacin Ruby on Rails orientada al desarrollo de pginas web. Existe una gran variedad en los lenguajes de scripting orientado a matemticas. Matlab, Maple, Mathematica, Scilab, Octave, Euler, O-Matrix, R o S son lenguajes de scripting. Los ms conocidos son Matlab, Mathematica y Maple. No debemos considerar Matlab como nicamente un producto. El scripting cientco es una gran herramienta que hay que dominar independientemente del programa. Una vez hayamos aprendido a usar Matlab es posible que se tengamos que aprender a utilizar R, orientado a anlisis de datos, o Scilab si trabajamos en Francia. con el sistema operativo mientras que un script lo hace con un intrprete que a su vez enva comandos al
bb
Qu hacemos a parte de quedarnos paralizados? Pues si esto es una calculadora vamos a usarlo como una calculadora:
bb PCP ns a R
17
18
Figura 1.1: Esta es una consola Linux, mucho ms til que el Command Prompt de Windows
Este ejemplo no sirve para nada pero resume perfectamente el uso de Matlab. En el fondo es una calculadora programable con unas posibilidades casi innitas. Si a esto se suma un lenguaje intuitivo y una gran biblioteca de funciones el resultado es una herramienta verdaderamente til para ingenieros y cientcos. Esta manera de trabajar no es un invento de Matlab, los lenguajes interpretados ya existan mucho antes. Lo que s es novedoso es basar la arquitectura del lenguaje en conceptos matemticos; entre ellos uno muy importante: la funcin. Mientras los lenguajes clsicos se basan en subrutinas o objetos Matlab dispone de una biblioteca formada exclusivamente por funciones. Este diseo tan simple es lo que ha llevado Matlab a su xito, es un acercamiento matemtico a la programacin orientada a matemticas. Si queremos calcular el seno de
bb sin@piGPA ns a I
Entonces nada impide usar el mismo concepto para resolver problemas mucho ms complejos:
4,5
J2,5 (x)dx
0
qud
detalles.
esselj
son funciones que se han compuesto del mismo modo que se compondran funciones
matemticas. Esta lnea de cdigo puede ser incomprensible pero al nal la entenderemos con todos los
Fm
1 En
Unix Matlab puede funcionar tambin desde el intrprete de comandos mediante la funcin
-nojvm.
Es una opcin
CAPTULO 1. INTRODUCCIN
19
ventana principal. Su funcin es facilitar la creacin de archivos de cdigo Matlab y para ello cuenta con Syntax Highlighting, tabulado automtico, soporte grco para debugging...
20
Es muy importante llegar a dominar todas las posibilidades del editor. Cuanto mejor lo conozcamos ms fcilmente y rpidamente programaremos. Finalmente el navegador de ayuda. Adems de ser el mejor sitio donde buscar ayuda puntual sus tutoras nos servirn para perfeccionar nuestra habilidad con el lenguaje y el entorno. Podemos acceder a l desde el men relp o mediante el icono con el smbolo interrogante en la barra de herramientas.
CAPTULO 1. INTRODUCCIN
21
1.4. Octave
Octave es tambin un lenuaje de scripting cientco. Aunque su nacimiento nada tiene que ver con Matlab ha ido convergiendo hacia la compatibilidad. Octave fue pensado como aplicacin para la consola UNIX. No tiene interfaz grca propia, navegador de ayuda, visor de variables, editor, debugger... Se puede decir que no tiene nada de nada. Es un intrprete muy estable, ligero y orientado a programadores ms experimentados. Octave es Software Libre soportado por una comunidad de desarrolladores sin nimo de lucro. Es un proyecto en colaboracin cuyos miembros nos prestarn ayuda cuando la solicitemos. Sus listas de correo son pblicas y son una gran fuente de informacin. Formar parte del desarrollo de Octave es la mejor manera de conocer Matlab en profundidad. El lenguaje Octave es un poco ms potente y mejor diseado, si no nos importa sacricar la compatibilidad tendremos un poco ms de libertad programando. Como parte del proyecto GNU su integracin en un entorno GNU/Linux es excelente; es por ello que se comunica perfectamente con otros lenguajes de programacin. Puede ser una buena excusa para perfeccionar o utilizar nuestros conocimientos de C++ o para profundizar en UNIX. Tampoco es verdad que Octave sea tan minimista. Existen esfuerzos para dotar a Octave de ms y ms herramientas fuera del paquete ocial. El ms relevante es sin duda Octave-forge. Cualquiera que eche de menos una funcin en Octave puede escribirla y mandarla al proyecto; si lo creen conveniente la incorporarn en la prxima versin de la coleccin. Adems Octave-forge es un gran directorio de cdigo escrito. Puede servirnos para aprender como escribir una funcin como es debido o como implementar algoritmos especialmente complejos. La calidad de las funciones es variable pero la media es muy alta. Otro proyecto interesante Octave Workshop de Sbastien Loisel. Se trata de una interfaz grca a la Matlab para Octave, orientada sobre todo hacia usuarios de Windows. Es un proyecto muy joven pero prometedor; desde el principio ha apostado por una solucin integrada. Llena un vaco muy importante, de otro modo la curva de aprendizaje se alarga por la necesidad de aprender a utilizar herramientas de UNIX en un entorno Windows.
Fm
Octave. Si no nos sentimos cmodos con l siempre podemos optar por otros editores como VIM o SciTe,
22
Figura 1.5: Emacs editando un archivo matlab, uno en C++ y debugeando simultneamente.
Aunque estas condiciones parecen obvias no siempre han sido las mismas. Durante las dcadas de los 70 y 80 programar se consideraba una tarea laboriosa y complicada en la que no deba ahorrarse horas de trabajo. Que un ingeniero pasara miles de horas sentado delante de un ordenador no se consideraba tiempo malgastado. Exista la creencia de que ninguna tecnologa era capaz de competir con la pericia y que cualquier aumento en el rendimiento compensaba con creces el tiempo dedicado. Durante los 90 aparecieron multitud de herramientas orientadas a aumentar la productividad y con ellas un cambio esencial de losofa. El criterio era mucho ms pragmtico: todo cuenta. Debemos valorar el tiempo total de desarrollo, la calidad del cdigo escrito, la portabilidad del programa... Ya no era slo el programador y su programa, se haba convertido en una pieza dentro de una gran maquinaria fuera consciente de ello o no. La aparicin de los lenguajes interpretados acentu an ms esta concepcin. Tareas que antes llevaban das podan hacerse en horas y cada vez se haca menos necesario un conocimiento preciso de informtica para programar.
CAPTULO 1. INTRODUCCIN
23
El criterio esencial pas de ser la calidad del resultado nal a ser la relacin esfuerzo por resultado. Los lenguajes interpretados suelen mejorar dicha relacin gracias a simplicar la metodologa de trabajo. Hemos hablado de la distincin entre lenguajes de cdigo fuente o compilados y los lenguajes interpretados pero no hemos tratado sus diferencias en el uso. Un lenguaje interpretado elimina la necesidad del ciclo escritura-compilado-debugging.
Realizar manualmente esta tarea puede requerir unos cuantos minutos pero si disponemos de un intrprete
bbb import os bbb for file in osFlistdir@9F9AX FFF if fileFfind@99A ba HX FFF osFsystem@9mv 7s 7s7s9 7@fileDfileD99AA
Parece fcil. Verdad? Si para los administradores de sistemas conocer un lenguaje interpretado de propsito general es as de til Por qu no iba a serlo para un ingeniero? Cuntas lneas de cdigo seran necesarias para programar lo mismo en C o Fortran? Los ordenadores incrementan exponencialmente su potencia y cada ao los lenguajes interpretados son ms y mas competitivos; ahora se usan para casi cualquier aplicacin y han obligado a todo el mundo a cambiar su punto de vista. Los lenguajes interpretados se utilizaban nicamente cuando se quera una interaccin directa con el usuario, una manera de extender las capacidades de un programa que estaba escrito en un lenguaje compilado. Ahora podemos utilizar lenguajes interpretados para aplicaciones de alto coste computacional y pasaremos a un programa puramente compilado slo en caso de necesidad. Las aplicaciones de simulacin suelen ser programas no muy largos que pueden o no solicitar una optimizacin mxima. En cualquiera de los dos casos se utilizar un lenguaje interpretado porque nuestro objetivo es el RAD o Rapid Application Development. En programas cortos porque es el nico modo de acortar el tiempo de desarrollo y en los largos para la fase de prototipado. Para que un lenguaje interpretado pueda ser utilizado como una herramienta de RAD debe cumplir los siguientes requisitos: 1. Debe ser lo sucientemente polivalente como no necesitar acudir a otros lenguajes de programacin durante del proceso de diseo. 2. Debe poner a nuestra disposicin sucientes herramientas como para que no sea necesario buscar. 3. Debe formar parte de un entorno de desarrollo cmodo y verstil y sencillo.
soberbios como todoterrenos. Somos tan capaces de arreglar cualquier cosa como incapaces de reconocer que un mejor diseo nos ahorrara muchos quebraderos de cabeza. En programas que requieren desarrollos de
horas o de das el coste de empezar de cero por culpa de un mal diseo no es ningn problema; medida que los tiempos de desarrollo crece las situacin se vuelve ms y ms crtica.
2 UML
estndar
estructura de cualquier cosa, aunque fueron pensados para sistemas altamente lgicos como los programas de ordenador.
CAPTULO 1. INTRODUCCIN
25
Si leemos cdigo escrito por nosotros mismos un ao antes es como si lo hubiera escrito alguien que no conocemos de nada. Esto sucede de verdad! Os lo digo por mi propia experiencia. Los comentarios son muy tiles, hay que comentar cualquier estructura que no tenga una lgica aplastante y escribir cdigo obvio no es tan fcil como parece.
3 Se dice que un lenguaje es escalable cuando todas sus virtudes se mantienen independientemente de la longitud del programa.
Matlab es escalable pero hasta un lmite; en aplicaciones especialmente grandes empiezan los problemas de uso de memoria y de acumulacin de archivos de funcin. Los lenguajes compilados son tpicamente escalables y algunos lenguajes interpretados como java y python tambin escalan perfectamente.
4 La
CAPTULO 2
MATLAB
2.1. El lenguaje y las bibliotecas
Antes de entrar en materia es importante que sepamos qu diferencias hay entre las sentencias de un lenguaje de programacin y la biblioteca de funciones. Las sentencias son las palabras clave independientes. Esto signica que si las eliminaremos del lenguaje no podramos sustituirlas con ninguna combinacin del resto de sentencias del lenguaje. Esta denicin no es estricta; algunas palabras clave comunes se consideran sentencias cuando se hace un uso muy frecuente de ellas. El total de sentencias y de reglas de escritura son lo que forman el lenguaje de programacin descrito en un documento llamado referencia. Como Matlab es un programa comercial no existe tal documento. El resto de funciones y subrutinas son parte de la biblioteca. Son palabras clave que cumplen una tarea y no pueden ser consideradas sentencias porque estn escritas con ellas. Algunas funciones de uso muy frecuente llegan a ser parte del mismo lenguaje, el grupo que forman se llama biblioteca estndar . El conjunto de sentencias y biblioteca estndar se conoce como especicaciones y en el caso que el lenguaje tome vida propia, es decir, sus especicaciones pasen a ser pblicas; se llama estndar. Estos documentos existen para la mayora de los lenguajes de programacin conocidos: C, C++, Ada, Fortran, Python... Matlab no es uno de ellos. Al ser un lenguaje sujeto a una herramienta Matlab es Matlab y punto; sin embargo podemos aplicar estas deniciones estrictas para acercarnos a l como lo haramos con el resto de lenguajes. La organizacin interna de Octave sigue este criterio. Se podra decir que Octave es el conjunto de sentencias mas la biblioteca estndar y que el resto de colecciones de funciones (y hay bastantes) son los toolkits. La Compatibilidad entre los dos se sita slo en las sentencias aunque se extiende en gran manera con la biblioteca de funciones. Por lo menos las funciones bsicas son compatibles, casi idnticas. Matlab tiene muy pocas sentencias. Como lenguaje es muy sencillo aunque cada versin incluye nuevas especicaciones. En los ltimos aos se ha aadido la extensin para programacin orientada a objetos y el diseo de interfaces grcas. Octave es ligeramente distinto en su concepcin; es ms minimista y cuenta con muchas menos funciones pero es ms fcilmente extensible. Son las diferencias tpicas entre los productos libres y los comerciales. Este captulo es la referencia del lenguaje; en l veremos argumentos, variables, operadores y sentencias que nos servirn para programar funciones y scripts as como la arquitectura general del programa. Es con diferencia la parte ms importante del libro y no se ha dividido en varios captulos para no romper el hilo conceptual.
Siempre que se hable exclusivamente de Matlab nos referiremos a las caractersticas comunes de Matlab y Octave. Cuando la palabra Matlab se utilice en una diferencia respecto a Octave nos estaremos reriendo al programa comercial. Por sencillez no se ha diferenciado tipogrcamente la palabra Matlab en los dos contextos.
27
28
2.2. CONVENCIONES
2.2. Convenciones
A partir de ahora escribiremos un comando escrito en la consola de la siguiente manera:
sin@xA.
Veremos que la sintaxis de Matlab no es muy distinta de la de cualquier otro lenguaje; las diferencias sern las de siempre, los smbolos de continuacin, los comentarios... Aunque sea un poco temprano los listamos a continuacin:
99 7 5
Comillas simples. Sirven para introducir texto literal, todo lo que se encuentre en este entorno ser tomado como texto y no como el nombre de una variable Comillas dobles. Smbolo de carcter tambin soportado en Octave.
Porcentaje. Es el smbolo del comentario. Todo lo que est por detrs de este smbolo en una lnea es ignorado por el intrprete. Almohadilla. Smbolo del comentario slo soportado por Octave. Es muy til cuando se quieren aadir comentarios en la cabecera de una funcin sin que el parser
FFF Y
Tres puntos. Al aadir alguno de estos dos smbolos al nal de una lnea signica que se tomar la posterior como continuacin
Barra invertida. El smbolo de continuacin de C, C++ y Python tambin est soportado en Octave. Punto y coma. Smbolo de retorno de carro. Sirve para concatenar ms de una sentencia en la misma lnea y para inhibir la salida por consola del resultado.
Importante:
El punto y coma al nal de una sentencia explicita el retorno de carro e inhibe que salga el
2 0,11/2
introduciremos enla consola:
0,4 21/3
b cd
e gf
bb G@GdEeGgfA
Los parntesis sirven para variar el orden normal de las operaciones a realizar.
1 Todos los lenguajes interpretados procesan el cdigo con una herramienta llamada parser. El parser lee cada lnea y distingue
las palabras clave, las variables y los argumentos para que el intrprete pueda hacer su trabajo sin problemas.
CAPTULO 2. MATLAB
29
trpz
Esta es una caracterstica comn de casi todas las consolas existentes, ya sea una consola de UNIX o el Command Prompt de Windows. La consola grca de Matlab es un poco ms potente gracias a su interfaz (gura 2.1):
Figura 2.1: Tab completion en Matlab A continuacin una lista de palabras clave y atajos de teclado que pueden hacernos la vida mucho ms fcil:
exit
Cierra el intrprete, equivalente a cerrar la ventana. Corta la ejecucin del comando actual (kill)
`gvbE
Reescribe lneas anteriores. A medida que presionemos este carcter aparecern en la lnea actual todos los comandos escritos anteriormente. Una vez estemos viendo los comandos podemos movernos entre ellos mediante los cursores.
`gvbC`Db l
2.3. La Ayuda(I)
La manera ms fcil de acceder a la ayuda tanto en Matlab como en Octave es mediante la consola y el comando
help.
Cada comando y funcin lleva consigo la informacin necesaria para que conozcamos su uso
bb help
nos aparecer una ayuda general desde donde podremos encontrar cualquiera de las funciones disponibles. Uno comando bastante til cuando trabajamos desde una consola o por red es comando con
more. Si activamos el more on activaremos el paginador de modo que cuando el texto que aparezca en pantalla se salga
de la misma interrumpir el texto hasta que nosotros le pidamos que contine. Esto evita el comportamiento tan desagradable que tienen las ayudas especialmente largas en las que siempre tenemos que utilizar la barra de desplazamiento para ver el principio. Para salir del texto sin tener que desplazarnos hasta el nal pulsaremos la tecla
`b.
2 Ms
adelante aprenderemos cmo introducir esta informacin a cualquier funcin que escribamos
30
Fm.
necesario que entendamos la arquitectura interna de Matlab. Gran parte de la funcionalidad de Matlab se basa en su biblioteca de funciones. Una funcin en Matlab es equivalente a una funcin matemtica; es una tarea encapsulada que puede depender de una o varias variables. Matlab tiene una extenssima biblioteca de funciones, la mayora de ellas son archivos con la extensin
Fm
que lee el intrprete. Pero el intrprete no puede saber por ciencia infusa dnde se encuentran
bb sin@xA
Cmo sabe Matlab dnde se encuentra la funcin seno? La respuesta es que Matlab ya sabe en qu directorios del sistema puede encontrar archivos
Fm
desde su instalacin.
Signica esto que si creamos nuestras funciones debemos guardarlas en estos directorios? Ni mucho menos. Matlab cuenta con un directorio especial en el que tambin busca funciones; es el llamado directorio
2.4.1. Funciones(I)
Una funcin es una unidad de programa, una tarea independiente que puede o no depender de variables externas. Las unidades de programa tpicas son las funciones, las subrutinas, las clases... Matlab basa toda su potencia y su sencillez en el constante uso de funciones. La razn es bien sencilla; si Matlab es un programa para clculo numrico es normal que la unidad de programa esencial sea la que tiene un signicado ms matemtico En Matlab se dene una funcin del siguiente modo: :
funtion vrilesdeslida nomre@vrilesdeentrdA gomndos que terminmos signndo ls vriles de slid {end}
Por ejemplo,si queremos implementar una funcin que sume dos escalares debemos hacer lo siguiente:
sumFm.
2.4.2. Scripts
Los scripts hacen la funcin de un programa completo, su hilo de sentencias tiene un principio y un nal y no necesita actuar con ninguna variable externa al cdigo. La diferencia entre un script y un archivo de cdigo fuente es que el script es una transcripcin literal de comandos de consola; se dice que es secuencial. Esto no nos permite explotar las posibilidades de los formatos libres ni utilizar secuencias de control tipo
goto4 .
Fm
Dentro del intrprete. Si hemos guardado el archivo en alguno de los directorios de bsqueda de funciones el intrprete ejecutar toda la secuencia de comandos introducindole el nombre del script
3 El
comando
end
slo es necesario en Octave cuando queremos acoplar funciones en los scripts o ms de una funcin en un
mismo archivo. En Matlab no es necesario porque cada funcin est asociada a un nico archivo, el nal del mismo hace de textttend.
4 Mejor,
CAPTULO 2. MATLAB
31
bb nomredelrhivo
Fuera del intrprete. Dentro de una consola llamando el intrprete con el nombre de archivo como argumento. Por ejemplo, en una consola cualquiera:
6b mtl nomredelrhivo
Podemos llamar a funciones en nuestros scripts siempre que sea con variables que hayamos inicializado antes de la llamada. El concepto es el mismo, no es ms que la transcripcin de los comandos que se introduciran en la consola.
out
x.
La
idea es mantener las caractersticas de una funcin matemtica. Una vez la hayamos guardado en el directorio de trabajo esta funcin puede ser llamada por el intrprete de Matlab o por cualquier script. Para probarlo nos vamos a la consola y tecleamos:
bb yaprsin@IFQA
que debe darnos como resultado:
y a HFWQQVQ
An es pronto para algunos conceptos, hay que aclarar un par de cuestiones: Las variables
out
usar las variables que queramos. Esta abstraccin es comn en todos los lenguajes de programacin; la entenderemos cuando hablemos de la diferencia entre variable y argumento. El punto y coma signica lo mismo que el retorno de carro. Tenemos que recordar siempre que la diferencia entre hacer un retorno de carro y poner el punto y coma es que en el segundo caso el programa no nos da ningn output. Llenaremos siempre las funciones de puntos y comas para no recibir resultados intermedios intiles.
omprrFm
y escribimos lo siguiente en l:
bb omprr
E inmediatamente va a aparecer la gura 2.2: An es temprano para entender exactamente qu hace el script, lo iremos viendo paso a paso; pero ha servido para ver cul es la relacin entre funciones, los scripts y Matlab.
32
2.5. ARGUMENTO
aprsin sin
1.5
0.5
-0.5
-1
-1.5
-2 -3 -2 -1 0 1 2 3
bb funtion asum@DA ccc funtion asum@DA | irrorX puntion definitions re not permitted t the prompt or in sriptsF
Recibimos un error. En cambio Octave puede denir funciones tanto en el intrprete como en un script, algo que dota a este intrprete alternativo de algo ms de versatilidad. ste es uno de los grandes puntos dbiles de Matlab. Ignoro el hecho por el que an no lo soportan. Lo que no se puede hacer ni en Matlab ni en Octave es acceder a varias funciones distintas en un mismo archivo. No es muy difcil ver por qu. El lenguaje Matlab, cuando llama a una funcin, busca por los directorios algn archivo que se llame como la funcin, y luego busca una sentencia ejecutable en l. Esto implica que cada archivo slo puede contener una cabecera . Si pensamos un poco tambin vemos que en Octave se puede usar un pequeo truco para cargar varias funciones sin necesitar una cabecera. Simplemente creamos un script cuyo nombre no coincida con ninguna de las funciones que contiene. ste archivo lo empezamos con algo que no sea la sentencia
funtion
bb soure@9hederFm9A
2.5. Argumento
El concepto preciso de argumento o valor es complejo pero a nosotros nos bastar con saber que es cualquier elemento manipulable en un cdigo. Los argumentos de un programa de simulacin numrica son los nmeros, los ndices, las matrices, las secuencias... Tenemos que hacer el esfuerzo conceptual de separar el concepto de argumento del de variable. Una variable es su contenedor, es lo que les da nombre y sirve para manipularlos. Sucede lo mismo en cualquier
5 Puede
contener ms funciones pero slo se puede llamar una. Esta es la funcin que tenga la cabecera en la primera linea
cuyo nombre coincida con el nombre del archivo. Esta funcin puede llamar a otras funciones que se pueden encontrar en el mismo archivo, pero nunca podremos acceder desde fuera a las donde se encuentran
CAPTULO 2. MATLAB
33
frmula matemtica; siempre se expresa mediante variables y toma sentido cuando stas contienen algn argumento. Matlab tiene varios tipos de valores y variables; en consecuencia ser valida cualquier combinacin entre ellos. Estos son los tipos de argumentos soportados :
2.5.1. Matrices
Matlab no distingue entre escalares y matrices. Si se dice que Matlab es un lenguaje de clculo matricial es porque todos los nmeros son en el fondo matrices. El nmero vez sin ningn problema:
inexistente con un 1.
bb foo@IHAaI
el programa lo va a hacer sin ningn problema
foo a H H
H H
H H
y si ahora le pido
bb foo@IIDRAaP
obtengo
foo a H H H H H H H H H H H H
6 Los
H H H H H H
H H H H H H
H H H H H H
H H H H H H
H H H H H H
H H H H H H
H H H H H H
I H H H H H
array
que es consistente con la denicin de tensor. Esto
fsicos tericos y los matemticos encontrarn mucho ms til Python; lenguaje que probablemente desconozcan. La
permite operar con tensores de varias dimensiones de una forma mucho ms natural. Es muy recomendable echarle un vistazo, la combinacin de Python y la coleccin de bibliotecas SciPy es una mejor opcin en el caso de aplicaciones ms complejas en las que Matlab escale mal.
34
2.5. ARGUMENTO
H H H H H
H H H H H
H H H H H
H H H H P
H H H H H
H H H H H
H H H H H
H H H H H
H H H H H
H H H H H
Vemos que el comportamiento es un poco extrao. Si nosotros utilizamos nicamente un ndice obtenemos un vector la, mientras que en una matriz la notacin es la usual, el primer elemento es el nmero de la y el segundo el nmero de columna. Esto nos obligar a trasponer vectores ms de una vez, sobretodo para resolver sistemas lineales de ecuaciones .
8 e inconvenientes.
Esta caracterstica facilita la tarea de escribir los algoritmos por primera vez pero tiene grandes peligros
Importante:
Las matrices se ordenan en Matlab del mismo modo que en la realidad, por las y columnas. La notacin para diferenciar si una serie de nmeros se encuentran en la misma la o en la misma columna es el siguiente: el espacio y la coma (,) separan elementos de una misma la el retorno de carro y el punto y coma (;) separan elementos de una misma columna Por ejemplo, si queremos escribir el vector la
e = (1 2 3)
lo haremos con:
bb eaIDPDQ e a I P Q bb eaI P Q e a I P Q
En cambio, para escribir el mismo vector pero en forma de columna:
bb faIYPYQ f a I P Q bb faI b P b Q f a I P Q
Esta es exactamente la misma notacin que se sigue para introducir una matriz entera. Lo intentamos con:
1 4 7
7 En 8 El
Octave existe la variable
2 5 8
3 6 9
prefer_column_vectors=1
el vector por
prefer_column_vectors.
defecto ser columna en vez de la emulando el comportamiento de Fortran. Sirva esto para mostrar que Octave es totalmente congurable. principal peligro de la asignacin dinmica de memoria es que nosotros no sabemos cundo usamos demasiada. Es muy importante en cdigos no usar ms memoria en ningn momento que la RAM disponible, porque en el caso que 'pisemos' fuera de la RAM, el proceso empezar a escribir sobre el disco duro y el rendimiento puede bajar hasta en dos rdenes de magnitud. El problema es que en ste caso lo hacemos sin querer y adems el programa no nos avisa. Es bueno entonces tener algn monitor del sistema que nos diga cunta memoria estamos usando en tiempo de ejecucin y si estamos pisando fuera, es decir, escribimos en el espacio 'swap'.
CAPTULO 2. MATLAB
35
bb maIDPDQYRDSDTYUDVDW m a I P Q R S T U V W
Aunque cualquier combinacin de las anteriores sera perfectamente vlida, por ejemplo:
bb maI P Q b R S T b U V W m a I P Q R S T U V W
La llamada simple a un elemento cualquiera de una matriz se hace indicando su la y su columna por ese orden. En el caso de la matriz
m:
bb m@PDIA ns a R
Aprenderemos a crear matrices de ms dimensiones en la seccin 3.2.1.
intV
bb xaintV@IDPYIHWPQURHIVPQHSTIVUQTSDVQFHWQVA x a I P IPU VQ
Llama la atencin el hecho de que el nmero 109237401823056187365 se ha convertido en el 127. Esto es debido a que el mayor entero de 8 bits que podemos almacenar es precisamente 127. Si necesitamos una aritmtica de mayor precisin entera siempre podemos hacer lo siguiente:
xaintTR@IDPYIHWPQURHIVPQHSTIVUQTSDVQFHWQVA x a I P WPPQQUPHQTVSRUUSVHU VQ
Ni siquiera el mayor entero disponible es capaz de almacenar el nmero anterior. Podemos tener la necesidad de manipular la cantidad de memoria dedicada a cada elemento de una matriz por dos motivos
36
2.5. ARGUMENTO
1. Estamos deniendo matrices de gran tamao y tenemos la necesidad de reducir la precisin de los argumentos reales; ya sea por la necesidad de reservar memoria o por requerimientos de velocidad de clculo 2. Necesitamos operar con tipos de enteros, ya sean con signo o sin signo para realizar con ellos operaciones lgicas por bits o utilizar lgica entera.
En Octave slo es posible lo segundo porque el tipo de real es siempre el de doble precisin. Hablaremos un poco ms de los tipos de argumentos escalares en la seccin dedicada a rutinas de creacin de matrices.
2.5.2. Secuencias
Son parecidas a los vectores pero no lo son. Aparecen por todos los elementos del lenguaje, en las submatrices, en los contadores en el funcionamiento interno de muchas funciones... Siempre que necesitemos contar algo aparecern las secuencias porque una lista de nmeros que nos cuente del
Si queremos
al
10
bb seueniaIXIH seueni a I P Q R
sucesivos:
IH
1
en
bb seueniaIXPXIH seueni a I Q S U W
bb HXHFSXR ns a golumns I through VX HFHHHHH HFSHHHH IFHHHHH golumn WX RFHHHHH bb HXHFSPXR ns a HFHHHHH HFSPHHH
QFHHHHH
QFSHHHH
Si el intervalo que introducimos no ajusta exactamente al lmite superior parar de contar sin pasarse.
IFHRHHH
QFIPHHH
QFTRHHH
Evidentemente este tipo particular de contadores no son adecuados para contar ndices porque genera nmeros no enteros. Su utilidad se encuentra en la discretizacin de intervalos necesaria, por ejemplo, en los ejes de coordenadas.
2.5.3. Submatrices
Para asignar partes de matrices a variables o operar dentro de una matriz con una parte de la misma es necesario asignarles una secuencia de ndices. Se puede decir que la submatriz se genera contando los ndices de la primera Para entender mejor cmo funciona este tipo de asignaciones mejor hacerlo mediante ejemplos. Iniciaremos una sesin en Matlab creando una matriz de nmeros aleatorios:
bb fooarnd@SDSA foo a HFVHVHRV HFVHRVHV HFIIRWTS HFSPRSQI HFRUTQSS HFSRRPQT HFUQTIHQ HFPQIVUT HFVHUHHP HFPRRIUP
CAPTULO 2. MATLAB
Ahora crearemos una submatriz llamada de la tercera a la quinta.
37
Pero las secuencias tienen la capacidad de contar de modos distintos, en el caso siguiente contaremos las las de 2 en 2 como muestra el siguiente ejemplo. En l crearemos una submatriz a la tercera.
foo
las las de la primera a la quinta de 2 en 2 (la primera, la tercera y la quinta) y las columnas de la primera
bb qweafoo@IXPXSDIXQA qwe a HFVHVHS HFVHRVI HFVUIIU HFRUTQS HFSRRPR HFPSRHI HFVHUHH HFPRRIU HFSHUQS
Si omitimos los elementos de la secuencia y dejamos slo el smbolo los elementos de la la o de la columna. Adems de una secuencia los ndices pueden introducirse mediante vectores:
bb qweafoo@IDPDIDPA
bb numomaPCQi
Tambin podemos usar otros signos para expresar complejo completo. Adems del nmero racionales
como
j, s
t.
crear vectores, matrices y tensores de nmeros complejos, y al buscar un ndice en ellos tendremos el nmero
como
pi
i tenemos e.
38
2.6. OPERADORES
bb 9me9D9gust9D9el9D9furo9 ns a megustelfuro
o en columna
true
flse.
2.6. Operadores
Cuando operamos elementos en Matlab, como cuando lo hacemos en cualquier lenguaje de programacin, debemos tener en cuenta la dicotoma entre variable y argumento. Es tan importante porque debemos comprender perfectamente la sutileza de que los operadores no operan variables sino argumentos, en el caso de Matlab, matrices. La consecuencia directa es que todos los operadores de Matlab son matriciales. En algunos casos, como la suma o la resta, los operadores matriciales son equivalentes a lo escalares (elementwise Por ejemplo, si tomamos dos matrices cualquiera:
9 o elemento a
IV SR WH
Todos los operadores de Matlab pasan de matriciales a escalares aadiendo un punto justo antes del smbolo del operador. En el caso de las matrices
Y si queremos una operacin escalar? anteriores:
bb eFBf ns a W IT PR PS PI IT
PI PR W
bb eP
Sea equivalente a:
bb eBeY
9 Elementwise
signica literalmente en ingls elemento a elemento.
CAPTULO 2. MATLAB
Operacin que es matricialmente del todo lgica. Este comportamiento provoca dos errores tpicos. 1. El operador se negar a elevar a un exponente matrices que no sean cuadradas. 2. Cuando el exponente es fraccionario da resultados que aparentemente no tienen ninguna lgica
39
Un ejemplo claro es lo que nos encontramos cuando elevamos la anterior matriz a una burda aproximacin del nmero
Nmeros complejos? El problema es que en Matlab cualquier argumento puede ser una matriz; olvidarnos el punto antes de utilizar la potencia...
es uno de los errores ms comunes. Por suerte los errores suelen ser tan evidentes que la sangre raramente llega al ro. El problema llega cuando elevamos al cuadrado matrices cuadradas. Los resultados obtenidos con el operador matricial y escalar son parecidos y del mismo orden de magnitud con lo que pueden ser un gran escollo en el proceso de depuracin.
xFBy xGy
Multiplicacin elemento a elemento. Si ambos operandos son matrices el nmero de las y de columnas debe coincidir.
(y )1 x
con la diferencia que en este caso no se calcula la inversa. En el caso que la matriz se da una solucin con la condicin de mnimo error
10 .
no sea cuadrada
xFGy xy
y.
x1 y
y sirve para resolver sistemas de ecuaciones lineales. Como en la divisin anterior no se calcula efectivamente la inversa de la matriz, de modo que en el caso que no sea cuadrada seguir dando un resultado. Analizaremos este operador con mucha ms profundidad en el apartado dedicado a lgebra lineal.
10 Esto
40
2.6. OPERADORES
Divisin de derecha a izquierda elementwise.
xFy xy xBBy
elevado a la potencia de
y.
Si
x y
es un veces
y si
BB
como
son
xFy xFBBy Potencia elementwise. Si los dos FBB slo se puede usar en Octave Ex x9
Negacin Traspuesta compleja conjugada. Si la matriz a hacer operandos son matrices deben ser del mismo tamao. La notacin
tamente el mismo que para la traspuesta. Si hay algn argumento complejo el operador es equivalente
onj@xF9A.
xF9
Traspuesta
es menor que
y. y.
x x x
y. y.
Verdadero si
es mayor que
y.
x3ay x~ay
Verdadero si el segundo.
x es distinto que y . En Octave son vlidos ambos signos mientras que Matlab slo soporta
11 Esta
es una buena manera de perder un da de trabajo tontamente. Es de estos errores que hacen que te rompas la cabeza
intentando entender qu es lo que funciona mal. Cuando se trabaja en el espacio de Fourier es muy normal que todos los coecientes sean complejos. Adems, si los datos que originan los coecientes son reales la matriz que forman es hermitiana que es como la extensin de la matriz simtrica para nmeros complejos. Probando un algoritmo de de resolucin de la ecuacin de Poisson en el plano espectral me puse a probar qu era lo que calculaba la transformada rpida de Fourier (se ver en los temas posteriores) bidimensional y si era equivalente con una combinacin de transformadas unidimensionales. En teora el algoritmo de transformada rpida de Fourier en un plano es transformar por columnas y luego hacerlo por las. Como la funcin transformada rpida de Fourier en Matlab es operacin sera
fft
la
fft(fft(a)')' Con esto se hace la operacin por columnas, se traspone, se hace la operacin por las y se vuelve a trasponer fft2(a)
Cual fue mi sorpresa cuando descubr que los coecientes que daba como resultado eran distintos. No es que el
para devolver la matriz a su estado inicial. Esta operacin debera ser equivalente a: resultado tenga que ser equivalente, es que tiene que ser exactamente el mismo. Despus de vez los resultados me d cuenta que el operador operacin sera:
'
ocho
no son equivalentes porque el resultado no es una matriz hermitiana hasta que se ha terminado la transformada. Entonces la
fft(fft(a).').'
Esta tontera bien puede haceros perder un da, como a mi, o un par de ellos por culpa de resultados que parecen vlidos. A ttulo de opinin personal creo que este es un gran fallo en la sintaxis general de matlab. Hay ms, incluso peores. Esto
Mucho cuidado. debera corregirse como en otros lenguajes donde los operadores tienen su forma abreviada (*) y una forma equivalente como funcin
CAPTULO 2. MATLAB
41
if
while.
para y,
para no. Si decimos que operan con matrices es porque aplicados a matrices de condiciones
bb IDPYHDI8HDIYHDI ns a H I H I bb 3HDIYPDH ns a I H H I
La expresin entera para condiciones lgicas es binaria usual. Para componer expresiones lgicas se usan los smbolos con la funcin
H para falso
y distinto de
88 para y if
y
y los anteriores es que el resultado siempre ser booleano. Si se aplica a una matriz colapsar sus elementos
ll
para llegar a una expresin nica. Como ya hemos dicho antes su aplicacin principal se
while.
bb it`efb itnd itmx itset itxor itmp itget itor itshift bb aSY 7n numero entero bb dePin@A 7ue tiene est represention deiml ns a IHI bb aitset@DIDHA 7eset del primer it a R bb aitset@DTDIA 7et del sexto it a QT bb dePin@A ns a IHHIHH bb aitset@IDTA 7 n form lterntiv de set a QQ bb dePin@A ns a IHHHHI bb itnd@DA 7 y logio ns a QP bb dePin@itnd@DAA 7 in itsFFF ns a IHHHHH bb itor@DA 7 o logio ns a QU bb dePin@itor@DAA 7 in itsFFF ns a IHHIHI bb itxor@DA 7 o exlusivo logio ns a S bb dePin@itxor@DAA 7 in itsFFF ns a IHI
Introduccin informal a Matlab y Octave
42
2.7. VARIABLES
2.7. Variables
Debemos pensar en ellas como cajas que ocupan memoria, independientemente de lo que lleven dentro. Debe abstraerse la variable del argumento que contenga, en el fondo no es ms que un nombre. Por el hecho de ser un lenguaje de scripting las variables no deben declararse. Esto hace que programar sea mucho ms sencillo, se haga con menos errores y en menos tiempo a costa de un mayor tiempo de ejecucin. Esto tambin signica que la cantidad de memoria asignada a una variable es dinmica, podemos ampliar una matriz
12 sin ningn problema con el simple hecho de llenar un elemento que no exista. 13 Aquello que nosotros asignamos a una variable se llamar argumento . A cada variable le asignaremos
uno o varios argumentos, de modo que la variable no es ms que un nombre por el que llamamos su contenido. Las variables pueden ser cualquier secuencia de letras, no hay limitacin en su nmero, slo que deben empezar con un carcter tipo letra o con _ . Se distingue entre maysculas y minsculas. Los nombres siguientes seran vlidos:
pi
ns.
parte de la conguracin interna del programa as que es importante conocerlas para no tener sorpresas
Figura 2.3: Comportamiento normal de una variable llamada por una funcin Si le damos a una variable el atributo de global con la palabra clave
ser vista por cualquier unidad de cdigo sin necesidad de llamarla en su cabecera. A estas variables no les importa si estn en el programa principal o en una funcin, su contexto es toda la ejecucin; pueden saltar a cualquier hilo como en el esquema de la gura 2.4:
12 Ampliar 13 El
una matriz es exactamente equivalente que asignar ms memoria a una variable. En Fortran sera dealocatear una
variable, ampliarla y alocatearla otra vez. concepto de argumento en programacin es mucho ms extenso, pero creo que es conveniente usarlo de este modo.
CAPTULO 2. MATLAB
43
Al estar denida como una variable global no slo puede ser vista por la funcin; si adems la funcin cambia su valor tambin cambiar en el programa principal. Un ejemplo de ello es el cdigo siguiente:
14 .
persistent
Un tercer atributo es el de
persistent.
estamos imponiendo que esta variable se guarde en memoria para la siguiente vez que se llame
la funcin en vez de hacerla desaparecer, como es normal. El diagrama conceptual es el de la gura 2.5.
14 El
uso de las variables globales es una de las pocas discusiones de estilo abiertas. En otros lenguajes de programacin, sobre
todo los que permiten la programacin orientada a objetos, no es necesario utilizar este tipo de variables. Es una discusin entre dos escuelas. Los que estamos ms acostumbrados a una programacin modular (Fortran) nos sentimos ms cmodos controlando el hilo de ejecucin con variables globales. En cambio, la escuela procedente de C++ y de Java preeren crear mtodos mucho ms ricos en los que las funciones son en realidad mtodos de un objeto que puede haber sido inicializado previamente. Creo que para un principiante el uso de variables globales es un buen ejercicio mental para aprender que hay distintos niveles de ejecucin en la programacin modular sin entrar en conceptos que muchos usan pero slo unos pocos entienden.
44
No tiene ningn sentido denir una variable como
2.7. VARIABLES
persistent
variables locales para el hilo principal no se destruyen hasta que termina la ejecucin.
isglol ler
que devuelve un
que borra el contenido de una o varias variables, funciones o variables globales dependiendo del
who que da una lista de las variables que en aqul mismo momento estn ocupadas por algn argumento.
Tambin acepta parmetros para variar su comportamiento.
whos
, lo mismo que
who
Importante:
Es necesario entender el concepto de variable local y global para comunicar funciones y scripts
2.7.3. Contenedores
La limitacin las matrices es que slo pueden contener elementos de un mismo tipo. Una matriz no puede contener una cadena de caracteres y un nmero a la vez. Si sumamos mentalmente dos matrices entenderemos facilmente por qu. Necesitemos entonces denir un tipo ms complejo que un caracter o un escalar. Un tipo derivado es una extensin del concepto de argumento en el que se permite que una variable contenga un argumento mltiple con elementos de distinta naturaleza. Un tipo derivado es lo que permite asignar a una variable un nmero y una cadena de caracteres a la vez. La estructura tpica de los tipos derivados es la que tiene forma de rbol. Son llamadas estructuras de
datos. En ellas, una variable primitiva contiene ms variables adicionales que a su vez pueden contener
ms ramicaciones. Otro tipo es emular el comportamiento de una matriz o un vector y permitir que sus elementos sean de tipos distintos. Obviamente esta ganancia de potencia se pierde en los operadores. Una matriz puede ser sumada a otra matriz, en cambio un tipo derivado no puede ser sumado a otro tipo derivado ya que Matlab no tiene ninguna informacin de qu contiene cada uno. Esto hace que la lnea divisoria entre el concepto de variable y el de argumento se difumine. Podemos pensar en una matriz como un nico argumento donde todos los elementos son del mismo tipo y los tipos derivados como estructuras de variables. Entrar en sutilezas tericas no es muy conveniente, simplemente debemos centrarnos en la gran utilidad de las estructuras de datos o las celdas de variables ya que permiten agrupar en forma de nica variable estructuras ms complejas de lo habitual.
estruturFm.
7 estruturFm 7 ste es el sript de prue pr ls vriles de tipo estrutur fooFnumaIFPQRY fooFstringa9hol mundo9Y fooFoptionsFoptionIatrueY fooFoptionsFoptionPaflseY
Lo guardamos en el directorio correspondiente y si nos vamos a la consola y tecleamos informacin por pantalla. Si queremos que nos diga qu hay dentro de la variable en la consola y nos aparecer lo siguiente:
estrutur
qu
obtenemos? Pues nada en absoluto porque le hemos pedido con los puntos y coma que no nos sacara ninguna
foo
debemos teclear
foo
CAPTULO 2. MATLAB
45
bb estrutur bb foo foo a { num a IFPQRH options a { optionI a I optionP a H } string a hol mundo }
que es exactamente la estructura de argumentos que hemos introducido ignorado por el intrprete. Adems de muchas otras, la mayor utilidad de las variables de tipo estructura es que nos permiten acortar las cabeceras de las funciones. Pongamos como ejemplo un programa que se congura con unos veinte parmetros. Si una funcin necesita quince de ellos signica que cada vez que llamemos a la funcin en nuestro cdigo aparecer una cabecera con quince variables. Esto hara el cdigo ms pesado de escribir y mucho ms difcil de leer y mantener. Podemos poner todos nuestros parmetros dentro de una variable que se llame comentarios en un script de Matlab, con el signo 7. Todo lo que escribamos a partir de ste smbolo ser
prms,
prms
vongitud, prmsFvongitud.
en
2.7.3.2.
Cell Arrays
Las celdas son matrices o hiper-matrices de variables. No debemos confundirlas con las matrices usuales que son estructuras de argumentos del mismo tipo. Una celda puede contener matrices, cadenas de texto y argumentos lgicos a la vez siempre que estn en celdas separadas. A diferencia de las estructuras de datos no tendremos que asignar un nombre a cada una de las celdas porque ya se les asignar un grupo de ndices. Podemos construir celdas de dos modos, el primero es declarar una variable como la estructura de datos
ell
y darle una
dimensiones. Por ejemplo construiremos una celda de 2 por 2 cuyos elementos parecidos a los contenidos en
foo:
bb foo a ell@PDPA foo a { IDI a PDI a IDP a PDP a } bb foo{IDI}aIFPQRHY bb foo{IDP}aIDPYQDRY bb foo{PDI}a9hol mundo9Y bb foo{PDP}atrueY bb foo foo a { IDI a IFPQRH PDI a hol mundo IDP a I P Q R PDP a I }
15 Si
queremos que Octave nos saque cualquier argumento por pantalla podemos usar la funcin
disp().
46
2.7. VARIABLES
Como en el caso de las matrices convencionales podremos ampliar las celdas con slo llenar una que no tenga ningn argumento asignado; las celdas sobrantes quedan vacas:
bb foo{QDI}aflse foo a { IDI a IFPQRH PDI a hol mundo QDI a H IDP a I P Q R PDP a I QDP a }
El otro modo de iniciar una estructura de celdas es hacer lo mismo que con una matriz pero usando llaves en vez de corchetes. Para iniciar las celdas
foo
bb fooa{IFPQRHDIDPYQDRY9hol mundo9Dtrue} foo a { IDI a IFPQRH PDI a hol mundo IDP a I P Q R PDP a I }
Importante:
Las celdas pueden almacenar cualquier tipo de argumento, incluso funciones. Es ms fcil y
CAPTULO 2. MATLAB
47
Cuando nuestros datos son muy complejos solemos pensar durante largo tiempo el mtodo ms adecuado de almacenar todos los datos. Crear una variable para cada trabajador no es muy recomendable porque es probable que tengamos que iterar sobre el total de ellos. Tampoco parece muy inteligente partir todos los datos en varias matrices y relacionarlas segn los ndices. La abstraccin llevada a los lenguajes de programacin modernos tiene una consecuencia muy importante:
debemos ser capaces de seguir uilizando las mismas herramientas de programacin sea cual sea el dato con el que estemos trabajando. Si un lenguaje se ha diseado con el paradigma de la abstraccin como prioridad
podremos seguir escalando la complejidad de las estructuras de datos tanto como queramos sin perder las herramientas de clculo. Matlab no es un prodigio en este sentido pero se deende bien. El elemento que mantiene la escalabilidad en las estructuras complejas de datos son los cell arrays. Al seguir una estructura matricial pueden encapsularse tantos cell arrays como queramos. Pueden contener tanto los tipos bsicos (nmeros y cadenas de texto) como estructuras de datos o otras celdas. De este modo podemos denir la estructura empleado del siguiente modo:
bb impledoIa{9quito lotes rrondo9Y9hequi9Y FFF {9hxs9DTRTVRQPITDIPIPPHHHDIPIPPHHH}Y FFF 9g fuenespernz IP IDP9Y FFF TTTPSIRVUDSSSTWVSRI} impledoI a { IDI a quito lotes rrondo PDI a hequi QDI a { IDI IDP IDQ IDR a a a a hxs TRTVRQPIT IPIPPHHH IPIPPHHH
SSSTWVSRI
bb impresa{impledoIDimpledoPDimpledoQ}
2.8. Sentencias
Como se ha dicho antes, las estructuras esenciales del lenguaje son los contadores y los condicionales. Ms comnmente conocidas como las sentencias
resto de lenguajes de programacin y de scripting existentes. La primera es un bucle contador que permite ejecutar varias tareas idnticas secuencialmente con la variacin de diversos ndices; se pueden encapsular con otros contadores y con otras sentencias. La segunda permite incluir variaciones en la ejecucin del cdigo segn el cumplimiento de ciertas condiciones lgicas. Estos no son las nicas estructuras de programacin, son las ms bsicas. A partir de ellas se derivan sentencias ms tiles y ms especcas como veremos a continuacin.
48
2.8. SENTENCIAS
Al igual que las funciones, las sentencias tienen un principio y un nal denido iniciado por una pala-
bra clave. Matlab utiliza la notacin clave-cuerpo-end al igual que Fortran; C, por ejemplo delimita estas estructuras mediante llaves y Python utiliza el sangrado. En este caso Matlab y Fortran presentan una diferencia esencial. Mientras Fortran tiene un cierre para cada una las estructuras; sistemtico de
endfor, endif...
end
do
end do,
end.
El uso
puede llevar a confusiones nefastas, es por ello que Octave tambin soporta el uso de
2.8.1. La sentencia if
Tenemos tres formas de condicional. La ms simple es:
bb estoaIY bb if esto FFF disp@9es esto9AY FFF end es esto bb estoaHY bb if esto FFF disp@9es esto9AY FFF end
Si queremos que la sentencia no se ignore, y que si la condicin no se cumple impongamos un cuerpo distinto podemos usar la estructura:
bb estoaIY bb if esto FFF disp@9es esto9AY FFF else FFF disp@9es lo otro9AY FFF end es esto
En la que se ve perfectamente que si no se cumple la condicin 1 inmediatamente se ejecuta el cuerpo2. Si tenemos ms de una condicin lgica sobre una misma variable podemos usar una condicional mltiple de la siguiente forma:
if @ondiin IA uerpo I elseif @ondiin PA uerpo P FFF elseif @ondiin nA uerpo n else uerpo x endif
CAPTULO 2. MATLAB
49
16 Debe recalcarse que la condicin debe ser sobre la misma variable para cerrar la lgica del condicional.
En el caso que tengamos condiciones lgicas sobre ms de una variable podemos encapsular los if sin ningn problema:
swith @vrileswithA se @posilevlorvrileswithA omndos se @posilevlorvrileswithA FFF otherwise omndos diionles endswith
Esta sentencia es la misma que
se
en Fortran y
swith
bb a 9dos9 bb swith @A se @9uno9A disp@9hs esogido el numero I9A se @9dos9A disp@9hs esogido el numero P9A otherwise disp@9no se que numero hs esogido9A endswith hs esogido el numero P
do
for vrile ontdoraseueni del ontdor uerpo dependiente o no de l vrile ontdor endfor
Es decir, para una determinada variable, que avanza de 1 en 1 desde el lmite inferior hasta el lmite superior ejecutamos el cuerpo. El cuerpo puede depender o no de la variable contador, sta puede ser un contador a parte, que simplemente nos imponga que una determinada sentencia se ejecute un nmero jo de veces. La mayora de las veces nuestro cuerpo depender de la variable que usemos como contador, es decir, ser un ndice de nuestro cuerpo.
elseif,
16 Mucho
cuidado los programadores acostumbrados a Fortran, sea cual sea la variante. Si nosotros usamos
else if en vez de
Matlab va a pensar que tenemos dos sentencias separadas, es decir, primero un else y luego un if dentro del else. Esto
signica que tenemos una ejecucin anmala en vez de un error. Es uno de estos casos en los que el programa nos ejecuta, nos da un resultado errneo y nosotros no vemos de ninguna manera el error de programacin
50
2.8. SENTENCIAS
Notemos que lo que utilizamos para contar una secuencia, como en el caso de las submatrices. Lo que har
el ndice contador ser tomar sucesivamente todos los valores que tengamos en la secuencia. Por ejemplo, si pedimos que una variable haga un bucle de ese tipo:
for iaIXPXIH
dentro del bucle la variable
i tomar los valores que salen por pantalla en el caso que llamemos la secuencia:
bb IXPXIH ns a I Q
Por ejemplo:
bb for iaSXSXPS FFF disp@iADdisp@9es multiple de S9A FFF end S es multiple de S IH es multiple de S IS es multiple de S PH es multiple de S PS es multiple de S
Los bucles con contador tambin se pueden encapsular, y ste encapsulado es esencial cuando trabajemos con matrices de dimensin mayor que 1. Por ejemplo, si queremos asignar una operacin compleja a una matriz de dimensin 3 debemos encapsular 3 contadores:
for iaIXswe for jaIXtwe for kaIXuwe uerpo endfor endfor endfor
En vez de controlar el bucle mediante un contador es muy til controlarlo mediante una condicin lgica. Para eso podemos usar una estructura
while.
CAPTULO 2. MATLAB
51
Slo debemos tener en cuenta cuando programamos que el uso de un while es mucho ms crtico que el uso de un for. Esto es porque la condicin lgica que controla el bucle debe aplicarse sobre una variable interna en el bucle. Entonces es probable que si programamos mal, la variable que usamos como control nunca llegue a cumplir la condicin que nos para la ejecucin. En Matlab o Octave no suele ser un gran problema, puesto que el sistema puede reaccionar y cortar el proceso de otro modo, pero en otros lenguajes puede tener consecuencias bastante desagradables. Tambin debemos tener en cuenta que los bucles controlados por una condicin lgica no permiten la paralelizacin en el caso que tengamos una versin para varios procesadores de Matlab o Octave.
en cada iteracin, es decir, el bucle no es consciente de las operaciones que se realicen con el ndice. En otros lenguajes de programacin como C o Fortran sucede todo lo contrario: todas las operaciones con el ndice son vlidas porque el bucle no se encarga de reasignarle el valor siguiente. Se limita a darle un valor inicial, incrementarlo el entero dado y pararlo segn una condicion lgica. El bucle
for
17 sobre un vector.
En la programacin moderna los bucles han desaparecido en favor de los iteradores porque los segundos son mucho ms polivalentes y seguros. Para demostrar qu signica esto de iterador sobre un vector nos sirve este simple ejemplo. Generaremos una serie de Fibonacci en un vector y luego iteraremos sobre el mismo.
bb fiaIDIDPDQDSDV fi a I I P Q S V
while
mucho menos
while
for
como para los otros tipos de bucles tenemos variables de control de la ejecucin que
rek
numaIHQY divaPY while @divBdiv `a numA if @rem @numD divA aa HA rekY endif
17 En 18 Se
informtica se dene iterador como un objeto que permite a un programa recorrer todos los elementos de un tipo iterable llama hilo precisamente a la lnea de ejecucin. Nos la podemos imaginar como la lnea de cdigo que siguen los procesos. independientemente del tipo de los elements. Este concepto va ligado ntimamente a la gestin de procesos y tiende a complicarse en lenguajes como C o Fortran.
52
divCCY endwhile if @rem @numD divA aa HA printf @9il divisor menor de 7d es 7d n9D numD divAY else printf @97d es primo n9D numAY endif
En cambio la sentencia
ontinue, en vez de sacarnos del bucle, hace que saltemos uno de los pasos del mismo
try
son de la forma:
bb arnd@SDSAYarnd@RDRAY bb try FFF B FFF th FFF disp@9himensiones inomptiles9A FFF end himensiones inomptiles
Esta estructura es muy parecida a
ifEelse
produce o no un error. Se usar cuando no sepamos si algo puede ejecutarse bien o no y no queramos que el error afecte al resto de la ejecucin del programa. Primero intentar ejecutar la sentencia que hayamos puesto en sentencia.
uerpo y si devuelve un error ejecutar lterntiv ignorando el error producido por la primera
sin y os, muchas de las presentes en la coleccin ni nos sonarn. Cumple el objetivo principal de ahorrarnos
bastante descriptivo; la funcin
tener que escribir cualquier funcin mnimamente conocida. El nombre que reciben estas funciones suele ser
se llamar
gmm y las funciones de Airy se llamarn iry. Fm, se escriben en un lenguaje compilado como C++ o Fortran para que
su velocidad sea mayor. No debemos tener miedo a usarlas tanto como sea posible.
2.9.2. La Ayuda(II)
Ya hemos hablado del comando
help
funciones de una ayuda parecida de una manera muy fcil. Todas las lneas
funtion
comando
help.
y la primera sentencia ejecutable nos saldrn por pantalla si llamamos a la funcin mediante el Por ejemplo:
CAPTULO 2. MATLAB
53
funtion outaderivdnumeri@inA 7 7 funin derivdnumeri glul ls diferenis entrds de 7 primer orden de un vetor entrdX in @vetorA slid X out @vetorA 7 FFF end
Cuando hagamos
help derivdnumeri
funin derivdnumeri glul ls diferenis entrds de primer orden de un vetor entrdX in @vetorA slid X out @vetorA
Disponemos tambin de dos funciones para manejar los errores de ejecucin,
2.9.3 tenemos un ejemplo de cmo se usan. Son de gran utilidad sobre todo cuando hagamos debugging de un programa grande. Si se produce un error en la lectura de los argumentos o en el clculo interno se imprime en pantalla toda la cadena de errores que han provocado el fallo, estos mensajes son a menudo demasiado crpticos. Si intuimos que la ejecucin puede fallar en algn sitio debemos preverlo, es una buena tctica pensar el hilo de ejecucin tanto si funciona correctamente como si no.
19
nrgin retorna el nmero de argumentos de entrada necesarios en una funcin, si lo aplicamos a entrd que acabamos de denir20 :
bb nrgin@9entrd9A ns a I
Mientras que dentro de la funcin es una constante cuyo valor es el nmero de argumentos de entrada:
funtion retvl a vg @vA 7 retvl a vg@vA v XX vetor 7 7 glul l medi de los elementos de un vetor retvl a HY if @nrgin 3a IA usge @9vg @vetorA9AY endif if @isvetor@vAA retvl a sum@vA G length@vAY else error @9vgX expeting vetor rgument9AY endif end error
19 En 20 En
Este ejemplo adems nos sirve para ver el control de errores de una funcin. Las palabras clave
usge
son los mensajes que saldrn por pantalla si se comete un mal uso o existe un error de ejecucin
texinfo
un tema muy avanzado. breve aprenderemos que la mejor manera de llamar este tipo de funciones es mediante un Function handle
54
bb help vg vg is the userEdefined funtion from the file GhomeGguillemGgursoriptingGejeriiosGvgFm retvl a vg@vA v XX vetor glul l medi de los elementos de un vetor bb vaIDPDQDRY bb vg@vA ns a PFSHHH bb uaRDQDPDIY bb vg@uDvA usgeX vg @vetorA errorX evluting if ommnd ner line VD olumn Q errorX lled from vg9 in file GhomeGguillemGgFFF bb waIDPYQDRY bb vg@wA errorX vgX expeting vetor rgument errorX evluting if ommnd ner line IID olumn Q errorX lled from vg9 in file GhomeGguillemGgFFF bb
Los corchetes son necesarios slo cuando queramos retornar ms de una variable:
bb funtion xDyDz a f@A xaIY yaPY end bb DDaf@A wrningX in f ner line UD olumn VX wrningX fX some elements in list of return vlues re undefined a I a P a bb
Si queremos saber cuantas variables de salida tiene una funcin debemos usar control muy interesante es la palabra clave palabra
return
return,
nrgout.
Una variable de
funtion out a nyzero@vA 7 out a nyzero @vA v XX vetor 7 7 devuelve un mensje si lgun elemento de v es H out a HY for i a IXlength@vA if @v @iA aa HA out a IY return endif endfor printf @9xo se h enontrdo ningun ero n9A bb uaIDPDQDHY bb vaIDPDQDRY
CAPTULO 2. MATLAB
55
2.9.4. inline
El uso que se le da a la funcin inline en esta seccin queda perfectamente cubierto por las funciones annimas. El uso de inline queda restringido a la evaluacin de una cadena de texto como funcin, no para la declaracin de funciones. Este apartado debe reescribirse
Si Matlab no puede denir funciones completas dentro de un script signica que para escribir cualquier expresin matemtica no bsica debemos crear un archivo. Esto no es del todo cierto por la sentencia
inline.
Lo que hace es interpretar una cadena de texto en la que escribimos una funcin y la conecta a una variable, como si de un puntero a una funcin se tratara. Su uso es muy sencillo, pero requiere cierta prctica. Si queremos introducir una funcin escribiremos:
bb fooainline@9sin@xABos@xA9D9x9AY
En la que obviamente introducimos los elementos como cadenas de texto. Para evaluar la funcin lo haremos del modo usual:
bb afoo@TA
que nos pondr en la variable
En el caso que nuestra funcin tenga ms de una variable de entrada podemos explicitarlas como:
bb fooPainline@9sin@xABos@yA9D9x9D9y9AY
Entonces los parmetros de entrada para la evaluacin van a ser dos y van a mantener el orden asignado en la sentencia
inline.
De hecho, este intrinsic funciona perfectamente con slo la funcin como argumento,
pero es casi un imperativo para saber cmo se introducen las variables en la evaluacin. Tambin podemos utilizar la sentencia de ello en el primer captulo cuando se introdujo el lenguaje:
bb qud@inline@9esselj@PFSDxA9ADHDRFSA ns a IFIIUV
Para integrar necesitamos una funcin de una sola variable de modo que hemos creado una nueva funcin con la sentencia
inline
esselj.
argumento. Esta prctica es muy frecuente y til, pensemos que por cada vez que utilicemos un ahorramos un archivo.
inline
nos
d.
vrsin
la
sin
bb vrsin a dsin
Introduccin informal a Matlab y Octave
56
A partir de ahora la variable sirve de interfaz a la funcin. Da igual que la funcin sea parte de la biblioteca estndar o que la acabemos de escribir nosotros mismos. Por si hay alguna duda de que funcin seno:
vrsin
es ahora la
bb vrsin@piGPA ns a I
Un uso muy interesante de los Function handles es la creacin de estructuras de datos con funciones. Como ejemplo crearemos unas celdas donde los elementos sean las funciones trigonomtricas bsicas:
inline
pero lo reco-
mendable es utilizar un Function handle. Por ejemplo, para hacer la siguiente integral mediante la funcin
qud:
I=
0
sin(x) dx
inline
utilizar un Function handle para declarar una funcin con la siguiente sintaxis:
d@rgumentosA senteniejeutle
Por ejemplo, la funcin como sigue:
fooP
inline
se escribira
CAPTULO 2. MATLAB
57
bb fooP@TDPA ns a HFIITPV
Obviamente tambin podemos utilizarlo en la cabecera de las funciones:
21 :
x=1
siendo
su nico argumento:
funtion outafhtest@rgA 7 7 funtion yafhtest@drgA 7 7 glul el vlor de l funion drg en I drg dee ser un puntion 7 rndle 7 outarg@IAY
Es muy importante crear una cabecera de ayuda cuando los argumentos de una funcin no son escalares comunes. Si no ser imposible saber que el argumento de
fhtest
crear tambin un mensaje de error en el caso que el argumento no fuera del tipo adecuado. Cuando una funcin no devuelve ningn resultado lo primero que haremos ser utilizar la ayuda:
bb help fhtest fhtest is the userEdefined funtion from the file GhomeGguillemGsynGgursoriptingGejeriiosGfhtestFm funtion yafhtest@drgA glul el vlor de l funion rg en I rg dee ser un puntion rndle
ser un alivio comprobar que existe. Para utilizar la funcin podemos llamarla directamente con un Function handle:
21 Este
cdigo provoca un error de segmentacin en Matlab 7.0.0.19901 (R14) y Octave en versiones inferiores a 2.9.12
58
bb fhtest@dsinA ns a HFVRIRU
o como siempre mediante una variable que lo contenga:
f unc = e(x
+y 2 )
bb fun@sqrt@log@SAADsqrt@log@SAAA ns a HFHRHHHH
Todas estas variables son locales para la funcin. Todas las variables de la funcin deben estar presentes en el interface. Se nos puede ocurrir reducir el nmero de variables de una funcin deniendo algunas de ellas externamente:
bb fun@PA errorX 9 undefined ner line W olumn PP errorX evluting inry opertor F 9 ner line WD olumn PQ errorX evluting inry opertor C9 ner line WD olumn PI errorX evluting prefix opertor E9 ner line WD olumn IS errorX evluting rgument list element numer I errorX lled from cunknownc9
Pero si hacemos exactamente lo mismo en Matlab...
CAPTULO 2. MATLAB
59
El programa el intrprete no nos devuelve ningn error. Esto es debido a que mientras Octave preere la denicin de variables globales como apuesta por la seguridad, Matlab es ms laxo con el acceso a las variables en el caso de los function handles. De hecho, este es el modo recomendado por los desarrolladores de Matlab para acortar algunas cabeceras mediante variables externas o para pasar parmetros a funciones dentro de funciones.
22 .
Lo ms sencillo sera hacer una funcin pasa-bajos que recibiera tres argumentos,
el espectro en frecuencias, la longitud del espectro y la frecuencia de corte. Una solucin mucho ms elegante puede ser denir una funcin de construccin que devuelve un function handle con un ltro que utilizamos como otra funcin por separado. De este modo conseguiramos reducir toda una coleccin de ltros a una nica funcin generadora. Esta prctica se llama introspeccin y es junto con la abstraccin las dos palabras claves de la programacin moderna. La capacidad de Matlab de convertir funciones en argumentos simples es la mayor potencia del lenguaje y a la vez el concepto ms complejo. Dominar bien la abstraccin a nivel de mtodos es dominar Matlab.
superiorto
inferiorto
nadie de los que lea este libro tenga necesidad de utilizar la sobrecarga jams pero puede ser til cuando se construyen prototipos de programas en Fortran 95. Tambin son tiles en el caso que estemos programando interfaces a otros programas en C++ donde el tipo de argumento es importante. Imaginemos que acabamos de implementar una funcin en C que se comporta de un modo distinto si el argumento es un nmero real o un complejo. En Octave no tendramos absolutamente ningn problema porque trata ambos tipos del mismo modo pero C es otra historia. Si nuestro cdigo fuera slo C tendramos que programarnos un interfaz que seleccionara la funcin segn la entrada; sobrecargar la funcin desde Octave es una solucin mucho ms elegante.
22 Existen
prod(1:n)
gamma(n+1)
60
2.10. ENTRADA/SALIDA
Los dos conceptos ms importantes de la programacin moderna son la abstraccin y la introspeccin. La
primera nos dice que debemos abstraernos de lo que estamos calculando, debemos centrarnos en el concepto y no ver un
PCQ
contenido de cada variable sino abstraerse tambin del mtodo utilizado. La abstraccin la dan las frmulas matemticas y la introspeccin los interfaces. Dentro de los mtodos de introspeccin uno de los ms utilizados es la sobrecarga de funciones. Es un tema bastante avanzado pero puede aportar grandes benecios en cdigos muy complejos. Sobrecargar una funcin es asignar ms de un mtodo a un nombre y aportarle un mtodo adicional para que segn el tipo de argumento se use un mtodo o otro.
dispatch
mtodo llamar utiliza una pequea referencia que asigna cada tipo a una funcin. Tambin nos permite administrar los interfaces para aadir y eliminar funciones a la sobrecarga. Por ejemplo, si utilizamos la funcin
dispth
otveXIb dispth@9exp9A yverloded funtion exp exp@fixed omplexDFFFAEbfexp@fixed omplexDFFFA exp@fixed omplex mtrixDFFFAEbfexp@fixed omplex mtrixDFFFA exp@fixed mtrixDFFFAEbfexp@fixed mtrixDFFFA exp@fixed slrDFFFAEbfexp@fixed slrDFFFA exp@gloisDFFFAEbgexp@gloisDFFFA fexp
y
gexp
son funciones llamadas builtin functions que son funciones de un nivel mucho ms bajo que no
builtin
Permite acceder a una funcin bsica ignorando el dispatch que tenga sobre ellas.
Todo lo que es potente es complejo y estos conceptos son ambas cosas. Es importante que slo usemos estas herramientas cuando las dominemos.
ihs Fm
Muestra informacin rpida sobre la variable o el nombre de la funcin. Si el argumento es una funcin o una subrutina dentro de un archivo muestra el contenido del archivo.
2.10. Entrada/Salida
Supongamos que hemos hecho un script para calcular la solucin a un problema de control y necesitamos que en el arranque el usuario nos introduzca los datos de entrada, o pongmonos en la situacin de estar utilizando un cdigo de mecnica de uidos computacional que nos escupe enormes matrices de datos en crudo. Cualquier interaccin de nuestro programa con el exterior necesitar funciones de comunicacin, ya sea un pequeo dilogo en la consola o la lectura de matrices de gran tamao. El primer caso es bastante sencillo pero el segundo requiere conocimientos bsicos de almacenamiento de datos que aprenderemos en breve.
format
Controla el formato numrico de salida por defecto. Es importante que entendamos que slo cambia
la impresin en pantalla o en un archivo, no estamos cambiando la precisin numrica real. llama con un argumento que determina el tipo de salida:
formt
se
CAPTULO 2. MATLAB
61
short long
decimal se sale de las cifras signicativas en algn caso todos los nmeros pasaran a escribirse segn la notacin cientca. Formato con 15 cifras signicativas en contenedores de 20 caracteres. Si el punto decimal se sale de las cifras signicativas en algn caso todos los nmeros pasaran a escribirse segn la notacin cientca
short e long e El mismo formato que short y long pero usando siempre la notacin cientca y denotando el exponencial con una e. short i long i El mismo formato que short y long pero usando siempre la notacin cientca y denotando el exponencial con una i. short g long g Escoge short q long q Escoge free none
entre el formato usual o la notacin cientca segn lo requiera cada
e.
i.
input
Es el equivalente a
disp
menu (tit,op1,...)
Imprime en pantalla el men con un ttulo y las opciones del argumento, cada una de las
opciones se presenta con un nmero y espera que se escoja uno de ellos por teclado. El valor retornado es el nmero de la opcin escogida. Cuando se est utilizando la interfaz grca de Matlab aparece una ventana y que muestra un botn por cada opcin Por ejemplo:
bb hoieamenu@9isto es un menu9D9uno9D9dos9D9tres9A isto es un menu I uno P dos Q tres pik numerD ny numerX Q hoie a Q
23 .
23 Uno
62
opiones.
sve.
La recomen-
dacin vuelve a ser que consultemos la ayuda. Matlab cuenta adems con la funcin
diry.
diary on,o,archivo
Para hacerlo:
bb bb bb bb bb
diry@9nomrerhivo9A diry on textoa9gr todo lo que ponemos qu9Y diry off textoPa9y h prdo l grin9Y
En el archivo de nombre nombrearchivo encontraremos la lnea:
m@PDQA
Pero los tuples tienen una funcin, la de agrupar variables. Si nos jamos en cmo es una llamada a una funcin entenderemos perfectamente la notacin escogida en muchos lenguajes para un tuple:
f@DA
CAPTULO 2. MATLAB
Podemos imaginar que lo que la funcin es un elemento del mismo. Todo este discurso sirve para entender que la denicin de las funciones en Matlab es inconsistente:
63
funtion xDyaf@DAFFF
Si
@DA es un doble... Por qu si lo que retorna es exactamente lo mismo, un doble, debemos utilizar la
misma notacin que las matrices? Esto no sera tan grave si no fuera porque Matlab verdaderamente tiene un tipo para estos casos: las celdas. Ahora podramos pensar que por lo menos las celdas se comportarn como verdaderos tuples per no. Si intentamos una doble asignacin:
funtion {xDy}af@DA
para que la asignacin
{xDy}af@PDQA
tenga sentido y convierta las celdas en autnticas tuplas. Desgraciadamente este cambio rompera todos los cdigos existentes por lo que no es posible.
dummyafun@xA adummy@IDXA
Pero si estamos utilizando el intrprete Octave podremos utilizar la llamada de ndices como sufjo de la siguiente manera:
dummyafun@xA@IDXA
Cdigo mucho ms leble para los ojos expertos. Otro caso interesante es el de los operadores
aa, CC, !, Ca
Ea
soporta, en cambio Octave s. Sustituyen esas lneas tan feas del estilo de
aCR
Por un ms leble
CaR
Introduccin informal a Matlab y Octave
64
Monkeys.
Octave es un humilde esfuerzo para paliar alguno de estos inconvenientes aunque la poltica de conseguir una compatibilidad mxima, por otro lado completamente comprensible, impide mayores cambios. Aunque esta seccin deje Octave en un mal lugar por parecer un mero imitador su labor es tremendamente importante por dos razones. Hay millones de lneas escritas en Matlab que no sern nunca portadas a otro lenguaje y demuestra a los desarrolladores de Matlab que es importante distinguir entre el lenguaje de programacin y la biblioteca de funciones. Si se extiende es incluso posible que Mathworks termine tomndolo en consideracin. Siempre he dicho que la existencia de Octave benecia indirectamente a Matlab porque la existencia de software libre siempre aumenta la difusin de una aplicacin. Dentro de la competencia comercial la alternativa ms razonable es Mathematica pero su uso parece ms adecuado a las necesidades de fsicos y matemticos. Mi apuesta personal es numpy y scipy (httpXGGsipyForg). La idea es dotar a un lenguaje de progra-
macin existente y ms conveniente de todas las funciones necesarias. Desde el inicio del proyecto ha ido ganando usuarios desilusionados o hastiados con Matlab que encuentran en Python un lenguaje directo, consistente y elegante. La maquinaria interna de Python es bastante parecida a la de Matlab pero el primero es mucho ms fcil de extender. Adems las perspectivas de crecimiento de Python son mucho ms optimistas. Hay muchas ms manos y ojos sobre el cdigo y numpy no es ms que una pequea pieza dentro de una gran maquinaria.
Parte II
La biblioteca de funciones
65
CAPTULO 3
Matrices y lgebra lineal
Se ha dicho y repetido que Matlab es un programa orientado a clculo matricial. Todo nmero en Matlab, hasta los escalares, son en realidad extensiones de matrices o matrices degeneradas. Esta caracterstica hace que todas las funciones puedan tomar matrices como argumento de forma natural. Aunque todas las funciones son en el fondo matriciales podemos clasicar unas cuantas cuyo propsito es precisamente manipular y crear matrices.
10limit .
meshdom(x,y) Equivalente a meshgrid. Se usaba en versiones anteriores de Matlab meshgrid(x,y) Crea una malla equiespaciada en dos dimensiones a partir de los vectores x e y. Retorna
dos matrices, una con la coordenada
y.
ones Devuelve una matriz de las dimensiones solicitadas cuyos elementos son todos 1 rand Devuelve una matriz de las dimensiones solicitadas cuyos elementos son nmeros
entre
pseudoaleatorios
1.
rand* zeros
donde
B pueden ser varias letras. Devuelve una matriz de las dimensiones solicitadas cuyos elementos
son nmeros pseudoaleatorios que siguen distintas distribuciones Devuelve una matriz cuyos elementos son todos ceros.
Las funciones que quizs requieran una pequea explicacin son frecuentemente y nos ser muy sencillo dominar su uso:
linspeD logspe
meshgrid.
La pri-
mera es la extensin de la secuencia (2.5.2) cuando los elementos no son nmeros enteros. La usaremos muy
bb linspe@EpiDeDPHA ns a golumns I through UX EQFIRISWQ EPFVQQIUV EPFSPRUTR golumns V through IRX EHFWVPTWP EHFTURPUU EHFQTSVTQ golumns IS through PHX IFIUTPIH IFRVRTPR IFUWQHQV logspe
EIFPWIIHT HFVTUUWS
67
68
bb logspe@EpiDeDPHA ns a golumns I through TX UFPIUVeEHR IFRTVQeEHQ golumns U through IPX SFIISTeEHP IFHRHUeEHI golumns IQ through IVX QFTPSTeCHH UFQUSTeCHH golumns IW nd PHX PFSTWTeCHP SFPPUReCHP
La funcin meshgrid es un poco ms compleja. Usaremos esta funcin cuando necesitemos una serie bidimensional de puntos equiespaciados que deniremos a partir de dos vectores, las diferencias segn el eje segn el eje
y.
Por ejemplo:
bb xxDyyameshgrid@IXPXIHDIXQXWA xx a I Q S U W I Q S U W I Q S U W yy a I I I I I R R R R R U U U U U bb HFSB@xxCyyA ns a IFHHHH PFHHHH QFHHHH RFHHHH SFHHHH PFSHHH QFSHHH RFSHHH SFSHHH TFSHHH RFHHHH SFHHHH TFHHHH UFHHHH VFHHHH
diag
Probablemente esta ltima sea la de mayor sentido fsico puesto que las matrices por bandas se encuentran muy a menudo en problemas de EDP. El ejemplo que adjunta Matlab en la ayuda de la funcin es perfecto para entender su funcionamiento:
bb m a SY bb dig@EmXmA C dig@ones@PBmDIADIA C ns a ES I H H H H H H H I ER I H H H H H H H I EQ I H H H H H H H I EP I H H H H H H H I EI I H H H H H H H I H I H H H H H H H I I I H H H H H H H I P I H H H H H H H I Q H H H H H H H H I H H H H H H H H H
dig@ones@PBmDIADEIA H H H H H H H H I R I H H H H H H H H H I S
bb iV a zeros@PDPD9intV9A iV a
69
H H H H bb iV@IDIAaIHPQ iV a IPU H H H
Por desgracia los operadores an no disponen de la versatilidad de otros lenguajes ms polivalentes como Fortran o Python; la siguiente operacin nos dar error:
bb iVBIPQFSQRDQPRFIPQYIPQFRQIDQPRFIPQ ccc irror using aab mtimes sntegers n only e omined withFFF
reshape(A,m,n,...)
Reordena la matriz
m n . . ..
manipula la forma, en el caso de que queramos ampliar su tamao en vez de aadir ceros dar un error.
transpose Traspuesta. (Ver los operadores aritmticos para su abreviatura) ctranspose Traspuesta conjugada. (Ver los operadores aritmticos para su abreviatura)
Una de las rutinas ms tiles es la siguiente:
cat(opt,a,b,...)
opt
argumentos siguientes matrices cuyas dimensiones permiten el 'pegado' entre ellas. Un ejemplo del uso de
sera:
optaP
se concatenan en sentido transversal. Esta funcin sirve como ejemplo de la gran potencia de la
notacin matricial. Es muy importante no subestimar la potencia del uso de la creacin y la modicacin de matrices con la notacin tpica como vemos en el siguiente ejemplo. Haremos el clculo anterior sin utilizar ninguna funcin:
70
ns a I I I I H H H H
Que sirva como leccin; nunca hay que subestimar la potencia de la notacin matricial.
reshpe para e.
repmat(A,[n,m,...])
nDmDFFF
Por ejemplo, si queremos crear un cubo de nmeros de lado 5 donde la tapa y el fondo sean matrices unidad y el resto sean ceros podemos hacer lo siguiente:
que sirve para concatenar matrices segn una dimensin dada. El uso
de esta funcin no tiene sentido en dimensin 2 porque sigue siendo vlida la notacin matricial siempre que
71
bb arnd@QDQAY bb arnd@QDQAY bb Y ns a HFIRRPRU HFRWIPHS HFISWUUU HFTWURHP HFUQWIHU HFPPWRHQ HFQHWWPT HFUHQWUP HFRWPUVH HFRWIPIS HFQVTSVR HFVSRIHR HFUTSWHW HFSWWIUP HFHIIRUI HFTUPHRH HFIWIHRW HFQHWTRH
a11 x1 + a12 x2 + a13 x3 + + a1N xN a21 x1 + a22 x2 + a23 x3 + + a2N xN a21 x1 + a22 x2 + a23 x3 + + a2N xN
. . .
= = = = =
b1 b2 b3
. . .
aM 1 x1 + aM 2 x2 + aM 3 x3 + + aM N xN
siempre puede expresarse de la forma
bM
ax = b
Pero una formulacin tan sencilla suele esconder grandes complicaciones. Todos coincidiremos en que aparentemente la solucin del problema anterior es:
x = a1 b
Pero el problema numrico va mucho ms all. La inversa de una matriz slo existe cuando sta es regular y no siempre tendremos tanta suerte. Buscamos una solucin al problema general de la forma
a.
se escapan en parte de los cursos de clculo numrico y plantea una dicultad adicional: el manejo intuitivo de matrices y vectores. Cuando uno se sumerge en el mundo del clculo matricial es bueno que encuentre modos de equivocarse lo menos posible. Es muy comn que multiplicaciones de matrices incompatibles acaben con un algoritmo brillante. No siempre trabajaremos con vectores columna post multiplicando matrices cuadradas. Un truco bastante utilizado en el clculo numrico es utilizar una notacin parecida a la de Einstein en la que aparecen las las y columnas como coordenadas co variantes y contra variantes:
ai xi = bj j
xi = (a1 )j bj i
Esta notacin es especialmente til porque ayuda a no equivocarse en los clculos, subndice son las y superndice son columnas. Por ejemplo para el producto de dos vectores el producto interno (producto escalar) sera:
xj yj = k
donde k es un escalar. En cambio si los dos vectores aparecen permutados obtenemos el producto externo de dos vectores en el que se amplan los ndices:
yj xi = ai j
Para entender perfectamente la siguiente operacin utilizaremos Matlab:
72
y k z k ai xi bj k
Cules sern las dimensiones de la matriz (o vector o escalar) resultante? Tenemos claro desde un principio que
es una matriz,
un vector columna e
y k z k ai xi bj = cj k
donde la repeticin de ndices en una misma posicin signica operacin escalar y no matricial. Vamos a exponer un ejemplo de la operacin para conseguir una idea ms grca:
y z
@@@yFBzABABxAB
aj xj = bi i
Es el problema ms importante del anlisis numrico. Casi todos algoritmos se reducen al planteamiento de un sistema de ecuaciones lineales. Los ms interesantes son los que vienen de una ecuacin en derivadas parciales. Las diferencias nitas, volmenes nitos, elementos nitos y mtodos espectrales terminan en la formulacin de un problema de este tipo. El anlisis preciso de estos problemas es una parte esencial de cualquier curso de anlisis numrico y tiene muchos claros y oscuros dependiendo siempre de la forma de la matriz
a.
73
es cuadrada y regular
a a
=a
lineales .
x = a1 b
Matlab proporciona con el operador resolucin de ecuaciones lineales un mtodo
universal
para resolver
estos problemas. Aunque Matlab sea capaz de darnos herramientas sencillas para resolver estos sistemas con matrices de gran tamao, en la referencia [3] se mencionan algunas de las dicultades planteadas. Cuando hemos clasicado los mtodos de resolucin segn las caractersticas de la matriz del sistema hemos diferenciado tres maneras de resolver el problema: los mtodos directos, los iterativos y el uso de las matrices sparse. Los tres mtodos no son exclusivos ya que las matrices sparse no son ms que un mtodo de almacenamiento alternativo para ahorrar memoria; hablaremos de ellas ms adelante. Cundo utilizar un mtodo directo o un mtodo iterativo es una sutileza necesaria puesto que ahorra quebraderos de cabeza importantes.
a,
cuando la
matriz est densamente llena de nmeros (no estemos utilizando almacenamientos alternativos como matrices sparse) y el tamao sea moderado. En el caso de las matrices sparse los algoritmos de resolucin algebraicos (descomposicin LU o Cholesky) no pueden competir en la mayora de los casos con la rapidez de los mtodos iterativos. Cuando las matrices son demasiado grandes la resolucin puede ser muy costosa. Esto no signica que Matlab sea incapaz de resolver sistemas de ecuaciones de gran tamao. Lo ms importante a parte de todas las consideraciones anteriores es recordar que Matlab cuenta con el operador universal es idntica a clara. Todos entendemos fcilmente la regla de la divisin:
a b1 ,
que permite resolver cualquier sistema de ecuaciones, la regla mnemotcnica es bastante f racab se calculara como G. Esta operacin
aunque en el caso matricial no sera rigurosamente cierto. La barra apunta hacia la
variable sobre la que se calcula la inversa. Parece una buena regla que la divisin apuntando a la variable invertida.
74
Pues del orden de la precisin de los propios clculos. Los algoritmos de resolucin de Matlab son muy sosticados mtodo directo o uno iterativo se debe principalmente a motivos de velocidad. Utilizaremos un mtodo
iterativo slo en el caso de que exista una ganancia de velocidad apreciable o una ventaja en la aplicacin del algoritmo de resolucin como se ve en el ejercicio resuelto 9.5.
100n,
iteraciones necesarias. Por supuesto en el caso que casi todos los elementos de la matriz sean distintos de cero. En el siguiente apartado veremos cmo tratar las matrices casi vacas. Quizs el mtodo iterativo ms utilizado es el del Gradiente Conjugado Precondicionado o PGC que analizaremos tambin en la siguiente seccin. Una de las posibilidades de las funciones que implementan mtodos iterativos es que no necesitan una matriz del sistema, les basta con una funcin que calcule veremos a continuacin.
ax.
Esto es ideal para formular los problemas de un modo alternativo o para utilizar las matrices sparse como
n siendo n el
nmero de elementos de la matriz. Hay multitud de casos de sistemas cuyas matrices son sparse, un ejemplo clsico son las matrices generadas por esquemas de elementos nitos tanto en el caso de mallas estructuradas como el de no estructuradas. La nalidad del uso de las matrices sparse es triple. Primero ahorrar la enorme cantidad de memoria desperdiciada almacenando una matriz llena de ceros; segundo, denir mtodos para realizar todas las operaciones disponibles en una matriz pero en el caso de almacenamiento sparse y por ltimo que los errores de resolucin no sean los equivalentes a resolver una matriz con
n.
Resumiendo,
aprovechar la forma de la matriz para obtener todas las propiedades beneciosas que se pueda.
Si la matriz argumento es sparse retornar verdadero. Si la matriz es cuadrada retorna el nmero de elementos por lado, si no lo es retorna falso.
Es un mtodo muy utilizado cuando ya sabemos que nuestra matriz va a ser sparse. Pinta un diagrama cuyos puntos son los elementos de la matriz que son distintos de cero. Un ejemplo de su uso se encuentra en la seccin 3.3.4.3.
Row Storage, Compressed Column Storage, Block Compressed Row Storage, Compressed Diagonal Storage, Jagged Diagonal Storage y Skyline Storage.
rutinas de las bibliotecas ATLAS y LAPACK, una autntica maravilla de la tecnologa. parte de los cursos avanzados de anlisis numrico y no suelen entrar en los planes de estudios de las
carreras de ingeniera. Son sin embargo una herramienta muy potente y en algunos casos imprescindible para resolver problemas de ingeniera bastante tpicos. No podramos resolver problemas de grandes estructuras sin la existencia del almacenamiento de matrices
sparse
y su relacin con los mtodos iterativos. Merece la pena echarle un vistazo a la bibliografa aunque lo ms
75
Probablemente el ms sencillo sea el primero. El algoritmo descompone la matriz en tres vectores, uno con los elementos de la matriz distintos de cero, otro con el ndice de columna donde se encuentra y un tercero el ndice de los vectores anteriores que inicia una nueva la. Si se descompone la matriz :
A=
los vectores resultado del CRS son:
10 3 0 3 0 0
0 0 0 9 0 0 7 8 7 0 8 7 8 0 9 4 0 0
2 0 0 5 9 2
0 3 0 0 13 1
val = (10, 2, 3, 9, 3, 7, 8, 7, 3, . . . , 13, 4, 2, 1) col_ind = (1, 5, 1, 2, 6, 2, 3, 4, 1, . . . , 5, 6, 2, 5, 6) row_ptr = (1, 3, 6, 9, 13, 17, 20)
El tipo de almacenamiento es oculto en Matlab principalmente por motivos de sencillez. Pero lo ms importante del uso de matrices sparse es que ni sepamos que hemos cambiado el tipo de almacenamiento. Por ejemplo, si a partir de una matriz normal pasamos a almacenamiento sparse gracias a la funcin
sprseD
sparse(M )
Almacena la matriz
bb waI H P QYH H H QYQ P H H w a I H P Q H H H Q Q P H H bb pwasprse@wA pw a gompressed golumn prse @rowsaQD olsaRD nnzaTA @I D IA Eb I @Q D IA Eb Q @Q D PA Eb P @I D QA Eb P @I D RA Eb Q @P D RA Eb Q
Nos devolver la informacin de cmo ha almacenado la matriz , nunca los vectores que est utilizando para almacenarla. Lo ms importante es que esta nueva matriz sparse puede operar con matrices de todo tipo ya sean sparse o convencionales transparentemente.
bb aIYPYQYR a I P Q R bb pwB ns a IW IP U
3 Octave
informa del tipo de almacenamiento utilizado, Matlab no dice absolutamente nada.
76
sprse no es nunca una buena opcin para crear una matriz sparse porque no tiene
absolutamente ninguna lgica. El motivo es claro, si la existencia de las matrices sparse es ahorrar memoria y aumentar la velocidad no tiene ningn sentido que tengamos que crear antes la matriz original y luego tener que liberar memoria. Entonces pensamos que sera muy cmodo contar con las mismas funciones de creacin de matrices convencionales para el caso sparse:
speye
Crea la matriz unidad en formato sparse Crea una matriz sparse con unos en los elementos que deseemos Crea una matriz sparse de nmeros aleatorios en posiciones aleatorias o siguiendo un determinado
spones sprand
patrn. Por ejemplo, si queremos una matriz sparse de nmeros aleatorios con una densidad de 0.01 y de dimensiones
100 100:
bb rndsprseasprnd@IHHDIHHDHFHIAY
Para ver cmo se reparten aleatoriamente los nmeros en la matriz utilizaremos la funcin conocemos:
spy
que ya
bb spy@rndsprseA
Y como resultado obtenemos la gura 3.1:
0
20
40
60
80
100 0 20 40 60 80 100
sprnd
spdiags
spdigs
que
dig tiene un gran sentido fsico. De hecho tiene mucha mayor utilidad en dig porque las matrices en banda entran en la denicin de matrices
sparse. La nica consideracin a tener en cuenta es que las matrices en banda se resuelven rpidamente de manera exacta mediante una factorizacin LU diseada para matrices sparse. Utilizaremos los mtodos iterativos con matrices que no cumplan ningn patrn evidente o sencillo.
3.3.4.4. Manipulacin y operaciones con matrices sparse sphcat Concatena horizontalmente dos matrices sparse de dimensiones compatibles. spvcat spabs
Concatena verticalmente dos matrices sparse de dimensiones compatibles. Calcula el valor absoluto de los elementos complejos de una matriz sparse sin cambiar el carcter de
la misma.
77
spreal
Calcula la parte real de los elementos complejos de una matriz sparse sin cambiar el carcter de la
misma.
spimag spinv
Calcula la parte imaginaria de los elementos de una matriz sparse sin cambiar el carcter de la
Sin embargo no es recomendable que utilicemos para invertir la matriz del sistema.
el caso de sistemas de ecuaciones en matrices convencionales es recomendable que optemos por el operador
trisolveF
A = U wV
donde
matrices ortogonales, o ms concretamente las matrices de una transformacin ortogonal, tienen la propiedad de mantener los ngulos en la transformacin. Las matrices de giro son un ejemplo de transformacin ortogonal. La matriz
w,
determinadas direcciones. La demostracin de la existencia de esta descomposicin va mucho ms all de los objetivos de este libro. Se utiliza la notacin
de matiz de transformacin ortogonal sus columnas deben ser vectores ortogonales; es slo un formalismo porque se demuestra tambin que la inversa de una transformacin ortogonal es tambin una transformacin ortogonal y es equivalente a su traspuesta. Ayuda escribir la anterior ecuacin especicando las dimensiones:
V 1 :
f : S T
podemos denir dos subespacios en espacios reales:
S ; el Ncleo, subespacio que forman los vectores que tienen al vector nulo f (S)de T . Por ejemplo, sean S y T los siguientes p(x) = a + bx + cx2 + dx3
Introduccin informal a Matlab y Octave
78
el espacio de funciones de
en
f : S T denida por f (p(x)) = p (x), la derivada segn la variable f (a+bx+cx2 +dx3 ) = b+2cx+3dx2 . La imagen de f es el subespacio de T formado por los polinomios de grado menor o igual que 2. El ncleo de f es el subespacio de T que forman los polinomios
Consideremos la aplicacin lineal de independiente; o sea: constantes. Si volvemos a la forma de la descomposicin propuesta por la SVD,
A(N M ) = U(N M ) w(M M ) V(M M ) N < M , es decir, un sistema con menos ecuaciones que incgnitas. En este caso f : RM RN , si ninguna de las las es combinacin lineal del resto tendremos una imagen de dimensin N y un ncleo de dimensin M N . Se cumple adems que la cantidad de valores singulares no nulos ser N y que las M N columnas asociadas a los valores singulares nulos formarn la
Tomemos la condicin de la aplicacin lineal ser base del ncleo. La demostracin de lo anterior est tambin fuera de los objetivos de este libro. Esta operacin es perfectamente vlida tambin para el caso que incgnitas. Para obtener las tres matrices de la descomposicin Matlab proporciona la siguiente funcin
N >M
svd
Descomposicin en valores singulares. Si se pide nicamente un valor de salida retorna un vector con valores singulares. Con tres valores de salida retorna la descomposicin matricial completa.
Para ejemplicar el uso de la ecuacin vamos a intentar descomponer en valores singulares la ya clsica matriz...
otveXQb aIDPDQYRDSDTYUDVDWY otveXRb DwDasvd@A a EHFPIRVR HFVVUPQ HFRHVPS EHFSPHSW HFPRWTR EHFVITSH EHFVPTQR EHFQVUWR HFRHVPS w a ITFVRVIH HFHHHHH HFHHHHH HFHHHHH IFHTVQU HFHHHHH HFHHHHH HFHHHHH HFHHHHH a EHFRUWTUI EHFUUTTWI EHFRHVPRV EHFSUPQTV EHFHUSTVT HFVITRWU EHFTTSHTR HFTPSQIV EHFRHVPRV
Efectivamente, uno de los valores singulares es nulo debido a que la matriz es singular. Para analizar ms en profundidad las matrices, Matlab proporciona adems las siguientes funciones:
rank null
Calcula el rango de la matriz, es decir, el nmero de valores singulares no nulos o la dimensin de la imagen de la aplicacin. Calcula la dimensin del ncleo de una aplicacin lineal expresada por una matriz, esto es, el nmero de valores singulares nulos.
x = a+ b + v
donde
es una combinacin lineal cualquiera de vectores del ncleo denido por la matriz
a.
Se demuestra
r |ax b|
v = 0.
Acabamos de deducir la forma de cualquier solucin hallada por el mtodo de los mnimos
cuadrados. En el apartado 6.1.1.1 analizaremos las propiedades de la SVD en el clculo de ajustes polinmicos de series de datos.
79
3.4. Autovalores
eig
Calcula los autovalores y autovectores de una matriz cuadrada.
80
3.4. AUTOVALORES
CAPTULO 4
Grcos
La representacin grca de funciones y de series de puntos es uno de los fuertes de los lenguajes de scripting cientco. Todos ellos tienen rutinas para dibujar, de modo sencillo y rpido, grcas de funciones. Matlab est orientado al dibujo de grcas elementales. Para visualizacin en tres dimensiones ser mejor optar por otra aplicacin ms especializada . Para las necesidades bsicas es ms que suciente. Sus funciones se pueden clasicar en dibujo de lneas, grcos estadsticos, grcas de contornos y supercies. Hay una gran variedad de funciones, aqu slo veremos las ms importantes. Pero antes de dibujar nada es conveniente que conozcamos infraestructura de grcos de Matlab .
tengamos ninguna ventana activa Matlab la llamar por nosotros. Ser necesario llamarla cuando queramos utilizar varias ventanas a la vez. Supongamos que acabamos de dibujar una curva en una ventana nueva con
bb plot@IDPDQA
Matlab abrir una ventana de nombre gure 1 ventana tendremos que llamar la funcin se encuentre activa, por ejemplo:
otra rutina grca, sea cual sea, la va a dibujar en la ventana activa, gure 1. Si queremos dibujar en otra
figure
bb figure@PA
A partir de ahora la ventana 1 va a estar inactiva y todo lo que dibujemos va a expresarse en la ventana 2.
figure
tambin sirve para volver a dibujar en una ventana existente pero inactiva, slo tenemos que darle
bb figure@IA
1 Matlab
no es un visualizador. Los visualizadores son bibliotecas o programas especializados en la exploracin de datos en 3 dimensiones. Supongamos que tenemos que manejar varios gigabytes en datos y necesitamos lneas de corriente, isosuperfcies transparentes... Si la complejidad es moderada nos servir algn programa de visualizacin pero en casos extremos ni esto ser suciente. La solucin ser crear un programa o una subrutina con algn lenguaje de alto nivel como C++, Java o Python utilizando las funciones de la biblioteca de visualizacin. Muchos de los visualizadores son interfaces grcos para ayudarnos a manipular estas funciones sin tener que escribir cdigo. Una empresa que durante muchos aos ha comercializado las mejores herramientas de visualizacin, tanto a nivel de hardware como de software, es SGI (Silicon Graphics). Esta empresa creci vendiendo estaciones de trabajo y desarroll una de las libreras ms conocidas para grcos 3D, OpenGL. Las herramientas de visualizacin estn encima de la capa bsica de OpenGL que es lo que manipula las funciones bsicas del dibujo. Tres de las bibliotecas ms importantes son OpenInventor de SGi, Data explorer o DX de IBM y VTK (Visualization ToolKit).
2 Octave
no tiene rutinas grcas propias, usa una aplicacin a parte llamada Gnuplot. Si nuestra instalacin de Octave
no va acompaada de Gnuplot no podremos dibujar absolutamente nada. Gnuplot es un programa bastante limitado y tiene una sintaxis distinta a Matlab, sin embargo Octave ofrece una capa de compatibilidad bastante decente que ir mejorando en futuras versiones. Algunas de las funciones comentadas tienen una implementacin distinta en Octave.
3 Octave
llama a las ventanas contando a partir del cero, Matlab las cuenta a partir del uno.
81
82
4.2.
TEXT.
Cuando dibujamos en una ventana activa en la que ya haba previamente una grca Matlab la borra automticamente. Lo que hace es llamar implcitamente la funcin a la anterior usaremos la funcin
hold.
bb hold on
Y cuando hayamos terminado:
bb hold off
Podemos tener la necesidad de dibujar varias grcas en una misma ventana, para ello existe la funcin
suplot.
figure
tres argumentos, el primero son el nmero de subgrcas por la, el segundo el nmero de subgrcas por columna y el tercero es la subgrca que activamos en cada momento. Por ejemplo el script:
suplot
ttulos y nombres de ejes como veremos a continuacin. Para activar y desactivar la cuadrcula se usa la funcin para activarla y
xes
grid off
grid
hold,
con
grid on
para desactivarla. Para ajustar los ejes a los valores deseados tenemos la funcin
a la que hay que pasarle un vector de datos. Encontraremos un ejemplo en la seccin 4.3.
title, xlel,
ylel
CAPTULO 4. GRFICOS
tomarn por el nombre de la grca, del eje y en la gura 4.2:
83
y del eje
1.0
0.5 Amplitud
0.0
-0.5
-1.00
100
200
Tiempo
300
400
500
En el caso que tengamos varias curvas en la misma grca podemos dar un nombre a cada una de ellas mediante la funcin
caracteres especiales o letras griegas. Para hacerlo hay que tener nociones bsicas de T X . Matlab por E defecto interpreta todos los caracteres empezados con una barra invertida \ como palabras clave en T X E como en el script siguiente que produce la gura 4.3:
x a linspe@HD SHHD IHHHHA plot@xDexp@ExGIHHABsin@xAA title@9{ it e e} {E lph it t}sin et{ it t} xlel@9iempo @ mu sA9A ylel@9emplitud @mA9A
lph`` et9A
caracteres especiales en cualquier punto de una gura. Como es de esperar es una funcin que requiere muchos argumentos de modo que tendremos que leer la ayuda cuidadosamente. Es una funcin que nos permite hacer cosas muy interesantes como la que se muestra en la gura 4.4. Es un ejercicio muy interesante que intentemos programarlo; el sombreado se consigue con la funcin
fill.
4 Podis
84
1.0
0.5
Amplitud (mV)
0.0
-0.5
-1.00
100
200
Tiempo (s)
300
400
500
f(x)
b a
a
f(x)dx
b
text
plot.
plot
Esta funcin dibuja curvas en dos dimensiones. Soporta mltiples combinaciones de argumentos. La llamada ms sencilla es:
bb plot @A
donde Y es la serie de ordenadas mientras que como coordenada X se toma la serie correspondiente a contar los puntos empezando desde 1. Si queremos pasarle ms argumentos plot los va a interpretar de la forma:
CAPTULO 4. GRFICOS
85
bb plot@DDpwDDDpwDFFFA
Los elementos X e Y son interpretados del modo siguiente: si ambos argumentos son vectores se representa la serie de puntos denida por los dos; esto implica que deben ser de la misma longitud. Si el primer argumento es un vector y el segundo es una matriz se representan las curvas correspondientes al vector junto con cada una de las las o columnas de la matriz. Se prueban primero las columnas, si es imposible la representacin luego se prueban las las; si ambos fallan se obtiene un mensaje de error. Si el primer argumento es una matriz y el segundo es un vector se acta de la misma manera. Si ambos argumentos som matrices se toman como datos para curva las columnas; requerir que tengan una forma idntica. FMT es el argumento que dene el tipo de lnea. Es una cadena de texto y en su ausencia se tomar como formato bsico la lnea slida. Para saber los tipos y colores de lneas disponibles mediante el formato consultaremos la ayuda.
xalinspe@EpiDpiDIHHAY plot@xDsin@xAD9mX9DxDos@xAD9k 9DxDtn@xAD9x9A xis@EpiDpiDEPDPA grid on legend@9line de puntos mgents9D9tringulos negros9D9rues zules9A
Dibuja en pantalla la el equivalente a la gura 4.5:
semilogx semilogy Dibuja una curva bidimensional utilizando una escala logartmica en el eje x e y respectivamente. loglog Dibuja una curva bidimensional utilizando una escala logartmica en ambos ejes. errorbar Dibuja una curva bidimensional con las barras de error correspondientes. Las combinaciones de
argumentos son parecidas a las de la funcin
plot.
bb errorr @DiA
Si la funcin plot acepta dos argumentos antes de dar el formato de curva, para entender su uso.
error
datos y cuatro para cada direccin de error en el punto. Al igual que en el caso anterior utilizaremos la ayuda
polar
86
hist
Dibuja un histograma. Con un nico argumento el resultado es un histograma con diez contenedores. El intervalo de datos de cada contenedor se calcula a partir del argumento. El segundo argumento es siempre el vector de puntos donde debe centrar cada uno de los contenedores. Las fronteras se determinarn como el punto medio entre el centro dado y el siguiente. El tercer argumento es siempre un escalar que sirve para normalizar el histograma de tal manera que la suma de todas las barras ser igual al mismo.
pie
Muestra los valores dados en una grca tipo tarta. Matlab normaliza los datos automticamente para que la suma de los datos sea el total de la tarta. Para separar alguna de las porciones podemos utilizar la opcin
explode;
ontour es congurable, rpida y muy fcil de utilizar. El ejemplo ms sencillo es utilizar la peks que genera una matriz de 49 49 representando las alturas de una supercie paramtrica:
CAPTULO 4. GRFICOS
87
bb ontour@peksA
45
40
35
30
25
20
15
10
5 10 15 20 25 30 35 40 45
peks.
Tambin podemos introducir tres vectores correspondientes a las coordenadas de los puntos en el espacio. Esta opcin es muy til en el caso de estar trabajando con datos estadsticos o de representar resultados obtenidos con mallas no estructuradas. Probablemente la opcin ms interesante sea la de poder introducir las curvas de nivel que deseemos en cada caso. En el siguiente ejemplo quince curvas de nivel:
bb ontour@peksDlinspe@mx@mx@peksAADmin@min@peksAADISAA
Introduccin informal a Matlab y Octave
88
GET
SET
45
40
35
30
25
20
15
10
10
15
20
25
30
35
40
quiver Dibuja un campo de vectores bidimensional. Suele utilizarse con la funcin grdient. mesh Dibuja una malla representando la superfcie paramtrica tridimensional dada por los argumentos surf Equivalente a mesh pero dando una apariencia slida a la superfcie meshc Funcin que combina mesh con ontour, es decir, dibuja la malla de la superfcie tridimensional
mientras que en el plano
z=0
view
que el ratn ya que nos ayuda a controlar las rotaciones con ngulos conocidos.
get
set
es que la
manipulacin del aspecto de un grco es independiente de la representacin de datos. Entenderemos muy fcilmente el funcionamiento de estos comandos si volvemos brevemente al comando plot. Si en vez de ejecutar el comando como sugerimos anteriormente le pedimos que devuelva un resultado:
bb paplot@IDPDQA
A parte de obtener la ventana habitual dispondremos de un handle al propio grco. Este handle tiene en Octave 3.0.0 la estructura siguiente:
CAPTULO 4. GRFICOS
89
bb get@pA ns a { tg a type a line prent a EIFVRHP hildren a @HxHA modified a I xdt a I P Q ydt a I P Q zdt a @HxHA ldt a @HxHA udt a @HxHA xldt a @HxHA xudt a @HxHA olor a H H I
linestyle a E linewidth a HFSHHHH mrker a none mrkeredgeolor a uto mrkerfeolor a none mrkersize a I keylel a interpreter a tex
Este no es el nico modo de obtener el handle de un grco, tambin podemos utilizar las funciones
siguientes: GCF GCA GCO GCBF GCBO get current gure (handle a la gura activa) get current axes (handle a los ejes de la gura activa) get current object (handle al objeto activo) handle a la gura padre del objeto activo handle al objeto padre del objeto activo
bb get@pD9linestyle9A ns a E
Entonces la funcin
set sirve para modicar cualquiera de estas propiedades como en el ejemplo siguiente:
90
GET
SET
CAPTULO 5
Clculo y Anlisis.
Este captulo trata de todas las funciones dentro de la biblioteca relacionadas con el clculo innitesimal y el anlisis matemtico. Matlab no es un lenguaje de clculo simblico, no calcula ni derivadas ni primitivas. Todas las rutinas de este captulo estn enfocadas al clculo numrico.
5.2. Polinomios
En Matlab los polinomios se almacenan como vectores de coecientes. Cada componente del vector es un coeciente ordenado del trmino de mayor a menor orden. La manera ms habitual de iniciar un polinomio es utilizar la siguiente funcin:
poly
Inicia un polinomio. Si el argumento es una matriz cuadrada devuelve el polinomio caracterstico, si es un vector devuelve un polinomio cuyas races son los elementos del vector.
roots Devuelve las races del polinomio cuyos coecientes son los elementos del vector argumento. polyval Calcula el valor del polinomio en el punto dado polyout (Octave) Escribe un polinomio en un formato ms leble:
Por ejemplo, si queremos escribir el polinomio
polyder Deriva un polinomio. polyint Integra analticamente un polinomio. conv Multiplica dos polinomios. deconv Dados dos polinomios a e y halla b y r que cumplen:
y = (a b) + r
91
92
5.3. DERIVADAS
Descompone el cociente de dos polinomios en fracciones con un nico polo. Por ejemplo, dados los
residue
polinomios
p = s2 + s + 1
q = s3 5s2 + 8s 4
la descomposicin sera:
3 2 7 s2 + s + 1 + = + 3 5s2 + 8s 4 2 s s 2 (s 2) s1
5.3. Derivadas
Todas las funciones de este apartado se reeren a la derivada numrica. No son derivadas de una funcin analtica sino el resultado de aplicar las ecuaciones de diferencias de orden ensimo a una serie discreta de puntos.
di
Aplica la frmula de diferencias ensimas a una serie de puntos Calcula el gradiente numrico de una matriz. Esta funcin es muy interesante por su relacin
gradient
quiver.
5.4. Integrales
La integracin es un vasto campo del clculo numrico y as se reeja en Matlab. Podemos hacer tanto integrales en una dimensin como en dos. Las rutinas ms relevantes son:
quad quadl
Integracin numrica de una funcin Su uso es idntico que la funcin anterior pero contiene un algoritmo de cuadratura de mayor precisin. Calcula la integral doble de una funcin de dos variables.
dblquad
qudPd
qudPdg
en Octave. En
el primer caso utiliza una cuadratura de Gauss-Chebyshev y en el segundo utiliza un esquema de integracin de Gauss.
triplequad trapz
Aplica la regla del trapecio para calcular la integral numrica de una serie discreta de puntos.
El nico misterio que puede tener la integracin numrica es cmo pasar la funcin a integrar como argumento. La manera recomendada de hacerlo es, como siempre en el que una funcin sea un argumento, con un function handle o una funcin annima. Por ejemplo, para calcular esta integral:
sin(x) cos(pi) dx
o
utilizaremos el cdigo siguiente:
bb qud@d@xA sin@xABos@xADHDPBpiA
Difcilmente encontraremos un caso en el que, teniendo la forma de la funcin analitica, sea necesario ms que una funcin annima. Las dudas llegan cuando se quiere integrar una serie de datos y no se dispone de ninguna funcin. Si disponemos de una serie de datos unidimensional
(x, y)
trapecio. Podemos utilizar una interpolacin con splines para llegar hasta orden 3 en la integracin. El truco es crear una funcin annima que llame a la interpolacin como sigue:
93
(x, y, z).
interpP
para generar la
griddt
dlqud
He tenido experiencias francamente malas con la integracin bidimensional en Matlab, sobretodo con integrales con dominios grandes o integrales impropias convergentes. Quizs la manera ms sencilla de conseguir que Matlab de un resultado errneo es integrar la campana de Gauss bidimensional en todo el espacio real bidimensional. Octave, en cambio, consigue llegar a un resultado correcto con la integracin por cuadratura de Gauss.
1 Los
algoritmos de integracin por cuadratura numrica escalan mal con el nmero de dimensiones a integrar. En el caso de
94
La precisin numrica es tambin muy importante pero el mismo esquema de integracin es capaz de controlarla. Daremos como vlido que a mayor precisin numrica mayor dicultad para obtener una solucin estable. Las diferencias entre Matlab y Octave en este caso son ms que signicativas. Octave dispone de las funciones de integracin de Matlab pero existen slo por motivos de compatibilidad, son mucho ms lentas y no se pueden congurar. Sin embargo Octave integra la suite ODEPACK, uno de los paquetes de integracin de EDOs ms robusto y efectivo.
5.5.1. Octave
Octave cuenta con las funciones de integracin de Matlab pero estn programadas como archivos no como parte de una biblioteca binaria. Es muy recomendable que utilcemos la funcin
lsode
2
Fm
(Livermore
Solver for Ordinary Dierential Equations), parte de ODEPACK. Utiliza un mtodo multipaso Adams Para problemas no sti y una BDF (Backward Dierentiation Formula) para los problemas sti.
lsode
dy = f (x, t) dt
dadas las condiciones iniciales.
pgx
Matriz de dos elementos tipo cadena de caracteres. El primero es el nombre de la funcin que queremos integrar y el segundo la funcin que calcula el jacobiano.
La funcin a integrar debe denirse necesariamente mediante una funcin, ya sea dentro del script o en un archivo a parte. La cabecera tendr slo dos variables y su forma ser
hyapxg@DA
donde tanto
como
hy
tegapteg@DA
donde variable
teg ser la matriz que implemente las funciones derivadas parciales . Se usa para acelerar la integracin en problemas sti.
Vector que determina los instantes temporales en los que se dar una solucin. Puntos en los que la rutina no debe integrar por la existencia de singularidades.
gs
sei
devolver el valor 2 y
wq
lsode_options
2 Personalmente
Funcin de conguracin de
lsode
creo que ste es uno de los pocos casos en el que Octave es superior a Matlab. Ni entiendo ni comparto la
organizacin de las rutinas de integracin de Matlab, me parece confusa, desacertada y poco ptima.
95
9solute tolerne9 9reltive tolerne9 9integrtion method9 9initil step size9 9mximum order9 9minimum step size9 9step limit9
9dms9 o 9nonEstiff9 para un esquema explcito o 9df9 o 9stiff9 para un esquema implcito
El valor del primer paso de integracin. Es un escalar Un nmero del 1 al 12 para 5 para
9stiff9
automtico rdenes mximos 0 100000
9stiff9
9nonEstiff9
y del 1 al
lsodeoptions
5.5.2. Matlab
El planteamiento de las rutinas para ODEs de Matlab es completamente distinto. En vez de tener una funcin que sirve ms o menos para todo nos permite escojer el mtodo de integracin. Disponemos de los presentes en la tabla 5.2: Funcin Tipo de problema no sti no sti no sti sti sti sti no sti/sti sti Observaciones Esquema Runge Kutta (4,5). Debe ser la primera opcin Esquema Runge Kutta de menor orden. Mayor estabilidad que
odeRS.
Mtodo multipaso de mayor precisin Para problemas sti. Mtodo completamente implcito. Lo usaremos en casos puntuales Primera opcin para problemas sti. -
D a solver@odefunDtspnDyHA D a solver@odefunDtspnDyHDoptionsA DDiDiDsi a solver@odefunDtspnDyHDoptionsA odefun es la llamada convencional a una funcin, preferiblemente un function handle. A diferencia de lsode
la funcin debe tener la forma:
y su resultado
96
usuales, ejemplo
son respectivamente los vectores tiempo y solucin del problema. En breve propondremos un
Tambin es necesario que conozcamos la funcin de conguracin bastante mayor a las disponibles en
lsode
odeset.
La cantidad de opciones es
mx x + (x ) + kx = 0
No es ms que el movimiento de una masa oscilante con amortiguamiento lineal y no lineal a la vez. Adimensionalizando el problema llegamos a la ecuacin.
x + x + (x 2 1)x = 0
Esta ecuacin tiene la particularidad de que a medida que el parmetro sti. Con un
de orden unidad el sistema puede considerarse no sti mientras que si aumenta hasta ser
del orden del millar la ecuacin introduce gradientes muy acusados. Este comportamiento tan particular la hace perfecta para ensayar los distintos mtodos de integracin. Lo primero es descomponer la ecuacin en un problema que Matlab pueda entender:
dy1 dt dy2 dt
con condiciones de contorno para Octave en C++: Matlab ya cuenta con estas funciones (vdpI y
= y2 2 = y2 (1 y1 ) y1
y1 (0) = 2 e y:2 (0) = 0. Resolveremos el problema para = 1 y = 1000 porque vdpIHHH). Para agilizar los clculos escribiremos las funciones
5inlude `otveGotFhb hipxhvh @vdpIDrgsD D 4iuion de n der ol pr muaI 4A { golumnetor xdot @PAY golumnetor x @rgs@HAFvetorvlue@AAY flot muaIY xdot@HA a x@IAY xdot@IA a muBx@IAB@IEx@HABx@HAAEx@HAY return otvevlue @xdotAY }
Y la funcin para
= 1000:
5inlude `otveGotFhb hipxhvh @vdpIHHHDrgsD D 4iuion de n der ol pr muaIHHH 4A { golumnetor xdot @PAY golumnetor x @rgs@HAFvetorvlue@AAY flot muaIHHHY xdot@HA a x@IAY xdot@IA a muBx@IAB@IEx@HABx@HAAEx@HAY return otvevlue @xdotAY }
97
10
15
20
=1
= 1000
t [0, 3000]
98
Octave
line 1
500
1000
1500
2000
2500
3000
= 1000
x1 x2 x3
Despues de introducirlo en la funcin
= x1 + x3 x2 = x2 + (x3 3,75)x1 = 1 x1 x2
rikitkeFmX
99
odeRS
Octave :
-2
-4
-6
50
100
150
200
250
300
Figura 5.3: Solucin del dipolo de Rikitake A primera vista puede parecer que la solucin est mal. Si representamos exactamente el mismo resultado pero mediante una curva paramtrica:
bb plotQ @x@XDIADx@XDPADx@XDQAA
llegamos a la gura 5.4.
line 1
7 6 5 4 3 2 1 2 3
-6
-4
-2
6 -3
-2
-1
Figura 5.4: Curva solucin del dipolo de Rikitake De este ejemplo aprendemos que las ecuaciones diferenciales no lineales pueden tener un comportamiento extrao. Un ejemplo claro de ello son las ecuaciones de Navier Stokes. Si simplicamos las ecuaciones para
4 Por
ode_fcn_format?
Introduccin informal a Matlab y Octave
100
ujo incompresible nos encontraremos un trmino lineal (el viscoso) y uno no lineal (el convectivo). El estudio analtico de estas ecuaciones an no ha llegado a la conclusin sobre la existencia y la unicidad de la solucin , sin embargo se resuelven por mtodos numricos. La turbulencia, uno de los fenmenos fsicos ms complejos, aparece de forma espontanea cuando intentamos resolver las ecuaciones de N-S. Parte de la disciplina de la CFD (Computational Fluid Dynamics) es estudiar los ujos turbulentos a partir de la resolucin numrica de las ecuaciones de N-S. La conclusin es que la integracin numrica de ecuaciones diferenciales es un problema complejo no slo por la fsica del problema sino porque adems se suman muchos otros factores. En esta pequea introduccin slo hemos visto los problemas sti y un caso muy sencillo de caos pero los problemas pueden complicarse muchsimo ms.
simblico suelen incluir un interfaz llamado notebook que sirve para ver las frmulas de entrada y salida en una notacin mucho ms matemtica. Las diferencias en el diseo de un programa de clculo numrico y otro de clculo simblico son a mi parecer irreconciliables. Esto no signica que sea un crimen utilizar las funciones de clculo simblico cuando uno disponga de ellas. Somos libres de hacer lo que queramos pero debemos ser conscientes de hasta qu punto no estamos utilizando la herramienta ideal para nuestro fn. Octave tambin dispone de un soporte muy limitado para realizar operaciones simblicas. Se podra decir que lo nico que puede hacer es derivar y resolver sistemas de ecuaciones lineales. Tampoco parece que en un futuro cercano estas funcines se amplen hasta un soporte equivalente al de Matlab. No son compatibles pero las funciones son tremendamente parecidas. Los siguientes apartados sirven como introduccin general al uso de variables simblicas pero no conseguiremos ms que araar la supercie del total de las posibilidades del toolkit.
bb symols
Tanto en Matlab como en Octave el modo ms fcil de denir una variable simblica es crear una variable que contenga un argumento simblico del mismo nombre:
sym
Dene una variable que contiene un argumento simblico. Es muy recomendable que la variable y el argumento tengan el mismo nombre para evitar confusiones
bb x a sym@9x9A
poly2sym
101
sin x
en Matlab haremos:
subs Substituye una o varias variables de una expresin simblica. collect Agrupa los trminos polinmicos en una variable dada. expand Desarrolla una expresin simblica. dierentiate Slo en Octave. Calcula la n-sima derivada de una expresin simblica.
Funcin que en Matlab recibe un nombre distinto:
di
int Encuentra la primitiva de una funcin simblica limit Calcula el lmite hacia un determinado valor de una funcin simblica. taylor Calcula el desarrollo en serie de Taylor respecto a un punto dado de una funcin simblica. symsum Calcula la suma de dos series.
Una de las pocas operaciones compatibles es la representacin de una curva determinada por una funcin simblica:
splot
Dibuja la curva representacin de una funcin simblica de una variable. El segundo argumento es un vector de dos elementos con el intervalo de la variable independiente.
6 Siempre
viene bien recordar que la arquitectura de Matlab distingue entre maysculas y minsculas
102
CAPTULO 6
Toolkits
Las funciones que que aparecen en este captulo no son necesariamente parte de un toolkit de Matlab. No es ms que una clasicacin articial de las funciones con una nalidad concreta que no justica la creacin de un captulo a parte. Esta seccin es mucho menos amplia de lo que debera, se ha sacricado a propsito a favor de temas ms bsicos como el clculo el lgebra o el dibujo de grcas. Mientras todo lo escrito hasta aqu es casi denitivo este captulo no se considerar nunca como terminado.
mean std
x=
1 n
n n=1
xi .
1 n1 n i=1 (xi
s=
x) 2 .
median Calcula la mediana de la muestra. min Valor mnimo de la muestra. max Valor mximo de la muestra. sort Ordena los elementos de menor a mayor. center Resta el valor medio de la serie de datos.
Es bastante usual utilizar erroneamente el ajuste por mnimos cuadrados; sirven para crear un modelo polinmico de una funcin, no para conseguir una curva a travs de unos puntos; para esto est la interpolacin. Por ejemplo, supongamos que disponemos de la siguiente serie de datos:
103
104
polyt
Devuelve los coecientes del polinomio del grado que queramos y soluciona el problema de ajuste
por mnimos cuadrados. Introducimos ahora las dos series de datos e intentamos ajustarlo por mnimos cuadrados para crear un modelo
fit, este vector son los dos coecientes del polinomio que
ajusta los datos; una recta. Ahora representaremos grcamente los datos del siguiente modo
3.6
3.4
3.2
2.8
2.6
2.4
2.2
Figura 6.1: Ajuste por mnimos cuadrados de una serie de puntos Resolver un problema de mnimos cuadrados es en el fondo resolver un problema mal condicionado. Si se plantean las ecuaciones del problema llegamos a un sistema lineal mal condicionado. El criterio de resolucin suele ser el de minimizar el error cuadrtico de la solucin dada (por eso el nombre de mnimos cuadrados). Este es exactamente el mismo problema planteado en la pseudoinversa, operacin que tambin se realiza por mnimos cuadrados. Nada nos obliga a ajustar los datos mediante un polinomio; la condicin de minimizacin del error cuadrtico puede utilizarse con cualquier funcin aunque siempre ser ms sencillo hacerlo con polinomios.
CAPTULO 6. TOOLKITS
105
Una prctica muy habitual es utilizar un ajuste exponencial, tctica para la que Matlab no ha escrito ninguna funcin. El motivo es bien sencillo, si tenemos una nube de puntos que creemos sigue un modelo exponencial lo nico que debemos hacer es calcular el logaritmo de la serie de datos para lo que recuperaremos automticamente el ajuste polinmico.
y(x) = a1 + a2 x + a3 x2 + . . . + aN xN 1
Este no es ms que el tipo ms sencillo de ajuste. Podramos utilizar tambin series de funciones armnicas o funciones arbitrarias de la forma
y(x) =
k=1
en las que
ak Xk (x)
por la expresin
E =
i=1
donde
yi
N k=1
ak Xk (xi )
es la desviacin estndar de la muestra i-sima. Esta formulacin permite generar una matriz
Aij =
Xj (xi ) i = b),
la mala es que la matriz no es cuadrada y no
Matriz que posee muchas ms las que columnas. La buena noticia es que acabamos de generar un problema tan simple como una aplicacin lineal (ax una SVD para resolver el sistema. servirn los mtodos de resolucin convencionales. Una de las posibles estrategias de resolucin es utilizar
106
interp1
Usa los puntos para interpolar en una dimension. Soprota interpolacin discreta, lineal, cbica,
xfaHXHFHSXIHYyfasin@PBpiBxfGSAY xpaHXIH Yypasin@PBpiBxpGSAY linainterpI@xpDypDxfAY splainterpI@xpDypDxfD9spline9AY uainterpI@xpDypDxfD9ui9AY nerainterpI@xpDypDxfD9nerest9AY title@9gomprion de ls opiones de interpI9A plot@xfDyfDxfDlinDxfDsplDxfDuDxfDnerA legend@9rel9D9linel9D9splines9D9ui9D9disret9A
Cuyo resultado es la gura 6.2.
-0.5
-1 0 2 4 6 8 10
Figura 6.2:
interp2
De entre todos los mtodos de interpolacin a trozos el ms efectivo suele ser siempre el uso de splines. Un spline es una curva cbica; de este modo reduciremos en gran medida el error en el caso que los puntos sean
de una funcin suave, cosa que no sabemos. Cuando interpolamos por trozos es importante conocer algo de
informacin sobre la funcin que representan, no sirve ninguna formula universal Sera muy lgico en este punto plantearse la siguiente pregunta. Por qu escoger una funcin denida a intervalos y no un nico polinomio de grado igual al nmero de puntos menos 1? La respuesta aparece cuando intentamos realizar el clculo. Los polinomios de alto orden tienen tendencia a oscilar en sus extremos, es el llamado fenmeno de Runge. Como patrn diremos que todo lo relacionado con polinomios de alto orden suele acarrear problemas. Trataremos con ms profundidad la interpolacin polinmica en un dominio nito en la seccin 6.2.3.
CAPTULO 6. TOOLKITS
107
6.2.1.1. Splines
La interpolacin polinmica a trozos ms comn en Matlab es la interpolacin mediante splines. Un spline es una curva denida mediante polinomios en intervalos nitos, la interpolacin ser entonces del orden que deseemos segn el polinomio aunque lo ms frecuente ser utilizar splines cbicos. Como en muchos otros casos los splines no sirven nicamente para convertir en continua una serie de datos discreta, funcin que cumple e incluso para resolver ecuaciones en derivadas parciales. Para quien desee algo de rigor matemtico denimos un spline como el conjunto de polinomios ajustan una determinada funcin
interpI. Pueden servir tambin para analizar ms profundamente los datos estimando sus derivadas
pj (x) que f (x) en [a, b], donde cada polinomio tiene validez en un intervalo j [a, b].
Adems de imponer que la curva pase por todos los puntos podemos imponer tambin que dichos polinomios se unan suavemente al nal de sus intervalos de denicin. Podemos representar el conjunto mediante sus coecientes y los nodos ( pp form )
pj (x) =
i=1
(x j )ki cij
o como B-spline, generalizacin de las curvas de Bzier. Matlab, en su spline toolkit, proporciona funiones para calcular y evaluar con toda libertad los coecientes de una interpolacin a trozos mediante splines, piecewise spline interpolation. Algunas de las funciones disponibles son las siguientes:
Llamada con dos parmetros retorna la matriz de coecientes de la interpolacin. Llamada con tres
parmetros retorna el valor de la interpolacin en los valores dados. Evala la interpolacin mediante splines en los puntos dados dada su representacin en coecientes. Dene Dene
Un posible uso de los splines es la interpolacin de curvas en ms de una dimensin. Es un mtodo muy habitual en diseo y es la base de las herramientas de CAD con las NURBS (Non-Uniform Rational B-Splines). Mediante puntos de control y unas pocas transformaciones geomtricas los splines denen casi todas las piezas producidas industrialmente.
xaI P Q R S T U V yaP R Q S R T S U
Y queremos generar una funcin que sea capaz de proporcionar los datos de forma continua. La solucin es la creacin del siguiente function handle:
(x, y):
bb newfun@QFRRQA ns a QFWITP
La tcnica de reducir variables mediante function handles no es vlida en Octave, donde los FH son estrictamente funciones independientes.
108
u=
k=
donde
uk .
Si la funcin admite el
desarrollo anterior tambin admitir una serie truncada de fourier. Esta serie tiene la forma:
PN u =
k= N 2
que constituye la serie truncada de Fourier de orden
uk eikx N.
modo que la anterior con la diferencia que truncamos el desarrollo a partir de un cierto nmero de onda. En el clculo numrico nunca trabajaremos con desarrollos con una cantidad innita de trminos; esto es dominio del clculo simblico. Si aproximamos la funcin inicial por un polinomio interpolante denido a partir de una serie de puntos llegamos a la serie discreta de Fourier. Se dice discreta porque tiene como datos los puntos en los que se evale la funcin. Exactamente del mismo modo podramos estar trabajando con una serie de puntos experimentales. Esto generar un desarrollo discreto porque slo con unos cuantos puntos no tenemos suciente informacin como para llegar a una serie innita. Como estamos obteniendo toda la informacin posible normalmente se habla de transformada discreta de
Fourier. El algoritmo para calcularla es la t ansformada rpida de Fourier o Fast Fourier Transform (FFT).
t it
Aplica la transformada rpida de Fourier a una serie de puntos utilizando como funciones base
x (x) =
eikx .
Calcula la antitransformada rpida de Fourier.
Las t's se usan muchsimo en los mtodos espectrales, resolucin de ecuaciones en derivadas parciales lineales y no lineales, anlisis de datos y ltrado de seales. Muchos de los problemas de la fsica con condiciones de contorno periodicas son mucho ms sencillos en su formulacin espectral. transformadas de fourier
Disponemos tambin de otras funciones que encapulan tareas comunes en las que estn involucradas
tshift Mueve el primer nmero de onda (frecuencia cero) al centro del espectro. tlt Aplica directamente un ltro espectral. t2 Transformada rpida de Fourier bidimensional. Tambin disponemos de una antitransformada para esta
funcin
1 La
gran ventaja de las transformadas rpidas de Fourier es que son una operacin especialmente rpida cuando tenemos
series de
2n
N log N
resolucin de ecuaciones en derivadas parciales lineales (ecuacin de ondas) o por mtodos espectrales. Un caso especialmente importante es el de la ecuacin de Poisson ( funcin de
= f (x)).
Supongamos que tenemos las ecuaciones de Navier-Stokes en dos dimensiones. Se demuestra que se pueden reescribir en
y de
1 + = t x y y x Re
2
Imaginemos entonces que queremos resolver un problema de turbulencia 2D istropa con condiciones de contorno peridicas. Esto nos obliga a resolver una ecuacin de Poisson por cada paso temporal, operacin bastante costosa porque requiere la inversin de una matriz. Podemos ahorrarnos gran cantidad de operaciones si hacemos la transformada de Fourier de la segunda ecuacin:
2 (i, j) exp((kx + ly)) 2 (i, j) exp((kx + ly)) + = exp((kx + ly)) x2 y 2 (i, j)(k2 + l2 ) = (i, j) (i, j)
y ya
Que es un sistema de ecuaciones de resolucin trivial. Acto seguido hacemos la antitransformada de los coecientes podemos pasar al paso de la ecuacin parablica.
CAPTULO 6. TOOLKITS
109
tn
ifftn.
Las libreras de transformadas rpidas de Fourier suelen disponer de transformadas del seno y del coseno para cubrir los casos de condiciones de contorno no periodicas. Los drivers para estas bibliotecas no son tan completos en Matlab y tendremos que convertir la transformada exponencial en transformada de seno o de coseno manualmente.
x.
x a golumns I through VX EIFHHHHH EHFVUSHH EHFUSHHH EHFTPSHH golumns W through ITX HFHHHHH HFIPSHH HFPSHHH HFQUSHH golumn IUX IFHHHHH y a golumns I through VX HFHSVVPR HFHUSRUP HFIHHHHH HFIQUWQI golumns W through ITX IFHHHHHH HFVHHHHH HFSHHHHH HFQHUTWP golumn IUX HFHSVVPR
puntos de la serie. El polinomio ser entonces:
EHFSHHHH HFSHHHH
EHFQUSHH HFTPSHH
EHFPSHHH HFUSHHH
EHFIPSHH HFVUSHH
HFPHHHHH HFPHHHHH
HFQHUTWP HFIQUWQI
HFSHHHHH HFIHHHHH
HFVHHHHH HFHUSRUP
N 1
suponiendo
el nmero de
p(x) =
i
problema que se cerrar con la condicin de que
ai xi1
Ac = y
donde
coecientes y
p(xi ) = yi . Al nal se llega a la misma ecuacin de siempre: A es la matriz de Vandermonde generada con los puntos xi , c el vector de incgnitas de los y el vector de puntos de la serie yi . El vector de coecientes se genera con este cdigo:
bb avnder@xA y9 a TFRUQWeCHQ QFTVRVeEII EPFIHRHeCHR EIFHIPQeEIH PFUPUIeCHR IFHRQHeEIH EIFVPQIeCHR ESFHWQReEII TFVPTVeCHQ IFPQUQeEII EIFRURIeCHQ EIFRIVReEIP
Introduccin informal a Matlab y Octave
110
y(x) =
0.8
0.6
0.4
0.2
-1
-0.5
0.5
Figura 6.3: Demostracin del fenmeno de Runge Como vemos, la funcin interpolante cumple los requisitos impuestos, pasa por todos los puntos; pero no hace nada ms bien. Cul es entonces el problema? Qu hay que hacer para solucionarlo? La interpolacin polinmica es un problema global, es decir, intenta aproximar toda una funcin con una cantidad limitada de datos (los puntos de los que tenemos valores). A la funcin interpolante los rboles no le dejan ver el bosque, si quiere ajustar con unos puntos dados (nodos) es incapaz de capturar la funcin de la que provienen. La solucin es comprender las implicaciones globales del problema. Ya no estamos intentando hacer pasar una curva por una serie de puntos, estamos intentando resolver la aproximacin de la misma curva. La solucin la encontramos desde el punto de vista global... Por qu los nodos deben ser equiespaciados? Y si acercamos los nodos entre ellos (clustering) en las zonas donde los errores son ms elvados? Sean cuales sean los tipos de polinomios que utilicemos as como el orden del que sean hay nodos ms adecuados para minimizar el error del problema global, por ejemplo los nodos de Chebyshev de la forma:
xj = cos(j/N ),
j = 0, 1, ..., N
puntos de Chabyshev-Lobatto o puntos extremos de Chebyshev. Esta formula es la proyeccin de los puntos equiespaciados en una circunferencia de radio unidad en el eje de abcisas. Si ahora en vez utilizar los nodos equiespaciados utilizamos los nodos ptimos de Chebyshev llegamos a que el polinomio de interpolacin es sensiblemente mejor (gura 6.4): Vemos entonces que recurrir a una eleccin ptima de nodos permite utilizar polinomios como base de desarrollos de funciones con un error ms que aceptable con todas las ventajas que implica trabajar con polinomios en nuestros clculos.
Importante:
Una demostracin de hasta dnde llega la importancia de elegir bien los nodos es pensar que el error que se comete con un polinomio de grado mayor no necesariamente se reduce con lo que estamos malgastando tiempo y potencia de clculo sin ganar precisin. Hay que hacer las cosas con cuidado.
CAPTULO 6. TOOLKITS
111
0.8
0.6
0.4
0.2
-1
-0.5
0.5
Figura 6.4: Uso de los nodos ptimos de Chebyshev para reducir el error de interpolacin
fzero
112
Lo nico que debemos recordar es que como cualquier funcin a la que hay que dar otra funcin como argumento nos obligar a utilizar un function handle. Por ejemplo, queremos encontrar el cero de la siguiente ecuacin:
ln x sin x = 0
Esta ecuacin no tiene una solucin analtica con lo que el uso del clculo numrico se hace imprescindible. Suele ayudar representar grcamente las dos funciones (gura 6.5) para saber si se cruzan en algn punto; si buscamos una solucin inexistente es probable que el mtodo nos devuelva soluciones complejas o espreas.
Figura 6.5: Representacin de las funciones a resolver. La funcin que se resolver ser siempre de la forma
fzero
desafortunada de esta limitacin. Si intentamos resolver la ecuacin anterior por el primer mtodo propuesto recibiremos un error, a priori incomprensible, mientras que con el segundo script llegaremos a la solucin.
CAPTULO 6. TOOLKITS
El motivo es el extico comportamiento de llamar a la funcin por ejemplo:
113
fsolve
fsolve
fsolve
fzero
function handles de modo que tendremos que pasarle la funcin por su nombre despues de haberla denido,
que cumple:
f (x) = 0
siendo
El objetivo de la bsqueda de soluciones de sistemas de ecuaciones no lineales es siempre el mismo. Llegar a una solucin vlida del sistema con el mnimo coste computacional posible. La no linealidad de las ecuaciones puede provocar todo tipo de catstrofes como la no convergencia o que el error se dispare hacia el innito. Siempre se parar automticamente la iteracin y se nos dar un mensaje de error. El coste computacional es una complicacin menor. Depende de dos aspectos, la eleccin del punto inicial y el algoritmo de evaluacin del gradiente de la funcin. Los mtodos ms sencillos de resolucin de ecuaciones no lineales se basan en la aproximacin lineal de la funcin en un punto. Si hacemos el desarrollo de Taylor de primer orden en el punto inicial tenemos que:
J(x0 )
x0 .
f (x0 ) + (x x0 )J(xo ) = 0
obtendremos el siguiente punto de la iteracin, en este caso
x = x1 :
x1 = x0 J
(x0 )f (x0 )
Iteracin que se llevar a cabo hasta que se una norma de la solucin sobrepase una cota de error. Este mtodo es conocido como Newton-raphson. Esto nos recuerda que una de las operaciones con mayor coste computacional es precisamente la inversin de una matriz. Adems la matriz es el gradiente de la funcin en un punto, gradiente que puede ser en algunos casos casi imposible de calcular. Nos encontramos ante el problema de evaluar de una manera ptima un gradiente para luego evaluarlo e invertirlo. Todo esto considerando que el punto inicial nos lleve ms o menos directamente a la solucin que buscamos. Nada de esto debe hacernos perder la referencia de que lo realmente importante de los mtodos de resolucin es la facilidad con la que converjan a una solucin ms que la rapidez con que lo hagan. Al igual que en el caso unidimensional, Matlab apuesta por la simplicidad. La funcin que nos realizar la tarea es:
fsolve
Busca una solucin de un sistema de ecuaciones dado. Esta funcin es diferente segn se use en
Matlab o en Octave; la versin de Matlab llamar al sistema de ecuaciones mediante su nombre o con un function handle mientras que la versin de Octave slo podra llamarlo por nombre. Las diferencias entre ambas slo se maniestan en el modo en el que llamaremos a la funcin, no en el modo en el que la deniremos porque es imposible expresar todo un sistema de ecuaciones slo con un function handle. Ser imprescindible denir una funcin propiamente dicha lo que en Matlab signicar crear un archivo de funcin.
2 fsolve
fzero
114
bb eqad@xA log@xAEsin@xAY bb fzero@eqDH RA rningX vog of zeroF b sn d@xA log@xAEsin@xA sn fzero t PIV ccc irror using aab fzero puntion vlues t intervl endpoints must e finite nd relF
Obviamente debido a que
ln 0 = .
CAPTULO 7
Temas avanzados
Este captulo nace de la necesidad de recojer todos los argumentos no necesariamente ligados al uso de Matlab. La mayora de ellos estn relacionados con la programacin general o en clculo numrico, sin embargo son de gran utilidad para escribir buenos programas. La teora que contiene este captulo es de un nivel mucho ms elevado al resto, estais avisados; esto no signica que todo est explicado del modo ms sencillo posible.
Se dice que una operacin es escalar cuando se hace elemento a elemento. Una suma escalar de dos vectores es tomar los elementos de cada uno de ellos, sumarlos y asignar el resultado a un tercer vector. Una operacin es vectorial cuando se hace por bloques mayores en la memoria. Una suma vectorial de dos vectores sera tomar partes del los vectores o los vectores enteros y sumarlos de golpe. Los compiladores modernos son capaces de vectorizar automticamente. Advierten que dos bucles pueden combinarse perfectamente y realizan la operacin por bloques ahorrando memoria y tiempo de clculo. Como Matlab es un programa secuencial carece de esta capacidad de optimizacin. Si nosotros le pedimos un bucle con operaciones escalares lo va a realizar sin ningn tipo de optimizacin. Si en cambio asignamos operamos las matrices mediante la notacin matricial y las submatrices Matlab s va a ser capaz de vectorizar la operacin. En la seccin 7.1.1.1 explicaremos la importancia que todas estas consideraciones tienen sobre la velocidad de ejecucin.
Un nombre propio en la arquitectura de ordenadores es Seymour Cray, su biografa est ntimamente ligada al los ordena-
115
116
to.
ti
y la de
bb HFIUWPSGHFHHHSVSHH ns a QHTFRI
Utilizar los operadores matriciales y las submatrices generar cdigo del orden de 100 veces ms rpido. Para una EDP esto es la diferencia entre un rato de espera y una semana de clculos, slo un contador mal puesto puede acabar con un cdigo globalmente bien escrito. La lentitud de los bucles llega hasta lmites insospechados. Supongamos que queremos multiplicar todas las las de una matriz por un escalar distinto. En un alarde decidimos convertir la serie de nmeros en un vector y utilizar un bucle contador para operar la matriz por las del siguiente modo:
66 66
y luego
multiplicarla por una matriz. Qu sorpresa nos llevamos cuando observamos que el tiempo de proceso es
bb tiYa9Bones@IDTTAFBYto ns a HFHHHTUHHH
Eliminando un bucle que pareca completamente justicado acabamos de reducir el tiempo de proceso a la dcima parte. A partir de ahora nos lo pensaremos dos veces antes de escribir la palabra intilmente.
for.
Si nos acostumbramos
pensar con submatrices nos ahorraremos tiempo de clculo y la engorrosa tarea de migrar cdigo a Fortran
2 El
ordenador con el que han sido efectuadas las pruebas es un Athlon XP 2600+ (1.920 GHz, bogomips=3301.37) con
512 Mb de RAM a 400 MHz y Octave 2.1.72. Matlab es ligeramente ms rpido con el manejo de bucles aunque de ningn modo se acerca a la velocidad de los operadores matriciales. Con la optimizacin mxima Matlab y Octave tienen resultados equivalentes. Las pruebas se han efectuado diez veces y se da el tiempo medio de la muestra.
117
Cada vez que ampliamos un vector llenando una posicin vaca Matlab debe comprobar que el elemento no existe, ampliar la memoria reservada al vector para poder situar el nuevo elemento donde debe y rellenar el resto con ceros y nalmente almacenar los datos del nuevo vector. Cuando sumamos dos vectores escalarmente el ciclo de vericacin-reserva-asignacin-cierre se realiza una sola vez. Podemos concluir entonces que la operacin de ampliacin de una matriz en Matlab es especialmente lenta. Aunque no estemos obligados a declarar las variables antes de inicializarlas es siempre una buena prctica comprobar que cada matriz se dena entera o mediante bloques lo sucientemente grandes. Este comportamiento est ligado al funcionamiento de los arrays en C; un buen texto para comprenderlo mejor es [3] donde encontraremos un captulo inicial sobre qu es verdaderamente un array y qu relacin tiene con un puntero. Como curiosidad diremos que mientras las operaciones de reserva y liberacin de memoria son bastante lentas, las operaciones de manipulacin de forma como la funcin sacricando tiempo de ejecucin.
reshpe
debemos tener miedo a cambiar la forma de las matrices segn nuestras necesidados pensando que estamos
nargin
Da el nmero de argumentos con el que se ha llamado una funcin Retorna el nmero de argumentos de salida de una funcin Permite que las funciones admitan cualquier combinacin de argumentos de entrada. Permite que las funciones adimitan cualquier combinacin de argumentos de salida. Retorna el nombre de la variable que se ha pasado como argumento de entrada en una funcin.
nargoun varargin
varargout
inputname
y
Estas funciones son una ayuda esencial cuando escribimos funciones muy polivalentes. Los mtodos
nrgin nrgout sirven para que las funciones se comporten de un modo distinto segn la cantidad de argumentos que reciban, vrrgin y vrrgout hacen que no tengamos que preocuparnos de escribir largas cabeceras
de funciones cuando estas reciben muchos argumentos, es como si recibiera una variable tipo celda de un modo automtico.
evalin
Por ejemplo, vamos a crear una funcin que intente capturar una variable del entorno de ejecucin principal en una funcin. Para ello escribiremos la siguiente funcin:
evlin
vr
118
bb testfun@A errorX dummy9 undefined ner line PQ olumn I errorX evluting ssignment expression ner line PD olumn R errorX lled from testfun9
Nos ha dado un error porque an no hemos denido la variable la variable y llamamos la funcin:
algoritmos. No ser literalmente un puntero porque en vez de apuntar una posicin de memoria apuntar a una variable pero como es la manera normal de denir los punteros podemos hacer que se comporte del mismo modo. Por ejemplo, en el caso anterior hemos denido una funcin que extrae el valor valor contenido en la variable ejecucin la variable
out
dummy.
dummy?
out
que apunta al
outaadummy
implcito.
assignin
Estas dos funciones es el mtodo recomendado para establecer una comunicacin entre el entorno de ejecucin de las funciones y el entorno principal. Se sugiere sacricar el uso de las variables globales en favor de la asignacin y la evaluacin entre workspaces. Sin embargo es una sutileza sujeta al estilo de programacin. Personalmente encuentro las variables globales mucho ms intuitivas.
3 Un
puntero es un tipo especial de variable cuya misin es apuntar a una direccin de memoria, normalmente expresada
por otra variable. El puntero no es una variable convencional, es loscamente algo distinto. el contenido de una variable slo podemos cambiarlo nosotros, en cambio el valor al que apunte el puntero puede cambiar si as lo exige la ejecucin. El concepto de un puntero es abstracto y requiere comprender qu es una posicin en la memoria fsica de un ordenador. Es un concepto interesante y requiere comprenderlo.
119
Un vector resultado que va creciendo a medida que se encuentran elementos que cumplen la condicin. El modo ms sencillo de crear este tipo de vectores o matrices en, por ejemplo, python son las list comprehensions que permiten crear directamente un array con una condicin lgica. La clave para implementar estos algoritmos de un modo eciente en Matlab es mediante el uso de la funcin
find.
Supongamos que queremos pasar todos los elementos de un vector mayores que cero a una nueva variable:
bb d a PDEQDRDEPDQDRDEI d a P EQ R EP Q R EI
bb d@find@dbHAA ns a P R Q R
keyboard
Esta palabra clave no es parte del debugging en sentido estricto pero puede ser muy til para
resolver errores del cdigo. Si introducimos esta funcin en un programa pararemos su ejecucin y pasaremos a tener el control en el punto de ejecucin donde nos encontremos. Se abrir un intrprete mediante el cual accederemos al estado actual del programa para poder acceder a las variables de modo interactivo. Una vez salgamos del intrprete continuaremos la ejecucin conservando los cambios que hayamos introducido. Este es el modo ms sencillo de hacer debugging en scripts porque las funciones para debugging clsicas slo operan dentro de funciones.
echo
Traducido eco. Controla si los comandos en archivos aparecen o no en pantalla. Esta sentencia slo tiene efecto dentro de un archivo o de una funcin. Normalmente los comandos ejecutables de funciones y scripts no aparecen en pantalla, slo aparece su resultado si no hemos puesto un punto y coma al nal de la lnea. Con
eho on
on Activa el eco en los scripts off Desactiva el eco en los scripts on ll Activa el eco en scripts y funciones off ll Desactiva el eco en scripts y funciones
type
Saca por pantalla el texto correspondiente a cualquier funcin que est en el rbol de directorios dentro de un archivo
Fm.
120
polyddFm
que implementa la
suma de dos polinomios. Las rutinas bsicas para el debugging de funciones son:
dbtype
Muestra la funcin con los nmeros de lnea para facilitar la inclusin de breakpoints
bb dtype polydd I funtion polyapolydd@polyIDpolyPA P if @nrgin 3a PA Q usge@9polydd@polyIDpolyPA9A R end S if @isvetor@polyIA 88 isvetor@polyPAA T if length@polyIA`length@polyPA U shortapolyIY V longapolyPY W else IH shortapolyPY II longapolyIY IP end IQ diffalength@longAElength@shortAY IR if diffbH IS polyazeros@IDdiffADshortClongY IT else IU polyalongCshortY IV end IW else PH error@9oth rguments must e polynomils9A PI end
Ahora queremos colocar dos breakpoints, uno en la lnea 14 y otro en la lnea 16. Para ello usaremos la siguiente funcin:
dbstop(func,line)
bb dstop@9polydd9D9IR9A ns a IR bb dstop@9polydd9D9IT9A ns a IU
Fijmonos que la funcin no nos ha dejado poner el breakpoint en la lnea 16 porque no es ejecutable. Para comprobar el estado de la funcin:
dbstatus
bb dsttus polydd ns a IR IU
Ahora utilizamos la funcin del modo usual. La ejecucin avanzar hasta que encuentre un breakpoint, entonces se abrir una consola que nos dar el control de la ejecucin.
deug
who
121
deugb who BBB lol user vrilesX nrgin rgn long nrgout diff poly
Aprovechamos para conocer algunas de ellas:
polyI polyP
short
deugb long long a Q P I Q deugb polyI polyI a Q P I Q deugb polyP polyP a Q P H deugb nrgin nrgin a P nrgin es el nmero de argumentos de entrada. Si salimos de la consola avanzaremos hasta el siguiente
breakpoint o nalizaremos la ejecucin. En este caso llegaremos hasta la lnea 17. Para eliminar alguno de los breakpoints:
dbclear(func,line)
mente complejas. El coste de la evaluacin de una funcin muy compleja puede reducirse signicativamente con la interpolacin polinmica. Un caso muy llamativo son las funciones con gran cantidad de trminos armnicos (senos, cosenos y tangentes) que en la evaluacin suelen cancelarse. Aunque la evaluacin de funciones no es una de las tareas ms optimizadas de Matlab no est de ms utilizar los conocimientos adquiridos para aumentar su rendimiento . Los polinomios de Chebyshev son un recurso bastante habitual porque implican un error de interpolacin pequeo. Tambin podramos pensar en utilizar un desarrollo de Taylor, pero tienen el inconveniente de que slo aproximan la funcin en un punto, mientras que lo que nos interesa es un error controlable en todo un intervalo. Otra caracterstica interesante es que cuando desarrollamos una funcin en serie, ya sea de Fourier o Polinmica, las operaciones elementales como las derivadas o las integrales son triviales y, lo que es ms importante, fciles de implementar .
4 Estas
consideraciones no son un caso nico de Matlab. El uso de un polinomio interpolante de alto orden para aproximar
una funcin analtica es efectivo en cualquier lenguaje de programacin. Es una prctica de optimizacin muy utilizada en los cdigos antiguos escritos en fortran cuando los compiladores no eran sucientemente listos como para evaluar las funciones de un modo eciente. Los cdigos altamente optimizados no tenan ninguna funcin que no estuviera escrita programador. Los tiempo en los que cada optimizar una funcin en concreto
op
a mano
por el
5 El
grado de optimizacin en los inicios de la informtica era tal que en un mismo bucle se aprovechaban los trminos
calculados para la evaluacin de una funcin para evaluar a la vez su derivada; en el caso que fuera necesario.
122
T0 (x) = 1 T1 (x) = x T2 (x) = 2x2 1 T3 (x) = 4x3 3x T4 (x) = 8x4 8x2 + 1 Tn+1 (x) = 2xTn (x) Tn1 (x)
Estos polinomios tienen la particularidad de contar con
n1
ceros en los puntos:
x = cos
y
(k 1/2) n k n
k = 1, 2, . . . , n
n + 1extremos
relativos en:
x = cos
acotados por el intervalo segn la funcin peso
[1, 1]. Estos polinomios, adems, tienen la caracterstica (1 x2 )1/2 . Se demuestra que los coecientes del desarrollo
N
f (x)
k=1
se calculan mediante:
1 ck Tk1 (x) c1 2
cj =
2 N
f
k=1
cos
(k 1/2) N
cos
(j 1)(k 1/2) N
Evidentemente no necesariamente nos interesa un desarrollo que contenga todos los puntos posibles; lo ms normal es calcular un desarrollo truncado de Chebyshev. Con el cambio de variable
y
conseguimos un desarrollo en el intervalo escribir la ayuda en formato texinfo
x 1 (b + a) 2 1 (b a) 2 [1, 1]
original.
[a, b],
La siguiente es una funcin escrita en C++ que implementa el desarrollo. Es interesante jarse en cmo
GB heyexpndF BG 5inlude `otveGotFhb 5inlude `mthFhb stti doule saRFBtn@IFAY hipxhvh@heyexpndDrgsD D 4EBE texinfo EBEn ddeftypefn {vodle puntion} {dvr{}a} heyexpnd @dvr{f}Ddvr{}Ddvr{}Ddvr{n}An n gheyshev fitXn n qiven funtion dvr{f} nd the intervl dvr{}Ddvr{} omputesn
123
the dvr{n} oeffiients of the gheyshev polynomil expnsionFn n dexmplen bb heyexpnd@dd@xA PBxPEIDEIDIDSAn ns an EPFTTRSeEITn IFIWRVeEIUn IFHHHHeCHHn UFWUVTeEIUn EIFHRPTeEITn dend exmplen n xote tht dvr{f} must e funtion hndle or n nonymous funtionn n dend deftypefn4A { int jDkY otvevluelist tmpY otvevluelist invlY otvefuntion BinputfnaHY if @rgs@HAFisfuntionhndle@A || rgs@HAFisinlinefuntion@AA inputfn a rgs@HAFfuntionvlue@AY else { error@4this is not funtion hndle nor n inline funtion4AY return otvevlue@EIAY } doule args@IAFdoulevlue@AY doule args@PAFdoulevlue@AY int nargs@QAFintvlue@AY golumnetor fagolumnetor@nAY golumnetor agolumnetor@nAY for @kaHYk`nYkCCA { invl@HAaotvevlue@os@sB@kCHFSAGnAB HFSB@EACHFSB@CAAY tmpainputfnEbdomultiindexop@IDinvlAY f@kAatmp@HAFdoulevlue@AY } for @jaHYj`nYjCCA { doule sumaHFY for @kaHYk`nYkCCA { sum Ca f@kABos@sBjB@kCHFSAGnAY } @jAasumBPFGnY } } return otvevlue@AY
Como ejemplo de cmo debe ser la ayuda de una funcin de octave iremos al intrprete y teclearemos:
124
EE vodle puntionX ga heyexpnd @pDeDfDxA gheyshev fitX qiven funtion p nd the intervl eDf omputes the x oeffiients of the gheyshev polynomil expnsionF bb heyexpnd@d@xA PBxPEIDEIDIDSA ns a EPFTTRSeEIT IFIWRVeEIU IFHHHHeCHH UFWUVTeEIU EIFHRPTeEIT xote tht p must e funtion hndle or n nonymous funtion
Ahora nos falta crear la funcin que dados los coecientes nos recupere el valor de la funcin de un modo eciente. Para ello utilizamos la siguiente recurrencia tambin denida en [3]:
1 f (x) d0 = d2 d3 + c1 2
Pero una funcin recurrente nos obliga a implementar un bucle, algo que rompe completamente el objetivo de crear una funcin que sea muy rpida. Sin embargo el esfuerzo de programarla en cualquier otro lenguaje es mnimo . Por ejemplo, en C++ para octave (crear un archivo .mex sera an ms fcil): El programa tiene
un bug
5inlude `otveGotFhb hipxhvh@hevyvlDrgsD D 4glul el vlor del desrrollo de ghevyshev en x4A { golumnetor @rgs@HAFvetorvlue@AAY doule @rgs@IAFdoulevlue@AAY doule @rgs@PAFdoulevlue@AAY doule x @rgs@QAFdoulevlue@AAY doule xxY doule yY doule ynmIY doule dummyY int iY int n aFlength@AY xxa@PFBxEEAG@EAY if @@xEAB@xEAbHA { error@4hevyvlX d input point4AY return otvevluelist@AY } else { ynmIa @nEIAY yaPFBxxBynmIC@nEPAY for @ianEQYi`HYiEEA { dummyayY yaPFBxxByCynmIC@iAY
6 Octave
cuenta con la funcin cheb.m pero est escrita en cdigo Matlab.
125
tf ss zp
Crea un bloque mediante su funcin de transferencia Crea un bloque mediante su representacin en el espacio de sus variabels de estado Crea un bloque mediante la informacin proporcionada por sus ceros y sus polos
El propio proceso de creacin se encarga de calcular las representaciones alternativas y almacenarlas dentro de la estructura. Por ejemplo, para introducir:
block(s) =
con
K=1
bb lokazp@EHFSDEIDEHFIDESDEIHDHDHDIA
El resultado es el siguiente sistema
126
lok a { innme a { IDI a uI } k a I n a S nz a H outnme a { IDI a yI } pol a EHFIHHHH stnme a { IDI IDP IDQ IDR IDS a a a a a xI xP xQ xR xS ESFHHHHH EIHFHHHHH HFHHHHH HFHHHHH
sys a I H I H
sysout
Esta funcin es bastante til para conocer funciones en tiempo real. Como ya est todo almacenado dentro de la estructura de datos del sistema no tenemos ms que solicitar cualquiera de ellas:
bb sysout@lokD9tf9A snput@sA IX uI yutput@sAX IX yI trnsfer funtion formX IBsP C IFSBsI C HFS EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE IBsS C ISFIBsR C SIFSBsQ C SBsP C HBsI C H bb sysout@lokD9zp9A snput@sA
127
IX uI yutput@sAX IX yI zeroEpole formX I @s C HFSA @s C IA EEEEEEEEEEEEEEEEEEEEEEEEEEEEEE sP @s C HFIA @s C SA @s C IHA bb sysout@lokD9ss9A snput@sA IX uI yutput@sAX IX yI stteEspe formX S ontinuous sttesD H disrete sttes tte@sAX IX xI PX xP QX xQ RX xR SX xS e mtrixX S EIHFHHHHH HFHHHHH HFHHHHH HFHHHHH HFHHHHH f mtrixX S H H H H I g mtrixX I EWFHHHHH h mtrixX I H x S ERFSHHHH ESFHHHHH HFHHHHH HFHHHHH HFHHHHH x I IFHHHHH IFHHHHH EHFIHHHH HFHHHHH HFHHHHH HFHHHHH HFHHHHH IFHHHHH HFHHHHH HFHHHHH HFHHHHH HFHHHHH HFHHHHH IFHHHHH HFHHHHH
x S ERFSHHHH x I
IFHHHHH
HFHHHHH
HFHHHHH
dcha1(s) =
1 2s + 4
Introduccin informal a Matlab y Octave
128
+
G
-
Al bloque decidimos llamarlo dhca1 por su posicin en el hipottico diagrama de bloques. Un ejemplo de bloque bien denido sera:
bb dhIatf@IDHDPDRDewaHD9dhIin9D9dhIout9A
Evidentemente los bloques denidos por sus funciones de transferencia o por sus ceros y sus polos tendrn slo una entrada y una salida. Una vez hemos visto cmo crear bloques elementales pasamos a conocer las funciones que permiten a los bloques interacturar entre ellos. Son las siguientes:
Combina dos bloques en paralelo de modo que la salida del conjunto es la suma de ambos.
sysmult Combina dos bloques en serie de modo que la salida del conjunto es el producto de ambos syssub Combina dos bloques en paralelo de modo que la salida del conjunto es la resta de ambos Operaciones de comunicacin entre bloques sysconnect
:
Conecta dos bloques deniendo una puerta de cada uno de ellos. Una puerta es una
sysgroup Agrupa varios bloques en uno que conserva sus entradas y salidas. sysdup Duplica las salidas y las entradas de un bloque. sysprune Elimina las entradas y las salidas espreas del sistema sysidx Extrae los nombres de las puertas de un bloque. Muy til cuando se utiliza con sysonnet. sysappend Introduce nuevas puertas de entrada o salida a un bloque ya existente buildssic Constructor de sistemas dinmicos. Para aprender ms sobre esta funcin es necesario utilizar la demo de creacin de sistemas,
ddemo.
sysdd
sysmult
sysprune, sysdup
F =
sysonnet
Para ver todo lo anterior aplicado nada mejor que un ejemplo. Supongamos que tenemos el siguiente sistema dinmico expresado por la gura 7.1 con
10 s2 (s+3) y G = s + 2: Primero construiremos el bloque de la derecha, el ms cercano a la salida. Su funcin de transferencia es: 10 DCHA(s) = s2 (s+3) de modo que empezaremos deniendo su bloque bsico:
bb hgreazp@DHDHDEQDIHDewaHD9hgresx9D9hgrey9AY
El paso siguiente es duplicar su salida
7 La
constante
TSAM
TSAM
es igual a cero.
129
bb hgredupasysdup@hgreDD9hgresx9AY hgredup a { a EQ H H a H H I a IH d a H H H H H H I I H H H I H
sys a P H H I
tsm a H yd a H
hgresx@dupA,
copia de
hgresx.
Ahora ya podemos
crear la recirculacin del primer estadio no sin antes cambiar el signo de la nueva puerta de salida:
bb hgredupasyssle@hgredupDDdig@IDEIAAY
Introduccin informal a Matlab y Octave
130
Este es un modo abrevidado de utilizar la funcin
sysle,
de un modo ms intuitivo. Ahora conectamos la seal a la salida con la nueva puerta de entrada y nalmente simplicamos el sistema par que tenga una nica entrada. Como paso nal comprobaremos que el resultado es realmente el deseado escribiendo la funcin de transferencia del sistema.
bb hgreendasysonnet@hgredupD9hgrey9D9hgresx@dupA9AY bb hgreendasysprune@hgreendD9hgrey9D9hgresx9AY bb sysout@hgreendD9tf9A snput@sA IX hgresx yutput@sAX IX hgrey trnsfer funtion formX IH EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE IBsQ C QBsP C IFSSReEISBsI C IH
La denicin del bloque de la izquierda es la nica limitacin del OCTS. No puede denir bloques cuyo nmero de ceros sea mayor a su nmero de polos. Esto es debido a la forma que tiene de hacer los clculos internos para crear la estructura de datos. Para seguir con el ejemplo tendremos que romper la estructura de datos creada por el primer bloque con recirculacin, multiplicarla por el polinomio del bloque de la izquierda y nalmente crear la ltima recirculacin. Esto no signica ningn problema porque podemos pasar de la representacin como estructura a funcin de transferencia slo con aplicar la funcin
sysPtf
bb numDdenasysPtf@hgreendAY
Para multiplicar el numerador de la funcin de transferencia por el nuevo trmino utilizamos la funcin que ya vimos en la seccin dedicada al clculo con polinomios.
onv
bb numaonv@IDPDnumAY
El paso siguiente es reconvertir la funcin de transferencia en el tipo estructura.
bb yevatf@numDdenDewaHD9sx9D9y9AY bb sysout@yevD9tf9A snput@sA IX sx yutput@sAX IX y trnsfer funtion formX IHBsI C PH EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE IBsQ C QBsP C IFSSReEISBsI C IH
bode
Hace el anlisis bode del sistema. En el caso que no se soliciten argumentos de salida se dibuja el diagrama bode
nyquist nichols
131
k
-
SYS
bb nyquist@yevA
Lo que genera la gura (7.3).
6 +w -w 4
2
Im( G(jw) )
-2
-4
-6 -3 -2 -1 0
Re( G(jw) )
bb ode@yevA
132
Gain in dB
10
100
150
Phase in deg
100 50 0 0.1
1
Frequency in rad/sec
10
100
7.6.1. Resolucin de la ecuacin del calor con simetra axial por volmenes nitos en un cilindro.
La ecuacin del calor no estacionaria para un volmen de control sin trmino convectivo se puede escribir como:
t U = q n
La variacin temporal (positiva) de energa interna es igual al ujo de calor entrante a travs de su frontera descrita por el vector normal saliente. La expresin de la energa interna es:
U=
V
cT dm =
V
cT dV
q=
V
k T dS
En todos los clculos sucesivos se supondr un volmen nito centrado en la celda compuesto por una porcin radial del tubo. En l slo se considerar el gradiente radial de temperaturas. Combinando las ecuaciones anteriores se obtiene la ecuacin para el volumen de control:
t
V
cT dV = n k
V
T dS
Agrupando todas las constantes y simplicando las integrales debido a la simetra cilndrica:
c t T k T = r T
y
dV = n
V
T
V
dS
V
dV
2r dr
CT =
c k :
dS = 2r
CT t T r dr = re r T |re ri r T |ri
El ltimo paso antes de la resolucin numrica es discretizar espacialmente la ecuacin con teniendo en cuenta que el elemento est centrado en el cuerpo.
dr = rj
r = rj
CT (t Tj )rj rj = re
T r
ri
re
T r
ri
133
rj+1 rj1 ,re 2
Tj Tj1 rj rj1 ):
rj +rj1 T , 2 r re
Tj+1 Tj T rj+1 rj y r ri
t Tj =
2 1 CT rj rj+1 rj1 1 1 CT rj r2 1 CT r2
t Tj =
y nalmente:
rj +
(Tj+1 Tj ) rj
(Tj Tj1 )
t Tj =
1+
r 2rj
Tj+1 2Tj + 1
r 2rj
Tj1
Llegamos a una expresin que puede ser integrada en el tiempo numricamente. De modo que el sistema de ecuaciones resultante es:
1 dt Tj = CT r2
.. .
0 1
r 2rj
Tj
1+
..
r 2rj
.
0
que a partir de ahora se expresar como
T = AT
Los elementos del contorno tendrn adems la contribucin de el calor que reciben por conveccin:
qconv =
V
dS
Entonces, para el elemento del interior del tubo y teniendo en cuenta que su espesor es de la mitad que los elementos interiores porque est centrado en la cara.
hi (Ti T1 ) k hi k T1 + r hi Ti k
T2 2 +
(1/2)CT t T r dr = re t TN = 2 CT r2 1 dt Tj = CT r2 r
he he Te 2 + k k 2+
..
4 2r hi k
r rj
.
0 2 1+
..
1 0
r 2rj
r 2rj
.
r rj
4 2r he k
2rTi hi k . . . 0 Tj + . . . 2rTe he k
T = AT + b
Esta es la forma que esperan las rutinas disponibles de integracin de problemas de Cauchy de modo que no ser necesario implementar ningn algoritmo de integracin temporal. Obtendremos todos los perles de temperatura con este script.
134
funtion xdotasistem@xDtA eaevlin@9se9D9e9D9none9AY aevlin@9se9D99D9none9AY xdotaeBxCY 7 gonstntes del prolem kaIHHY 7G@muA rhoaIHHHY aPRHHY hiaIHHHY heaIHHHY riaHFIY reaHFPY xaIHY iaIHHY eaHY 7 gonstntes derivds garhoBGkY dra@reEriAG@xEIAY ralinspe@riDreDxAY eazeros@xDxAY 7elloting 7higonl prinipl pdazeros@xDIAY pd@IAaEREPBdrBhiGkY pd@xAaEREPBdrBheGkY pd@PXxEIAaEPBones@xEPDIAY eadig@pdDHAY 7higonl superior udazeros@xEIDIAY ud@IXxEIA a ICdrFG@PBr@IXxEIAAY eaeCdig@udDIAY 7higonl inferior ldazeros@xEIDIAY ld@IXxEIA a IEdrFG@PBr@PXxAAY eaeCdig@ldDEIAY eaIFG@gBdrFPAFBeY azeros@xDIAY @IAaPBdrBiBhiGkY @xAaPBdrBeBheGkY tiY alsode@dsistemDzeros@xDIADlinspe@HDIHHDIHHAAY to
CAPTULO 8
Extender Octave con otros lenguajes.
Gran parte de esta seccin, sobre todo los ejemplos, se basa en el tutorial Dal segno al Coda de Paul Thomas. Podeis encontrarlo en el Wiki del proyecto Octave.
Octave est escrito en C++, adems es el lenguaje desde el que es ms sencillo extenderlo. Ahora deberamos preguntarnos cundo queremos extender Octave. Si Matlab es un lenguaje de programacin completo deberamos ser capaces de programar cualquier cosa. El problema es que programar cualquier cosa no se hace a cualquier precio, los bucles son un ejemplo de ello. Imaginemos que tenemos un programa que va demasiado lento, que casi todo el tiempo de proceso se debe a la evaluacin de una funcin miles de millones de veces y el coste de implementarla en otro lenguaje no es demasiado grande. La solucin a nuestro problema ser escribir la funcin en C++ o en Fortran y luego hacer un interfaz para que Octave pueda entenderla. Para hacerlo antes tendremos que asegurarnos que disponemos de las cabeceras (headers) de Octave. No se encuentran en algunos paquetes y puede ser que tengamos que instalarlos a parte. Preparar la infraestructura es un poco complejo, tambin necesitaremos un compilador en el entorno accesible por consola, preferentemente los de la coleccin gcc (gcc, g++, g77 y gfortran). Las cabeceras sirven tanto para escribir pequeas funciones como para crear interfaces completos a libreras escritas en C, C++ o Fortran. los archivos terminados en
Fot
mkotfile
han sido creados con dicha funcin. Algunas de las libreras utilizadas
son FFTW para las transformadas rpidas de Fourier, ODEPACK para resolver ecuaciones diferenciales ordinarias, UMFPACK para las matrices sparse y ATLAS para el clculo matricial. Los respectivos interfaces son una gran fuente de informacin de cmo adecuar Octave a nuestras necesidades.
segmentation fault o un resultado sin ninguna lgica en vez de lo esperado. Muchas veces los programas
no son compilar y listo, los programadores experimentados en C y C++ saben de lo que hablo. Otra de las ventajas de los lenguajes interpretados es que el intrprete es un binario standalone . Octave es un programa que depende de varias libreras externas, glibc, atlas, readline... Todas estas libreras deben ser compiladas previamente de tal modo que sean compatibles con el intrprete de Octave. Es normal que alguna de las dependenicas se construya con un compilador distinto al que se utilice para Octave. Normalmente no tendremos ningn problema pero esto no implica que no se produzcan jams. Un ejemplo de ellos es cuando intentamos aadir cdigo externo a Octave con el programa mkoctle. Lo que estamos haciendo es compilar un archivo escrito en C++ con el compilador del sistema que puede ser distinto al que se utiliz para Octave. Es incluso probable que los compiladores sean incompatibles como por ejemplo el GCC4 y el intel C++ compiler. Debemos tener en cuenta que Octave es a partir de ahora un verdadero entorno de desarrollo, nico y monoltico. Si queremos ponernos a jugar de verdad lo mejor
1 Este
to stand alone
de ser compilado ya no tiene ninguna dependencia externa; puede tenerlas en tiempo de compilacin pero no en tiempo de ejecucin. En un sistema operativo tipo UNIX esto es imposible porque todo depende como mnimo de la librera estndar de C.
135
136
ser que compilemos nosotros mismos Octave con el compilador del sistema. Si somos incapaces de hacerlo instalaremos el compilador con el que se construy nuestro Octave as como las libreras propias de C y C++ sobre las que funciona. Si podemos tener problemas con los compiladores de C++ con los de Fortran debemos prepararnos para sufrir de lo lindo. Octave se compila con gcc3, sin soporte para Fortran 95. Si queremos utilizar cdigo en este dialecto tendremos que utilizar gcc4 pero entonces las versiones de las libreras de C++ sern incompatibles. Disponemos de dos opciones: 1. Seguir con gcc3, escribir cdigo en Fortran 77 y compilar con g77. 2. Pasarnos a la rama inestable de Octave, compilarla con gcc4 y gfortran y rezar para que no rompa nada. Por suerte estos problemas desaparecern cuando gcc4 se consolide.
Fot y los Fmex de Matlab es que en este caso contamos con cabeceras otFh, en l se eqlorentzF:
5inlude `otveGotFhb hipxhvh @eqlorentzDrgsD D 4iuion de vorentz en gCC4A { golumnetor xdot @QAY golumnetor x @rgs@HAFvetorvlue@AAY int aIHY int aPVY doule aVFGQY xdot@HA a B@x@IAEx@HAAY xdot@IA a x@HAB@Ex@PAAEx@IAY xdot@PA a x@HABx@IAEBx@PAY return otvevlue @xdotAY }
Esta es la funcin de la ecuacin diferencial del atractor de Lorentz:
x = a(y x) y = x(b z) y z = xy cz
con
a = 10, b = 28, c =
8 3
Encontraremos el script que resuelve el problema en el ejercicio 9.3. Tenemos que evaluar la ecuacin del atractor un mnimo de 5000 veces, nos ahorraremos algo de tiempo escribiendo la funcin en C++ y convirtindola en una funcin de Octave con:
eqlorentzFot
bb help eqlorentz eqlorentz is the dynmillyElinked funtion from the file GhomeGguillemGsynGgursoriptingGejeriiosGeqlorentzFot iuion de vorentz en gCC bb eqlorentz@IDIDIDIA ns a HFHHHHH PTFHHHHH EIFTTTTU
137
Otra posibilidad interesante es la de crear subrutinas optimizadas para un tipo determinado de hardware. No es lo mismo llamar a una subrutina que funcionara en cualquier PC que optimizarla para utilizar todas las posibilidades de un Xeon o de un Opteron.
mkotfile
la famlia gcc, podemos pasarle parmetros de compilacin para conseguir una optimizacin mxima.
otvefuntion
que contiene todos los mtodos necesarios, el problema (si es que lo es) es que debe referirse al argumento como
otvefuntion
gruente con la denicin hecha anteriormente; una funcin se llama mediante el mtodo que recibe como argumentos el nmero de variables de entrada y un La salida ser tambin un funcin
otvevluelist.
Ya en octave, para pasar las funciones debemos utilizar un function handle, una funcin annima o la rutina lo compruebe se utilizan los mtodos
inline, de otro modo Octave no sabr que uno de los argumentos es una funcin. Para que la propia isfuntionhndle y isinlinefuntion.
GBtestfhFBG 5 inlude `otveGotFhb hipxhvh@testfhDrgsD D 4testing how gCC n ll n otve funtion4A { otvevluelist tmpY otvevluelist invlY otvefuntion BinputfnaHY if @rgs@HAFisfuntionhndle@A || rgs@HAFisinlinefuntion@AA inputfn a rgs@HAFfuntionvlue@AY else { error@4this is not funtion hndle nor n inline funtion4AY return otvevlue@EIAY } doule x a rgs@IAFdoulevlue@AY invlFppend@otvevlue@xAAY tmp a inputfnEbdomultiindexop@IDinvlAY return tmpY }
Esta funcin recibe un function handle o un inline y un escalar de doble precisin. Retorna la funcin evaluada en el punto denido por el escalar. Para compilarlo haremos:
bb testfh@9sin9DFIPQA errorX this is not funtion hndle nor n inline funtion bb testfh@dsinDpiGPA ns a I bb testfh@d@xA sin@xABexp@xGPADpiGRA ns a IFHRUP bb testfh@inline@9sin@xABexp@xGPA9ADpiGRA ns a IFHRUP
Introduccin informal a Matlab y Octave
138
abre signicativamente el abanico de posibilidades de octave. Las funciones escritas en C++ ya no son algo monoltico, es decir, una subrutina tonta que slo es capaz de recibir y devolver valores. Ahora podemos interactuar con toda la plataforma de octave, incluso con las funciones pasadas por cabecera.
fUUEfn
cientco es lgico que Octave le de un trato especial. Desgraciadamente la capacidad de integracin de Fortran en Octave es bastante limitada debido sobre todo a las dicultades de comunicacin entre C y Fortran. Otros lenguajes interpretados cumplen mucho mejor la labor de comunicarse con sus primos compilados como Python, Java o Ruby.
5inlude `iostremb using nmespe stdY void lorentz@doule tDdoule ByDdoule BypA { onst int aIHY onst int aPVY onst doule aVFGQY ypHaB@yIEyHAY ypIayHB@EyPAEyIY ypPayHByIEByPY } int min@int rgDhr BrgvA { doule yQY doule ypQY yHaIFY yIaIFY yPaIFY
2 gfortran
es un fork del proyecto G95 por desavenencias en el desarrollo con su creador. gfortran est dentro de gcc mientras que G95 es un proyecto a parte.
139
5inlude `iostremb using nmespe stdY void lorentz@doule tDdoule ByDdoule BypA { onst int aIHY onst int aPVY onst doule aVFGQY ypHaB@yIEyHAY ypIayHB@EyPAEyIY ypPayHByIEByPY } int min@int rgDhr BrgvA { doule yQY doule ypQY yHaIFY yIaIFY yPaIFY lorentz@IFDyDypAY int iY out `` yp `` 9n9Y } return HY
Y al ejecutar el programa:
HxfeIQTH
El programa ha escupido una direccin de memoria. Para un programador experimentado en C esto resultar tan obvio como desconcertante para el resto de los mortales. La relacin entre los arrays y los punteros es
140
de amor-odio. Salpica cualquier programa escrito en C o en C++ y puede llegar a ser una tortura cuando slo nos interesan los arrays. Fortran no slo es ms seguro sino que ayuda a programar con pocos errores tanto en la implementacin del algoritmo como en el uso de la memoria. Otra ventaja importante es que la biblioteca estndar de Fortran contiene funciones orientadas al clculo cientco y que la mayora de las bibliotecas de clculo numrico estn pensadas para comunicarse con Fortran y no con C o C++.
aP
estamos haciendo dos cosas: primero reservamos el espacio en memoria necesario para almacenar un 2 y luego le estamos asignando el nombre de una variable. El nombre est slidamente unido a la posicin de memoria. Ahora supongamos que queremos referirnos a la variable a. Podemos hacerlo de dos maneras. La primera es llamar el contenido de a, es decir, 2. La segunda es referirnos a la variable segn la posicin de memoria que ocupa. Llamamos posicin de memoria a el punto de la memoria fsica en el que se encuentra
realmente contenida la variable y se expresa mediante una direccin de memoria que suele ser una cadena
de 8 caracteres. Esto nos permite distinguir entre dos tipos esenciales de variables, las que contienen un valor y las que apuntan a una determinada direccin de memoria. Las primeras se llaman variables y las segundas reciben el nombre de punteros. Los programadores experimentados en C y C++ dominan el concepto de puntero pero los que no lo hayan odo en su vida lo entendern mejor con este pequeo programa en C:
5inlude `stdioFhb int Y int BptrY int min@int rgD hr BrgvA { aPY ptr a 8Y printf@4 es 7i n4DAY printf@4l direion de es 7p n4DptrAY printf@4el puntero ptr ontiene 7i n4DBptrAY return HY }
Primero declaramos una variable de tipo entero y luego un puntero del mismo tipo, luego le asignamos a la variable el valor de 2 y el puntero a la posicin de memoria de la variable. Imprimimos en pantalla el resultado para saber qu contiene cada una de ellas y el resultado es el siguiente:
141
Una vez hemos entendido la diferencia entre una posicin de memoria y el valor que esta contiene daremos el siguiente paso. Supongamos que acabamos de escribir una funcin o una subrutina. Esta unidad de programa necesita argumentos adicionales para funcionar especicados en su cabecera. Si la funcin no recibe los argumentos necesarios en tiempo de ejecucin recibiremos un error. Pero acabamos de ver que para el ordenador es equivalente recibir un valor que la posicin de memoria del bloque que la contiene. En un programa parecido al anterior denimos la una funcin suma:
5inlude `stdioFhb int DY int sum@int Dint A { int resultY resultaCY return resultY } int min@int rgD hr BrgvA { aPY aQY int resultdoasum@DAY printf@4l sum de 7i y 7i es 7i n4DDDresultdoAY return HY }
Qu hace C para pasar los valores a la funcin? C pasa los argumentos a las funciones por valor. Esto signica que las memoria utilizada por la funcin y por el programa principal son independientes. Cuando pasamos los argumentos a la funcin suma se copia su valor a las variables locales sin tocar las globales; la funcin espera un valor, no una direccin de memoria; espera un 2, no un 0x748361. Fortran es diametralmente opuesto a C en este sentido. Todas las variables de Fortran son en realidad punteros. Fortran no sabe de valores reales, slo est interesado en posiciones de memoria. La identicacin entre la memoria y la variable es absoluta. Vamos a descifrar lo dicho hasta ahora mediante un programa ejemplo:
progrm test integer XX DD aP aQ ll sum@DDA write@BDBA end progrm test suroutine sum@rgIDrgPDresultdoA integerD intent@inA XX rgIDrgP integerD intent@outA XX resultdo resultdoargICrgP end suroutine sum
Cuando llamamos a la subrutina sum no estamos pasando los valores 2 y 3 sino que estamos identicando las posiciones de memoria. Le estamos diciendo a la subrutina que su arg1 se encuentra en la posicin de a y arg2 en la de b. Por eso tenemos que declarar las variables en las subrutinas con el atributo intent; estamos operando con las mismas posiciones de memoria, si nos equivocamos no podemos volver atrs. Esto se llama pasar los argumentos por referencia. Este punto de vista es mucho menos versatil pero evita el uso de ms memoria de la necesaria. Por eso Fortran es un lenguaje muy indicado para manejar variables de gran tamao. Esto signica que programando en C tendremos que pasar punteros y no variables a las funciones escritas en Fortran.
142
8.3.3. Llamar una funcin de C desde Fortran o la manera ms difcil de sumar 2+2
Para entender mejor el signicado de la llamada por referencia en Fortran vamos a aprovechar que los archivos objeto creados con el GCC son independientes del frontend utilizado. La estrategia es la siguiente, crearemos una funcin en C que sume la primera y la segunda variable y retorne el resultado en la tercera. El cdigo es el siguiente:
void
2. El nombre de la funcin va seguido de una barra baja (trailing underscore) para que el nombre de la subrutina generada sea compatible con Fortran. Ignoro el por qu pero de otro modo no funciona. 3. Como la funcin espera una asignacin de argumentos por referencia espera punteros a las variables. En la funcin debemos ser consecuentes y utilizar el operador de retorno de referencia para hacer la operacin. Compilamos la funcin con:
sh6~Gb g E funtionF
Slo falta crear el programa que implemente la llamada. Es el siguente:
143
rryISY rryQSY
son equivalentes. Ser muy importante utilizar las cabeceras de Octave porque nos proporcionarn los tipos necesarios para utilizar cmodamente matrices y arrays.
suroutine eqlorentzfsu@xDxdotA rel@VADdimension@XADintent@inA XX x rel@VADdimension@XADintent@outA XX xdot rel@VA XX aIHdHDaPVdH rel@VA XX aVdHGQdH xdot@IAa B@x@PAEx@IAA xdot@PAa x@IAB@Ex@QAEx@PAA xdot@QAa x@IABx@PAEBx@QA end suroutine eqlorentzfsu
El wrapper correspondiente para esta funcin es el siguiente:
5inlude `otveGotFhb 5inlude 4fUUEfnFh4 extern 4g4 int pUUpxg @eqlorentzfsuD ivyixpfA@douleBDdouleBAY hipxhvh@eqlorentzfDrgsD D4xdotaeqlorentz@xA4A { otvevluelist retvlY golumnetor wrgin@rgs@HAFvetorvlue@AAY golumnetor wrgout@QAY pUUpxg@eqlorentzfsuDivyixpfA@wrginFfortrnve@AD wrgoutFfortrnve@AAY retvlFppend@wrgoutAY return retvlY }
Hacemos siempre uso de los objetos propocionados por las cabeceras de octave, para ello se supone que tenemos nociones de programacin orientada a objetos. El wrapper sirve nicamente para pasar las variables de entrada y salida a punteros que Fortran sea capaz de reconocer. Las variables de entrada y salida de la funcin para octave van a ser punteros: 1. Recogeremos la variable de entrada de la funcin que Octave dejar en la variable que utilizar un tipo propio de Octave. En el caso del wrapper anterior declaramos un llamado
xdot
rgs.
Si es un
escalar podemos utilizar una variable propia de C, si queremos un vector o una matriz tendremos
wrgin
rgs@HA
golumnetor
en forma de vector.
golumnetor,
otvevluelist.
como argumentos los punteros que hemos creado para ella, en nuestro caso
hipxhvh
pUUpxg a rgin
la que pasaremos y
rgout.
todos los
Previa-
wrgout
a la variable
retvl
144
Una vez tengamos la funcin y el wrapper escritos compilaremos la funcin en Fortran con un compilador compatible con el que se ha compilado octave. El wrapper llamar al cdigo objeto que se haya creado con el archivo de Fortran. Los comandos son los siguientes:
bb eqlorentzf@IDPDQA ns a IH PQ ET
La necesidad de que los dos compiladores sean compatibles es un gran contratiempo. De momento Octave slo se puede compilar con la versin 3 del compilador GCC que slo es capaz de compilar cdigo en Fortran 77. Si intentamos mezclar archivos compilados con gcc 4, que entiende Fortran 95, y gcc 3 muy probablemente tendremos un Segmentation Fault. De momento nos conformaremos con escribir cdigo en Fortran 77, aunque no por mucho tiempo. Slo como ejemplo la misma funcin en Fortran 77 se escribira como:
suroutine eqlorentzfsu@xDxdotA relBV x@BADxdot@BA relBV DD aIHdH aPVdH aVdHGQdH xdot@IAa B@x@PAEx@IAA xdot@PAa x@IAB@Ex@QAEx@PAA xdot@QAa x@IABx@PAEBx@QA end suroutine eqlorentzfsu
Podemos escribir wrappers que sean capaces de retornar los mensajes de error de la subrutina. Para ello es necesario que el wrapper llame a la funcin subrutina siguiente :
pUUpgx
en vez de
pUUpxg.
g g
fysxi xsxi @syD ewyhD D D D D fD fD fA sxiqi sy hyfvi igssyx ewyh@IHAD D D D D fD fD f iste es un ejemplo pr pror un wrpperF esign l sum de ewyh D y D D fD fD f sxiqi s a HhH hy saID IH a C ewyh @sA ixh hy f a f a f a ixh
3 La
subrutina est escrita en Fortran 77. Aunque se considere una variante obsoleta de Fortran es necesario conocer sus
particularidades porque es el lenguaje en el que estn escritas la mayora de las bibliotecas de funciones. Es por ello que Octave preere utilizar una nomenclatura orientada a Fortran 77. Esto no genera ningn problema porque el cdigo objeto generado por los compiladores de Fortran 77 es compatible con los de Fortran 95. Wrappers ms sosticados como f2py ya incorporan una sintaxis parecida a Fortran 95.
145
5inlude `otveGotFhb 5inlude 4fUUEfnFh4 extern 4g4 { int pUUpxg @tnineD xsxiA @onst int 8 syD onst douleB ewyhD doule 8 D onst doule 8 D onst doule 8 D onst doule 8 D doule 8 fD doule 8 fD doule 8 f AY } hipxhvh @tWTD rgsD D 4E vodle puntionX D fD fD f a tWT @wD D D A n n eturns the sum of w in nd D D nd in fD fD nd fF4A { otvevluelist retvlY onst int dummyinteger a HY wtrix pmY onst doule x a rgs@IAFdoulevlue@AD y a rgs@PAFdoulevlue@AD z a rgs@QAFdoulevlue@AY doule psD xD yD zY pm a rgs@HAFmtrixvlue @AY pUUpgx @tnineD xsxiD @dummyintegerD pmFfortrnve@AD psD xD yD zD xD yD zA AY if @fUUexeptionenounteredA { error @4unreoverle error in tWT4AY return retvlY } retvl@HA a otvevlue @psAY retvl@IA a otvevlue @xAY retvl@PA a otvevlue @yAY retvl@QA a otvevlue @zAY return retvlY }
Para convertir el archivo y el wrapper en una funcin de Octave introducimos en la consola:
bb help tWT tWT is the dynmillyElinked funtion from the file GhomeGguillemGhesktopGsndoxGtWTFot E punionX D fD fD f a tWT @wD D D A esign l sum de w y D D fD fD fF bb unoDdosDtresDutroatWT@IXIHDpiDeDRA uno a SS dos a QFIRIT tres a PFUIVQ utro a R
Hemos declarado todas las variables de la subrutina, tanto las internas como las externas, para que si se produce un error en la parte escrita en Fortran Octave sea capaz de encontrarlo. El wrapper se encarga de tomar los argumentos de entrada, convertirlos en algo que Fortran sea capaz de entender y recoger el resultado. Octave tambin soporta la denicin de los tipos derivados de Fortran. Para la subrutina:
146
suroutine fWSsuP@dinDdoutA type XX mytype relBV XX mydoule integerBR XX myint end type mytype type @mytypeA XX din D dout dout7mydoule a din7mydoule BB flot@ din7myint A dout7myint a din7myint B din7myint end suroutine fWSsuP
Primero la compilaremos con
5inlude `otveGotFhb 5inlude `otveGfUUEfnFhb strut mystrut { doule mydouleY int myintY }Y extern 4g4 int pUUpxg @fWSsuDfWSfA @ mystrut 8D mystrut 8AY hipxhvh @fWSdemoD rgs D D4wDz a fWSdemo@ x D y A returns w a x y nd z a y B y for integer y4A { otvevluelist retvlY mystrut dinptr D doutptrY dinptrFmydoule a rgs@HAFslrvlue@AY dinptrFmyint a int@ rgs@IAFslrvlue@A AY pUUpxg @fWSsuDfWSfA @dinptrDdoutptr AY retvlFppend@ otvevlue@ doutptrFmydoule A AY retvlFppend@ otvevlue@ doule@ doutptrFmyint A A AY return retvlY }
Y nalmente llamaremos a
mkotfile:
puede utilizarse como extensin natural de C++ para el clculo cientco. La cabecera oct.h proporciona
sea una biblioteca de lo ms completa. Esto proporciona a Octave una cualidad no tan esperada; todos los tipos necesaros para el clculo numrico, matrices, vectores la y columna, operaciones matriciales un programa de lo ms simple:
y vectoriales... Incluso resolucin de EDOs! Para abrir boca nada mejor que un pequeo experimento con
GBtestotvestndloneFBG 5inlude `iostremb 5inlude `otFhb int min@voidA { stdXXout `` 4ytve y CC n4Y wtrix aidentitymtrix@PDPAY stdXXout `` Y } EElinkEstndElone
Para compilarlo utilizaremos la aplicacin
mkotfile
147
6 FGtestFexe ytve y CC I H H I
La biblioteca en C++ de Octave es mucho ms potente como demuestra el siguiente ejemplo:
GBtestPFBG 5inlude `iostremb 5inlude `otFhb int min@voidA { wtrix awtrix@PDPAY golumnetor agolumnetor@PAY @HDHAaPFY @IDHAaSFY @HDIAaETFY @IDIAaQFY @HAaIFY @IAaHFY stdXXout `` Fsolve@AY return HY }
donde resolvemos el siguiente sistema de ecuaciones:
2 5
6 3
x=
1 0
ot
mex.
extensin son completamente distintos pero Octave tambin soporta las extensiones de Matlab. De este modo Octave no consigue la compatibilidad a nivel de intrprete sino que tambin algunas extensiones de Matlab compilarn con la biblioteca de Octave sin ningn cambio. Parece entonces justicado describir sin demasiada precisin las funciones
mex
mxerry.
de segmentacin porque no se ejecuta ningn control de tipos. Por si an no ha quedado del todo claro, es signicativo que en Octave slo se pueda retornar un programadores en C los
otvevlue
o un
otvevluelist.
Si se est ampliando el intrprete de Octave los programadores en C++ preferirn los archivos
mex.
ot y los
Como suele suceder en los lenguajes interpretados, el tipo estndar, en este caso
mxerry, es en realidad
una estructura C de la que no es importante conocer demasiados detalles. El modo usual de crear, introducir y extraer elementos de la estructura es mediante las funciones de la propia API; entonces el conocimiento y la experiencia de la misma es lo que permite escribir mejores extensiones.
148
nlude `stringFhb 5inlude 4mexFh4 void mexpuntion@int nlhsD mxerry Bplhs D int nrhsD onst mxerry Bprhs A { int jY doule BoutputY doule dt a {IFHD PFID QFH}Y GB grete the rry BG plhsH a mxgretehoulewtrix@IDQDmxievAY output a mxqetr@plhsHAY GB opulte the output BG mempy@outputD dtD QBsizeof@douleAAY }
Es un programa muy sencillo. No recibe ningn argumento y se limita a copiar un array de tres elementos en el argumento de salida. Para compilarla con Octave en la consola de sistema:
6b mex testmexF
o bien
testmexFmex
ot.
Para probarlo,
De este primer ejemplo se deduce que la llamada nlhs plhs nrhs prhs Nmero de argumentos de salida
Array de punteros a los argumentos de salida Nmero de argumentos de entrada Array de punteros a los argumentos de entrada.
Es importante recordar que los argumentos de entrada no pueden modicarse dentro del archivo estn representadas en memoria.
mex
puesto que pertenecen al intrprete. Nunca es una buena manera cambiar variables que no sabemos cmo
mxqettr;
mxgretehoulewtrix ns
no es necesario decir mucho sobre cul es su misin. Un detalle que s puede pasar inadvertido
prhs
plhs
puesto que el intrprete siempre est esperando como mnimo un valor para la variable
149
mex son, como su propio nombre indica, funciones. Su labor es recibir argumentos y devolver mxerry. No se realiza ninguna vericacin mexirrwsgxt. mex
comprobar
otros una vez realizados los clculos correspondientes. El tipo de los argumentos, tanto de entrada como de salida, es
de tipo as que si el intrprete pasa a la funcin un valor con un tipo incorrecto es muy posible que reciba a cambio un error de segmentacin. Esto nos obligar a, siempre que escribamos una funcin convenientemente los argumentos de entrada. Una funcin til para ello es
150
Parte III
Ejercicios
151
CAPTULO 9
Ejercicios resueltos
Este captulo se basa en los ejemplos. Se propondrn una serie de ejercicios, se comentarn los algoritmos necesarios para resolverlos y nalmente se dar la solucin a cada uno de ellos.
Metodologa de programacin
Quizs el mayor punto fuerte de Matlab o Octave no es su sencillez o su productividad sino la gran cantidad de funciones tiles que nos proporcionan. El ncleo de Matlab son slo unos pocos Mbytes, en cambio la instalacin completa ocupa tres CD-ROMs. Todo son funciones y archivos cuya razn de ser es hacernos la vida mucho ms fcil. Esto genera una ley un poco paradjica: cuanto menos programemos mejores sern nuestros scripts. Uno puede pensar que el cdigo que escribe uno mismo es mejor, que si al intuitrprete le pasamos todas las lneas que debe usar ir ms rpido. Que si tenemos que cargar ms funciones en memoria haremos que la ejecucin vaya ms lenta... Es justo lo contrario. La mayora de las funciones en Octave, por ejemplo, son funciones escritas en C++ o en Fortran compiladas de una manera especial para que Octave las interprete. Signica que la velocidad de ejecucin de estas subrutinas ser mucho ms cercana a la velocidad de los programas binarios que a la del intrprete.
grad(M ) =
x (M ) y (M )
Que genera una matriz de menor tamao al perder los extremos. Escribir la funcin que devuelve el resultado en una variable tipo estructura:
grdFx=x (M )
grdFy=y (M ).
end.
Por ejemplo, si nosotros queremos los elementos del quinto al ltimo del vector
b bu@SXendA.
pero
153
154
x.
Las condiciones sern que en el punto de empalme de los dos arcos haya continuidad
tanto de la funcin como de la derivada primera. Las dos funciones a ajustar sern entonces (con el problema convenientemente adimensionalizado)
y = P x2 + 0,1
arcos:
y+ = l
Ax + B x
donde se empalman los dos
es el punto en
A 2P l = 2 Al + B 2 P l + 0,1 = Ax + B A+B =1 P
aproximadamente
P = 1,2
fsolve.
funtionfatt@xA glol i f@IAax@IAG@PBsqrt@x@IABx@QACx@PAAAEPBiBx@QAY f@PAaiBx@QABBPCHFIEsqrt@x@IABx@QACx@PAAY f@QAasqrt@x@IACx@PAAEIY end funtionfatoer@xDDDlDA if x`l faB@xBxACHFIY else fasqrt@BxCAY endif end
155
xHaI I IY aHFW I IFPY hold on for iaIXQ glol i ia@iAY resafsolve@9tt9DxHAY xoordalinspe@HDIDIHHAY for jaIXIHH to@jAatoer@xoord@jADres@IADres@PADres@QAD@iAAY end plot@xoordDtoA end hold off
El resultado lo vemos en la gura 9.1.
1.1 1 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1
0.2
0.4
0.6
0.8
x = a(y x) y = x(b z) y z = xy cz
y representarla en el espacio.
con
a = 10, b = 28, c =
8 3
dx dt
= f (x, t)
lsode;
en Matlab utilizaremos
odeRS
porque el problema no es sti. Utilizar la ayuda para saber de qu manera tenemos que escribir la
156
plotQ.
line 1
Figura 9.2: Resultado del script y el tiempo necesario para resolver la EDO que es de La funcin
3,1488
segundos
lsode
de Matlab. Tambin lo es en el sentido que es menos rigurosa en la manera de escribir la funcin, en este caso hemos escrito la variable
xdot
igualmente el uso de un vector columna. Octave permite denir la funcin en el script de modo que podemos resolver el problema con un nico archivo.
157
lsodeoptions@9integrtion method9D9nonEstiff9A
Podemos hacerlo sin miedo porque el problema del atractor de Lorentz, aunque es catico, no es sti. El tiempo de ejecucin desciende a
2,0016
segundos.
lsode
es aceptable
pero podemos rebajarla bastante ms escribiendo la funcin de la ecuacin diferencial en C++ y utilizando
mkotfile. Ya hemos aprendido a hacerlo en la seccin 8. Supongamos que eqlorentzFot que usaremos del mismo modo que cualquier funcin. El script
0,28444
segundos que es el 10 %
0,17314
segundos. Aunque
todas estas consideraciones sobre velocidad pueden parecer intiles debemos tener en cuenta que la integracin de EDOs y EDPs son los problemas numricos ms exigentes en lo que respecta a uso de CPU. Entrar en este tipo de discusiones a menudo comporta grandes benecios aunque en este caso sean irrisorios. Este ltimo tiempo es comparable al obtenido con cdigo enteramente escrito en C++ y slo un poco ms lento que el escrito en C o Fortran y el esfuerzo necesario para escribir el programa ha sido mucho menor.
9.3.2.6. Matlab
columna (lorentzFm): En Matlab necesitaremos dos archivos. El archivo de funcin devuelve el resultado en forma de vector
bastante costoso tanto por el tiempo de desarrollo como por el esfuerzo necesario. Muchas veces se empieza con un prototipo escrito con un lenguaje de RAD (Rapid Application Development) y posteriormente se reescriben sus partes. El mayor obstculo en los proyectos grandes es que deben participar varios desarrolladores. Cada uno puede tener sus preferencias y las guas de estilo no siempre son una solucin efectiva porque slo arreglan el formato del cdigo escrito. Todas estas dicultades unidas al aumento de velocidad de lenguajes como Python o Matlab ha llevado a la creacin del concepto de lenguaje pegamento. Se trata de dejar a medias el cdigo entre el prototipo y el programa denitivo. Partiendo del prototipo se van analizando las partes que consumen ms recursos y, sin cambiar las cabeceras ni el esquema de variables, se reescriben en algn lenguaje rpido. Se para cuando se consigue un equilibrio entre nivel de interactividad, velocidad y coste de mantenimiento de cdigo. Probablemente el mejor lenguaje pegamento sea Python gracias a Pyrex, SWIG y F2Py. El primero es capaz de convertir el cdigo Python en C++ automticamente (rendimiento mximo y coste cero) y el segudo y el tercero son generadores automticos de interfaces, SWIG para C y C++ y F2Py para Fortran 77 y Fortran 95.
158
I=
e(x
+y 2 )
dx dy
Calcular la solucin
inline
annima. Las rutinas de integracin tienen muchos problemas con las singularidades porque trabajan con una precisin limitada, esto nos impide usar lmites de integracin demasiado grandes y ni mucho menos podremos usar
snf
. Con
qudPdg.
bb help qudPdg qudPdg is the userEdefined funtion from the file GusrGshreGotveGPFIFTRGsiteGmGotveEforgeGintegrtionGqudPdgFm usgeX int a qudPdg@9pun9DxlowDxhighDylowDyhighA or int a qudPdg@9pun9DxlowDxhighDylowDyhighDtolA his funtion is similr to eh or ehV for PEdimensionl integrtionD ut it uses qussin qudrture integrtion shemeF int E{}E vlue of the integrl pun E{}E pun@xDyA @funtion to e integrtedA xlow E{}E lower x limit of integrtion xhigh E{}E upper x limit of integrtion ylow E{}E lower y limit of integrtion yhigh E{}E upper y limit of integrtion tol E{}E tolerne prmeter @optionlA xote tht if there re disontinuities the region of integrtion should e roken up into seprte pieesF end if there re singulritiesD more pproprite integrtion qudrture should e used @suh s the qussEgheyshev for speifi type of singulrityAF
159
= 0,
que formulada en
2 2 + 2 =0 x2 y
Si se toman diferencias nitas centradas de segundo orden para puntos dependiendo de ecuacin en diferencias siguiente:
llegamos a la
A = b,
donde
es un
es la matriz de incgnitas
expresada en forma de vector columna. La traslacin del problema bidimensional a un vector de incgnitas es un paso que nos puede costar de entender pero si tenemos una matriz de incgnitas el tensor del sistema tendr tres dimensiones con lo que ya no tendremos rutinas escritas para resolver el sistema. Usaremos como parmetros
se nos quedaramos sin memoria. Esta matriz de incgnitas se va a convertir en un vector signica que la matriz del sistema va a tener llegamos a
n m,
lo que
108
el vector posterior:
ple que implemente la transformacin de la matriz al vector. La entrada sern n. La salida de la funcin ser la posicin en pleaiCn@jEIA.
2. Crear la matriz del sistema con la ecuacin en diferencias y la funcin creada en el apartado anterior 3. Poner las condiciones de contorno al gusto en el vector del trmino independiente y resolver el sistema lineal
a ) Para resolver el sistema lineal del modo usual basta con hacer
b ) Para resolver el sistema con matrices sparse primero creamos la matriz sparse con:
e.
speasprse@eA
de la memoria.
y luego resolveremos el sistema del modo usual. Es una buena idea eliminar la matriz del sistema
dxaPYdyaQYnaSHYmaPSY
A continuacin creamos una funcin que reordena cualquier elemento de una matriz bidimensional en un vector en el que se concatenan las columnas.
nm nm
elementos.
eazeros@nBmDnBmAY for iaIXnBm e@iDiAaIY end for iaPXnEI for jaPXmEI e@ple@iDjDnADple@iDjDnAAaEPB@IG@dxBdxACIG@dyBdyAAY e@ple@iDjDnADple@iEIDjDnAAaIG@dxBdxAY e@ple@iDjDnADple@iCIDjDnAAaIG@dxBdxAY e@ple@iDjDnADple@iDjEIDnAAaIG@dyBdyAY e@ple@iDjDnADple@iDjCIDnAAaIG@dyBdyAY end end
Una vez denida la matriz del sistema creamos el vector del trmino independiente que contiene las condiciones de contorno.
iaIY for jaIXm @ple@iDjDnAAasin@piB@jEIAG@mEIAAY end ianY for jaIXm @ple@iDjDnAAaEsin@piB@jEIAG@mEIAAY end jaIY for iaIXn @ple@iDjDnAAasin@piB@iEIAG@nEIAAY end janY for iaIXn @ple@iDjDnAAaHY end
ae 9Y areshpe@DnDmAY ontour@AY
161
line 1
10
15
20
25
30
35
40
45
10
15
20
25
30
35
40
45
50
En el captulo dedicado a la representacin grca de soluciones hemos hablado sobre lo poco tiles que suelen ser las superfcies coloreadas para dar un resultado. Aunque una de estas representaciones pueda parecer muy explicativa e intuitiva nunca debemos perder de vista que lo que nos importa es mostrar un resultado y una superfcie no lo consigue. Por muy bien que coloquemos los colores o las barras no conocemos el valor de cada punto con precisin y si encima colocamos lneas de nivel dotamos al grco de un exceso de informacin. Aunque sea mucho ms espartano y pueda parecer inapropiado la solucin al problema son las curvas de nivel, en ingls contours . Aunque en un principio cueste un poco ms entender la solucin estamos ofreciendo muchsima ms informacin de un modo netamente ms simple. Se podra decir que no hay motivos para no utilizar las curvas de nivel a parte de intentar demostrar nuestra pericia en el uso de Matlab.
50 45 40 35 30 25 20 15 10 5 0 5 10 15 20 25 30 35 40 45 50 0
ti
to.
dxaPY dyaQY naSHY maSHY funtion pleaple@iDjDnA pleaiCnB@jEIAY end eazeros@nBmDnBmAY ti for iaIXnBm FFF end toYdisp@9greion de l mtriz del sistem9ADdisp@toAYtiY iaIY for jaIXm @ple@iDjDnAAasin@piB@jEIAG@mEIAAY FFF @ple@iDjDnAAaHY end toYdisp@9greion del vetor 9ADdisp@toAYtiY ae 9Y toYdisp@9esoluion del sistem9ADdisp@toAY areshpe@DnDmAY
Los tiempos en cada paso son:
bb ejeriioR greion de l mtriz del sistem IFHTII greion del vetor HFHIUHQV esoluion del sistem PFIRSU
Parece que debemos mejorar la construccin de la matriz del sistema y la resolucin del mismo. Cmo? El primer paso suele ser analizar la forma de la matriz con la funcin
spy.
bb spy@eA
Que tiene como resultado el siguiente patrn (gura 9.5): Esto nos demuestra que es una matriz n-diagonal por bandas lo que entra en la denicin de matriz sparse. Parece que la solucin a nuestros ligeros problemas de velocidad pueden solucionarse con el uso de este tipo de matrices.
163
2000
1500
1000
500
500
1000
1500
2000
2500
for
spdigs.
dig
Dx + Dy
=0
Este planteamiento carece de solucin analtica pero sirve para plantear un problema iterativo en el que slo hay que evaluar la expresin. Empezaremos la subrutina del mismo modo que la anterior, deniendo la funcin que recoloca los elementos de la matriz bidimensional.
dxaPYdyaQYglol naSHYglol maSHY 7 resoluion del prolem on un solver itertivo onstruion de los 7 operdores en diferenis funtion pleaple@iDjDnA pleaiCnB@jEIAY end
Ahora deniremos las matrices de los operadores diferenciales. Las denimos como variables globales al igual que las dimensiones de la matriz porque son necesarios dentro de la funcin que calcula el paso de iteracin y sta puede tener slo un argumento de entrada.
164
A continuacin la funcin que calcula el trmino en cada iteracin. Notemos el hecho de que el argumento que recibe la funcin debe ser un vector por requerimientos de la rutina de resolucin. Para calcular sobre las matrices utilizamos la funcin
reshpe.
iaIYjaIYaIY for jaIXm @ple@iDjDnAAasin@piB@jEIAG@mEIAAY end ianY for jaIXm @ple@iDjDnAAaEsin@piB@jEIAG@mEIAAY end jaIY for iaIXn @ple@iDjDnAAasin@piB@iEIAG@nEIAAY end janY for iaIXn @ple@iDjDnAAaHY end
Y nalmente resolvemos el sistema.
trisolve
rutina para resolver directamente sistemas tridiagonales porque trata este tipo de matrices como sparse. Para resolver el mismo problema en Matlab utilizaremos la funcin y luego resolveremos el sistema de ecuaciones del modo usual.
Este ejercicio es una pequea demostracin de hasta dnde puede llegar el ahorro de cdigo con Matlab. Se trata de resolver la ecuacin del calor unidimensional con condiciones de contorno Dirichlet. La discretizacin espacial sern diferencias nitas de sevundo rden y la temporal ser un esquema Crank Nicholson. Tomaremos este esquema porque permite usar saltos de tiempo ms grandes, de hecho nos permitir llegar al resultado sin tener que calcular ninguna iteracin temporal. La solucin propuesta tiene slo unas pocas lneas. Una solucin tan breve requiere algo de preparacin matemtica de modo que hay que estar muy atento al planteamiento analtico del problema.
spdiags
2 Este
165
t = xx
Como cualquier EDP parablica se puede formular de la siguientes manera:
d = F (x, t) dt
Si utilizamos un esquema Crank Nicholson la discretizacin temporal ser de la forma:
n+1 n 1 = F n+1 + F n t 2
Discretizando tambin el lado derecho de la ecuacin con diferencias nitas de segundo orden llegamos a la ecuacin discretizada:
n+1 i
t 2
= n + i
t 2
n 2n + n n+1 i1 i x2
n+1
t t An+1 = n + An 2 2 B = I
t 2 A y utilizando un
x = 1
B n+1 = B+ n
donde la matriz
tiene la forma:
A= . . . 0 0
2 1 0
1 2 1
0 1 2 0 0
0 0 1
.. .
1 0
2 1
. . . 1 2
0 0 0
=0
en
x=0
=1
en
x = 10
(x) = 0
t = 10.
trisolve.
166
phiazeros@IHDIAY phi@IHDIAaIY dtaHFIY for iaIXSH 5etivte loop in se of preision lek phi@PXWAa@IEdtABphi@PXWACHFSBdtBphi@IXVACHFSBdtBphi@QXIHAY phiatrisolve@EHFSBdtBones@VDIAYHDIY@ICdtABones@VDIAYIDFFF EHYHFSBdtBones@VDIADphiAY end
De este modo llegamos al resultado del problema con una precisin aceptable. La gura del perl de temperaturas es:
0.8
0.6
Temperatura
0.4
0.2
0 0 0.2 0.4
Longitud
0.6
0.8
dig
phiazeros@IHDIAY phi@IHDIAaIY dtaHFIY fadig@ID@ICdtABones@IDVADIDHACFFF dig@EHFSBdtBones@IDVADHDEIACFFF dig@EHDHFSBdtBones@IDVADIAY for iaIXSH phi@PXWAa@IEdtABphi@PXWACHFSBdtBphi@IXVACHFSBdtBphi@QXIHAY phiaf phiY end
167
Muy atentos al modo de denir la condicin lgica que indica cundo pintar
phiazeros@IHDIAY phi@IHDIAaIYdtaHFIY 5 times to output toutaHFIDIDPDSDIHDPHDSHDIHHY hold on for iaIXSHH phi@PXWAa@IEdtABphi@PXWACHFSBdtBphi@IXVACHFSBdtBphi@QXIHAY phiatrisolve@EHFSBdtBones@VDIAYHDIY@ICdtABones@VDIAYIDFFF EHYHFSBdtBones@VDIADphiAY if sum@@dtBiABones@IDlength@toutAAaatoutAaaI plot@phiA end end hold off title@9oluion de l euion del lor unidimensionl9A xlel@9vongitud @dimensionlA9A ylel@9empertur @dimensionlA9A legend@{9HFI9D9I9D9P9D9S9D9IH9D9PH9D9SH9D9IHH9}DPA
0.8
0.6
Temperatura
0.4
0.2
0 0 0.2 0.4
Longitud
0.6
0.8
168
u(1) = u(1) = 1
Cmo podemos resolver esta ecuacin diferencial? Podramos utilizar un esquema de diferencias nitas. Sera sencillo pero... Quien ha dicho que vamos a escoger el mtodo ms sencillo? Uno de los objetivos de este ejercicio es realizar una breve introduccin prctica a los mtodos espectrales de resolucin de ecuaciones diferenciales. Son ms complicados y especcos pero ms precisos y una herramienta ms potente en manos expertas. Los mtodos espectrales se basan en descomponer la solucin en una suma de funciones base que, multiplicadas por una serie de coecientes, aproxima la solucin:
uN =
i=0
ai i (x)
Denimos el residuo como la diferencia entre la solucin exacta y la aproximada por nuestro desarrollo:
uN (x; ai ) = 1 + (1 x2 )(a0 + a1 x + a2 x2 + + aN xN )
Si nos jamos, la eleccin del desarrollo tiene bastante lgica. Es un trmino constante acorde con las condiciones de contorno, una funcin que asegura que las condiciones de contorno se cumplan siempre y un desarrollo polinmico de potencias pares porque se deduce de la ecuacin que la solucin ser simtrica. Con esta solucin calcularemos el residuo y lo igualaremos a cero en los puntos de Gauss-Chebyshev:
xi = cos
(2i 1) 2N
9.7.2. Algoritmo.
Implementar el algoritmo no es tan difcil, lo que es ms complicado es encontrar la forma ptima de hacerlo en Matlab. Para ello nos crearemos un vector de coecientes
a = [a0 , a1 , a2 , . . . , aN ]T
ordenado
p(x) =
i
ai xi
Un mtodo muy utilizado en estos casos es crear una serie de operadores que actan sobre los coecientes. Estos operadores son distintos para cada caso y se representan como una matriz que multiplicar nuestro vector de coecientes. Necesitamos los operadores
c,xx , x6 y x2 3 .
3 Ntese
impares.
que este algoritmo ignora la simetra puesto que tiene en cuenta todos los coecientes, tanto los pares como los
169
9.7.2.1. Operador c
El operador de producto por un escalar aplicado a los coecientes de un polinomio es equivalente a:
c M = c Mij
siendo
9.7.2.2. Operador xx
Si tomamos un polinomio:
p(x) = a0 + a1 x + a2 x2 + a3 x3 +
y lo derivamos dos veces respecto a
el resultado ser:
xx a = [2 1a2 , 3
2a3 , 4 3a4 , . . .] . 0 0 0 xx = 0 . . . 0
0 0 0 0
. . .
21 0 0 32 0 0 0 0
. . . . . .
0 0 43 0
. . .
0 0 0 54
. . .
0 0 0 0 0 N (N 1)
p(x) = a0 + a1 x + a2 x2 + a3 x3 +
es multiplicado por una potencia de su variable los coecientes se mueven hacia las potencias mayores tantas posiciones como sea la potencia de la variable. La matriz ser entonces, para el caso
x2 :
x2 =
0 0 1 0 0
. . .
0 0 0 1 0
0 0 0 0 1
..
Ejercicio1: Crear tres funciones que generen las matrices correspondientes a los operadores y
xx (dxx.m ),
xn (xn.m )
para un vector
de
M elementos. M =N +1
dxx.m
funtion retadxx@wA 7 rgumentosX 7 w XX eslr entero 7 etorn el operdor derivd segund pr 7 un vetor de oefiientes de tmno w if isslr@wA retazeros@wEPDIADzeros@wEPDIADdig@PXwEIAFBdig@IXwEPAY else disp@9w dee ser un eslr9A end
Introduccin informal a Matlab y Octave
170
xn.m
funtion retaxn@wDnA 7 rgumentosX 7 w XX eslr entero 7 XX eslr entero 7 etorn l mtriz orrespondiente l operdor 7 xn on ulquier exponente entero pr un 7 vetor de oefiientes de w elementos if isslr@wA 88 isslr@nA retazeros@nDwAYeye@wAY else disp @9emos rgumentos deen ser eslres9A end
a,
entonces
el operador suma y la multiplicacin por un escalar van a tener los mismos efectos que en la realidad:
a = (1 x2 )a
Llamaremos a este operador
b. b
para un vector
de
elementos.
La solucin a este ejercicio plantea el siguiente problema: Si intentamos utilizar la funcin cdot juntndola con la funcin xn con n=2 aparece el inconveniente de que las matrices no son compatibles. Como este problema se va a repetir ms adelante crearemos una funcin que adapte las matrices y les aada tantos ceros como sea necesario para hacerlas compatibles con la matriz mayor. Esta funcin se llamar join Solucin:
join.m
funtion retajoin@eDfA 7 rgumentosX 7 e XX wtrizD rel 7 f XX wtrizD rel 7 hevuelve un opi de l mtriz e omptile 7 on l mtriz f en el so que sen trnsformiones 7 de un vetor size a size@eAY sizf a size@fAY if size@PA aa sizf@PA 88 size@IA ` sizf@IA retaeYzeros@sizf@IAEsize@IADsize@PAAY else disp@9vs mtrieso son omptiles9A retaHY end
Creacin de la matriz b en funcin de M:
171
R(a ) = xx (a ) x6 (a ) 3x2 (a ) R(a ) = (xx b)(a) (x6 b)(a) (3x2 b)(a) R(a ) = (xx b) (x6 b) (3x2 b) (a)
Ejercicio 3: Crear a partir de los operadores anteriores la funcin que genere el operador de
en funcin
teniendo en cuenta que los resultados parciales pueden generar vectores de tamaos distintos. Esto
signica que se va a reproducir el problema que ya encontramos en el segundo ejercicio pero esta vez no existe una solucin universal. Solucin: R.m
funtion reta@wA 7 hifiil de desifrrF gomentrio pendiente 7 puionF dxx a dxx@wCPAB@wAY 7 rimer termino xT a xn@wCPDTAB@wAY 7 egundo termino xPQ a QBxn@wCPDPAB@wAY 7 erer termino ret a join@dxxDxTAExTEjoin@xPQDxTAY
Denimos
como
a = R(a),
o en forma matricial:
a =Ra
Alguien especialmente observador habr notado que en el opeSe ha eliminado de los operadores porque al no ser dependiente
+1. L
de ningn coeciente queda como trmino independiente. Este trmino debe calcularse a parte . Si pasamos este
+1
por el operador
x + 3x
R(x, ai )
2 3 6 a0 + a1 i + a2 i + a3 i + = i + 3 2
llamamos entonces al sistema:
Sa = q
Ejercicio 4: Plantear un sistema de ecuaciones anterior para los puntos:
i = cos
(2i 1) 2M a
es de dimensiones diferentes a
a.
es mayor al de
a.
(SR)a = q
4 Parte
de la tarea de la eleccin de buenas funciones base est en evitar que aparezcan estos trminos independientes.
172
la matriz del sistema el nmero de las de Solucin:
S debe ser compatible con el operador Residuo R. M , debe ser igual al nmero de elementos de a.
SRq.m
funtion Dqaq@A 7 lul l mtriz en funion de l mtriz residuo 7odos de quss gheyshev 7 omo w de wasize@A@PAY 7esto es legl en ytve pero ilegl en wtl 7ytve permite un esritur muho ms ompt nga@os@@PB@IXwAEIABpiG@PBwAAAF9Y grdoasize@A@IAY 7xo hy ms remedio que utilizr un uleF a9Y for iaHXgrdoEI @XDiCIAangFiY end qangFTCQBngFPY
Ahora slo nos falta resolver el sistema de ecuaciones nal:
(S R)a = q
siendo q el vector de trminos independientes que hemos calculado a parte. Ejercicio 5: Resolver el sistema de ecuaciones para calcular funcin de
para
M =5,
Solucin:
ra@SAY sDqaq@rAY solwSa@sBrAqY ra@IHAY sDqaq@rAY solwIHa@sBrAqY ra@PHAY sDqaq@rAY solwPHa@sBrAqY ra@QHAY sDqaq@rAY solwQHa@sBrAqY
u(x) = exp
x4 1 4
Esto nos permite comparar el resultado obtenido con la solucin, algo que ser imposible hacer en la mayora de los problemas no lineales. Ejercicio 6: Representar grcamente la solucin analtica junto con cada una de las soluciones obtenidas anteriormente. Debemos tener en cuenta que los coecientes que hemos obtenido en el ejercicio anterior no son de un polinomio Matlab por dos motivos:
173
uN (x; ai ) = 1 + (1 x2 )(a0 + a1 x1 + a2 x2 + + aN xN )
Para transformar los coecientes en el polinomio solucin crearemos una funcin llamada transsol que nos devolver el polinomio solucin. Solucin: transsol.m
funtion retatrnssol@solA 7 rgumentos 7 sol XX vetor rel 7 vetor de oefiientes soluion del prolem solarotWH@rotWH@solAAY solaonv@EIDHDIDsolAY sol@length@solAACCY 7 yperdor slo vlido en ytve retasolY 7 proviene de g
Ahora, para representar grcamente las soluciones:
bb bb bb bb bb bb bb
La precisin del resultado es tan alta que no se distinguen las curvas a partir de
Solucion completa
0.9
0.85
0.8
-1
-0.5
0.5
174
0.003 0.0025 0.002 0.0015 0.001 0.0005 0 -0.0005 -0.001 -0.0015 -1 -0.8 -0.6 -0.4
-0.2
9.7.3.1. Convergencia.
En la mayora de los casos es imposible saber si la solucin que obtenemos es la real, lo que s podemos analizar es si nuestro algoritmo converge a una determinada solucin. La convergencia de los mtodos espectrales es, como ya hemos visto, especialmente buena. Para asegurarnos que la solucin converge debemos demostrar que entre los trminos que obviamos (las potencias mayores) no son lo sucientemente relevantes como para inuir en la solucin. Un grco especialmente til es el que representa el logaritmo del mdulo de los coecientes en funcin del nmero de trmino que representan. Calcularemos tomaremos el caso
M = 30
y representaremos
log|an |en
funcin de
n.
-5
-10
-15
log|an|
-20
-25
-30
-35
-40 5 10 15
n
20
25
30
Si se toma la tendencia de los coecientes el problema converge hacia una solucin. Lo ms sorprendente es que, como la solucin es simtrica, los coecientes impares deberan ser nulos.El mayor coeciente impar
175
del real de doble precisin lo que nos induce a pensar que el error es
176
CAPTULO 10
Ejercicios propuestos
10.1. Matrices
1. Dado el vector elementales.
x = [3, 1, 5, 7, 9, 2, 6],
a) b) c) d) e) f) g)
2. Dada la matriz
a ) El vector
xI
A.
a un vector llamado
y.
A.
c ) Calcular la suma de los elementos de las columnas de d ) Calcular la suma de los elementos de las las de
A. A. 7 6 5 7
2 3 A= 8 4
a ) Asignar los elementos impares de la matriz b ) Asignar los elementos pares de la matriz
7 1 1 2 A
9 5 2 8
a otra matriz
a otra matriz
10.2. Programacin
1. Dado el vector
xaQ IS W P EI H EIP W T I
177
178
b ) Multiplicar los valores impares de x por cinco. c ) Asignar los valores de mdulo mayor a 10 a otro vector. d ) Convertir los elementos que son menores a la media en cero e ) Convertir los elementos que son mayores a la media en la media.
2. Escribir una funcin cuyo resultado sea:
10.2. PROGRAMACIN
y(x)
2 x4 36 x
x<6 6 x 20 20 x 36
representarla grcamente para ver que tiene forma triangular con 3. Calcular el nmero
fplot.
1 1012 ?
Cunta es la precisin de
Fn = Fn1 + Fn2
Fn Fn1 se va 1+ 5 aproximando al nmero ureo = a medida que n aumenta. En qu trmino de la serie de 2 12 Fibonacci nos acercamos al nmero ureo con una precisin de 1 10 ?
con
F0 = F1 = 1.
Pn (x)
P0 (x) = 1, P1 (x) = x
P2 (x) =
a = 1,
1 , t 2 deseada:
b=
1 4 y
x = 1.
y t x
a a a a a
piest a @@CAPAG@RBtA
para estimar
con:
1 1012 ?
7. Escribir un programa que pida por lnea de comandos un entero (n) y luego calcule lo siguiente. 1. Mientras el valor de
par; si es impar cambiarlo por tres veces su valor mas 1. 2. Repetir estas operaciones cclicamente y obtener el nmero de iteraciones hasta que el algoritmo se para en 1. Por ejemplo, para han sido 6. 3. Representar la longitud de las secuencias en funcin del entero de entrada de 2 a 30 e intentar descubrir un patrn. Si no se deduce intentarlo con ms nmeros. 4. Hay algn nmero para el que la secuencia sea interminable?
179
9. Escribir un programa que haga la funcin inversa, que pase de nmeros decimales a romanos. En ambos casos el nmero se pedir por pantalla.
x x 2x
2. Sean
2y + 3y 5y
+ +
3z 5z
= 9 = 4 = 17
bases en
R3 ,
y sea
T : R3 R3 P P
de
B,
B B B
.
de
que es la matriz
expresada en la base
[v]B
encontrar
1 = 2 3 P 1 [T (v)]B
y luego como
[v]B
[T (v)]B
de dos maneras, primero como tal que:
e ) Encontrar
[T (v)]B
A [v]B
3. Crear la matriz de
55 T
Tkl = k l
y calcular sus autovalores y autovectores 4. Un proceso para encriptar un mensaje secreto es usar cierta matriz cuadrada con elementos enteros y cuya inversa es tambin entera. Se asigna un nmero a cada letra (A=1, B=2... espacio=28) y se procede como sigue a continuacin. Supongamos que la matriz es:
A=
1 2 1 1 2
2 3 5 8 2 2 1 0 4 6
4 5 8 9 7 9 6 12 8 11
y el mensaje que queremos enviar es ALGEBRA LINEAL. Para codicar el mensaje romperemos la cadena de nmeros en vectores de cinco elementos y los codicaremos.
a ) Cul ser la cadena de datos encriptada que enviaremos? b ) Descifrar el mensaje: 48 64 -40 300 472 61 96 -90 346 538 16 -5 71 182 332 68 131 -176 322 411
66 125 -170 301 417.
180
y=
y su asntota. (2 ) 2. Hallar la longitud
x2 1 x2 + 1
0 t 2
= a(1 + cos )
(Sobre el eje de simetra y en
x=
4a 5 )
Integrarlas con una condicin inicial cualquiera y representar grcamente las trayectorias. 5. Resolver el sistema de ecuaciones diferenciales siguiente:
dx dt dy dt
donde
= =
a = 0,05, b = 0,0002, c = 0,00001, d = 0,0003 y e = 0,06. Crear el mapa de fases linealizando la quiver. Resolverlo para t [0, 300] con distintos valores iniciales y
ver que las soluciones siguen el camino marcado por el gradiente numrico. 6. Resolver el siguiente sistema que representa un modelo depredador-presa:
x1 x2
con condicin inicial por
= x1 (15 x2 ) = x2 (15 + x1 x2 )
Si los depredadores vienen dados por
x1 (0) = 10
x2 (0) = 15.
x1 ,
las presas
x2
y el tiempo est medido en meses, cuntos predadores y presas hay al cabo de un ao? Se
x1 x2
x1
en funcin de
x2 .
10
y desviacin
9. 10. B+
y
2. Generar una muestra de 1000 elementos que sigan una distribucin uniforme de media cero y desviacin tpica
3. Calcular y representar los caminos de un grupo de partculas con movimiento aleatorio connadas por un par de barreras
xj+1 = xj + s
181
la funcin siguiente:
a ) La posicin media de las partculas en funcin del tiempo. b ) La desviacin tpica de las posiciones de las partculas en funcin del tiempo. c ) Inuyen las condiciones de contorno en las distribuciones? d ) Para los casos de absorcin y absorcin parcial representar grcamente el nmero de partculas
supervivientes en funcin del nmero de saltos temporales. 4. Desarrollar en serie de Fourier la funcin
f (x) = x2
< x < .
182
Parte IV
Apndices
183
APNDICE A
Gua de estilo. Los 10 mandamientos
En muy bueno para un lenguaje de programacin que tenga una gua de estilo asociada. Cmo formatear el cdigo debe ser algo ms que una marca de estilo personal, un estndar que todo el mundo siga a rajatabla. En algunos lenguajes la sintaxis viene acoplada a unas ciertas reglas de escritura, por ejemplo Python nos obliga a tabular las estructuras; si no ordenamos bien el inicio de las lneas el cdigo no funcionar. C, C++ y Java usan corchetes para agrupar niveles de ejecucin y se recomienda dejar slo el corchete en la lnea y tabular todo lo que contenga. En muchos casos estas reglas son en realidad recomendaciones. En Fortran recomiendan marcar los niveles de ejecucin con tabulados de dos espacios, algo parecido se recomienda en Matlab. Pero tanto en Fortran como en Matlab estas normas son sistemticamente ignoradas. El programador cientco no ha recibido ninguna educacin sobre las reglas de escritura y tiene muy poca experiencia con lenguajes ms fuertemente estructurados como C o Java. El resultado es un cdigo plano, desestructurado, desorganizado y mal comentado. Una de las herramientas esenciales para evitar este desastre es el editor de texto. Sera muy largo describir el funcionamiento de un editor de texto, simplemente diremos que es un programa que edita cdigo fuente y que tiene todas las herramientas disponibles para que sea mucho ms fcil. Colorea las palabras clave, tabula el cdigo automticamente, corrije algunos fallos comunes... Matlab posee un buen editor de textos, pero no le llega ni a la suela del zapato a Emacs o VIM. El funcionamiento de Emacs puede resultar hasta sorprendente. Imaginemos que abrimos un archivo de cdigo escrito en Fortran 95. Est lleno de falta un
if y do sin
ordenar y mal tabulado. Adems el compilador nos dice que hay una estructura que est sin cerrar; que nos el texto se tabula automticamente.
end. Si estamos editando el archivo con Emacs slo tenemos que pulsar `eltb`gontrolb`b y todo
Sin embargo el estilo de un buen programador es insustituible. Matlab no tiene ninguna gua de estilo, sin embargo puede decirse que existen una serie de normas no escritas para que el cdigo sea ms leble y, no menos importante, ejecute rpido. Estas normas parecen inservibles para pequeos scripts que escribimos para consumo propio. He aprendido que cuando se recupera un script que se ha escrito seis meses antes es como si lo hubiera escrito otro. Siempre que escribamos un programa tomaremos esta actitud; lo estamos escribiendo para que un desconocido lo entienda. Todas las buenas prcticas se resumen en diez tcnicas, los 10 mandamientos del Matlab.
1.
Utilizar funciones
inline
Ya hemos visto que en Matlab (que no en Octave) denir una nueva funcin signica crear un archivo. Esto hace que el cdigo de el programa principal sea ms difcil de entender y de comentar. Aunque Matlab escala bien no es muy recomendable escribir programas demasiado largos y si tenemos demasiadas funciones y archivos es que no estamos haciendo las cosas bien. Las sentencias
inline
2.
Usar bucles
for
Esta es la gran diferencia entre Matlab y Fortran. Una de las grandes decepciones de los programadores en Fortran cuando utilizan Matlab es la gran diferencia de velocidad. Esta diferencia existe y es de entre
185
186
uno y dos rdenes de magnitud. El problema es que es gravemente acentuada por usar el estilo de Fortran en el cdigo Matlab. En Fortran los bucles
do
los contadores se optimizan como estructura entera, incluso algunos compiladores advierten cuando los bucles encapsulados no son dependientes y paralelizan la tarea automticamente. El programador en Fortran encapsula porque sabe que el compilador le va a ayudar. Matlab no es capaz de optimizar el cdigo de esta manera porque su arquitectura no lo permite. La solucin para obtener una velocidad aceptable es usar siempre submatrices.
3.
Usar estructuras
if
planas.
Cuando hablamos de condicionales dijimos que el encapsulado tipo matroska no era recomendable porque complica mucho la lectura del cdigo. Adems disminuye la velocidad de ejecucin por la creacin de ms variables adicionales. Si utilizamos condiciones lgicas compuestas (siempre dentro de un lmite) el resultado ser ms leble y posiblemente ms rpido.
4.
zeros, ones, eye, linspe o meshgrid son tremendamente tiles. El cdigo de un buen
programador estar siempre lleno de composicin de estas funciones para generar matrices. La alternativa es utilizar bucles, prohibido por el segundo mandamiento.
5.
Cuando se pasan los argumentos a una funcin lo habitual es crear primero las variables que los contienen y luego poner las variables en la cabecera. Si lo hacemos es casi obligado hacerlo justo antes de llamar a la funcin. De otro modo tendremos que navegar por el cdigo hasta encontrar dnde se dene la variable que pasa el argumento. Es recomendable tambin que las constantes o los argumentos simples se denan directamente en la cabecera. Puede parecer que el resultado es difcil de leer, pero cuando uno se acostumbra resulta ser todo lo contrario. Es mucho mejor una lnea con varios comandos que no repartir sentencias asociadas por todo el cdigo.
6.
Este es el No matars de los mandamientos de Matlab. La alternativa es utilizar bucles con un puntero que vaya rastreando la matriz; demasiado lento. El equivalente de esta recomendacin en Fortran sera utilizar el
forll
Esta prctica slo tiene ventajas. El cdigo es ms leble, es plano, mejor encapsulado, se entiende perfectamente y es ms rpido. Cuando se dice que Matlab es un programa de clculo matricial no se dice gratuitamente. No hay que pensar contando ndices con la notacin del sumatorio como en Fortran, hay que pensar matricialmente.
7.
Aunque ya hemos aprendido que lo ms importante es evitar el encapsulado de estructuras de ejecucin en algunos casos no tendremos ms salida. En ese caso el tabulado de cada uno de los bloques es muy recomendable. Adems de obteber un resultado ms leble evitaremos los errores tontos como los bucles o los condicionales sin cerrar.
8.
Lo repito, cuando recuperemos cdigo escrito unos meses antes ser como si lo hubiera escrito otro. puede ser que una sentencia especialmente brillante sea adems crptica; comentaremos sistemticamente todo lo que sea necesario.
9.
Este mandamiento es directamente derivado del octavo. A medida que escribamos funciones terminaremos con una pequea biblioteca personal. El resultado ser que tendremos que usar funciones sin recordar ni la forma de su cabecera. El comando nos servir en las que escribamos nosotros mismos.
187
10.
Las soluciones ms justas no siempre son las ms fciles. Octave es ms espartano y difcil pero ha sido posible gracias al esfuerzo de muchos desarrolladores que han colaborado desinteresadamente en el proyecto. El resultado es un programa de gran calidad que no para de mejorar da a da. El hecho de que se trate de software libre es un valor aadido. Podremos escudriar en sus entraas para descubrir su funcionamiento, extenderlo con otros lenguajes de programacin, ayudar en proyectos secundarios. Una vez se entra en este juego no se para de aprender.
188
APNDICE B
A L T X es capaz de preparar documentos con un acabado profesional con cualquer PC como nica herraE 1 A de texto y el WYSIWYG . Cuando nos dicen que para obtener un documento L T X hay que compilar un E archivo de documento y que la salida es en formato DVI probablemente tengamos un escalofro. Lo que pasa
es que hemos ganado potencia a base de bajar el nivel de la aplicacin. Si nos miramos un procesador de texto detenidamente veremos que en realidad no estamos escribiendo lo que sale en pantalla; en realidad el procesador escribe un documento en formato XML que tiene muy poco que ver con el resultado en pantalla. mienta. El aprendizaje no es sencillo debido a la gran inuencia que actualmente tienen los procesadores
A Escribir en L T X sera como si nos pusieramos a teclear directamente XML y pasramos del procesador de E textos.
Cuanto ms potente es una herramienta ms esfuerzo requiere dominarla, an as para hacer los primeros
A pasos con el L T X no se requieren ms de unas horas. Para empezar es importante tener un libro o una E
gua. Es un lenguaje que se basa en comandos con lo que tener un listado convenientemente explicado es
A esencial. Para encontrar algn tutorial se puede acceder a la pgina del grupo de usuarios de L T X de E
Espaa,
httpXGGfilemonFmeniFupmFesGgervneG.
A Otra opcin es optar por algn procesador de textos L T X, una especie de hbrido entre procesador de E 2 A textos y escritura L T X directa. No hay mucha variedad, suelen llamarse procesadores WYSIWYM porque E en pantalla no se ve el output denitivo, sigue siendo necesario compilar el documento. Los dos ms conocido
son LyX y Scientic Word. Este documento ha sido preparado con LyX. Es un gran procesador de textos libre y gratuito y completamente multiplataforma; esto es, tiene versiones para todos los sistemas operativos mayoritarios. Es um programa de gran calidad, con mucha documentacin adjunta y una comunidad muy activa. Merece la pena probarlo. Scientic Word, al igual que su hermano mayor Scientic Workplace, es un entorno parecido a LyX pero ms orientado hacia Windows. Tiene cierta compatibilidad con Microsoft Oce y soporta mejor los formatos de este sistema operativo. La diferencia entre Scientic Word y Scientic Workplace es que el segundo cuenta adems con un sistema de clculo simblico embebido. Slo existe versin para Windows.
A Es muy importante tener nociones de la sintaxis de L T X porque Matlab soporta sus smbolos en los E
grcos y porque la mayora de los editores de ecuaciones basan el lenguaje de su intrprete en las mismas palabras clave.
1 What You See Is What You Get 2 Whay You See Is What You Mean
189
190
\leq \infty \clubsuit \diamondsuit \heartsuit \spadesuit \leftrightarrow \leftarrow \uparrow \rightarrow \downarrow \circ \pm \geq \propto \partial \bullet \div \neq \mp
\hbar \oint \supseteq \subset \nabla \cdots \ldots \prime \top \mid \sum \iint
...
Adems de estos caracteres es importante conocer algunas convenciones de la escritura de frmulas. Antes de cada clave se puede aplicar un atributo para modicar el tipo de letra, por ejemplo el subndice se denota con
y el superndice con
la cursiva con
it
j
y la negrita con
f.
A=
i
i Aij
haremos
APNDICE C
Software y formatos libres.
Para escribir este curso he usado una de las herramientas de publicacin ms potentes que hay en la
A actualidad, T X. Es un poco ms conocida una coleccin de macros llamada L T X. No he escrito directaE E A mente cdigo L T X sino que he usado un editor de textos llamado LyX. La calidad del documento nal E
es apreciable; las fuentes son claras y la tipografa es perfecta. Probablemente a alguno le sorprenda saber que estas herramientas son gratuitas. No me reero a que las haya pirateado ni que me las hayan regalado; podemos descargarnos todos estos programas e instalarlos en nuestro ordenador de forma gratuita (siempre que respetemos la licencia adjunta). Adems no solo podemos descargar el programa, sino que el cdigo fuente tambin est disponible con una licencia que permite su modicacin y su redistribucin. T X es quizs el ejemplo ms llamativo por ser el primero. Lo program Donald E. Knuth porque estaba E muy descontento con la calidad de la tipografa de algunas editoriales con las que tena tratos. A partir de entonces la cantidad de proyectos cuya mxima es la posibilidad de compartir y redistribuir el cdigo libremente no ha hecho ms que aumentar. Otros ejemplos conocidos (algunos ms otros menos) son Linux, implementacin libre y gratuita de un ncleo de sistema operativo tipo UNIX; Emacs, posiblemente el editor ms completo y extensible que existe; Apache, el servidor web ms usado; PostgreSQL, una base de datos muy popular; KDE, un entorno de escritorio completo que rivaliza en calidad con WindowsXP y Mac OSX... El software libre tiene dos grandes ventajas respecto al comercial, el coste cero sin garanta y (ventaja poco valorada) ser proyectos llevados en comunidad. Una vez un programa comercial sale al mercado se independiza completamente de sus desarrolladores; el mantenimiento pasa a ser labor del servicio tcnico. Si el programa funciona mal o de un modo distinto al supuesto habr que llamar por telfono y solicitar ayuda. Una comunidad es una estructura completamente distinta. Supongamos que encontramos un bug en Octave, uno grave que no nos permita seguir con nuestro trabajo. A quin llamamos? No hay ninguna empresa que ofrezca garanta, adems en la licencia pone bien claro que Octave no es un producto mercantil y por tanto no est sujeto a ninguna normativa concreta. La frase usada es use this software at your own risk. Lo que haremos ser ir a google e investigar si alguien ha tenido antes el mismo problema; si la respuesta es negativa pasaremos a las listas de correo. Las listas de correo son la base de una comunidad de desarrolladores junto con los canales IRC. Para quien no lo sepa una lista de correo es una direccin de correo electrnico que manda lo que recibe a todos los miembros de la lista. Si vemos que somos los primeros en detectar el fallo debemos suscribirnos a la lista de usuarios de Octave (bastante activa, por cierto), describir el fallo y pedir amablemente que alguien nos ayude. Si tenemos suerte es probable que John W. Eaton, creador de Octave, nos responda. Si adems le damos nosotros la solucin y esto sucede unas cuantas veces puede ser que nos de permiso de escritura en el repositorio de cdigo y que nos de una cuenta de desarrollador. En Octave todo se hace a pequea escala; en proyectos grandes como KDE el proceso de desarrollo involucra a unas mil personas y varias empresas. Este fenmeno ha crecido gracias a dos pequeos detalles, el uso de licencias copyleft y el uso de estndares abiertos. He publicado este texto bajo una licencia Creative Commons, creada por una fundacin cuyo n es la publicacin de licencias de distribucin copyleft. Lo he hecho por la creencia personal de que el conocimiento debe ser pblico y gratuito. Este afn altruista puede provocar consecuencias bastante desagra-
191
192
dables en el caso que no sea perfectamente planeado. Es aqu donde entran las licencias libres o de copyleft. Una licencia libre asegura la mxima libertad de uso; es un blindaje comercial absoluto que puede ser tan bebecioso en algunos casos como perjudicial en otros. Luego nos encontramos varias licencias que limitan las libertades de uso, siempre intentando preservar primero los derechos del autor. En este caso he utilizado una licencia no comercial pero sin posibilidad de un trabajo derivado. Esto signica que cedo la libertad de copiar literalmente el texto sin ningn coste econmico pero que me reservo el derecho de cobrar por ello cuando quiera. Tambin impide que cualquier otro autor que copie partes del libro pueda hacerlo sin citarme. Cuando alguien con este afn altruista, normalmente acompaado de un desprecio total por el lucro, pretende programar una aplicacin o publicar un libro en comunidad nunca inventar su propio formato de distribucin. Lo que har ser buscar el formato ms extendido para que su trabajo llegue a la mayor cantidad de gente posible. Esto est asegurado con el uso de estndares abiertos. Los estndares abiertos son tipos de archivos o protocolos de comunicacin cuyas especicaciones tcnicas se han publicado enteras. Ejemplos de estndares abiertos son los protocolos TCP/IP, HTTP, FTP, SSH; los lenguajes C, C++, Python; los tipos de documentos HTML, SGML, RTF, PS, PDF, OD*... Permiten que dos programas que no tienen ninguna lnea de cdigo en comn puedan entenderse a la perfeccin. El software libre o de cdigo abierto (hay una diferencia muy sutil entre los dos) utiliza casi siempre estndares abiertos porque es absurdo no hacerlo. Cuando alguien publica un programa con su propio estndar debe hacerlo desde una posicin de fuerza para conseguir imponerlo. He aqu el gran enemigo del software libre, los estndares cerrados. Los ejemplos de estndares cerrados ms maniestos son los impuestos por Microsoft. Cada producto que sacan al mercado tiene su propio formato de archivo incompatible con los ya existentes. Es una prctica monopolstica muy habitual y las consecuencias han sido nefastas para el mundo de la informtica. Slo hace poco han decidido publicar parte de las especicaciones porque as lo han requerido varios gobiernos por motivos de seguridad nacional.
Todos los formatos cerrados son nocivos; cuanto ms extendidos ms perjudiciales. El archivo .doc ha hecho un dao irreparable. Microsoft Word es el nico procesador de textos existente que no exporta a PDF. Por qu? Porque Microsoft intenta imponer el archivo DOC para distribucin de archivos de texto. Si uno usa Windows en su ordenador es su problema, si usa Explorer all l pero si usa Microsoft Oce el problema es de todos. Utilizar un programa
de software libre es una garanta de uso de estndares abiertos. Si uno preere seguir utilizando productos de Microsoft que consiga un plugin de salida a PDF o que use el formato RTF (Rich Text Format). Todos los que no seamos esclavos de Microsoft se lo vamos a agradecer eternamente. No estoy sugiriendo que todo el mundo instale Linux en su ordenador (aunque as viviramos en un mundo mejor). Lo que s recomiendo encarecidamente es que se usen formatos abiertos para compartir documentos. Hace muy poco se publicaron las especicaciones tcnicas de la alternativa a los formatos de Microsoft Oce llamados Open Document. Los programas que lo soportan son, de momento, OpenOce y Koce. OpenOce es una suite de omtica muy completa de un invel equivalente a Microsoft Oce. Tiene versiones nativas para Linux, Windows, Solaris y Mac OSX. Koce es la suite particular de KDE y es un proyecto a una escala menor. Otro ejemplo agrante es el del estndar html. Es el lenguaje de marcas en el que estn escritas las pginas web. Todos los navegadores estn diseados para soportar todas las especicaciones del estndar excepto uno. Esta oveja negra es el Microsoft Internet Explorer. Adems los desarrolladores de este navegador han asegurado que no pretenden soportar enteramente el formato html ms actual en un futuro cercano. Esto obliga a los desarrolladores de pginas web a utilizar las especicaciones del html soportado para el Internet Explorer y no las que marca el estndar de la w3c, organizacin sin nimo de lucro que vela por los estndares de publicacin en Internet. Esta situacin vergonzosa es provocada por la maniesta falta de calidad del navegador de Microsoft y por la aplicacin de tcnicas monopolsticas en el mercado de el diseo de pginas web. Cuntas pginas en el mundo estn optimizadas para el Internet Explorer? Cuntas llevan el sello de w3c? Espero que este apndice ayude a concienciar a alguien de lo importante que es no ceder al chantaje de ciertas empresas cuyo nico objetivo es enriquecerse a costa manipular al consumidor.
APNDICE D
GNU Free Documentation License
Version 1.2, November 2002 Copyright c 2000,2001,2002 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
Preamble
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the eective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modications made by others. This License is a kind of copyleft, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
Document, below, refers to any such manual or work. Any member of the public is a licensee, and you. You accept the license if you copy, modify or distribute the work in a way requiring Modied Version
of the Document means any work containing the Document or a portion of it, is a named appendix or a front-matter section of the Document that deals
permission under copyright law. either copied verbatim, or with modications and/or translated into another language.
Secondary Section
exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
193
194
The
Invariant Sections are certain Secondary Sections whose titles are designated, as being those of
Invariant Sections, in the notice that says that the Document is released under this License. If a section does not t the above denition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none. The
Cover Texts are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover
Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words. A
Transparent copy of the Document means a machine-readable copy, represented in a format whose
specication is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent le format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modication by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not Transparent is called
Opaque.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modication. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only. The
Title Page means, for a printed book, the title page itself, plus such following pages as are needed Entitled XYZ means a named subunit of the Document whose title either is precisely XYZ or Acknowledgements, Dedications, Endorsements,
of such a section when you modify the Document means that it
to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, Title Page means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text. A section
contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specic section name mentioned below, such as or
remains a section Entitled XYZ according to this denition. The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no eect on the meaning of this License.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to t legibly, you should put the rst ones listed (as many as t reasonably) on the actual cover, and continue the rest onto adjacent pages.
195
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
4. MODIFICATIONS
You may copy and distribute a Modied Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modied Version under precisely this License, with the Modied Version lling the role of the Document, thus licensing distribution and modication of the Modied Version to whoever possesses a copy of it. In addition, you must do these things in the Modied Version: A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modications in the Modied Version, together with at least ve of the principal authors of the Document (all of its principal authors, if it has fewer than ve), unless they release you from this requirement. C. State on the Title page the name of the publisher of the Modied Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modied Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. H. Include an unaltered copy of this License. I. Preserve the section Entitled History, Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modied Version as given on the Title Page. If there is no section Entitled History in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modied Version as stated in the previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the History section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. K. For any section Entitled Acknowledgements or Dedications, Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section Entitled Endorsements. Such a section may not be included in the Modied Version. N. Do not retitle any existing section to be Entitled Endorsements or to conict in title with any Invariant Section.
196
O. Preserve any Warranty Disclaimers. If the Modied Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modied Version's license notice. These titles must be distinct from any other section titles. You may add a section Entitled Endorsements, provided it contains nothing but endorsements of your Modied Version by various partiesfor example, statements of peer review or that the text has been approved by an organization as the authoritative denition of a standard. You may add a passage of up to ve words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modied Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modied Version.
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this License, under the terms dened in section 4 above for modied versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodied, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but dierent contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections Entitled History in the various original documents, forming one section Entitled History; likewise combine any sections Entitled Acknowledgements, and any sections Entitled Dedications. You must delete all sections Entitled Endorsements.
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
8. TRANSLATION
197
Translation is considered a kind of modication, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail. If a section in the Document is Entitled Acknowledgements, Dedications, or History, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
Copyright c YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the with . . . Texts. line with this:
with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
198
BIBLIOGRAFA
[1] Turbulence and Vortex Dynamics; Javier Jimnez; July 26, 2004;
httpXGGtorrojFdmtFupmFesG
[2] Fortran 95/2003 Explained; Michael Metcalf, John Reid, Malcolm Cohen; Oxford University Press; 2004. [3] Numerical Recipes in Fortran 77, The Art of Scientic Computing; Second Edition; William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery; Cambridge University Press, 1997 [4] Fluid Flow Phenomena, A Numerical Toolkit; Paolo Orlandi; Kluwer Academic Publishers, 2000. [5] Computational Fluid Dynamics; T.S. Chung; Cambridge University Press, 2002 [6] C++: The Complete Reference; Herbert Schildt; Tata Mc Graw-Hill ,1999 [7] Scary Octave;
httpXGGwikiFotveForgG httpXGGwwwFotveForgG
[8] The Octave Language for Numerical Computations; John W. Eaton; [9] Python Tutorial; Guido van Rossum; [10] MathWorld; Eric W. Weisstein;
httpXGGwwwFpythonForgGtutGtutFhtml
httpXGGmthworldFwolfrmFomG
[11] Mecnica de Fluidos; Amable Lin; Publicaciones ETSIA, Universidad Politcnica de Madrid. [12] Clculo Numrico I; Varios; Publicaciones ETSIA, Universidad Politcnica de Madrid. [13] Anlisis y Clculo Numrico en Ecuaciones en Derivadas Parciales; Juan A. Hernndez, Eusebio Valero; Publicaciones ETSIA, Universidad Politcnica de Madrid. [14] Spectral methods in MATLAB; Lloyd N. Trefethen; SIAM, 2000 [15] Algebra Lineal y Geometra Cartesiana; Juan de Burgos; McGraw Hill, 2000 [16] Fortran 95; Programacin Multicapa para la simulacin de sistemas fsicos; Juan A. Hernndez, Mario A. Zamecnik; ADI, 2001. [17] Wikipedia, the free encyclopedia:httpXGGenFwikipediForgGwikiGikipedi [18] The Humble Programmer; Edsger W. Dijkstra;
ihHQxxGihQRHFhtml
httpXGGwwwFsFutexsFeduG~ihGtrnsriptionsG httpXGGlpleFphysisFuFGeopleG
jsonGreferenesGfoydPedFpdf
httpXGGsipyForgG
199
NDICE ALFABTICO
lgebra, 67 addpath, 60 Argumentos, 32 assignin, 114 Ayuda, 52 BDF, 90 biblioteca, 27 biblioteca estndar, 27 bode, 126 break, 51 buildssic, 124 builtin, 60 caos, 94 cat, 70 celdas, 44 cell arrays, 44 center, 99 clear, 43 collect, 97 compilador, 17 Contenedores, 43 continue, 51 contour, 84 conv, 87 csape, 102 csapi, 102 ctranspose, 69 dbclear, 117 dblquad, 88 dbstop, 116 dbtype, 116 deconv, 87 Derivadas, 88 diag, 68 diary, 61 di, 88, 97 dierentiate, 97 dispatch, 59 Divisin, 39 do-until, 51
echo, 115 ecuaciones diferenciales, 89 edit, 60 EDO, 89 eig, 78 error, 53 errorbar, 83 Estructuras, 44 evalin, 113 expand, 97 eye, 67 factorial, 58 t, 103 t2, 104 tlt, 104 tn, 104 tshift, 104 Figure, 79 ll, 81 for, 49 free, 61 fsolve, 108 funcin, 30 funciones annimas, 56 function handles, 55 fzero, 106 global, 42 Grcos, 79 gradient, 88 grid, 80 help, 29, 52 hist, 84 hold, 79 if, 47 it, 103 inline, 54 input, 61 inputname, 113 int, 97 intrprete, 17
200
NDICE ALFABTICO
Integrales, 88 interp1, 101 interp2, 102 introspeccin, 57 issparse, 74 issquare, 74 LaTeX, 183 legend, 80 limit, 97 linspace, 67 load, 61 loglog, 83 logspace, 67 long, 60 Lorentz, 151 lsode, 90 quad, 88 Matlab, 17 Matrices, 32 max, 99 mean, 99 median, 99 men, 61 mesh, 85 meshc, 85 meshdom, 67 meshgrid, 67 min, 99 more, 29 Multiplicacin, 39 Nmeros Complejos, 37 nargin, 53, 113 nargoun, 113 nargout, 54 Negacin, 39 nichols, 126 no, 40 none, 61 null, 78 nyquist, 126 o, 40 Octave, 21 Octave-forge, 21 ode113, 91 ode15i, 91 ode15s, 91 ode23, 91 ode23s, 91 ode23t, 91 ode23tb, 91 ode45, 91 ODEPACK, 90 ones, 67 Operadores, 37 Operadores aritmticos, 39 operadores de comparacin, 40 save, 61 script, 30 scripting, 17 semilogx, 83 semilogy, 83 Sentencias, 47 short, 60 sort, 99 spabs, 76 sparse, 74, 75 spdiags, 76 speye, 76 sphcat, 76 spimag, 76 spinv, 76 spline, 102 splot, 97 spones, 76 sprand, 76 spreal, 76 spvcat, 76 spy, 74 ss, 121 std, 99 rand, 67 rank, 78 recursivas, 58 referencia, 27 repmat, 70 reshape, 69 residue, 88 Resta, 39 return, 54 Rikitake, 94 roots, 87 quad2dc, 88 quad2dg, 88 quadl, 88 quiver, 85 parser, 28 persistent, 43 pie, 84 plot, 82 polar, 83 poly, 87 poly2sym, 96 polyder, 87 polyt, 100 polyint, 87 polyout, 87 polyval, 87 Potencia, 39 ppval, 102 operadores lgicos, 40
201
202
sti, 89 Submatrices, 36 subplot, 79 subs, 97 Suma, 39 surf, 85 svd, 78 switch, 48 sym, 96 symsum, 97 sysadd, 124 sysappend, 124 sysconnect, 124 sysdup, 124 sysgroup, 124 sysidx, 124 sysmult, 124 sysout, 122 sysprune, 124 syssub, 124 taylor, 97 TeX, 81, 183 text, 80 texto, 37 tf, 121 tipo, 43 tipo derivado, 43 Title, 80 transpose, 69 trapz, 88 Traspuesta, 39 triplequad, 88 trisolve, 77 try, 51 type, 60, 115 usage, 53 Van der Pol, 92 varargin, 113 varargout, 113 Variables, 41 variables lgicas, 37 vdp1, 92 vdp1000, 93 view, 85 while, 49 who, 43 whos, 43 xlabel, 80 y, 40 ylabel, 80 zeros, 67 zp, 121
NDICE ALFABTICO