Si Matlab no puede definir funciones completas dentro de un script significa que para escribir cualquier expresión matemática no básica 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 función y la conecta a una variable, como si de un puntero a una función se tratara. Su uso es muy sencillo, pero requiere cierta práctica.

Si queremos introducir una función escribiremos:

>> foo=inline('sin(x)*cos(x)','x');

En la que obviamente introducimos los elementos como cadenas de texto. Para evaluar la función lo haremos del modo usual:

>> c=foo(6)

que nos pondrá en la variable c el valor de la función en 6, -0.26829.

En el caso que nuestra función tenga más de una variable de entrada podemos explicitarlas como:

>> foo2=inline('sin(x)*cos(y)','x','y');

Entonces los parámetros de entrada para la evaluación van a ser dos y van a mantener el orden asignado en la sentencia inline. De hecho, este intrinsic funciona perfectamente con sólo la función como argumento, pero es casi un imperativo para saber cómo se introducen las variables en la evaluación.

También podemos utilizar la sentencia inline cuando se nos pida evaluar una función. Vimos un ejemplo de ello en el primer capítulo cuando se introdujo el lenguaje:

>> quad(inline('besselj(2.5,x)'),0,4.5)

 ans = 1.1178

Para integrar necesitamos una función de una sola variable de modo que hemos creado una nueva función con la sentencia inline para modificar la función besselj. La nueva función (sin nombre) acepta sólo un argumento. Esta práctica es muy frecuente y útil, pensemos que por cada vez que utilicemos un inline nos ahorramos un archivo.

2.9.5 Function handles

Hemos enfatizado en la necesidad de diferenciar los conceptos de variable y de argumento. Ahora introduciremos un concepto aún más complejo, el de la manipulación de funciones. En Matlab la función no es un elemento inerte como en Fortran, se parece bastante más a las funciones de C. Un ejemplo de esta diferencia es que en C podemos crear matrices cuyos elementos sean funciones gracias al uso de punteros.

Fuera de estas consideraciones teóricas diremos que Matlab tiene una herramienta para asignar funciones (aunque sería más correcto llamarlos métodos) a variables. Esta herramienta se llama Function handle por comparación con una herramienta real, sería conveniente llamarla ``asa'' o ``mango''. Pensemos en un martillo; la herramienta en sí es sólo la cabeza y lo que nos ayuda a manejarlo es el mango cuya función, aunque secundaria, es imprescindible. Lo mismo sucede con las asas de una paellera. Las funciones en un archivo son como paelleras sin asas, cumplen su función pero no las podemos manejar. Si utilizamos los Function handles para asignar una función a una variable podemos utilizar la función sin hacerlo directamente al igual que operamos los argumentos mediante variables.

Un Function handle se denota con la letra @. Por ejemplo, si queremos asignar a la variable varsin la función sin lo haremos del siguiente modo:

>> varsin = @sin

A partir de ahora la variable sirve de interfaz a la función. Da igual que la función sea parte de la biblioteca estándar o que la acabemos de escribir nosotros mismos. Por si hay alguna duda de que varsin es ahora la función seno:

>> varsin(pi/2)

 

 ans = 1

Un uso muy interesante de los Function handles es la creación de estructuras de datos con funciones. Como ejemplo crearemos unas celdas donde los elementos sean las funciones trigonométricas básicas:

>> trifun={@sin,@cos,@tan}

 trifun =

 {

   [1,1] =

 sin

   [1,2] =

 cos

   [1,3] =

 tan

 }

 >> trifun{3}(pi/4)

 ans = 1.0000

Esto hace que tengan un papel protagonista en las cabeceras de las funciones. Cuando una función necesita a otra como argumento podemos asignarla también por nombre o por una sentencia inline pero lo recomendable es utilizar un Function handle. Por ejemplo, para hacer la siguiente integral mediante la función quad:

∫

sin(x) dx

>> I=quad('sin',0,pi)

 I = 2

 >> I=quad(inline('sin(x)'),0,pi)

 I = 2

 >> I=quad(@sin,0,pi) # Forma recomendada

 I = 2

La tercera es equivalente a pasar antes el Function handle con la función seno a una variable:

>> fhandle=@sin

 fhandle =

 sin

 >> I=quad(fhandle,0,pi)

 I = 2

Y así con todas las rutinas que requieran una función como argumento.

2.9.5.1 Funciones anónimas

La sentencia inline se considera obsoleta (aunque no oficialmente). El recurso que la ha apartado es utilizar un Function handle para declarar una función con la siguiente sintaxis:

@(argumentos) sentencia_ejecutable

Por ejemplo, la función foo2 que en la sección anterior se ha declarado mediante un inline se escribiría como sigue:

>> foo2 = @(x,y) sin(x)*cos(y)

Con la llamada usual:

>> foo2(6,2)

 ans = 0.11628

Obviamente también podemos utilizarlo en la cabecera de las funciones:

>> quad(@(x) besselj(2.5,x),0,4.5)

 ans = 1.1178

Alguien puede pensar que el nombre de ``función anónima'' está mal porque si la asignamos a una variable pasará a tener el nombre de la variable. Esta idea, aunque razonable, es completamente errónea. Una y otra vez hemos enfatizado que una variable no es un argumento ni una función, es algo completamente distinto. La función es anónima porque no tiene ningún nombre fijo, seguirá siendo la misma función independientemente del nombre de la variable.

2.9.5.2 Funciones como argumentos de funciones.

Si gracias a los Function handles podemos asignar funciones a variables esto nos servirá para pasar funciones como argumentos. Una de las prácticas más beneficiosas en programación es la de la introspección. Es la capacidad de un algoritmo de no depender de los argumentos que utilicemos. La introspección más común es la aplicada a los números y las matrices; es lo que sucede cuando escribimos cualquier fórmula matemática o función en Matlab, pero aplicar la introspección a las funciones no es tan sencillo. Es muy fácil integrar una función cuando la conocemos, lo que no es integrar una función cualquiera. Debemos encontrar automáticamente los puntos singulares para concentrar los puntos en ellos, controlar automáticamente la precisión y pasar un argumento a la función. La introspección es intentar hacer un algoritmo lo más genérico posible y para ello necesitamos llamar funciones como argumentos como sucede con las rutinas de integración.

Si lo pensamos un poco nos daremos cuenta que no es nada fácil llamar a una función cuyo nombre no conocemos y sin saber en qué directorio se encuentra. La solución a este problema son los Function handles, por eso se recomienda encarecidamente su uso. Supongamos que queremos una rutina que calcule el valor de cualquier función en el punto x=1 siendo x su único argumento:

function [out]=fhtest(arg)

 %

 % function OUT=fhtest(@arg)

 %

 % Calcula el valor de la funcion @arg en 1 @arg debe ser un Function

 % Handle

 %

 out=arg(1);

Es muy importante crear una cabecera de ayuda cuando los argumentos de una función no son escalares comunes. Si no será imposible saber que el argumento de fhtest es un Function handle. Lo correcto sería crear también un mensaje de error en el caso que el argumento no fuera del tipo adecuado. Cuando una función no devuelve ningún resultado lo primero que haremos será utilizar la ayuda:

>> help fhtest

 fhtest is the user-defined function from the file

 /home/guillem/sync/CursoScripting/ejercicios/fhtest.m

  function OUT=fhtest(@arg)

  Calcula el valor de la funcion _arg_ en 1

   _arg_ debe ser un Function Handle

será un alivio comprobar que existe. Para utilizar la función podemos llamarla directamente con un Function handle:

>> fhtest(@sin)

 ans = 0.84147

o como siempre mediante una variable que lo contenga:

>> fhsin=@sin

 fhsin =

 sin

 >> fhtest(fhsin)

 ans = 0.84147

Esta estructura permite hacer

2.9.5.3 Acceso a las variables desde las funciones anónimas.

Otra pequeña diferencia entre Matlab y Octave es cómo las funciones anónimas entienden las variables dadas en la cabecera. En Octave, una función anónima es estrictamente una función a parte. Las variables internas no tienen ninguna relación con las variables del resto del entorno de ejecución. Por ejemplo, si queremos definir la siguiente función de dos variables:

func=e^-(x2+y2)

a partir de una función anónima debemos hacerlo como

>> func=@(x,y) exp(-(x. ^2+y. ^2)) 

 func =

 @(x, y) exp (-(x . ^ 2 + y . ^ 2))

Y llamamos la nueva función del modo usual:

>> func(sqrt(log(5)),sqrt(log(5)))

 ans = 0.040000

Todas estas variables son locales para la función. Todas las variables de la función deben estar presentes en el interface. Se nos puede ocurrir reducir el número de variables de una función definiendo algunas de ellas externamente:

>> a=2;

 >> func=@(x) exp(-(x. ^2+a. ^2)) 

 func =

 @(x) exp (-(x . ^ 2 + a . ^ 2))

