INTRODUCCIÓN A GNU OCTAVE. Francisco Javier Aragón Artacho

Transcripción

1 INTRODUCCIÓN A GNU OCTAVE Francisco Javier Aragón Artacho Departamento de Estadística e Investigación Operativa Universidad de Alicante Diciembre 2

2 Contenido Primeros pasos con Octave 3. Operadores básicos Asignación de variables Vectores y matrices Matrices especiales Operaciones con matrices y vectores Operadores lógicos y de comparación Cadenas de texto Salida y entrada de datos Algunos comandos útiles Control de flujo de ejecución 6 2. Sentencia condicional if Bucle for Bucles while y do...until Sentencias break y continue Sentencia switch Sentencia try...catch Funciones 2 3. Funciones anónimas Funciones en línea El comando function Gráficos En el plano: 2D En el espacio: 3D Cargar y guardar datos en archivos 4 5. Datos numéricos y funciones Gráficos Imágenes Ejemplos prácticos Cálculo aproximado de pi Billetes y monedas Edición de una imagen Método del trapecio Índice de comandos 5 2

3 Primeros pasos con Octave En esta sección comenzaremos viendo los operadores básicos en Octave que nos permiten definir y hacer operaciones con escalares, vectores y matrices, así como con cadenas de texto. Veremos cómo utilizar los operadores lógicos (con los cuales podremos hacer comparaciones lógicas de tipo / o verdadero/falso) y finalizaremos con unos cuantos comandos que pueden sernos útiles.. Operadores básicos +,,,/ son los operadores suma, resta, multiplicación y división, respectivamente. Con ( ) agrupamos las operaciones. >>> (9 3)/2 23, son dos formas de escribir el operador de potencia. >>> >>> Para calcular la raíz cuadrada se usa sqrt. >>> sqrt(2).442 El valor absoluto se obtiene con la función abs. >>> abs( 3.5) 3.5 El número complejo i se puede escribir de varias formas: i,j,i,j. >>> sqrt( ) + i Las funciones trigonómetricas más usuales son sin, cos, tan, asin, acos, atan (seno, coseno, tangente, arcoseno, arcocoseno, arcotangente). >>> cos(pi) Las funciones exponencial y logaritmo neperiano se obtienen con los comandos exp,log. >>> exp(log(2)) 2 Para mostrar más o menos cifras decimales, usamos format long y format short. Para otras opciones, véase en la ayuda con help format. >>> format long >>> / >>> format short >>> /

4 .2 Asignación de variables Las variables se definen de forma muy sencilla con el operador =. >>> a = 2; >>> 3 a 6 Como podemos observar en este ejemplo, al escribir ; al final de una sentencia ocultamos el resultado. Esto es útil para no mostrar por pantalla resultados intermedios. Podemos definir varias variables a la vez si comparten un valor. >>> a = b = c = 5; Esto sería equivalente a >>> a = 5;b = 5;c = 5; Es posible restablecer el valor de constantes del sistema mediante el comando clear. >>> pi = 5;2 pi >>> clear pi;pi 3.46 Podemos aumentar el valor de una variable en una unidad mediante el operador ++. >>> a = 2;a + +;a 3 El comando a + + es equivalente a escribir a = a +. Es posible utilizar este operador dentro de cualquier expresión, en cuyo caso, dependiendo de si colocamos el operador ++ delante o detrás de la variable tendrá un comportamiento u otro. Al ponerlo a la derecha, primero se realiza la operación, y después se incrementa el valor de la variable: >>> a = 2;2 + (a + +) 4 >>> a 3 Si escribimos el operador a la izquierda de la variable, se incrementa el valor de la variable antes de realizar la operación: >>> a = 2;2 + (+ + a) 5 >>> a 3 El operador tiene un comportamiento similar al operador ++, restando una unidad a la variable. Con + = podemos sumarle al valor de una variable el de otra. Por ejemplo >>> a = 2; a+ = 4 a = 6 sería equivalente a escribir >>> a = 2; a = a + 4 De igual manera podemos restarle a una variable otra, multiplicarla, dividirla o elevarla, con los operadores =, =, / = y =. 4

5 .3 Vectores y matrices Los vectores fila se definen como números entre corchetes separados por comas o por espacios. Podemos realizar cualquier operación con vectores, como multiplicar por un escalar: >>> v = [,2,3];2 v v = Para definir un vector columna, utilizamos punto y coma para separar las componentes. >>> w = [4;5;6] w = Es fácil trasponer un vector (o matriz) mediante (es el carácter que en los teclados españoles aparece en la misma tecla que? ). >>> w Podemos crear vectores de cualquier longitud cuyos elementos distan en una unidad mediante los rangos. La sintaxis es PtoInicio : PtoFin. >>> : Para crear vectores con cualquier otro incremento, se usa PtoInicio : Incremento : PtoFin. >>> : 2 : Otra forma de crear vectores con valores equidistantes es mediante el comando linspace. Su sintaxis es linspace(inicio,fin,númerodepuntos). >>> linspace(, 2, 5) Se puede obtener la longitud de cualquier vector mediante el comando length. >>> v = [2,4,8, ]; length(v) 4 Las matrices se crean fácilmente separando los elementos de una fila por comas (o espacios) y las filas por punto y coma. >>> A = [,2,3;4,5,6;7,8,9] A = Realmente, el operador calcula la traspuesta conjugada, que en el caso de matrices o vectores reales coincide con la traspuesta. 5

6 Mediante A(i,j) obtenemos el elemento de la fila i y la columna j de la matriz A. >>> A(3,2) 8 Es posible cambiar de forma sencilla cualquier elemento de una matriz, o introducir un nuevo elemento: >>> A(,) = ; A A = >>> A(4,2) = A = El operador : sirve para seleccionar todos los elementos de una fila/columna en una matriz. >>> A = [,2,3;4,5,6;7,8,9]; A(2,:) También podemos elegir elementos de una matriz (por ejemplo, una submatriz) mediante un vector que especifique las filas y/o columnas. >>> A(2 : 3,[,3]) El comando size nos devuelve un vector con las dimensiones de la matriz. >>> A = [,2,3;4,5,6]; size(a) 2 3 Se puede obtener el último elemento de una fila o columna de una matriz o vector mediante end. >>> A = [,2,3;4,5,6]; A(end,) 4.3. Matrices especiales El comando rand nos permite crear números aleatorios 2 distribuidos uniformemente en el intervalo (,). Mediante rand(m,n) obtenemos una matriz de tamaño m n con elementos formados por este tipo de números. >>> rand(2, 4) En realidad se trata de números pseudoaleatorios. Para más información, introducir help rand en Octave. 6

7 La matriz identidad se obtiene con el comando eye. >>> eye(3) Para obtener una matriz de ceros 3, usar el comando zeros. >>> zeros(2) Con el comando ones obtenemos una matriz de unos. >>> ones(2, 3) Introduciendo diag(v) Octave nos devuelve una matriz con el vector v en la diagonal. >>> diag([, 2, 3]) 2 3 Escribiendo un segundo parámetro diag(v,k) obtenemos una matriz con el vector v posicionado en la k-ésima diagonal superior (o inferior, si k < ). >>> diag([,2,3], ) 2 3 Aplicado a una matriz, el comando diag devuelve su k-ésima diagonal. >>> A = [,2,3;4,5,6;7,8,9]; diag(a) Operaciones con matrices y vectores Es esencial tener siempre en cuenta que Octave ha sido diseñado para trabajar con matrices. Es por ello que es necesario tener cuidado a la hora de utilizar operaciones como la multiplicación, la división o la potencia, cuyo significado no es el mismo para escalares que para matrices. Esto suele originar la mayoría de los fallos cuando utilizamos Octave. 3 Es más eficiente crear una matriz de ceros y luego cambiar los valores de sus elementos que crear una matriz vacía e ir rellenando sus valores (cuando se agranda una matriz, internamente se le asigna una nueva posición en la memoria). 7

8 Usaremos el producto para multiplicar cualquier matriz o vector por un escalar o por otra matriz. >>> A = [,,;,,;,,]; 5 A >>> b = [;2;3]; A b >>> B = [,,2;,5,4;3,2,]; A B Octave es capaz de elevar rápidamente una matriz a cualquier potencia, esto es, multiplicar la matriz por sí misma un número determinado de veces (por consiguiente la matriz deberá ser cuadrada). Para ello se usa el operador. Así A 3 = A A A. >>> A = [,2,3;4,5,6;7,8,9]; A Es posible realizar operaciones elemento a elemento con vectores y matrices. Para ello sólo hay que introducir un. antes del operador correspondiente. Así tendríamos las operaciones.,. o./. Con la suma y la resta no es necesario utilizarlo ya que ambas operaciones actúan siempre elemento a elemento. >>> A = [,2,3;4,5,6;7,8,9]; A Comparar el resultado con el ejemplo previo. Para calcular la inversa de una matriz usaremos A o inv(a). >>> A = [,,;,,;,,]; A El determinante de una matriz se obtiene con det. >>> A = [,,;,,;,,]; det(a) Para resolver un sistema Ax = b, usaremos A\b. Octave lo resuelve con un algoritmo mucho más preciso y rápido que si calculamos x = inv(a) b. Si la matriz A fuese singular, Octave devolverá 8

9 un mensaje de advertencia y calculará una solución de norma mínima. >>> A = [,2,;3,5,2;3,2,]; b = [;2;3]; A\b.. 2. La función tril devuelve una matriz triangular inferior de una matriz dada. Introduciendo un segundo argumento tril(a, k) especificamos cuántas diagonales por encima o por debajo de la diagonal principal deben ser cero. >>> A = [,2,3,4;5,6,7,8;9,,,2;3,4,5,6]; tril(a) >>> tril(a, ) >>> tril(a, ) El comando triu se comporta como tril, pero devuelve una matriz triangular superior. Con poly obtenemos los coeficientes del polinomio característico de cualquier matriz. >>> poly([,,;,,;,,2]) La función eig devuelve los autovalores de una matriz. >>> eig([,,;,,;,,2]) Se puede conseguir que la función eig nos devuelva también los vectores propios asociados a estos autovalores pidiéndole 2 argumentos de salida, por ejemplo [V, L] = eig(a), en cuyo caso A V = V L. >>> [V,LAMBDA] = eig([,,;,,;,,2]) V =

10 LAMBDA = Diagonal Matrix El comando norm(v,k) permite calcular la norma de cualquier vector 4 v = (v,...,v n ). Por defecto, si no se especifica k o si k = 2, calcula la norma euclídea o L 2, v 2 = v v2 n. Otras opciones del parámetro k son para la norma L, v = v v n, e Inf para la norma L, v = máx{ v,..., v n }. >>> v = [,2,3,4]; norm(v) >>> norm(v, ).4 Operadores lógicos y de comparación En Octave el valor verdadero viene representado por y falso por. El operador de comparación de igualdad es ==. No debe confundirse con el operador de asignación =. Si comparamos dos matrices obtendremos una matriz de unos y ceros, donde cada elemento será el resultado verdadero/falso de comparar ambas matrices. >>> 2 == 3 >>> a = 2; a == 2 >>> A = [,2,3;4,,]; A == De manera similar se comportan los operadores de comparación mayor estricto >, mayor o igual >=, menor estricto <, menor o igual <= y distinto! =. Este último también puede escribirse como 5 =. >>> b = [,2,3]; b > >>> b! = 2 El comando all nos dice si todos los elementos de un vector son distintos de cero. En caso de emplearlo con una matriz, nos devuelve este resultado por columnas. >>> b = [,2,3]; all(b > ) 4 También calcula la norma de cualquier matriz, ver la ayuda para más información. 5 El símbolo se obtiene en un teclado español pulsando Alt Gr + 4 y pulsando después espacio.

11 >>> A = [,2,3;4,,]; all(a <= 2) El comando any nos dice si algún elemento es distinto de cero. Se utiliza de manera similar a all. El operador lógico de conjunción y se escribe en Octave con el símbolo &. El valor de x&y es sólo cuando x y y. Su tabla de verdad es: x y x&y Puede emplearse con vectores o matrices, en cuyo caso ofrecerá una comparación elemento a elemento. >>> b = [,7,2,, 3,4,5]; (b < 3)&(b! = 3) El operador lógico de disyunción o se escribe 6 con el símbolo. El valor de x y es si x o si y. Su tabla de verdad es: x y x y Al igual que el operador & puede emplearse con vectores y matrices. >>> b = [,2,3,4,5,6]; (b < 3) (b > 4) El operador lógico de negación no se puede escribir de dos maneras: con el símbolo! o con el símbolo sim. El valor de!x es si x =. Su tabla de verdad es: x!x También puede emplearse con vectores y matrices. >>> b = [,2,3,4,5,6];!((b < 3) (b > 4)).5 Cadenas de texto Para escribir cadenas de texto en Octave tenemos dos opciones: escribir el texto entre comillas simples o entre comillas dobles. >>> a = mi ; b = casa ; Es importante entender cómo Octave trata internamente las cadenas de texto. Podemos intuirlo si 6 En un teclado español, pulsando Alt Gr +.