De este modo estamos pidiendo que la función tome una variable que en realidad es externa como propia. En Octave esto da un error en el momento de la llamada:

>> func(2)

 error: `a' undefined near line 9 column 22

 error: evaluating binary operator `. ^' near line 9, column 23

 error: evaluating binary operator `+' near line 9, column 21

 error: evaluating prefix operator `-' near line 9, column 15

 error: evaluating argument list element number 1

 error: called from `?unknown?'

Pero si hacemos exactamente lo mismo en Matlab...

>> a=2;

 >> func=@(x) exp(-(x. ^2+a. ^2))

 func =

     @(x) exp(-(x. ^2+a. ^2))

 >> func(2)

 ans =

    3.3546e-04

 >>

El programa el intérprete no nos devuelve ningún error. Esto es debido a que mientras Octave prefiere la definición de variables globales

como apuesta por la seguridad, Matlab es más 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 parámetros a funciones dentro de funciones.

2.9.6 Funciones recursivas

Matlab soporta funciones que durante su ejecución se llaman a ellas mismas porque las llamadas a las funciones se hacen por valor y no por variable. Es muy difícil encontrar un ejemplo donde la manera más efectiva de resolver un problema sea acudir a la recursión. Es una técnica peligrosa además de ser muy agresiva con la memoria y debemos evitarla. Un ejemplo de función recursiva sería esta manera tan poco eficiente de calcular un factorial²⁰.

function out = fact ()

   if (n > 0)

     out = n* fact (n-1);

   else

     out = 1;

   endif

2.9.7 Encapsulado de funciones

El encapsulado de funciones o nested functions tiene dos utilidades principales:

Encapsular partes del cálculo en una función principal dentro de una función secundaria
Posibilitar que argumentos de salida sean funciones mediante function handles.

El primer uso es trivial. Podemos definir subfunciones siempre que no tengan ninguna repercusión en la cabecera. No es más que agrupar una tarea repetitiva para no tener que escribirla varias veces.

El segundo uso es una de las sutilezas proporcionadas por los function handles. Como podemos definir subfunciones siempre que no influyan en la cabecera nada nos impide asignarlas a un function handle que se pasará en la salida como argumento. Es exactamente el mismo concepto que el de utilizar funciones como argumentos de funciones pero a la inversa.

Por ejemplo, supongamos que estamos diseñando un filtro para una señal, un filtro pasa-bajos según una determinada frecuencia ω. Lo más sencillo sería hacer una función pasa-bajos que recibiera tres argumentos, el espectro en frecuencias, la longitud del espectro y la frecuencia de corte. Una solución mucho más elegante puede ser definir una función de construcción que devuelve un function handle con un filtro que utilizamos como otra función por separado. De este modo conseguiríamos reducir toda una colección de filtros a una única función generadora. Esta práctica se llama introspección y es junto con la abstracción las dos palabras claves de la programación moderna. La capacidad de Matlab de convertir funciones en argumentos simples es la mayor potencia del lenguaje y a la vez el concepto más complejo. Dominar bien la abstracción a nivel de métodos es dominar Matlab.

2.9.8 Sobrecarga de funciones.(Octave)

Este es un tema bastante avanzado sólo interesante para la programación de algoritmos muy complejos. Octave proporciona varias subrutinas para la gestión de la sobrecarga de funciones que no he sido capaz de encontrar en Matlab. La única herramienta equivalente que Matlab posee son las funciones inferiorto y superiorto que controlan la preferencia de búsqueda de funciones en el árbol de directorios. Dudo que nadie de los que lea este libro tenga necesidad de utilizar la sobrecarga jamás pero puede ser útil cuando se construyen prototipos de programas en Fortran 95. También 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 función en C que se comporta de un modo distinto si el argumento es un número real o un complejo. En Octave no tendríamos absolutamente ningún problema porque trata ambos tipos del mismo modo pero C es otra historia. Si nuestro código fuera sólo C tendríamos que programarnos un interfaz que seleccionara la función según la entrada; sobrecargar la función desde Octave es una solución mucho más elegante.

Los dos conceptos más importantes de la programación moderna son la abstracción y la introspección. La primera nos dice que debemos abstraernos de lo que estamos calculando, debemos centrarnos en el concepto y no ver un 2+3 sino un a+b. La introspección va un poco más lejos; la idea es no sólo abstraernos del contenido de cada variable sino abstraerse también del método utilizado. La abstracción la dan las fórmulas matemáticas y la introspección los interfaces.

Dentro de los métodos de introspección uno de los más utilizados es la sobrecarga de funciones. Es un tema bastante avanzado pero puede aportar grandes beneficios en códigos muy complejos. Sobrecargar una función es asignar más de un método a un nombre y aportarle un método adicional para que según el tipo de argumento se use un método o otro.

dispatch: Función que se encarga de gestionar la sobrecarga de métodos en un nombre. Para saber qué método llamar utiliza una pequeña referencia que asigna cada tipo a una función. También nos permite administrar los interfaces para añadir y eliminar funciones a la sobrecarga.

Por ejemplo, si utilizamos la función dispatch con la función exponencial vemos que en realidad es un método sobrecargado dependiente del tipo:

octave:1> dispatch('exp')

 Overloaded function exp

 exp(fixed complex,...)->fexp(fixed complex,...)

 exp(fixed complex matrix,...)->fexp(fixed complex matrix,...)

 exp(fixed matrix,...)->fexp(fixed matrix,...)

 exp(fixed scalar,...)->fexp(fixed scalar,...)

 exp(galois,...)->gexp(galois,...)

fexp y gexp son funciones llamadas builtin functions que son funciones de un nivel mucho más bajo que no serían útiles por sí solas.

builtin: Permite acceder a una función básica ignorando el dispatch que tenga sobre ellas.

Todo lo que es potente es complejo y estos conceptos son ambas cosas. Es importante que sólo usemos estas herramientas cuando las dominemos.

2.9.9 Herramientas útiles para la manipulación de funciones.

addpath: Añade uno o varios directorios a la lista de la base de datos de funciones.
edit: Llama al editor descrito en la variable EDIT para editar la función pasada como argumento
type: Muestra información rápida sobre la variable o el nombre de la función. Si el argumento es una función o una subrutina dentro de un archivo .m muestra el contenido del archivo.

2.10 Entrada/Salida

Supongamos que hemos hecho un script para calcular la solución a un problema de control y necesitamos que en el arranque el usuario nos introduzca los datos de entrada, o pongámonos en la situación de estar utilizando un código de mecánica de fluidos computacional que nos escupe enormes matrices de datos en crudo.

Cualquier interacción de nuestro programa con el exterior necesitará funciones de comunicación, ya sea un pequeño diálogo en la consola o la lectura de matrices de gran tamaño. El primer caso es bastante sencillo pero el segundo requiere conocimientos básicos de almacenamiento de datos que aprenderemos en breve.

2.10.1 E/S básica por pantalla.

disp: Es la función de salida más sencilla. Imprime en pantalla el argumento con el que se llama ya sea una cadena de texto o el contenido de una variable.
format: Controla el formato numérico de salida por defecto. Es importante que entendamos que sólo cambia la impresión en pantalla o en un archivo, no estamos cambiando la precisión numérica real. format se llama con un argumento que determina el tipo de salida:

short Formato con 5 cifras significativas en contenedores de 10 caracteres. Si el punto decimal se sale de las cifras significativas en algún caso todos los números pasaran a escribirse según la notación científica.

long Formato con 15 cifras significativas en contenedores de 20 caracteres. Si el punto decimal se sale de las cifras significativas en algún caso todos los números pasaran a escribirse según la notación científica

short e

long e El mismo formato que short y long pero usando siempre la notación científica y denotando el exponencial con una e.

short E

long E El mismo formato que short y long pero usando siempre la notación científica y denotando el exponencial con una E.

short g

long g Escoge entre el formato usual o la notación científica según lo requiera cada número. En el caso de la notación científica la exponencial se denota con una e.

short G

long G Escoge entre el formato usual o la notación científica según lo requiera cada número. En el caso de la notación científica la exponencial se denota con una E.

free

none Formato libre igual al formato libre de Fortran.
input: Es el equivalente a disp pero para la introducción de valores por teclado. Imprime por pantalla lo pedido en el argumento y espera a la escritura de un valor por teclado.
menu (tit,op1,...): Imprime en pantalla el menú con un título y las opciones del argumento, cada una de las opciones se presenta con un número y espera que se escoja uno de ellos por teclado. El valor retornado es el número de la opción escogida. Por ejemplo:

>> choice=menu('Esto es un menu','uno','dos','tres')

 Esto es un menu

   [ 1] uno

   [ 2] dos

   [ 3] tres

 pick a number, any number: 3

 choice = 3

2.10.2 E/S básica con archivos

Las palabras clave para guardar variables y sesiones son compatibles pero no idénticas. Esto es porque mientras Matlab tiene sus propios formatos de lectura y escritura Octave ha optado por formatos abiertos²¹.

Matlab puede leer y escribir archivos en formato binario; esto necesita una pequeña explicación. Hay dos maneras principales de almacenar números en memoria, en formato texto y en formato binario. En el primer caso se escriben en un fichero que un humano puede leer, normalmente codificado en ASCII de 8 bits. El programa se encarga de alinear las columnas y situar la coma para poder leerlo cuando sea oportuno. El precio de mantener cada número como algo leíble tiene un coste en memoria mucho mayor, esto nos forzará en algunos casos a utilizar la lectura y escritura en binario. Cuando almacenamos variables en formato binario ya no somos capaces de leer nada, incluso es probable que ni el ordenador sea capaz de hacerlo; esto es porque hay multitud de formatos binarios.

Matlab tiene tres formatos binarios a los que llama según la versión en la que se introdujeron, la versión 4, la 6 y la 7. No es necesario decir cuál es la más optimizada. La última versión de Octave es capaz de leer y escribir en los tres, tiene soporte para utilizar el formato binario abierto hdf5 además de su tener el suyo propio.

Tendremos siempre la posibilidad de guardar o cargar las variables que queramos, el almacenamiento es capaz de reconocer qué variables hemos guardado en él.

save opciones v1 v2 ...: Guarda las variables solicitadas en el archivo de nombre dado con el formato pedido con el argumento opciones. Lo mejor para conocer los formatos disponibles y sus posibles incompatibilidades es consultar la ayuda.
load opciones archivo v1 v2: Carga las variables del mismo modo en que las guarda save. La recomendación vuelve a ser que consultemos la ayuda.

Matlab cuenta además con la función diary. Sirve para grabar la sesión literalmente en un archivo cuyo nombre le hemos dado con anterioridad.

diary on,off,archivo: Guarda todos los comandos y resultados en un archivo.

Para hacerlo:

>> diary('nombrearchivo')

 >> diary on

 >> texto='graba todo lo que ponemos aquí';

 >> diary off

 >> texto2='ya ha parado la grabación';

En el archivo de nombre nombrearchivo encontraremos la línea:

>> texto='graba todo lo que ponemos aquí';

1: Todos los lenguajes interpretados procesan el código con una herramienta llamada parser. El parser lee cada línea y distingue las palabras clave, las variables y los argumentos para que el intérprete pueda hacer su trabajo sin problemas.
2: Más adelante aprenderemos cómo introducir esta información a cualquier función que escribamos
3: El comando end sólo es necesario en Octave cuando queremos acoplar funciones en los scripts o más de una función en un mismo archivo. En Matlab no es necesario porque cada función está asociada a un único archivo, el final del mismo hace de textttend.
4: Mejor, porque este tipo de estructuras no son nada aconsejables.
5: Puede contener más funciones pero sólo se puede llamar una. Esta es la función que tenga la cabecera en la primera linea cuyo nombre coincida con el nombre del archivo. Esta función puede llamar a otras funciones que se pueden encontrar en el mismo archivo, pero nunca podremos acceder desde fuera a las subfunciones puesto que Matlab no tiene información para saber donde se encuentran
6: Los físicos teóricos y los matemáticos encontraran mucho más útil Python; lenguaje que probablemente desconozcan. La extensión numérica estándar de Python, Numeric, soporta el tipo array que es consistente con la definición de tensor. Esto permite operar con tensores de varias dimensiones de una forma mucho más natural. Es muy recomendable echarle un vistazo, la combinación de Python y la colección de bibliotecas SciPy es una mejor opción en el caso de aplicaciones más complejas en las que Matlab escale mal.
7: En Octave existe la variable prefer_column_vectors. Activando esta variable con prefer_column_vectors=1 el vector por defecto será columna en vez de fila emulando el comportamiento de Fortran. Sirva esto para mostrar que Octave es totalmente configurable.
8: El principal peligro de la asignación dinámica de memoria es que nosotros no sabemos cuándo usamos demasiada. Es muy importante en códigos no usar más memoria en ningún 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 además el programa no nos avisa. Es bueno entonces tener algún monitor del sistema que nos diga cuánta memoria estamos usando en tiempo de ejecución y si estamos pisando fuera, es decir, escribimos en el espacio 'swap'.
9: Elementwise significa literalmente en inglés elemento a elemento.
10: Esto se hace calculando la pseudo inversa
11: Esta es una buena manera de perder un día 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 coeficientes sean complejos. Además, si los datos que originan los coeficientes son reales la matriz que forman es hermitiana que es como la extensión de la matriz simétrica para números complejos.

Probando un algoritmo de de resolución de la ecuación de Poisson en el plano espectral me puse a probar qué era lo que calculaba la transformada rápida de Fourier (se verá en los temas posteriores) bidimensional y si era equivalente con una combinación de transformadas unidimensionales. En teoría el algoritmo de transformada rápida de Fourier en un plano es transformar por columnas y luego hacerlo por filas. Como la función transformada rápida de Fourier en Matlab es fft la operación sería

>>fft(fft(a)')' Con esto se hace la operación por columnas, se traspone, se hace la operación por filas y se vuelve a trasponer para devolver la matriz a su estado inicial. Esta operación debería ser equivalente a:

>>fft2(a) Cual fue mi sorpresa cuando descubrí que los coeficientes que daba como resultado eran distintos. No es que el resultado tenga que ser equivalente, es que tiene que ser exactamente el mismo. Después de ocho horas de revisar una y otra vez los resultados me dí cuenta que el operador ' no es la traspuesta sino la traspuesta compleja conjugada y que en este caso no son equivalentes porque el resultado no es una matriz hermitiana hasta que se ha terminado la transformada. Entonces la operación sería:

>>fft(fft(a).').'

Esta tontería bien puede haceros perder un día, como a mi, o un par de ellos por culpa de resultados que parecen válidos. Mucho cuidado.

A título de opinión personal creo que este es un gran fallo en la sintaxis general de matlab. Hay más, incluso peores. Esto debería corregirse como en otros lenguajes donde los operadores tienen su forma abreviada (*) y una forma equivalente como función
12: Ampliar una matriz es exactamente equivalente que asignar más memoria a una variable. En Fortran sería dealocatear una variable, ampliarla y alocatearla otra vez.
13: El concepto de argumento en programación es mucho más extenso, pero creo que es conveniente usarlo de este modo.
14: El uso de las variables globales es una de las pocas discusiones de estilo abiertas. En otros lenguajes de programación, sobre todo los que permiten la programación orientada a objetos, no es necesario utilizar este tipo de variables. Es una discusión entre dos escuelas. Los que estamos más acostumbrados a una programación modular (Fortran) nos sentimos más cómodos controlando el hilo de ejecución con variables globales. En cambio, la escuela procedente de C++ y de Java prefieren crear métodos mucho más ricos en los que las funciones son en realidad métodos 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 ejecución en la programación modular sin entrar en conceptos que muchos usan pero sólo unos pocos entienden.
15: Si queremos que Octave nos saque cualquier argumento por pantalla podemos usar la función disp(). En este caso al final de nuestro script podríamos añadir:
disp('nuestra estructura es')
disp(foo)
16: Mucho cuidado los programadores acostumbrados a Fortran, sea cual sea la variante. Si nosotros usamos else if en vez de elseif, Matlab va a pensar que tenemos dos sentencias separadas, es decir, primero un else y luego un if dentro del else. Esto significa que tenemos una ejecución anómala en vez de un error. Es uno de estos casos en los que el programa nos ejecuta, nos da un resultado erróneo y nosotros no vemos de ninguna manera el error de programación
17: Se llama hilo precisamente a la línea de ejecución. Nos la podemos imaginar como la línea de código que siguen los procesos. Este concepto va ligado íntimamente a la gestión de procesos y tiende a complicarse en lenguajes como C o Fortran.
18: En Octave también podemos escribir la ayuda en formato texinfo para incluir caracteres matemáticos y fracciones pero es un tema muy avanzado.
19: En breve aprenderemos que la mejor manera de llamar este tipo de funciones es mediante un Function handle
20: Existen varias maneras de calcular un factorial. Las dos más eficientes probablemente sean prod(1:n) y gamma(n+1)
21: Uno de los apéndices trata de la importancia del uso de los formatos abiertos

< anterior | 1 .. 5 6 7 8 9 .. 27 | siguiente >

Autor y licencia de 'Introducción informal a Matlab y Octave'

Tutorial de Guillem Borrell i Nogueras . Extraido de: http://torroja.dmt.upm.es/%7Eguillem/matlab/ CopyLeft

Este contenido ha sido recopilado por el equipo de Wikilearning. Todo el contenido recopilado se ha obtenido respetando y comunicando en nuestro site la licencia de cada fuente.

Introducción informal a Matlab y Octave - MATLAB (IV)

7 - MATLAB (IV)

2.9.4 inline