12 sumamos a cualquier texto el número cero: >>> b En este ejemplo aparecen 4 números (tantos como letras tiene la palabra casa ). Observamos que el segundo número es igual al último. Esto ocurre porque Octave trata las cadenas de texto como si fueran matrices. Los números representan el código ASCII 7 extendido de cada letra. Podemos crear pues una matriz con las dos cadenas de texto definidas anteriormente: >>> [a;b] mi casa Se pueden unir también horizontalmente: >>> [a,,b] mi casa Es sencillo trabajar con cadenas teniendo en cuenta qué representan para Octave. Así, si texto es una variable que contiene cualquier cadena de texto, escribiendo texto() obtendremos la primera letra de esta palabra, con texto(end) la última, etc. >>> b(2 : 3) as Para convertir cualquier vector con números entre y 255 en una cadena de texto usaremos el comando char. >>> char([99, 97, 5, 97]) casa Observar que la cadena que representa a cualquier número es distinta al número en sí. Por ejemplo no es lo mismo que el número : >>> a = ; a + 49 Esto ocurre porque el código ASCII de es el 49. Sin embargo es posible convertir cualquier número escrito como cadena de texto en un número con la función str2num: >>> a = ; str2num(a) + También podemos realizar el proceso contrario con el comando num2str; esto es, convertir un número en una cadena de texto. Un comando útil cuando trabajamos con cadenas de texto es index, que busca una cadena de texto dentro de otra y nos devuelve la posición de la primera ocurrencia. Si no la encuentra, devuelve. >>> index( El coche de Carlos, coche ) 4 Debemos siempre tener en cuenta que Octave distingue entre mayúsculas y minúsculas (ya que su código ASCII es distinto): >>> index( El coche de Carlos, c ) 4 >>> index( El coche de Carlos, C ) 3 7 ASCII es el acrónimo inglés de American Standard Code for Information Interchange. Se trata de una tabla de 256 caracteres que pueden ser representados mediante 8 bits. 2

13 .6 Salida y entrada de datos Los comandos de salida básicos son disp y printf. El comando disp nos muestra por pantalla el valor de una variable. >>> disp( El valor de pi es : ); disp(pi) El valor de pi es : 3.46 Con printf tenemos un control mayor del resultado que aparece en pantalla. Podemos especificar operadores de conversión de las variables. Los más usados son %d, %f y %s, que corresponden a número entero, número en punto flotante 8 y cadena de texto, respectivamente. Veamos en unos ejemplos cómo funciona: >>> a = 4; printf( El valor de a es %d,a) El valor de a es 4 >>> Para conseguir introducir un salto de línea, escribiremos \n. >>> a = 4; printf( El valor de a es %d\n,a) El valor de a es 4 Aquí tenemos más ejemplos con %f y %s: >>> printf( El valor de pi es%f\n., pi) El valor de pi es >>> nombre = Pedro ; printf( Hola %s!\n,nombre) Hola Pedro! Es posible usar varias variables en una cadena de texto. Sólo tendremos que introducir en el orden correspondiente las variables separadas por comas. >>> a = 2; b = 5; >>> printf( De las %d personas, sólo %d iban disfrazadas\n., a, b) De las 2 personas, sólo 5 iban disfrazadas. Octave nos permite controlar la anchura mínima de una variable en punto flotante, así como el número de decimales que aparecerán por pantalla. La sintaxis es %ancho.decimalesf, donde ancho es un entero que representa la anchura mínima de la variable (incluyendo decimales y el signo. ) y decimales es el número de decimales que mostrará. Si el tamaño de la variable fuese menor que la anchura especificada, se introducirán espacios. Por ejemplo: >>> printf( El valor de pi es%.f\n., pi) El valor de pi es >>> printf( %.f\n, 3.5); printf( %2.f\n, 3.5); 4 4 En este ejemplo, como le hemos pedido que no muestre decimales, redondea el número 3.5 a 4. Existen más opciones, consultar el manual. Como en la mayoría de lenguajes de programación, disponemos de la sentencia de entrada input que solicita al usuario un valor. >>> nombre = input( Cómo te llamas? ) Cómo te llamas? Octave esperará que el usuario introduzca un valor. Cuando pulse Intro lo que haya introducido pasará a ser el valor de la variable nombre. 8 Números con decimales. 3

14 .7 Algunos comandos útiles La instrucción who muestra por pantalla los nombres de las variables definidas. La variante whos muestra información más detallada, incluyendo el tamaño, el número de bytes de memoria empleados en almacenar cada variable y el tipo de datos. Tenemos cuatro opciones para redondear un número con decimales a entero: floor, ceil, fix y round. El comando floor(x) devuelve el mayor entero que sea menor o igual que x. Con ceil(x) obtenemos el menor entero mayor o igual que x. La instrucción fix(x) nos da la parte entera de x. Por último, round(x) redondea x hacia el entero más próximo. >>> floor([.3,.6,.3,.6]) 2 2 >>> ceil([.3,.6,.3,.6]) 2 2 >>> fix([.3,.6,.3,.6]) >>> round([.3,.6,.3,.6]) 2 2 La función rem(x,y) nos devuelve el resto de la división x./y, es decir, x y. fix(x./y). >>> rem(, 4) 2 Para sumar elementos de un vector usaremos la función sum. Si la utilizamos con una matriz A, nos devolverá la suma de los elementos de cada columna. Para obtener la suma por filas, escribiremos sum(a,2). >>> A = [,2,3;4,5,6]; sum(a) >>> sum(a, 2) 6 5 El producto de elementos de un vector o matriz se obtiene con la función prod. Su uso es similar a sum. El comando clock nos proporciona un vector con la fecha y la hora actual del sistema en el siguiente orden: [año, mes, día, horas, minutos, segundos]. Con time obtenemos los segundos transcurridos desde el de enero de 97. En un principio podría parecer un dato bastante inútil, pero comparando dos valores de time podremos calcular el tiempo transcurrido en realizar un proceso. En el siguiente ejemplo lo utilizamos para calcular cuánto se tarda en obtener millones de números aleatorios y calcular su producto: >>> t = time; prod(rand(e8, )); tiempo = time t; >>> printf( Tiempo transcurrido : %.2f segundos\n, time t) Tiempo transcurrido : 4.22 segundos 4

15 Los comandos tic y toc tienen un fin similar. El primero no produce ningún resultado aparente, pero resulta como poner a cero un cronómetro. Al introducir posteriormente toc nos dirá los segundos transcurridos desde que se ejecutó tic. >>> tic; prod(rand(e8, )); toc Elapsed time is 4.49 seconds. La función factor(n) nos devuelve la descomposición en factores primos de n. >>> factor(5)

16 2 Control de flujo de ejecución Vamos a estudiar las distintas sentencias que nos ofrece Octave para controlar el flujo de ejecución de un algoritmo. Estas sentencias nos permitirán dirigir el comportamiento de nuestro programa ante distintas situaciones, repetir procesos un número determinado de veces o hasta que se cumpla cierta condición, etc. Para ello disponemos de la sentencia condicional if, el bucle finito for, los bucles condicionados while y do until, la sentencia switch y la sentencia try...catch. Además, con break y continue podremos saltar iteraciones dentro de un bucle. 2. Sentencia condicional if Se trata de una de las herramientas más básicas, que está disponible en todo lenguaje de programación sensato. Nos permite evaluar si se cumple una condición lógica o no. Su forma más sencilla sería: if condición acción endif Cuando ejecutemos este código, si condición es cierta, se ejecutará acción. Veamos un ejemplo: v=5; if v==3 printf("v vale 3\n") endif El código anterior no devolvería nada, ya que v tiene el valor 5. Sólo ejecuta el comando printf cuando la condición lógica v == 3 sea cierta. Podríamos estar interesados en que sucediera algo en caso contrario, esto es, cuando la condición lógica sea falsa. Es posible hacerlo usando else. La sintaxis es la siguiente: if condición acción else acción2 endif En el ejemplo anterior, podríamos escribir: v=5; if v==3 printf("v vale 3\n") else printf("v es distinto de 3\n") endif Ahora al ejecutarlo nos devolverá v es distinto de 3 Existe una tercera opción, con elseif, mediante la cual podemos hacer que si la primera condición no es cierta, evalúe otras condiciones: if condición acción elseif condición2 acción2 elseif condición3 acción3... else acción endif 6

17 Podríamos utilizar tantos elseif como fuesen necesarios. En el ejemplito anterior: v=5; if v==3 printf("v vale 3\n") elseif v==5 printf("v vale 5\n") else printf("v es distinto de 3 y de 5\n") endif 2.2 Bucle for Otra de las herramientas claves en programación son los bucles for, que nos permiten repetir una acción un número finito de veces. Su sintaxis es: for variable=expresión acción endfor Su funcionamiento es el siguiente: variable va tomando de uno en uno los valores en expresión y para cada uno de estos valores se ejecuta acción. Normalmente, expresión será un rango como :, un vector como [,3,5, 2,] o incluso una matriz. En el siguiente ejemplo sumamos 9 los números de a : suma=; for k=: suma=suma+k; endfor disp(suma) En el siguiente ejemplo sumamos a cada elemento de la matriz A definida con números aleatorios, y mostramos el resultado por pantalla: >>> A = rand(3) A = for j=a disp(j+); endfor >>> Podemos anidar varios bucles for, por ejemplo para recorrer los elementos de una matriz. El siguiente algoritmo define una matriz n m cuyo elemento A(j,k) vale j k: 9 Ésta no sería una forma eficiente de sumar los números del al n. Una opción preferible sería escribir sum( : n), aunque la más eficiente sería usar la fórmula n(n+) 2. 7

18 n=2;m=3; for j=:n for k=:m A(j,k)=j*k; endfor endfor A >>> A = Bucles while y do...until Con la sentencia while podemos crear otro tipo de bucles que se ejecutarán hasta que se verifique cierta condición. Aunque son muy útiles, hay que llevar cuidado a la hora de usarlos, ya que podemos crear un bucle infinito si la condición que imponemos nunca se verifica (lo cual colgaría Octave). La sintaxis es la siguiente: while condición acción endwhile El código anterior se ejecuta si condición tiene el valor verdadero, en cuyo caso, realizará acción y volverá a verificar si se verifica condición. Una vez iniciado un bucle while, se ejecutará la acción repetidamente hasta que deje de verificarse la condición. El siguiente bucle escribirá los números del al : a=; while a<= disp(a); a=a+; endwhile El siguiente bucle sería infinito, ya que la condición siempre es cierta (de hecho bloquea Octave): a=; while (a>-2) (a<=) disp(a); a=a+; endwhile Los bucles do...until son similares a los bucles while. La diferencia radica en el hecho de que la condición es evaluada al final, en vez de al inicio del bucle, y el bucle no finaliza hasta que no se verifique la condición (al contrario que en un bucle while). Su sintaxis es: do acción until condición En un bucle do...until la acción siempre se ejecutará al menos una vez. Veamos un ejemplo: do x=rand until x>.6 El código anterior calcula un número aleatorio entre y y lo muestra por pantalla, hasta que el número calculado sea mayor que.6. 8

19 >>> x = x =.76 x =.3339 x = Sentencias break y continue Los comandos break y continue son bastante útiles. Con break escapamos de cualquier bucle for, while o do...until aunque el bucle no haya terminado. Por ejemplo, el siguiente código nos devuelve el valor k = 5, a pesar de que el bucle for llegaría normalmente hasta : for k=: if k==5 break endif endfor disp(k) Con la sentencia continue saltamos al final del código de un bucle for, while o do...until, sin ejecutar el resto del algoritmo y continúa con el siguiente valor. Veamos un ejemplo: for k=: if k==5 continue endif disp(k) endfor El código anterior mostraría los números del al excepto el Sentencia switch La sentencia switch es muy parecida a if. La sintaxis es: switch x case valor acción case valor2 acción2... otherwise acción endswitch El código anterior sería equivalente a escribir if x==valor acción elseif x==valor2 acción2... else acción endswitch En ciertos casos puede ser más práctico utilizar switch que un bucle if: el código puede ser más claro de leer y más fácil de modificar. También tiene la ventaja de que switch acepta comparaciones con cadenas de texto del tipo 9

20 switch respuesta case "sí" acción case "no" acción2 otherwise printf("escriba sí o no") endswitch Para hacer esto con if necesitaríamos usar el comando all, ya que para Octave una cadena de texto es un vector, y por tanto compararía elemento a elemento. El código quedaría: if all(respuesta=="sí") acción elseif all(respuesta=="no") acción2 else printf("escriba sí o no") endif Si quisiéramos cambiar el nombre de la variable respuesta, con un código switch sólo tendríamos que cambiarlo en un lugar (al inicio), mientras que con if deberíamos cambiarlo en cada comparación. 2.6 Sentencia try... catch Para controlar posibles errores un comando útil es try. Con él le pedimos a Octave que intente realizar una acción. Si al hacerlo obtiene cualquier error, en vez de pararse le decimos que realice otra acción. Veamos su sintaxis: try acción catch acción2 end_try_catch En el código anterior Octave intentará ejecutar acción. Si se produjese un error, continuaría normalmente ejecutando acción2, en vez de acción. El siguiente código intenta sumar al valor de x una unidad. Si por ejemplo x no estuviera definida, en vez de sumarle una unidad, le da el valor cero. try x=x+; catch x=; end_try_catch En catch podríamos poner cualquier mensaje de advertencia al usuario. 2

21 3 Funciones En esta sección veremos cómo definir cualquier tipo de función en Octave. Existen tres tipos de funciones: las funciones anónimas, funciones en línea (del inglés inline) y las funciones definidas mediante el comando function. Los dos primeros tipos son usados para funciones matemáticas sencillas, mientras que el tercer tipo se utiliza para crear algoritmos más complicados. En Octave podemos ver el código de cualquier función del sistema, a diferencia de Matlab R, que al ser un software comercial, no nos permite saber qué algoritmo hay detrás de cada comando. Ésta es una de las ventajas de Octave sobre Matlab R, ya que en el segundo estamos utilizando una caja negra para obtener los resultados, sin poder saber cómo funcionan los algoritmos de las funciones que empleamos. 3. Funciones anónimas Se trata de una de las formas más sencillas de escribir una función en Octave. Para ello se utiliza el ), especificando entre los paréntesis la/s variable/s que emplea la función y escribiendo a continuación la función en sí. Por ejemplo, si quisiéramos definir la función f(x) = x 2 sólo tendríamos que introducir >>> f x 2; Ahora podríamos calcular el valor de la función en cualquier punto: >>> f(2) 4 Es conveniente definir las funciones de modo que sean aplicables a vectores y matrices. La función del ejemplo anterior no podría utilizarse con un vector, ya que al intentar multiplicar el vector daría error al no coincidir las dimensiones. Es por ello que es conveniente utilizar los operadores elemento a elemento, poniendo un. delante de operaciones como, / y, pues éstas no actúan elemento a elemento cuando son aplicadas a matrices: >>> f x. 2; f([,2,3]) 4 9 Es igual de sencillo definir funciones de más variables: >>> g x. y ( + x)./( + z. 2); g(,2,3).8; >>> g([,],[2,3],[4, 2]) Funciones en línea Resulta muy fácil definir funciones en línea utilizando el comando inline. Simplemente tendremos que escribir la función que deseemos definir entre comillas (simples o dobles). En realidad el comando inline crea una función a partir de una cadena de texto. Veamos cómo se definiría la función f(x) = x 2 : >>> f = inline( x. 2 ); f = f(x) = x. 2 El código de algunos comandos, como por ejemplo sort, no está disponible. Esto ocurre porque son funciones compiladas con el fin de acelerar su ejecución. Podemos encontrar todas las funciones en la carpeta m que es una de las subcarpetas que se encuentra dentro de la carpeta donde hayamos instalado Octave. 2

22 También podemos definir funciones de más variables. A la hora de llamar a la función, Octave usará el orden alfabético para saber qué valor corresponde a cada variable. Por ejemplo: >>> g = inline( 2. x + a. 2 + b ) g = f(a,b,x) = 2. x + a. 2 + b >>> g(,2,3) 9 Un comando útil con las funciones en línea es vectorize, que convierte cualquier operador que hayamos usado en un operador elemento a elemento, esto es, transforma cualquier aparición de en., / en./, etc. >>> f = inline( x 2 + /x ); f([,2]) >>> error : for A b, A must be square error : called from : error : at line, column >>> g = vectorize(f) g = f(x) = x. 2 +./x >>> g([,2]) El comando function A la hora de definir funciones más complejas disponemos de la sentencia function. En su forma más sencilla tiene la siguiente sintaxis: function nombre comandos endfunction donde nombre es el nombre con el que llamaremos a la función. Es posible definir funciones desde la consola en Octave. Sin embargo es más práctico hacerlo desde el editor, creando un fichero con extensión.m y cuyo nombre sea el mismo nombre que escribimos tras function. Debemos guardar este fichero en un lugar en el que Octave sea capaz de encontrarlo. Tenemos dos opciones: guardarlo en una de las carpetas en las que Octave busca funciones 2, o bien acceder al directorio correspondiente. Desde QtOctave podemos entrar fácilmente a cualquier carpeta del sistema mediante el navegador (la ventana que aparece por defecto en la esquina inferior izquierda), seleccionando el directorio donde hayamos guardado nuestro archivo. También es posible hacerlo directamente con el comando cd seguido de la ruta entre comillas: >>> cd F : /Documentos Veamos una función sencilla: function hola printf("hola Fran\n") endfunction Esta función debemos guardarla con el nombre hola.m, ya que de otro modo Octave no será capaz de detectarla. Ahora podemos llamar a nuestra función como si se tratara de cualquier otro comando del sistema: Evitar usar tildes, espacios, la letra ñ y caracteres extraños en el nombre de la función. 2 Escribiendo path Octave mostrará las carpetas en las que busca ficheros de funciones. Es posible añadir más carpetas a las existentes, para más información introducir help path. 22

23 >>> hola Hola Fran Normalmente querremos que nuestra función acepte argumentos de entrada. En este caso escribiremos: function nombre(ent,ent2,...,entn) comandos endfunction donde ent,...,entn son los valores de entrada con los que el usuario llamará a la función. A continuación mostramos una modificación del ejemplo anterior. function hola(nombre) printf("hola %s\n",nombre) endfunction Ahora nuestra función hola acepta un valor de entrada: >>> hola( Pedro ) Hola Pedro Es muy sencillo definir valores por defecto de los argumentos de entrada. Sólo tendremos que poner arg=valor defecto cuando definamos la función. En la siguiente modificación de hola, si el usuario no introduce ningún argumento, el valor de la variable nombre será Fran. function hola(nombre="fran") printf("hola %s\n",nombre) endfunction >>> hola Hola Fran >>> hola( Pedro ) Hola Pedro Para especificar que nuestra función utilice el valor por defecto de un parámetro debemos escribir : como valor de entrada de la función: >>> hola(:) Hola Fran En la muchas ocasiones estaremos interesados en que nuestra función devuelva uno o varios valores de salida. Para esto escribiremos: function [sal,sal2,...,salm]=nombre(ent,ent2,...,entn) comandos endfunction donde sal,sal2,...,salm son las variables de salida. No es necesario escribir los corchetes [ ] en caso de que sólo necesitemos una variable de salida: function valor=f(x) valor=x.ˆ2+./x; endfunction Un ejemplo de función con dos valores de salida es el comando eig que hemos visto en la primera sección. Veamos otro ejemplo: imaginemos que queremos escribir una función que dado un vector v nos diga cuál es el elemento máximo y en qué posición se encuentra 3. En este caso, nuestra función, que llamaremos maximo tendrá dos valores de salida: M que será el valor máximo e id que guardará su posición. 3 Esta función viene ya predefinida (y compilada) en Octave, la función max, por lo que en realidad no sería necesario crear una nueva. 23

24 function [M,id]=maximo(v) M=v(); id=; n=length(v); for k=:length(v) if M<v(k) M=v(k); id=k; endif endfor endfunction Escribimos la función anterior en la consola, o bien en el editor y la guardamos con el nombre maximo.m. >>> v = [,4,2,7, 3,8,5,]; [valor,posicion] = maximo(v) valor = 8 posicion = 6 Dentro de cualquier función que definamos, contamos con dos variables especiales que pueden sernos bastante útiles: nargin y nargout. La primera toma el valor del número de argumentos que haya introducido el usuario al llamar a la función; la segunda variable nargout nos devuelve el número de variables que el usuario espera recibir de nuestra función. Veamos un ejemplo: function prueba printf( %d valores de entrada y %d valores de salida\n,nargin,nargout) endfunction A continuación llamamos a la función con un diferente número de variables de entrada y salida: >>> prueba valores de entrada y valores de salida >>> prueba(, 2) 2 valores de entrada y valores de salida >>> [a,b,c] = prueba(,2) 2 valores de entrada y 3 valores de salida >>> error : value on right hand side of assignment is undefined En el último caso obtenemos un error debido a que estamos pidiéndole a la función 3 valores de salida, cuando en realidad la función no devuelve ningún valor de salida. Las variables nargin y nargout son útiles a la hora de escribir un algoritmo pues nos permiten controlar cuántos datos ha introducido el usuario y cuántos espera recibir de la función. Finalizamos esta sección con el comando return que finaliza una función aunque no haya terminado de ejecutar el código. function k=prueba(n) for k=:n if k== return endif endfor endfunction >>> prueba(5) 5 >>> prueba(5) En la función anterior vemos que la ejecución se detiene si k alcanza el valor y devuelve el valor que k tenga en ese momento, sin finalizar de ejecutar el resto del algoritmo. 24

25 4 Gráficos 4. En el plano: 2D El comando plot(x,y), donde x e y son vectores, dibuja una línea en el plano que une consecutivamente los puntos ( x(),y() ),..., ( x(end),y(end) ). Este comando será muy útil a la hora de dibujar gráficas de funciones: sólo tendremos que elegir un número suficiente de puntos para que el gráfico sea una buena aproximación de la gráfica real de la función. >>> x = :. : ; >>> plot(x, sin(x)) Podemos dibujar varias funciones a la vez: >>> plot(x, sin(x), x, cos(x)) Existen diversas opciones que pueden ser especificadas mediante el comando plot. Por ejemplo, mediante la opción linewidth controlamos el grosor de la línea. Con la opción color podemos cambiar el color, introduciendo a continuación un vector con 3 componentes RGB (rojo, 25

26 verde y azul) con valores entre y. También existen algunos colores predefinidos como red, green, blue o yellow. Para más información, consultar el manual. >>> plot(x,x. cos(x), color,[,.8,.6], linewidth,6) Por defecto el comando plot dibuja puntos y los une con una recta (puede especificarse con la opción ). Es posible modificar este comportamiento con las opciones +,, o, x y. Usando una de estas opciones, plot dibujará uno de estos símbolos: >>> x = linspace( pi,pi,3); plot(x,sin(x), o ) Se puede cambiar el tamaño de los marcadores anteriores con la opción markersize, especificando después un número. Sería interesante poder dibujar puntos rellenos, pero por algún problema de Octave 4 la opción. sólo produce puntos minúsculos que no se ven afectados por el modificador markersize. Podemos sin embargo solucionar este problema fácilmente dibujando círculos con un tamaño de pequeño y con una tamaño de línea gorda, con lo que conseguiremos la apariencia de puntos rellenos: >>> plot(x,sin(x), o, markersize,2, linewidth,5) 4 En Matlab R sí que funciona correctamente. 26

27 El comando area(x,y), donde x e y son vectores, se comporta como plot con la diferencia de que area pinta la gráfica por debajo/arriba hasta el origen. Podemos cambiar el color con la opción facecolor. >>> x = :. : ; >>> area(x,sin(x), facecolor,[,.5,]) Es posible cambiar la posición hasta la cuál rellena el gráfico mediante un parámetro adicional: >>> area(x,sin(x),.5, facecolor,[,.5,])

28 Con axis off ocultamos los ejes de coordenadas. Para volver a mostrarlos, usar axis on. Mediante axis square conseguimos que ambos ejes midan lo mismo (y por tanto obtenemos un dibujo cuadrado). Usando axis equal logramos que las longitudes en ambos ejes sean iguales. También es posible especificar los ejes mediante axis([x min,x max,y min,y max ]). Las figuras son las ventanas donde nos aparecen los gráficos. Es posible crear nuevas figura mediante el comando figure. Con figure(n) seleccionamos la figura activa (en la que se dibuja), donde n N es un número asignado a cada figura. Tras introducir hold on, Octave no creará una figura nueva cada vez que le pidamos que dibuje un gráfico. Esto es útil a la hora de dibujar varios gráficos en una misma figura. Se restablece el comportamiento con hold off. Introduciendo clf borramos la figura activa. También podemos eliminarla escribiendo close. Para crear gráficos en coordenadas polares, usaremos el comando polar(theta,rho). >>> polar( :. : pi, :. : pi) Es muy fácil crear un gráfico de sectores. Solo hay que introducir un vector con los porcentajes usando el comando pie. >>> pie([5, 25, 4,, 2]); axis off; 5% 2% 25% % 4% 28

29 Para otros tipos de gráficos estadísticos consultar el manual. El comando grid on permite mostrar una rejilla de coordenadas. Para desactivarla escribiremos grid off. >>> x = linspace(,, 2); plot(x, x. sin(./x. 2)); grid on; Al introducir box off eliminamos la caja que rodea por defecto a las gráficas. Para mostrarla usaremos box on. Con fplot podemos dibujar varias funciones de forma sencilla, sin necesidad de definir previamente un vector x con valores: >>> fplot( sqrt(x) cos(/x),[,.]); box off;.4 sqrt(x).*cos(./x)

30 ezplot nos permite también dibujar gráficos de funciones sin tener que definir antes x. Si no se especifican los límites dibuja por defecto entre 2π y 2π. Es posible especificar también el número de puntos que queremos dibujar: >>> ezplot( x 2 sin(/x),[.5,.5], e4 } {{ } límites }{{} n o puntos ) x 2 sin(/x) x Podemos dibujar funciones definidas de forma implícita, es decir, los puntos (x, y) tales que F(x,y) = para una función F. Para ello sólo debemos usar ezplot con una función dos variables (x,y) y Octave dibujará la función F(x,y) =. >> ezplot(@(x,y) x. 2 + y. 2,); axis equal; x 2 + y 2 - =.5 y x Para ponerle un título a nuestro gráfico usaremos el comando title. Para mostrar un nombre en los ejes disponemos de los comandos 5 xlabel e ylabel. Si queremos cambiar o introducir una leyenda al gráfico, usaremos legend. 5 En dibujos en 3D disponemos también del comando zlabel. 3

31 >>> x = 2 :. : 2; plot(x,exp( x. 4),x,x. exp( x. 2), color, red ); >>> title( Mi gráfico ); xlabel( Eje x ); ylabel( Eje y ); >>> legend( exp( x 4), x exp( x 2) ); axis([ 2,2,.5,.2]).2 Mi gráfico exp(-x 4 ) x*exp(-x 2 ).8.6 Eje y Eje x Para introducir cualquier cadena de texto en un gráfico usaremos text(pos x,pos y, texto ), donde pos x,pos y son las coordenadas del texto en el gráfico. Se puede cambiar el tamaño con la opción fontsize. Existen más parámetros opcionales disponibles, consultar el manual. >>> text(., 2, punto de inflexión, fontsize, 4) Con subplot(fil, col, id) podemos crear varios gráficos dentro de una misma figura, donde fil es el número de filas, col el número de columnas, e id el índice contando de izquierda a derecha por filas, empezando por arriba. >>> x = : e 2 : ; >>> subplot(2, 3, ); plot(x, x. 2); subplot(2, 3, 2); plot(x, x. 3, color, red ); >>> subplot(2, 3, 3); plot(x, sin(pi x), color,[.6,.4,.8]); >>> subplot(2,3,4); plot(x,x. sin(2 pi x), color,[,.7,.5]); >>> subplot(2,3,5); plot(x,exp(x). sin(2 pi x), color,[.6,,.5]); >>> subplot(2,3,6); plot(x,x. exp( x). sin(2 pi x), color,[,.8,]);

32 4.2 En el espacio: 3D Para realizar gráficos en dos dimensiones con el comando plot, hemos creado un vector de puntos x sobre los cuales calculábamos el vector y = f(x). El comando plot se encargaba de unir los pares (x(i),y(i)) por rectas. Para crear un gráfico en tres dimensiones haremos algo similar, pero el proceso es ligeramente más complicado. Ahora crearemos dos vectores de puntos x e y y calcularemos los puntos z = f(x,y) para todas las combinaciones posibles de puntos de x y de y. Necesitaremos pues crear una rejilla con todas las combinaciones posibles. De ello se encarga el comando meshgrid: >>> [X,Y] = meshgrid( 3 } {{ : 2 }, } 3 : {{ 2 : 9 } ) vector x vector y X = Y = La función meshgrid crea dos matrices, que en este ejemplo hemos llamado X e Y. En la primera copia el vector x por filas tantas veces como elementos tiene el vector y. En la segunda, el vector y es copiado por columnas tantas veces como filas tiene el vector x. De este modo tendremos dos matrices X e Y cuya dimensión será length(y) length(x), y los elementos (X(i,j),Y(i,j)) formarán todas las combinaciones posibles de pares de elementos del vector x y del vector y. Sólo quedará pues calcular la matriz z = f(x,y) y así tendremos una nube de puntos en tres dimensiones: >>> [X,Y] = meshgrid( 2 :. : 2, 2 :. : 2); Z = X. exp( X. 2 Y. 2); A continuación mostramos los comandos más utilizados. La función mesh crea una rejilla en 3D con los valores de las matrices (X,Y,Z). >>> mesh(x,y,z)

33 El comando hidden off convierte la rejilla en transparente. Para volverla opaca (por defecto) introducir hidden on. >>> mesh(x, Y, Z); hidden off; La variante meshc crea una rejilla en 3D con los valores de las matrices (X,Y,Z) y además muestra en el plano xy las curvas de nivel de la función. >>> meshc(x,y,z) Para crear un gráfico sólo con las curvas de nivel disponemos de los comandos contour, contourf y contour3. El primero crea una gráfica en dos dimensiones con las curvas de nivel a partir de las matrices (X,Y,Z): >>> contour(x, Y, Z) 33

34 El comando contourf es similar, pero pinta las áreas entre las curvas de nivel. >>> contourf(x, Y, Z) Con contour3 crearemos un gráfico en 3D con las curvas de nivel, donde cada curva estará a la altura z que le correspondería en la gráfica. >>> contour3(x, Y, Z)

35 Los comandos surf y surfc son similares a mesh y meshc. A diferencia de los últimos, éstos colorean el interior de la rejilla. >>> surf(x, Y, Z); axis([ 2, 2, 2, 2,.5,.5]); Con shading podemos controlar la apariencia de los pedazos o parches que componen una superficie dibujada con surf. Disponemos de las opciones flat, faceted e interp. Por defecto se representan las superficies con la opción faceted, que dibuja los bordes de los pedazos. Introduciendo shading flat conseguiremos eliminar estos bordes. La opción interp, interpola el color entre los distintos parches y hace invisible los vértices, dando la apariencia de una curva suave sin bordes. >>> shading flat

36 >>> shading interp Es posible cambiar los colores usados en los gráficos con el comando colormap A, donde A es una matriz con 3 columnas correspondientes a los matices RGB de cada color (fila). Podemos crear una matriz de colores A o bien usar una de las predefinidas: autumn, bone, cool, copper, flag, gray, hot, hsv, jet, ocean, pink, prism, rainbow, spring, summer, white, winter. Se puede restablecer la configuración por defecto (jet) introduciendo colormap default. >>> [X,Y] = meshgrid( 3 pi :.5 : 3 pi, 3 pi :.5 : 3 pi); >>> Z = sin(sqrt(x. 2 + Y. 2))./sqrt(X. 2 + Y. 2); >>> surf(x, Y, Z); colormap cool; El comando plot3 nos permite dibujar curvas paramétricas en el espacio. Dados tres vectores (x,y,z), dibuja una línea que une sucesivamente los puntos: (x(), y(), z()) con (x(2), y(2), z(2)), 36

37 (x(2),y(2),z(2)) con (x(3),y(3),z(3)), etc. Para dibujar la curva paramétrica {x = f(t),y = g(t),z = t}, sólo tendremos pues que crear un vector de valores t y a partir de él los vectores x = f(t) e y = g(t), y finalmente representar los puntos con plot3(x,y,t). >>> t = linspace(,2 pi,); x = 5 cos(5 t); y = 5 sin(5 t); >>> plot3(x, y, t); Para realizar dibujos en el plano disponíamos del comando ezplot con el cual se puede representar una función sin tener que definir previamente un conjunto de puntos. En el espacio disponemos también de comandos similares: ezplot3 dibuja una curva definida de forma paramétrica mediante funciones. >>> ezplot3( t cos(t), t sin(t), t,[, pi],); x = tcos(t),y = tsin(t), z = t y x ezmesh dibuja una rejilla de una función. >>> f sqrt(abs(x. y))./( + x. 2 + y. 2); ezmesh(f,[ 3,3]); 37

38 sqrt (abs (x y)) / ( + x 2 + y 2 ) y x 2 3 Pasándole tres funciones de dos variables al comando ezmesh conseguimos que realize un dibujo de la función paramétrica (f x (s,t),f y (s,t),f z (s,t)): >>> fx cos(s). cos(t); fy sin(s). cos(t); fz sin(t); >>> ezmesh(fx, fy, fz,[ pi, pi, pi/2, pi/2], 2); x = cos (s) cos (t),y = sin (s) cos (t), z = sin (t) t s.5 ezsurf se comporta como ezmesh pero pintando el interior de la rejilla: >>> ezsurf(fx, fy, fz,[ pi, pi, pi/2, pi/2], 2); x = cos (s) cos (t),y = sin (s) cos (t), z = sin (t) t s.5 38

39 ezcontour dibuja las curvas de nivel de una función. >>> ezcontour( sqrt(abs(x. y))./( + x. 2 + y. 2),[ 2,2],2) 2 sqrt(abs(x y)) / ( + x 2 + y 2 ).5.5 y x En el ejemplo anterior, el intervalo [ 2,2] son los valores mínimo y máximo de ambos ejes, y 2 es el número de puntos. La variante ezcontourf pinta las áreas entre las curvas de nivel: >>> ezcontourf( sqrt(abs(x. y))./( + x. 2 + y. 2),[ 2,2],2) 2 sqrt(abs(x y)) / ( + x 2 + y 2 ).5.5 y x 39

40 5 Cargar y guardar datos en archivos 5. Datos numéricos y funciones Los comandos save y load permiten, respectivamente, guardar y cargar datos en Octave de forma fácil. Con save podemos guardar variables, matrices y funciones; datos que podremos recuperar posteriormente con load durante otra sesión sin necesidad de tener que introducirlos o calcularlos de nuevo. La sintaxis del comando save es (la de load es similar): save nombre.extensión dato dato 2... dato n donde nombre es el nombre del fichero a guardar, extensión es la extensión del fichero (por ejemplo txt), y dato dato 2... dato n son los datos (variables, matrices y/o funciones) que queremos guardar (cargar, en el caso de load). Veamos un ejemplo sencillo, donde crearemos una matriz aleatoria A de tamaño 4 4 con números enteros entre y 9, y una función f. Guardaremos en el fichero datos.txt la matriz A, la función f y la matriz f(a). Para almacenar f(a) debemos asignar su valor a una variable (matriz) B. >>> A = floor(rand(4) ); f x. sin(x. 2); B = f(a); >>> save datos.txt A f B La función save creará un fichero llamado datos.txt en el directorio donde estemos trabajando. El contenido de este fichero será semejante a: # Created by Octave 3.2.4, Sat Dec 8 9:6:44 2 Hora estándar romance <unknown@unknown> # name: A # type: matrix # rows: 4 # columns: # name: f # type: x.* sin (x.ˆ 2) # length: 2 # name:.nargin. # type: scalar # name:.nargout. # type: scalar # name: B # type: matrix # rows: 4 # columns: En una sesión posterior podríamos cargar todos estos datos (o sólo algunos, en cuyo caso debemos especificar cuáles tras el nombre del fichero): >>> load datos.txt 5.2 Gráficos Es posible guardar la figura actual (el gráfico) en un archivo mediante el comando print. Admite multitud de formatos en los que almacenar la imagen; entre ellos los más usuales son pdf, eps y jpg. La opción para especificar el formato es d seguido del formato en el que queremos guardar la imagen. Así, los tres formatos anteriores serían dpdf, depsc y djpg (usaremos depsc para que guarde la figura en color, ya que la opción deps lo hace en escala de grises). A la hora de incrustar un gráfico en un documento de LATEXes preferible usar archivos pdf o eps, ya que son más pequeños y 4