INTRODUCCI

ON A
GNU OCTAVE
Francisco Javier Arag on Artacho
Departamento de Estadstica e Investigaci on Operativa
Universidad de Alicante
Diciembre 2010
Contenido
1 Primeros pasos con Octave 3
1.1 Operadores b asicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Asignaci on de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Vectores y matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Matrices especiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.2 Operaciones con matrices y vectores . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Operadores l ogicos y de comparaci on . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 Cadenas de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6 Salida y entrada de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.7 Algunos comandos utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Control de ujo de ejecuci on 16
2.1 Sentencia condicional if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Bucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Bucles while y do. . . until . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Sentencias break y continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Sentencia switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.6 Sentencia try. . . catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Funciones 21
3.1 Funciones an onimas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Funciones en lnea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 El comando function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4 Gr acos 25
4.1 En el plano: 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.2 En el espacio: 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5 Cargar y guardar datos en archivos 40
5.1 Datos num ericos y funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.2 Gr acos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3 Im agenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6 Ejemplos pr acticos 43
6.1 C alculo aproximado de pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2 Billetes y monedas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.3 Edici on de una imagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
6.4 M etodo del trapecio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Indice de comandos 50
2
1 Primeros pasos con Octave
En esta secci on comenzaremos viendo los operadores b asicos en Octave que nos permiten denir y
hacer operaciones con escalares, vectores y matrices, as como con cadenas de texto. Veremos c omo
utilizar los operadores l ogicos (con los cuales podremos hacer comparaciones l ogicas de tipo 0/1 o
verdadero/falso) y nalizaremos con unos cuantos comandos que pueden sernos utiles.
1.1 Operadores b asicos
+, , , / son los operadores suma, resta, multiplicaci on y divisi on, respectivamente. Con ( )
agrupamos las operaciones.
>>> 8+5(93)/2
ans = 23
, son dos formas de escribir el operador de potencia.
>>> 82
ans = 64
>>> 82
ans = 64
Para calcular la raz cuadrada se usa sqrt.
>>> sqrt(2)
ans = 1.4142
El valor absoluto se obtiene con la funci on abs.
>>> abs(3.5)
ans = 3.5
El n umero complejo i se puede escribir de varias formas: i, j, I, J.
>>> sqrt(1)
ans = 0+1i
Las funciones trigon ometricas m as usuales son sin, cos, tan, asin, acos, atan (seno, coseno,
tangente, arcoseno, arcocoseno, arcotangente).
>>> cos(pi)
ans =1
Las funciones exponencial y logaritmo neperiano se obtienen con los comandos exp, log.
>>> exp(log(2))
ans = 2
Para mostrar m as o menos cifras decimales, usamos format long y format short. Para otras
opciones, v ease en la ayuda con help format.
>>> format long
>>> 1/7
ans = 0.142857142857143
>>> format short
>>> 1/7
ans = 0.14286
3
1.2 Asignaci on de variables
Las variables se denen de forma muy sencilla con el operador =.
>>> a = 2;
>>> 3a
ans = 6
Como podemos observar en este ejemplo, al escribir ; al nal de una sentencia ocultamos el
resultado. Esto es util para no mostrar por pantalla resultados intermedios.
Podemos denir varias variables a la vez si comparten un valor.
>>> a = b = c = 5;
Esto sera equivalente a
>>> a = 5; b = 5; c = 5;
Es posible restablecer el valor de constantes del sistema mediante el comando clear.
>>> pi = 5; 2pi
ans = 10
>>> clear pi; pi
ans = 3.1416
Podemos aumentar el valor de una variable en una unidad mediante el operador ++.
>>> a = 2; a++; a
ans = 3
El comando a++ es equivalente a escribir a = a+1. Es posible utilizar este operador dentro
de cualquier expresi on, en cuyo caso, dependiendo de si colocamos el operador ++ delante o
detr as de la variable tendr a un comportamiento u otro. Al ponerlo a la derecha, primero se realiza
la operaci on, y despu es se incrementa el valor de la variable:
>>> a = 2; 2+(a++)
ans = 4
>>> a
ans = 3
Si escribimos el operador a la izquierda de la variable, se incrementa el valor de la variable antes
de realizar la operaci on:
>>> a = 2; 2+(++a)
ans = 5
>>> a
ans = 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
sera 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
1.3 Vectores y matrices
Los vectores la se denen como n umeros entre corchetes separados por comas o por espacios.
Podemos realizar cualquier operaci on con vectores, como multiplicar por un escalar:
>>> v = [1, 2, 3]; 2v
v =
2 4 6
Para denir un vector columna, utilizamos punto y coma para separar las componentes.
>>> w = [4; 5; 6]
w =
4
5
6
Es f acil trasponer
1
un vector (o matriz) mediante
/
(es el car acter que en los teclados espa noles
aparece en la misma tecla que ?).
>>> w
/
ans =
4 5 6
Podemos crear vectores de cualquier longitud cuyos elementos distan en una unidad mediante los
rangos. La sintaxis es PtoInicio : PtoFin.
>>> 1 : 5
ans =
1 2 3 4 5
Para crear vectores con cualquier otro incremento, se usa PtoInicio : Incremento : PtoFin.
>>> 10 : 2 : 1
ans =
10 8 6 4 2
Otra forma de crear vectores con valores equidistantes es mediante el comando linspace. Su
sintaxis es linspace(Inicio, Fin, NumeroDePuntos).
>>> linspace(1, 2, 5)
ans =
1.0000 1.2500 1.5000 1.7500 2.0000
Se puede obtener la longitud de cualquier vector mediante el comando length.
>>> v = [2, 4, 8, 1]; length(v)
ans = 4
Las matrices se crean f acilmente separando los elementos de una la por comas (o espacios) y las
las por punto y coma.
>>> A = [1, 2, 3; 4, 5, 6; 7, 8, 9]
A =
1 2 3
4 5 6
7 8 9
1
Realmente, el operador
/
calcula la traspuesta conjugada, que en el caso de matrices o vectores reales coincide con la
traspuesta.
5
Mediante A(i, j) obtenemos el elemento de la la i y la columna j de la matriz A.
>>> A(3, 2)
ans = 8
Es posible cambiar de forma sencilla cualquier elemento de una matriz, o introducir un nuevo
elemento:
>>> A(1, 1) = 0; A
A =
0 2 3
4 5 6
7 8 9
>>> A(4, 2) = 1
A =
0 2 3
4 5 6
7 8 9
0 1 0
El operador : sirve para seleccionar todos los elementos de una la/columna en una matriz.
>>> A = [1, 2, 3; 4, 5, 6; 7, 8, 9]; A(2, :)
ans =
4 5 6
Tambi en podemos elegir elementos de una matriz (por ejemplo, una submatriz) mediante un
vector que especique las las y/o columnas.
>>> A(2 : 3, [1, 3])
ans =
4 6
7 9
El comando size nos devuelve un vector con las dimensiones de la matriz.
>>> A = [1, 2, 3; 4, 5, 6]; size(A)
ans =
2 3
Se puede obtener el ultimo elemento de una la o columna de una matriz o vector mediante end.
>>> A = [1, 2, 3; 4, 5, 6]; A(end, 1)
ans = 4
1.3.1 Matrices especiales
El comando rand nos permite crear n umeros aleatorios
2
distribuidos uniformemente en el inter-
valo (0, 1). Mediante rand(m, n) obtenemos una matriz de tama no mn con elementos formados
por este tipo de n umeros.
>>> rand(2, 4)
0.832122 0.859706 0.078132 0.423514
0.852109 0.752108 0.507478 0.197817
2
En realidad se trata de n umeros pseudoaleatorios. Para m as informaci on, introducir help rand en Octave.
6
La matriz identidad se obtiene con el comando eye.
>>> eye(3)
ans =
1 0 0
0 1 0
0 0 1
Para obtener una matriz de ceros
3
, usar el comando zeros.
>>> zeros(2)
ans =
0 0
0 0
Con el comando ones obtenemos una matriz de unos.
>>> ones(2, 3)
ans =
1 1 1
1 1 1
Introduciendo diag(v) Octave nos devuelve una matriz con el vector v en la diagonal.
>>> diag([1, 2, 3])
ans =
1 0 0
0 2 0
0 0 3
Escribiendo un segundo par ametro diag(v, k) obtenemos una matriz con el vector v posicionado
en la k- esima diagonal superior (o inferior, si k < 0).
>>> diag([1, 2, 3], 1)
ans =
0 0 0 0
1 0 0 0
0 2 0 0
0 0 3 0
Aplicado a una matriz, el comando diag devuelve su k- esima diagonal.
>>> A = [1, 2, 3; 4, 5, 6; 7, 8, 9]; diag(A)
ans =
1
5
9
1.3.2 Operaciones con matrices y vectores
Es esencial tener siempre en cuenta que Octave ha sido dise nado para trabajar con matrices. Es por ello
que es necesario tener cuidado a la hora de utilizar operaciones como la multiplicaci on, la divisi on o
la potencia, cuyo signicado no es el mismo para escalares que para matrices. Esto suele originar la
mayora de los fallos cuando utilizamos Octave.
3
Es m as eciente crear una matriz de ceros y luego cambiar los valores de sus elementos que crear una matriz vaca e ir
rellenando sus valores (cuando se agranda una matriz, internamente se le asigna una nueva posici on en la memoria).
7
Usaremos el producto para multiplicar cualquier matriz o vector por un escalar o por otra matriz.
>>> A = [1, 1, 1; 0, 1, 0; 0, 1, 1]; 5A
ans =
5 5 5
0 5 0
0 5 5
>>> b = [1; 2; 3]; Ab
ans =
6
2
5
>>> B = [0, 0, 2; 1, 5, 4; 3, 2, 1]; AB
ans =
4 7 7
1 5 4
4 7 5
Octave es capaz de elevar r apidamente una matriz a cualquier potencia, esto es, multiplicar la
matriz por s misma un n umero determinado de veces (por consiguiente la matriz deber a ser
cuadrada). Para ello se usa el operador . As A3 = AAA.
>>> A = [1, 2, 3; 4, 5, 6; 7, 8, 9]; A2
ans =
30 36 42
66 81 96
102 126 150
Es posible realizar operaciones elemento a elemento con vectores y matrices. Para ello s olo hay
que introducir un . antes del operador correspondiente. As tendramos las operaciones .,
. o ./. Con la suma y la resta no es necesario utilizarlo ya que ambas operaciones act uan
siempre elemento a elemento.
>>> A = [1, 2, 3; 4, 5, 6; 7, 8, 9]; A. 2
ans =
1 4 9
16 25 36
49 64 81
Comparar el resultado con el ejemplo previo.
Para calcular la inversa de una matriz usaremos A1 o inv(A).
>>> A = [1, 1, 1; 0, 1, 0; 0, 1, 1]; A1
ans =
1 0 1
0 1 0
0 1 1
El determinante de una matriz se obtiene con det.
>>> A = [1, 1, 1; 0, 1, 0; 0, 1, 1]; det(A)
ans = 1
Para resolver un sistema Ax = b, usaremos Ab. Octave lo resuelve con un algoritmo mucho m as
preciso y r apido que si calculamos x = inv(A) b. Si la matriz A fuese singular, Octave devolver a
8
un mensaje de advertencia y calcular a una soluci on de norma mnima.
>>> A = [1, 2, 1; 3, 5, 2; 3, 2, 1]; b = [1; 2; 3]; Ab
ans =
1.00000
1.00000
2.00000
La funci on tril devuelve una matriz triangular inferior de una matriz dada. Introduciendo un
segundo argumento tril(A, k) especicamos cu antas diagonales por encima o por debajo de la
diagonal principal deben ser cero.
>>> A = [1, 2, 3, 4; 5, 6, 7, 8; 9, 10, 11, 12; 13, 14, 15, 16]; tril(A)
ans =
1 0 0 0
5 6 0 0
9 10 11 0
13 14 15 16
>>> tril(A, 1)
ans =
1 2 0 0
5 6 7 0
9 10 11 12
13 14 15 16
>>> tril(A, 1)
ans =
0 0 0 0
5 0 0 0
9 10 0 0
13 14 15 0
El comando triu se comporta como tril, pero devuelve una matriz triangular superior.
Con poly obtenemos los coecientes del polinomio caracterstico de cualquier matriz.
>>> poly([1, 1, 1; 1, 0, 1; 0, 0, 2])
ans =
1.00000 3.00000 1.00000 2.00000
La funci on eig devuelve los autovalores de una matriz.
>>> eig([1, 1, 1; 1, 0, 1; 0, 0, 2])
ans =
1.61803
0.61803
2.00000
Se puede conseguir que la funci on eig nos devuelva tambi en los vectores propios asociados a
estos autovalores pidi endole 2 argumentos de salida, por ejemplo [V, L] = eig(A), en cuyo caso
AV = VL.
>>> [V, LAMBDA] = eig([1, 1, 1; 1, 0, 1; 0, 0, 2])
V =
0.85065 0.52573 0.80178
0.52573 0.85065 0.53452
0.00000 0.00000 0.26726
9
LAMBDA =
Diagonal Matrix
1.61803 0 0
0 0.61803 0
0 0 2.00000
El comando norm(v, k) permite calcular la norma de cualquier vector
4
v = (v
1
, . . . , v
n
). Por
defecto, si no se especica k o si k = 2, calcula la norma eucldea o L
2
, |v|
2
=

v
2
1
+. . . +v
2
n
.
Otras opciones del par ametro k son 1 para la norma L
1
, |v|
1
=[v
1
[ +. . . +[v
n
[, e Inf para la
norma L

, |v|

= m ax[v
1
[, . . . , [v
n
[.
>>> v = [1, 2, 3, 4]; norm(v)
ans = 5.4772
>>> norm(v, 1)
ans = 10
1.4 Operadores l ogicos y de comparaci on
En Octave el valor verdadero viene representado por 1 y falso por 0.
El operador de comparaci on de igualdad es ==. No debe confundirse con el operador de asig-
naci on =. Si comparamos dos matrices obtendremos una matriz de unos y ceros, donde cada
elemento ser a el resultado verdadero/falso de comparar ambas matrices.
>>> 2 == 3
ans = 0
>>> a = 2; a == 2
ans = 1
>>> A = [1, 2, 3; 4, 1, 1]; A == 1
ans =
1 0 0
0 1 1
De manera similar se comportan los operadores de comparaci on mayor estricto >, mayor o igual
>=, menor estricto <, menor o igual <= y distinto ! =. Este ultimo tambi en puede escribirse
como
5
=.
>>> b = [1, 2, 3]; b > 1
ans =
0 1 1
>>> b! = 2
ans =
1 0 1
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 = [1, 2, 3]; all(b > 1)
ans = 0
4
Tambi en calcula la norma de cualquier matriz, ver la ayuda para m as informaci on.
5
El smbolo se obtiene en un teclado espa nol pulsando Alt Gr+ 4 y pulsando despu es espacio.
10
>>> A = [1, 2, 3; 4, 1, 1]; all(A <= 2)
ans =
0 1 0
El comando any nos dice si alg un elemento es distinto de cero. Se utiliza de manera similar a
all.
El operador l ogico de conjunci on y se escribe en Octave con el smbolo &. El valor de x&y es
1 s olo cuando x ,= 0 y y ,= 0. Su tabla de verdad es:
x y x&y
0 0 0
0 1 0
1 0 0
1 1 1
Puede emplearse con vectores o matrices, en cuyo caso ofrecer a una comparaci on elemento a
elemento.
>>> b = [1, 7, 2, 0, 3, 4, 5]; (b < 3)&(b! =3)
ans =
1 0 1 1 0 0 0
El operador l ogico de disyunci on o se escribe
6
con el smbolo [. El valor de x[y es 1 si x ,= 0 o
si y ,= 0. Su tabla de verdad es:
x y x[y
0 0 0
0 1 1
1 0 1
1 1 1
Al igual que el operador & puede emplearse con vectores y matrices.
>>> b = [1, 2, 3, 4, 5, 6]; (b < 3)[(b > 4)
ans =
1 1 0 0 1 1
El operador l ogico de negaci on no se puede escribir de dos maneras: con el smbolo ! o con el
smbolo sim. El valor de !x es 1 si x = 0. Su tabla de verdad es:
x !x
0 1
1 0
Tambi en puede emplearse con vectores y matrices.
>>> b = [1, 2, 3, 4, 5, 6]; !((b < 3)[(b > 4))
ans =
0 0 1 1 0 0
1.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 omo Octave trata internamente las cadenas de texto. Podemos intuirlo si
6
En un teclado espa nol, pulsando Alt Gr+1.
11
sumamos a cualquier texto el n umero cero:
>>> b+0
ans =
99 97 115 97
En este ejemplo aparecen 4 n umeros (tantos como letras tiene la palabra casa). Observamos que el
segundo n umero es igual al ultimo. Esto ocurre porque Octave trata las cadenas de texto como si fueran
matrices. Los n umeros representan el c odigo ASCII
7
extendido de cada letra. Podemos crear pues una
matriz con las dos cadenas de texto denidas anteriormente:
>>> [a; b]
ans =
mi
casa
Se pueden unir tambi en horizontalmente:
>>> [a, , b]
ans = mi casa
Es sencillo trabajar con cadenas teniendo en cuenta qu e representan para Octave. As, si texto es una
variable que contiene cualquier cadena de texto, escribiendo texto(1) obtendremos la primera letra de
esta palabra, con texto(end) la ultima, etc.
>>> b(2 : 3)
ans = as
Para convertir cualquier vector con n umeros entre 0 y 255 en una cadena de texto usaremos el comando
char.
>>> char([99, 97, 115, 97])
ans = casa Observar que la cadena que representa a cualquier n umero es distinta al n umero en s. Por
ejemplo 1 no es lo mismo que el n umero 1:
>>> a =
/
1
/
; a+0
ans = 49
Esto ocurre porque el c odigo ASCII de 1 es el 49. Sin embargo es posible convertir cualquier n umero
escrito como cadena de texto en un n umero con la funci on str2num:
>>> a =
/
1
/
; str2num(a) +0
ans = 1
Tambi en podemos realizar el proceso contrario con el comando num2str; esto es, convertir un n umero
en una cadena de texto.
Un comando util cuando trabajamos con cadenas de texto es index, que busca una cadena de texto
dentro de otra y nos devuelve la posici on de la primera ocurrencia. Si no la encuentra, devuelve 0.
>>> index(El coche de Carlos, coche)
ans = 4
Debemos siempre tener en cuenta que Octave distingue entre may usculas y min usculas (ya que su
c odigo ASCII es distinto):
>>> index(El coche de Carlos, c)
ans = 4
>>> index(El coche de Carlos, C)
ans = 13
7
ASCII es el acr onimo ingl es de American Standard Code for Information Interchange. Se trata de una tabla de 256
caracteres que pueden ser representados mediante 8 bits.
12
1.6 Salida y entrada de datos
Los comandos de salida b asicos 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.1416
Con printf tenemos un control mayor del resultado que aparece en pantalla. Podemos especi-
car operadores de conversi on de las variables. Los m as usados son %d, %f y %s, que corre-
sponden a n umero entero, n umero en punto otante
8
y cadena de texto, respectivamente. Veamos
en unos ejemplos c omo funciona:
>>> a = 4; printf(El valor de a es %d, a)
El valor de a es 4 >>>
Para conseguir introducir un salto de lnea, escribiremos n.
>>> a = 4; printf(El valor de a es %dn, a)
El valor de a es 4
Aqu tenemos m as ejemplos con %f y %s:
>>> printf(El valor de pi es%fn., pi)
El valor de pi es 3.141593.
>>> nombre =
/
Pedro
/
; printf(Hola %s!n, nombre)
Hola Pedro!
Es posible usar varias variables en una cadena de texto. S olo tendremos que introducir en el orden
correspondiente las variables separadas por comas.
>>> a = 200; b = 50;
>>> printf(De las %d personas, solo %d iban disfrazadasn., a, b)
De las 200 personas, solo 50 iban disfrazadas.
Octave nos permite controlar la anchura mnima de una variable en punto otante, as como el
n umero de decimales que aparecer an por pantalla. La sintaxis es %ancho.decimalesf, donde
ancho es un entero que representa la anchura mnima de la variable (incluyendo decimales y el
signo .) y decimales es el n umero de decimales que mostrar a. Si el tama no de la variable fuese
menor que la anchura especicada, se introducir an espacios. Por ejemplo:
>>> printf(El valor de pi es%.10fn., pi)
El valor de pi es 3.1415926536.
>>> printf(%1.0fn, 3.5); printf(%2.0fn, 3.5);
4
4
En este ejemplo, como le hemos pedido que no muestre decimales, redondea el n umero 3.5 a 4.
Existen m as opciones, consultar el manual.
Como en la mayora de lenguajes de programaci on, disponemos de la sentencia de entrada input que
solicita al usuario un valor.
>>> nombre = input(Como te llamas?)
Como te llamas?
Octave esperar a que el usuario introduzca un valor. Cuando pulse Intro lo que haya introducido pasar a
a ser el valor de la variable nombre.
8
N umeros con decimales.
13
1.7 Algunos comandos utiles
La instrucci on who muestra por pantalla los nombres de las variables denidas. La variante whos
muestra informaci on m as detallada, incluyendo el tama no, el n umero de bytes de memoria em-
pleados en almacenar cada variable y el tipo de datos.
Tenemos cuatro opciones para redondear un n umero 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 on fix(x) nos da la parte
entera de x. Por ultimo, round(x) redondea x hacia el entero m as pr oximo.
>>> floor([1.3, 1.6, 1.3, 1.6])
ans =
2 2 1 1
>>> ceil([1.3, 1.6, 1.3, 1.6])
ans =
1 1 2 2
>>> fix([1.3, 1.6, 1.3, 1.6])
ans =
1 1 1 1
>>> round([1.3, 1.6, 1.3, 1.6])
ans =
1 2 1 2
La funci on rem(x, y) nos devuelve el resto de la divisi on x./y, es decir, xy. fix(x./y).
>>> rem(10, 4)
ans = 2
Para sumar elementos de un vector usaremos la funci on sum. Si la utilizamos con una matriz
A, nos devolver a la suma de los elementos de cada columna. Para obtener la suma por las,
escribiremos sum(A, 2).
>>> A = [1, 2, 3; 4, 5, 6]; sum(A)
ans =
5 7 9
>>> sum(A, 2)
ans =
6
15
El producto de elementos de un vector o matriz se obtiene con la funci on 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 no, mes, da, horas, minutos, segundos]. Con time obtenemos los segundos
transcurridos desde el 1 de enero de 1970. En un principio podra parecer un dato bastante in util,
pero comparando dos valores de time podremos calcular el tiempo transcurrido en realizar un
proceso. En el siguiente ejemplo lo utilizamos para calcular cu anto se tarda en obtener 100
millones de n umeros aleatorios y calcular su producto:
>>> t = time; prod(rand(1e8, 1)); tiempo = timet;
>>> printf(Tiempo transcurrido : %1.2f segundosn, timet)
Tiempo transcurrido : 4.22 segundos
14
Los comandos tic y toc tienen un n similar. El primero no produce ning un resultado aparente,
pero resulta como poner a cero un cron ometro. Al introducir posteriormente toc nos dir a los
segundos transcurridos desde que se ejecut o tic.
>>> tic; prod(rand(1e8, 1)); toc
Elapsed time is 4.491 seconds.
La funci on factor(n) nos devuelve la descomposici on en factores primos de n.
>>> factor(1150)
ans =
2 5 5 23
15
2 Control de ujo de ejecuci on
Vamos a estudiar las distintas sentencias que nos ofrece Octave para controlar el ujo de ejecuci on de un
algoritmo. Estas sentencias nos permitir an dirigir el comportamiento de nuestro programa ante distintas
situaciones, repetir procesos un n umero determinado de veces o hasta que se cumpla cierta condici on,
etc. Para ello disponemos de la sentencia condicional if, el bucle nito for, los bucles condicionados
while y do until, la sentencia switch y la sentencia try. . . catch. Adem as, con break y continue
podremos saltar iteraciones dentro de un bucle.
2.1 Sentencia condicional if
Se trata de una de las herramientas m as b asicas, que est a disponible en todo lenguaje de programaci on
sensato. Nos permite evaluar si se cumple una condici on l ogica o no. Su forma m as sencilla sera:
if condicion
accion
endif
Cuando ejecutemos este c odigo, si condicion es cierta, se ejecutar a accion. Veamos un ejemplo:
v=5;
if v==3
printf("v vale 3\n")
endif
El c odigo anterior no devolvera nada, ya que v tiene el valor 5. S olo ejecuta el comando printf
cuando la condici on l ogica v == 3 sea cierta. Podramos estar interesados en que sucediera algo en
caso contrario, esto es, cuando la condici on l ogica sea falsa. Es posible hacerlo usando else. La
sintaxis es la siguiente:
if condicion
accion1
else
accion2
endif
En el ejemplo anterior, podramos 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 a
v es distinto de 3
Existe una tercera opci on, con elseif, mediante la cual podemos hacer que si la primera condici on no
es cierta, eval ue otras condiciones:
if condicion1
accion1
elseif condicion2
accion2
elseif condicion3
accion3
...
else
accion
endif
16
Podramos 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 on son los bucles for, que nos permiten repetir una acci on
un n umero nito de veces. Su sintaxis es:
for variable=expresion
accion
endfor
Su funcionamiento es el siguiente: variable va tomando de uno en uno los valores en expresion y
para cada uno de estos valores se ejecuta accion. Normalmente, expresi on ser a un rango como 1 : 100,
un vector como [1, 3, 5, 2, 1] o incluso una matriz. En el siguiente ejemplo sumamos
9
los n umeros de
1 a 1000:
suma=0;
for k=1:1000
suma=suma+k;
endfor
disp(suma)
En el siguiente ejemplo sumamos 1 a cada elemento de la matriz A denida con n umeros aleatorios, y
mostramos el resultado por pantalla:
>>> A = rand(3)
A =
0.57089 0.68758 0.27159
0.37951 0.90257 0.32629
0.26264 0.59358 0.76674
for j=A
disp(j+1);
endfor
>>> 1.5709
1.3795
1.2626
1.6876
1.9026
1.5936
1.2716
1.3263
1.7667
Podemos anidar varios bucles for, por ejemplo para recorrer los elementos de una matriz. El siguiente
algoritmo dene una matriz nm cuyo elemento A(j, k) vale jk:
9

Esta no sera una forma eciente de sumar los n umeros del 1 al n. Una opci on preferible sera escribir sum(1 : n), aunque
la m as eciente sera usar la f ormula
n(n+1)
2
.
17
n=2;m=3;
for j=1:n
for k=1:m
A(j,k)=j
*
k;
endfor
endfor
A
>>> A =
1 2 3
2 4 6
2.3 Bucles while y do. . . until
Con la sentencia while podemos crear otro tipo de bucles que se ejecutar an hasta que se verique cierta
condici on. Aunque son muy utiles, hay que llevar cuidado a la hora de usarlos, ya que podemos crear
un bucle innito si la condici on que imponemos nunca se verica (lo cual colgara Octave). La sintaxis
es la siguiente:
while condicion
accion
endwhile
El c odigo anterior se ejecuta si condicion tiene el valor verdadero, en cuyo caso, realizar a accion y
volver a a vericar si se verica condicion. Una vez iniciado un bucle while, se ejecutar a la acci on
repetidamente hasta que deje de vericarse la condicion. El siguiente bucle escribir a los n umeros del
0 al 10:
a=0;
while a<=10
disp(a);
a=a+1;
endwhile
El siguiente bucle sera innito, ya que la condici on siempre es cierta (de hecho bloquea Octave):
a=0;
while (a>-2)|(a<=10)
disp(a);
a=a+1;
endwhile
Los bucles do. . . until son similares a los bucles while. La diferencia radica en el hecho de que
la condici on es evaluada al nal, en vez de al inicio del bucle, y el bucle no naliza hasta que no se
verique la condici on (al contrario que en un bucle while). Su sintaxis es:
do
accion
until condicion
En un bucle do. . . until la accion siempre se ejecutar a al menos una vez. Veamos un ejemplo:
do
x=rand
until x>0.6
El c odigo anterior calcula un n umero aleatorio entre 0 y 1 y lo muestra por pantalla, hasta que el n umero
calculado sea mayor que 0.6.
18
>>> x = 0.48369
x = 0.076110
x = 0.13339
x = 0.72870
2.4 Sentencias break y continue
Los comandos break y continue son bastante utiles. Con break escapamos de cualquier bucle for,
while o do. . . until aunque el bucle no haya terminado. Por ejemplo, el siguiente c odigo nos devuelve
el valor k = 5, a pesar de que el bucle for llegara normalmente hasta 1000:
for k=1:1000
if k==5
break
endif
endfor
disp(k)
Con la sentencia continue saltamos al nal del c odigo de un bucle for, while o do. . . until, sin
ejecutar el resto del algoritmo y contin ua con el siguiente valor. Veamos un ejemplo:
for k=1:10
if k==5
continue
endif
disp(k)
endfor
El c odigo anterior mostrara los n umeros del 1 al 10 excepto el 5.
2.5 Sentencia switch
La sentencia switch es muy parecida a if. La sintaxis es:
switch x
case valor1
accion1
case valor2
accion2
...
otherwise
accion
endswitch
El c odigo anterior sera equivalente a escribir
if x==valor1
accion1
elseif x==valor2
accion2
...
else
accion
endswitch
En ciertos casos puede ser m as pr actico utilizar switch que un bucle if: el c odigo puede ser m as claro
de leer y m as f acil de modicar. Tambi en tiene la ventaja de que switch acepta comparaciones con
cadenas de texto del tipo
19
switch respuesta
case "s"
accion1
case "no"
accion2
otherwise
printf("Escriba s o no")
endswitch
Para hacer esto con if necesitaramos usar el comando all, ya que para Octave una cadena de texto es
un vector, y por tanto comparara elemento a elemento. El c odigo quedara:
if all(respuesta=="s")
accion1
elseif all(respuesta=="no")
accion2
else
printf("Escriba s o no")
endif
Si quisi eramos cambiar el nombre de la variable respuesta, con un c odigo switch s olo tendramos
que cambiarlo en un lugar (al inicio), mientras que con if deberamos cambiarlo en cada comparaci on.
2.6 Sentencia try. . . catch
Para controlar posibles errores un comando util es try. Con el le pedimos a Octave que intente realizar
una acci on. Si al hacerlo obtiene cualquier error, en vez de pararse le decimos que realice otra acci on.
Veamos su sintaxis:
try
accion1
catch
accion2
end_try_catch
En el c odigo anterior Octave intentar a ejecutar accion1. Si se produjese un error, continuara normal-
mente ejecutando accion2, en vez de accion1. El siguiente c odigo intenta sumar al valor de x una
unidad. Si por ejemplo x no estuviera denida, en vez de sumarle una unidad, le da el valor cero.
try
x=x+1;
catch
x=0;
end_try_catch
En catch podramos poner cualquier mensaje de advertencia al usuario.
20
3 Funciones
En esta secci on veremos c omo denir cualquier tipo de funci on en Octave. Existen tres tipos de fun-
ciones: las funciones an onimas, funciones en lnea (del ingl es inline) y las funciones denidas medi-
ante el comando function. Los dos primeros tipos son usados para funciones matem aticas sencillas,
mientras que el tercer tipo se utiliza para crear algoritmos m as complicados.
En Octave podemos ver el c odigo de cualquier funci on del sistema
10
, a diferencia de Matlab

, que
al ser un software comercial, no nos permite saber qu e algoritmo hay detr as de cada comando.

Esta
es una de las ventajas de Octave sobre Matlab

, ya que en el segundo estamos utilizando una caja

negra para obtener los resultados, sin poder saber c omo funcionan los algoritmos de las funciones que
empleamos.
3.1 Funciones an onimas
Se trata de una de las formas m as sencillas de escribir una funci on en Octave. Para ello se utiliza el
comando @( ), especicando entre los par entesis la/s variable/s que emplea la funci on y escribiendo a
continuaci on la funci on en s. Por ejemplo, si quisi eramos denir la funci on f(x) = x
2
s olo tendramos
que introducir
>>> f = @(x) x2;
Ahora podramos calcular el valor de la funci on en cualquier punto:
>>> f(2)
ans = 4
Es conveniente denir las funciones de modo que sean aplicables a vectores y matrices. La funci on
del ejemplo anterior no podra utilizarse con un vector, ya que al intentar multiplicar el vector dara
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 estas no act uan elemento
a elemento cuando son aplicadas a matrices:
>>> f = @(x) x. 2; f([1, 2, 3])
ans =
1 4 9
Es igual de sencillo denir funciones de m as variables:
>>> g = @(x, y, z) x. y(1+x)./(1+z. 2); g(1, 2, 3)
ans = 1.8000;
>>> g([1, 1], [2, 3], [4, 2])
ans =
1.8824 2.6000
3.2 Funciones en lnea
Resulta muy f acil denir funciones en lnea utilizando el comando inline. Simplemente tendremos
que escribir la funci on que deseemos denir entre comillas (simples o dobles). En realidad el comando
inline crea una funci on a partir de una cadena de texto. Veamos c omo se denira la funci on f(x) =x
2
:
>>> f = inline(x. 2);
f =
f(x) = x. 2
10
El c odigo de algunos comandos, como por ejemplo sort, no est a disponible. Esto ocurre porque son funciones compi-
ladas con el n de acelerar su ejecuci on. 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.
21
Tambi en podemos denir funciones de m as variables. A la hora de llamar a la funci on, Octave usar a el
orden alfab etico para saber qu e 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(1, 2, 3)
ans = 9
Un comando util con las funciones en lnea es vectorize, que convierte cualquier operador que
hayamos usado en un operador elemento a elemento, esto es, transforma cualquier aparici on de
en ., / en ./, etc.
>>> f = inline(x2+1/x); f([1, 2])
>>> error : for Ab, A must be square
error : called from :
error : at line 1, column 1
>>> g = vectorize(f)
g =
f(x) = x. 2+1./x
>>> g([1, 2])
ans =
2.0000 4.5000
3.3 El comando function
A la hora de denir funciones m as complejas disponemos de la sentencia function. En su forma m as
sencilla tiene la siguiente sintaxis:
function nombre
comandos
endfunction
donde nombre es el nombre con el que llamaremos a la funci on
11
. Es posible denir funciones desde
la consola en Octave. Sin embargo es m as pr actico hacerlo desde el editor, creando un chero con ex-
tensi on .m y cuyo nombre sea el mismo nombre que escribimos tras function. Debemos guardar
este chero 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
12
, o bien acceder al directorio correspondi-
ente. Desde QtOctave podemos entrar f acilmente a cualquier carpeta del sistema mediante el naveg-
ador (la ventana que aparece por defecto en la esquina inferior izquierda), seleccionando el directorio
donde hayamos guardado nuestro archivo. Tambi en es posible hacerlo directamente con el comando cd
seguido de la ruta entre comillas:
>>> cd F : /Documentos
Veamos una funci on sencilla:
function hola
printf("Hola Fran\n")
endfunction
Esta funci on debemos guardarla con el nombre hola.m, ya que de otro modo Octave no ser a capaz de
detectarla. Ahora podemos llamar a nuestra funci on como si se tratara de cualquier otro comando del
sistema:
11
Evitar usar tildes, espacios, la letra n y caracteres extra nos en el nombre de la funci on.
12
Escribiendo path Octave mostrar a las carpetas en las que busca cheros de funciones. Es posible a nadir m as carpetas a
las existentes, para m as informaci on introducir help path.
22
>>> hola
Hola Fran
Normalmente querremos que nuestra funci on acepte argumentos de entrada. En este caso escribiremos:
function nombre(ent1,ent2,...,entN)
comandos
endfunction
donde ent1, . . . , entN son los valores de entrada con los que el usuario llamar a a la funci on. A contin-
uaci on mostramos una modicaci on del ejemplo anterior.
function hola(nombre)
printf("Hola %s\n",nombre)
endfunction
Ahora nuestra funci on hola acepta un valor de entrada:
>>> hola(
/
Pedro
/
)
Hola Pedro
Es muy sencillo denir valores por defecto de los argumentos de entrada. S olo tendremos que poner
arg=valor defecto cuando denamos la funci on. En la siguiente modicaci on de hola, si el usuario no
introduce ning un argumento, el valor de la variable nombre ser a
/
Fran
/
.
function hola(nombre="Fran")
printf("Hola %s\n",nombre)
endfunction
>>> hola
Hola Fran
>>> hola(
/
Pedro
/
)
Hola Pedro
Para especicar que nuestra funci on utilice el valor por defecto de un par ametro debemos escribir :
como valor de entrada de la funci on:
>>> hola(:)
Hola Fran
En la muchas ocasiones estaremos interesados en que nuestra funci on devuelva uno o varios valores de
salida. Para esto escribiremos:
function [sal1,sal2,...,salM]=nombre(ent1,ent2,...,entN)
comandos
endfunction
donde sal1, sal2, . . . , salM son las variables de salida. No es necesario escribir los corchetes [ ] en
caso de que s olo necesitemos una variable de salida:
function valor=f(x)
valor=x.2+1./x;
endfunction
Un ejemplo de funci on con dos valores de salida es el comando eig que hemos visto en la primera
secci on. Veamos otro ejemplo: imaginemos que queremos escribir una funci on que dado un vector v
nos diga cu al es el elemento m aximo y en qu e posici on se encuentra
13
. En este caso, nuestra funci on,
que llamaremos maximo tendr a dos valores de salida: M que ser a el valor m aximo e id que guardar a su
posici on.
13
Esta funci on viene ya predenida (y compilada) en Octave, la funci on max, por lo que en realidad no sera necesario crear
una nueva.
23
function [M,id]=maximo(v)
M=v(1); id=1; n=length(v);
for k=1:length(v)
if M<v(k)
M=v(k); id=k;
endif
endfor
endfunction
Escribimos la funci on anterior en la consola, o bien en el editor y la guardamos con el nombre maximo.m.
>>> v = [1, 4, 2, 7, 3, 8, 5, 1]; [valor, posicion] = maximo(v)
valor = 8
posicion = 6
Dentro de cualquier funci on que denamos, contamos con dos variables especiales que pueden sernos
bastante utiles: nargin y nargout. La primera toma el valor del n umero de argumentos que haya
introducido el usuario al llamar a la funci on; la segunda variable nargout nos devuelve el n umero de
variables que el usuario espera recibir de nuestra funci on. Veamos un ejemplo:
function prueba
printf(%d valores de entrada y %d valores de salida\n,nargin,nargout)
endfunction
A continuaci on llamamos a la funci on con un diferente n umero de variables de entrada y salida:
>>> prueba
0 valores de entrada y 0 valores de salida
>>> prueba(1, 2)
2 valores de entrada y 0 valores de salida
>>> [a, b, c] = prueba(1, 2)
2 valores de entrada y 3 valores de salida
>>> error : value on right hand side of assignment is undefined
En el ultimo caso obtenemos un error debido a que estamos pidi endole a la funci on 3 valores de salida,
cuando en realidad la funci on no devuelve ning un valor de salida. Las variables nargin y nargout
son utiles a la hora de escribir un algoritmo pues nos permiten controlar cu antos datos ha introducido el
usuario y cu antos espera recibir de la funci on.
Finalizamos esta secci on con el comando return que naliza una funci on aunque no haya termi-
nado de ejecutar el c odigo.
function k=prueba(n)
for k=1:n
if k==10
return
endif
endfor
endfunction
>>> prueba(5)
ans = 5
>>> prueba(15)
ans = 10
En la funci on anterior vemos que la ejecuci on se detiene si k alcanza el valor 10 y devuelve el valor que
k tenga en ese momento, sin nalizar de ejecutar el resto del algoritmo.
24
4 Gr acos
4.1 En el plano: 2D
El comando plot(x, y), donde x e y son vectores, dibuja una lnea en el plano que une consecuti-
vamente los puntos

x(1), y(1)

, . . . ,

x(end), y(end)

. Este comando ser a muy util a la hora de

dibujar gr acas de funciones: s olo tendremos que elegir un n umero suciente de puntos para que
el gr aco sea una buena aproximaci on de la gr aca real de la funci on.
>>> x =10 : 0.01 : 10;
>>> plot(x, sin(x))
-1
-0.5
0
0.5
1
-10 -5 0 5 10
Podemos dibujar varias funciones a la vez:
>>> plot(x, sin(x), x, cos(x))
-1
-0.5
0
0.5
1
-10 -5 0 5 10
Existen diversas opciones que pueden ser especicadas mediante el comando plot. Por ejemplo,
mediante la opci on
/
linewidth
/
controlamos el grosor de la lnea. Con la opci on
/
color
/
pode-
mos cambiar el color, introduciendo a continuaci on un vector con 3 componentes RGB (rojo,
25
verde y azul) con valores entre 0 y 1. Tambi en existen algunos colores predenidos como
/
red
/
,
/
green
/
,
/
blue
/
o
/
yellow
/
. Para m as informaci on, consultar el manual.
>>> plot(x, x. cos(x), color, [1, .8, .6], linewidth, 6)
-10
-5
0
5
10
-10 -5 0 5 10
Por defecto el comando plot dibuja puntos y los une con una recta (puede especicarse con la
opci on
/

/
). Es posible modicar este comportamiento con las opciones
/
+
/
,
/

/
,
/
o
/
,
/
x
/
y
/

/
.
Usando una de estas opciones, plot dibujar a uno de estos smbolos:
>>> x = linspace(pi, pi, 30); plot(x, sin(x),
/
o
/
)
-1
-0.5
0
0.5
1
-4 -3 -2 -1 0 1 2 3 4
Se puede cambiar el tama no de los marcadores anteriores con la opci on
/
markersize
/
, especi-
cando despu es un n umero. Sera interesante poder dibujar puntos rellenos, pero por alg un prob-
lema de Octave
14
la opci on
/
.
/
s olo produce puntos min usculos que no se ven afectados por el
modicador
/
markersize
/
. Podemos sin embargo solucionar este problema f acilmente dibujando
crculos con un tama no de peque no y con una tama no de lnea gorda, con lo que conseguiremos
la apariencia de puntos rellenos:
>>> plot(x, sin(x),
/
o
/
,
/
markersize
/
, 2,
/
linewidth
/
, 5)
14
En Matlab

s que funciona correctamente.

26
-1
-0.5
0
0.5
1
-4 -3 -2 -1 0 1 2 3 4
El comando area(x, y), donde x e y son vectores, se comporta como plot con la diferencia de
que area pinta la gr aca por debajo/arriba hasta el origen. Podemos cambiar el color con la
opci on facecolor.
>>> x =10 : 0.01 : 10;
>>> area(x, sin(x),
/
facecolor
/
, [0, 0.5, 1])
-1
-0.5
0
0.5
1
-10 -5 0 5 10
Es posible cambiar la posici on hasta la cu al rellena el gr aco mediante un par ametro adicional:
>>> area(x, sin(x), 0.5,
/
facecolor
/
, [0, 0.5, 1])
-1
-0.5
0
0.5
1
-10 -5 0 5 10
27
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 en es posible especicar los ejes mediante axis([x
min
, x
max
, y
min
, y
max
]).
Las guras son las ventanas donde nos aparecen los gr acos. Es posible crear nuevas gura me-
diante el comando figure. Con figure(n) seleccionamos la gura activa (en la que se dibuja),
donde n N es un n umero asignado a cada gura.
Tras introducir hold on, Octave no crear a una gura nueva cada vez que le pidamos que dibuje
un gr aco. Esto es util a la hora de dibujar varios gr acos en una misma gura. Se restablece el
comportamiento con hold off.
Introduciendo clf borramos la gura activa. Tambi en podemos eliminarla escribiendo close.
Para crear gr acos en coordenadas polares, usaremos el comando polar(theta, rho).
>>> polar(0 : 0.1 : 10pi, 0 : 0.1 : 10pi)
-30
-20
-10
0
10
20
30
-30 -20 -10 0 10 20 30
Es muy f acil crear un gr aco de sectores. Solo hay que introducir un vector con los porcentajes
usando el comando pie.
>>> pie([5, 25, 40, 10, 20]); axis off;
5%
25%
40%
10%
20%
28
Para otros tipos de gr acos estadsticos consultar el manual.
El comando grid on permite mostrar una rejilla de coordenadas. Para desactivarla escribiremos
grid off.
>>> x = linspace(1, 1, 2000); plot(x, x. sin(1./x. 2)); grid on;
-1
-0.5
0
0.5
1
-1 -0.5 0 0.5 1
Al introducir box off eliminamos la caja que rodea por defecto a las gr acas. Para mostrarla
usaremos box on.
Con fplot podemos dibujar varias funciones de forma sencilla, sin necesidad de denir previa-
mente un vector x con valores:
>>> fplot(sqrt(x) cos(1/x), [0, .1]); box off;
-0.4
-0.3
-0.2
-0.1
0
0.1
0.2
0.3
0.4
0 0.02 0.04 0.06 0.08 0.1
sqrt(x).*cos(1./x)
29
ezplot nos permite tambi en dibujar gr acos de funciones sin tener que denir antes x. Si no
se especican los lmites dibuja por defecto entre 2 y 2. Es posible especicar tambi en el
n umero de puntos que queremos dibujar:
>>> ezplot(x2sin(1/x), [.05, .05]

lmites
, 1e4

n
o
puntos
)
-0.002
-0.001
0
0.001
0.002
-0.04 -0.02 0 0.02 0.04
x
x
2
sin(1/x)
Podemos dibujar funciones denidas de forma implcita, es decir, los puntos (x, y) tales que
F(x, y) =0 para una funci on F. Para ello s olo debemos usar ezplot con una funci on dos variables
(x, y) y Octave dibujar a la funci on F(x, y) = 0.
>> ezplot(@(x, y) x. 2+y. 21, 1000); axis equal;
-1
-0.5
0
0.5
1
-1 -0.5 0 0.5 1
y
x
x
2
+ y
2
- 1 = 0
Para ponerle un ttulo a nuestro gr aco usaremos el comando title. Para mostrar un nombre en
los ejes disponemos de los comandos
15
xlabel e ylabel. Si queremos cambiar o introducir una
leyenda al gr aco, usaremos legend.
15
En dibujos en 3D disponemos tambi en del comando zlabel.
30
>>> x =2 : 0.01 : 2; plot(x, exp(x. 4), x, x. exp(x. 2), color, red);
>>> title(Mi grafico); xlabel(Eje x); ylabel(Eje y);
>>> legend(exp(x4), xexp(x2)); axis([2, 2, .5, 1.2])
-0.4
-0.2
0
0.2
0.4
0.6
0.8
1
1.2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
E
j
e

y
Eje x
Mi grfico
exp(-x
4
)
x*exp(-x
2
)
Para introducir cualquier cadena de texto en un gr aco usaremos text(pos
x
, pos
y
, texto),
donde pos
x
, pos
y
son las coordenadas del texto en el gr aco. Se puede cambiar el tama no
con la opci on fontsize. Existen m as par ametros opcionales disponibles, consultar el manual.
>>> text(1.1, 2, punto de inflexion, fontsize, 14)
Con subplot(fil, col, id) podemos crear varios gr acos dentro de una misma gura, donde
fil es el n umero de las, col el n umero de columnas, e id el ndice contando de izquierda a
derecha por las, empezando por arriba.
>>> x =1 : 1e2 : 1;
>>> subplot(2, 3, 1); plot(x, x. 2); subplot(2, 3, 2); plot(x, x. 3, color, red);
>>> subplot(2, 3, 3); plot(x, sin(pix), color, [0.6, 0.4, .8]);
>>> subplot(2, 3, 4); plot(x, x. sin(2pix), color, [0, .7, .5]);
>>> subplot(2, 3, 5); plot(x, exp(x). sin(2pix), color, [0.6, 0, .5]);
>>> subplot(2, 3, 6); plot(x, x. exp(x). sin(2pix), color, [1, 0.8, 0]);
-2
-1.5
-1
-0.5
0
0.5
-1 -0.5 0 0.5 1
-3
-2
-1
0
1
2
-1 -0.5 0 0.5 1
-0.8
-0.6
-0.4
-0.2
0
0.2
0.4
-1 -0.5 0 0.5 1
-1
-0.5
0
0.5
1
-1 -0.5 0 0.5 1
-1
-0.5
0
0.5
1
-1 -0.5 0 0.5 1
0
0.2
0.4
0.6
0.8
1
-1 -0.5 0 0.5 1
31
4.2 En el espacio: 3D
Para realizar gr acos en dos dimensiones con el comando plot, hemos creado un vector de puntos x
sobre los cuales calcul abamos el vector y = f(x). El comando plot se encargaba de unir los pares
(x(i), y(i)) por rectas. Para crear un gr aco en tres dimensiones haremos algo similar, pero el proceso
es ligeramente m as complicado. Ahora crearemos dos vectores de puntos x e y y calcularemos los pun-
tos 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

vector x
, 3 : 2 : 9

vector y
)
X =
3 2 1 0 1 2
3 2 1 0 1 2
3 2 1 0 1 2
3 2 1 0 1 2
Y =
3 3 3 3 3 3
5 5 5 5 5 5
7 7 7 7 7 7
9 9 9 9 9 9
La funci on meshgrid crea dos matrices, que en este ejemplo hemos llamado X e Y. En la primera
copia el vector x
/
por las tantas veces como elementos tiene el vector y. En la segunda, el vector y es
copiado por columnas tantas veces como las tiene el vector x. De este modo tendremos dos matrices X
e Y cuya dimensi on ser a length(y) length(x), y los elementos (X(i, j), Y(i, j)) formar an todas las
combinaciones posibles de pares de elementos del vector x y del vector y. S olo quedar a pues calcular
la matriz z = f(x, y) y as tendremos una nube de puntos en tres dimensiones:
>>> [X, Y] = meshgrid(2 : 0.1 : 2, 2 : 0.1 : 2); Z = X. exp(X. 2Y. 2);
A continuaci on mostramos los comandos m as utilizados.
La funci on mesh crea una rejilla en 3D con los valores de las matrices (X, Y, Z).
>>> mesh(X, Y, Z)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2 -0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
32
El comando hidden off convierte la rejilla en transparente. Para volverla opaca (por defecto)
introducir hidden on.
>>> mesh(X, Y, Z); hidden off;
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2 -0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
La variante meshc crea una rejilla en 3D con los valores de las matrices (X, Y, Z) y adem as muestra
en el plano xy las curvas de nivel de la funci on.
>>> meshc(X, Y, Z)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-1.5
-1
-0.5
0
0.5
Para crear un gr aco s olo con las curvas de nivel disponemos de los comandos contour, contourf
y contour3. El primero crea una gr aca en dos dimensiones con las curvas de nivel a partir de
las matrices (X,Y,Z):
>>> contour(X, Y, Z)
33
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
El comando contourf es similar, pero pinta las areas entre las curvas de nivel.
>>> contourf(X, Y, Z)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
Con contour3 crearemos un gr aco en 3D con las curvas de nivel, donde cada curva estar a a la
altura z que le correspondera en la gr aca.
>>> contour3(X, Y, Z)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2 -0.4
-0.3
-0.2
-0.1
0
0.1
0.2
0.3
0.4
34
Los comandos surf y surfc son similares a mesh y meshc. A diferencia de los ultimos, estos
colorean el interior de la rejilla.
>>> surf(X, Y, Z); axis([2, 2, 2, 2, 0.5, 0.5]);
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-0.4
-0.2
0
0.2
0.4
Con shading podemos controlar la apariencia de los pedazos o parches que componen una
supercie dibujada con surf. Disponemos de las opciones flat, faceted e interp. Por defecto
se representan las supercies con la opci on faceted, que dibuja los bordes de los pedazos.
Introduciendo shading flat conseguiremos eliminar estos bordes. La opci on interp, interpola
el color entre los distintos parches y hace invisible los v ertices, dando la apariencia de una curva
suave sin bordes.
>>> shading flat
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-0.4
-0.2
0
0.2
0.4
35
>>> shading interp
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-0.4
-0.2
0
0.2
0.4
Es posible cambiar los colores usados en los gr acos con el comando colormap A, donde A es
una matriz con 3 columnas correspondientes a los matices RGB de cada color (la). Podemos
crear una matriz de colores A o bien usar una de las predenidas: autumn, bone, cool, copper,
flag, gray, hot, hsv, jet, ocean, pink, prism, rainbow, spring, summer, white, winter.
Se puede restablecer la conguraci on por defecto (jet) introduciendo colormap default.
>>> [X, Y] = meshgrid(3pi : 0.5 : 3pi, 3pi : 0.5 : 3pi);
>>> Z = sin(sqrt(X. 2+Y. 2))./sqrt(X. 2+Y. 2);
>>> surf(X, Y, Z); colormap cool;
-10
-5
0
5
10
-10
-5
0
5
10 -0.4
-0.2
0
0.2
0.4
0.6
0.8
1
El comando plot3 nos permite dibujar curvas param etricas en el espacio. Dados tres vectores
(x,y,z), dibuja una lnea que une sucesivamente los puntos: (x(1), y(1), z(1)) con (x(2), y(2), z(2)),
36
(x(2), y(2), z(2)) con (x(3), y(3), z(3)), etc. Para dibujar la curva param etrica x =f(t), y =g(t), z =
t, s olo tendremos pues que crear un vector de valores t y a partir de el los vectores x = f(t) e y = g(t),
y nalmente representar los puntos con plot3(x, y, t).
>>> t = linspace(0, 2pi, 1000); x = 5cos(5t); y = 5sin(5t);
>>> plot3(x, y, t);
-6
-4
-2
0
2
4
6
-6
-4
-2
0
2
4
6 0
1
2
3
4
5
6
7
Para realizar dibujos en el plano disponamos del comando ezplot con el cual se puede representar
una funci on sin tener que denir previamente un conjunto de puntos. En el espacio disponemos tambi en
de comandos similares:
ezplot3 dibuja una curva denida de forma param etrica mediante funciones.
>>> ezplot3(tcos(t), tsin(t), t, [0, 10pi], 1000);
x = tcos(t),y = tsin(t), z = t
-30
-20
-10
0
10
20
30
40
x
-30
-20
-10
0
10
20
30
y
0
5
10
15
20
25
30
35
ezmesh dibuja una rejilla de una funci on.
>>> f = @(x, y) sqrt(abs(x. y))./(1+x. 2+y. 2); ezmesh(f, [3, 3]);
37
sqrt (abs (x y)) / (1 + x
2
+ y
2
)
-3
-2
-1
0
1
2
3
x
-3
-2
-1
0
1
2
3
y
0
0.05
0.1
0.15
0.2
0.25
0.3
0.35
0.4
Pas andole tres funciones de dos variables al comando ezmesh conseguimos que realize un dibujo
de la funci on param etrica (f
x
(s, t), f
y
(s, t), f
z
(s, t)):
>>> fx = @(s, t) cos(s). cos(t); fy = @(s, t) sin(s). cos(t); fz = @(s, t) sin(t);
>>> ezmesh(fx, fy, fz, [pi, pi, pi/2, pi/2], 20);
x = cos (s) cos (t),y = sin (s) cos (t), z = sin (t)
-1
-0.5
0
0.5
1
s
-1
-0.5
0
0.5
1
t
-1
-0.5
0
0.5
1
ezsurf se comporta como ezmesh pero pintando el interior de la rejilla:
>>> ezsurf(fx, fy, fz, [pi, pi, pi/2, pi/2], 20);
-1
-0.5
0
0.5
1
-1
-0.5
0
0.5
1 -1
-0.5
0
0.5
1
x = cos (s) cos (t),y = sin (s) cos (t), z = sin (t)
s
t
38
ezcontour dibuja las curvas de nivel de una funci on.
>>> ezcontour(sqrt(abs(x. y))./(1+x. 2+y. 2), [2, 2], 200)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
y
x
sqrt(abs(x y)) / (1 + x
2
+ y
2
)
En el ejemplo anterior, el intervalo [2, 2] son los valores mnimo y m aximo de ambos ejes, y
200 es el n umero de puntos. La variante ezcontourf pinta las areas entre las curvas de nivel:
>>> ezcontourf(sqrt(abs(x. y))./(1+x. 2+y. 2), [2, 2], 200)
y
x
sqrt(abs(x y)) / (1 + x
2
+ y
2
)
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
39
5 Cargar y guardar datos en archivos
5.1 Datos num ericos y funciones
Los comandos save y load permiten, respectivamente, guardar y cargar datos en Octave de forma f acil.
Con save podemos guardar variables, matrices y funciones; datos que podremos recuperar posterior-
mente con load durante otra sesi on sin necesidad de tener que introducirlos o calcularlos de nuevo. La
sintaxis del comando save es (la de load es similar):
save nombre.extensi on dato 1 dato 2 . . . dato n
donde nombre es el nombre del chero a guardar, extensi on es la extensi on del chero (por ejemplo
txt), y dato 1 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 no 44 con n umeros enteros entre 0 y 9, y una funci on f. Guardaremos en el chero datos.txt
la matriz A, la funci on f y la matriz f(A). Para almacenar f(A) debemos asignar su valor a una variable
(matriz) B.
>>> A = floor(rand(4) 10); f = @(x) x. sin(x. 2); B = f(A);
>>> save datos.txt A f B
La funci on save crear a un chero llamado datos.txt en el directorio donde estemos trabajando. El
contenido de este chero ser a semejante a:
# Created by Octave 3.2.4, Sat Dec 18 19:16:44 2010 Hora estandar romance <unknown@unknown>
# name: A
# type: matrix
# rows: 4
# columns: 4
6 8 0 7
6 6 3 9
5 7 2 9
6 9 2 5
# name: f
# type: function handle
@<anonymous>
@(x) x .
*
sin (x . 2)
# length: 2
# name: .nargin.
# type: scalar
1
# name: .nargout.
# type: scalar
1
# name: B
# type: matrix
# rows: 4
# columns: 4
-5.950673120658695 7.360208305574325 0 -6.676268569316303
-5.950673120658695 -5.950673120658695 1.23635545572527 -5.668991948470085
-0.6617587504888651 -6.676268569316303 -1.513604990615856 -5.668991948470085
-5.950673120658695 -5.668991948470085 -1.513604990615856 -0.6617587504888651
En una sesi on posterior podramos cargar todos estos datos (o s olo algunos, en cuyo caso debemos
especicar cu ales tras el nombre del chero):
>>> load datos.txt
5.2 Gr acos
Es posible guardar la gura actual (el gr aco) en un archivo mediante el comando print. Admite
multitud de formatos en los que almacenar la imagen; entre ellos los m as usuales son pdf, eps y jpg. La
opci on para especicar el formato es d seguido del formato en el que queremos guardar la imagen.
As, los tres formatos anteriores seran dpdf, depsc y djpg (usaremos depsc para que
guarde la gura en color, ya que la opci on deps lo hace en escala de grises). A la hora de incrustar
un gr aco en un documento de L
A
T
E
Xes preferible usar archivos pdf o eps, ya que son m as peque nos y
40
ofrecen una calidad mucho mayor
16
. El comando plot admite otras opciones, v ease la ayuda.
El resultado puede no ser muy satisfactorio en el caso de cheros eps y pdf, principalmente porque
el tama no del texto de los gr acos aparece muy peque no. Adem as suele dejar bastante espacio en blanco
alrededor del gr aco, por lo que al incluirlo en un documento L
A
T
E
X no queda ajustado al texto. Para
evitar estos problemas, es aconsejable usar las siguientes funciones:
function eps(nombre)
papersize=[30,21]/9;
set(gcf,"papersize",papersize);
set(gcf,"paperposition",[0,0,papersize]);
print("-depsc", strcat(nombre,".eps"))
endfunction
function pdf(nombre)
set(gcf,"paperorientation","landscape");
papersize=[30,21]/2.54;
set(gcf,"papersize",papersize);
set(gcf,"paperposition",[0,0,papersize]);
print(strcat(nombre,".pdf"))
endfunction
Guardando cada funci on en un archivo .m (la primera en eps.m y la segunda en pdf.m) dentro
del directorio de trabajo, resultar a muy sencillo crear documentos eps y pdf adecuados. S olo tendremos
que introducir uno de los siguientes comandos
>>> eps(nombre)
>>> pdf(nombre)
donde nombre es el nombre con el que queremos guardar el gr aco sin la extensi on (las funciones
anteriores se encargan de introducirla).
5.3 Im agenes
Una imagen digitalizada es, b asicamente, un conjunto de tres matrices de datos correspondientes a la
intensidad de cada componente RGB (rojo, verde y azul; del ingl es Red, Green, Blue) de cada pxel
de la imagen
17
. En Octave es posible utilizar 256 intensidades distintas de cada uno de estos colores,
lo que proporciona un total de casi 16,8 millones de colores distintos
18
. Por tanto cualquier imagen
quedar a determinada al especicar qu e cantidad de cada uno de estos colores se debe utilizar en cada
uno de los pxeles que la forman. Necesitaramos 8 bits para almacenar la informaci on de la intensidad
de cada color RGB en cada pxel, lo cual requerira unos archivos de gran tama no para albergar toda esta
informaci on. Es por eso que normalmente las im agenes se encuentran comprimidas, siendo el formato
m as usual en la actualidad el jpg.
Con Octave es muy f acil obtener la informaci on de una imagen en una matriz mediante el comando
imread, el cual es capaz de leer multitud de formatos. Su sintaxis es
hip mat = imread(nombre archivo)
donde hip mat es la hipermatriz
19
en la que queramos guardar los datos de la imagen. Por ejemplo:
16
Los archivos pdf y eps guardan la informaci on del gr aco de forma vectorial en vez de convertirlo a un mapa de pxeles
como hacen los jpg (en los cuales adem as se pierde calidad al comprimirse la informaci on).
17
Cualquier color se puede obtener como la composici on de los colores primarios rojo, verde y azul.
18
256
3
= 16.777.216 16, 8 millones de colores.
19
Las hipermatrices son una generalizaci on del concepto de matriz. Una matriz tiene dos dimensiones: las (dimensi on 1)
y columnas (dimensi on 2). Una hipermatriz de 3 dimensiones de tama no mnk podramos imaginarla en el espacio como
un cubo, y estara formada for k matrices de tama no mn. Octave permite trabajar con hipermatrices de cualquier dimensi on,
no s olo 3.
41
>>> A = imread(Irlanda.jpg);
La imagen Irlanda.jpg tiene un tama no 600 800, por lo que la hipermatriz A tendr a un tama no
6008003 (tendremos 3 matrices A(:, :, 1), A(:, :, 2) y A(:, :, 3) de tama no 600800, una para cada
color).
Para mostrar im agenes en pantalla podemos usar dos comandos: imshow e image. Su compor-
tamiento es bastante similar, aunque imshow tiene la ventaja de no mostrar los ejes y de poder mostrar
im agenes en blanco y negro (las cuales son bidimensionales).
>>> imshow(A);
Si quisi eramos guardar la imagen anterior (por ejemplo, tras modicarla o editarla) en un archivo
de imagen, usaremos el comando imwrite:
>>> imwrite(A, Irlanda2.jpg)
La sentencia anterior nos creara un nuevo archivo llamado Irlanda2.jpg que contendra la imagen
almacenada en la hipermatriz A.
42
6 Ejemplos pr acticos
En esta secci on veremos algunos algoritmos sencillos: un m etodo bastante rudimentario para c alculo el
c alculo aproximado de , un algoritmo que nos facilite la divisi on de una cantidad dada en billetes y
monedas, la edici on de una imagen cualquiera, y el m etodo del trapecio para la integraci on aproximada
de una funci on en un intervalo dado.
6.1 C alculo aproximado de
Vamos a ver como ejemplo un m etodo bastante simple para el c alculo aproximado de . La idea es
la siguiente: si dibujamos un crculo inscrito en un cuadrado de lado unitario (pongamos un metro) y
lanzamos granos de arroz al aire, de forma aleatoria, contando los granos que caigan dentro del crculo y
dividi endolo por el n umero total de granos que haya cado dentro del cuadrado nos dar a una estimaci on
del area del crculo; que en este caso sera /4.
Ahora bien, c omo podemos crear un algoritmo que realice este experimento por nosotros? Comence-
mos por facilitar el an alisis a nadiendo unos ejes de coordenadas al dibujo anterior, haci endolo m as
grande (con el crculo de radio 1, en vez de 1/2) y dibujando s olo un cuarto de circunferencia. Podemos
representar un grano de arroz por un punto (x, y) [0, 1] [0, 1]. Para saber si el grano est a dentro del
crculo, s olo tendremos que calcular su distancia al origen y ver si es menor o igual que 1:
0
0.2
0.4
0.6
0.8
1
0 0.2 0.4 0.6 0.8 1
(x,y)
43
Para tirar aleatoriamente los granos de arroz usaremos el comando rand. Vamos a ver dos algoritmos
distintos para resolver el problema: en el primero lanzaremos n granos de arena y contaremos los
que hay dentro; en el segundo, lanzaremos un grano y repetiremos el experimento n veces. Podemos
tirar n granos de arroz con el comando rand(2, n), el cual nos construye una matriz aleatoria 2 n
donde cada columna representar a un grano de arroz. Para calcular la distancia al origen de cada grano
(x, y) necesitamos calcular

x
2
+y
2
y contar los que su distancia sea menor o igual que 1. Podemos
ahorrarnos calcular La raz cuadrada, pues

x
2
+y
2
1 x
2
+y
2
1.
El c alculo de cada componente x e y al cuadrado lo obtenemos con rand(2, n). 2. Con el comando
sum obtenemos la suma por columnas: sum(rand(2, n). 2). A nadimos ahora la condici on <= 1 y
sumamos para contar as el n umero de granos que cayeron dentro, esto es, sum(sum(rand(2, n). 2) <= 1).
Para obtener una aproximaci on de , como el area del cuarto de crculo en la gura anterior es /4,
s olo tendremos que multiplicar por 4 el n umero de granos que cayeron dentro y dividirlo por el n umero
total de granos lanzados n. Denimos una funci on con todo ello:
>>> aprox pi = @(n)4sum(sum(rand(2, n). 2) <= 1)/n;
>>> aprox pi(1000)
ans = 3.1200
>>> aprox pi(1e7)
ans = 3.1410
Observamos que el m etodo no es muy preciso. Adem as, si intentamos repetir el experimento con n muy
grande vamos a tener problemas de memoria:
>>> aprox pi(1e8)
>>> error : memory exhausted or requested size too large for range of Octave
/
s in
dex type trying to return to prompt
Esto ocurre porque estamos creando y almacenando en memoria una matriz extremadamente grande.
Podemos evitar este error considerando un algoritmo que en vez de lanzar todos los granos a la vez,
lo haga de uno en uno y repita el proceso n veces, usando para ello un bucle for:
function p=aprox_pi(n)
p=0;
for k=1:n
p=p+(sum(rand(2,1).2)<=1);
endfor
p=4
*
p/n;
endfunction
Este algoritmo podremos ejecutarlo con un tama no n tan grande como queramos, aunque es bastante
m as lento que el anterior. S olo ser a cuesti on de tiempo obtener el resultado...
>>> tic; aprox pi(1e7); toc
Elapsed time is 380.1 seconds.
Quiz as lo m as eciente para el c alculo aproximado de por este m etodo rudimentario sea una mezcla
de ambos algoritmos.
6.2 Billetes y monedas
Imaginemos que queremos construir un algoritmo para un banco o una tienda, de modo que dada una
cantidad, nos la descomponga en billetes de 500, 200, 100, 50, 20 y 5 y en monedas de 2, 1, 0.50, 0.20,
0.10, 0.05, 0.02 y 0.01. El objetivo es utilizar el menor n umero de billetes y monedas posible, por lo que
la soluci on devolver todo en c entimos no sera v alida. El siguiente algoritmo construye una funci on
que realiza tal descomposici on.
44
function desc(c)
printf("\n%.2f EUR pueden descomponerse en:\n\n",c)
c=c
*
100; %Transformamos la cantidad a centimos para evitar errores de redondeo
V=[50000,20000,10000,5000,2000,1000,500,200,100,50,20,10,5,2,1];
for k=1:length(V)
numero=fix(c/V(k));
if numero>0
if k<8
texto1="billete";
else
texto1="moneda";
endif
if k<10
texto2="euros";
valor=num2str(V(k)/100);
elseif k<15 %Distinguimos la moneda de 1 centimo (evita "1 centimos")
texto2="centimos";
valor=num2str(V(k));
else
texto2="centimo";
valor=num2str(V(k));
endif
if numero>1
texto1=[texto1,"s"]; %Agregamos una s en caso de que sean varios
endif
printf("%d %s de %s %s\n",numero,texto1,valor,texto2)
c=round(rem(c,V(k))); %Redondeamos el resto (evita errores de aproximacion)
endif
endfor
endfunction
>>> desc(1927.48)
1927.48 EUR pueden descomponerse en :
3 billetes de 500 euros
2 billetes de 200 euros
1 billete de 20 euros
1 billete de 5 euros
1 moneda de 2 euros
2 monedas de 20 centimos
1 moneda de 5 centimos
1 moneda de 2 centimos
1 moneda de 1 centimo
6.3 Edici on de una imagen
En este ejemplo vamos a manipular una imagen de una ardilla. Antes que nada es importante entender
c omo es guardada una imagen en formato digital (v ease la Secci on 5.3). Mostramos que con Octave es
muy sencillo cargar la informaci on de una imagen en una matriz mediante imread(NombreArchivo).
Veamos un ejemplo de una ardilla, guardada en el archivo squirrel.jpg.
>>> A = imread(squirrel.jpg);
>>> size(A)
ans =
300 400 3
45
Vemos que se trata de una imagen de 300 pixels de alto por 400 pixels de ancho. La tercera dimensi on
corresponde a cada color RGB. Mostramos la imagen con imshow:
>>> imshow(A)
La matriz tridimensional A contiene n umeros enteros entre 0 y 255. Si dividimos A entre 2, conseguire-
mos oscurecer la imagen, ya que el valor de cada color ser a proporcionalmente m as bajo:
>>> imshow(A/2)
Multiplicando por 2 conseguiramos el efecto contrario. Es f acil conseguir un negativo de la imagen:
s olo tendremos que restar 255 a cada color de la matriz A para obtener el color complementario.
>>> imshow(255A)
46
El siguiente c odigo voltea la imagen horizontalmente guard andola en una matriz B :
[m,n,colores]=size(A);
for k=1:n
B(:,k,:)=A(:,n+1-k,:);
endfor
imshow(B)
Para voltearla verticalmente s olo tendramos que modicar ligeramente el c odigo anterior:
[m,n,colores]=size(A);
for k=1:m
B(k,:,:)=A(n+1-k,:,:);
endfor
imshow(B)
6.4 M etodo del trapecio
Se trata de un m etodo num erico de integraci on (por tanto aproximado) de una funci on dada f : RRen
un intervalo [a, b]. La idea no es muy complicada: la integral ( area) de f puede aproximarse dividiendo
47
el intervalo [a, b] en n subintervalos y calculando una aproximaci on de la integral en cada uno de estos
subintervalos mediante el area de un trapecio.
b a x
k
x
k+1
f
Cada subintervalo tiene longitud (ba)/n, por lo que el area de cada uno de estos trapecios vale
f (x
k
) + f (x
k+1
)
2

ba
n
,
donde x
k
y x
k+1
son dos puntos adyacentes.
f(x
k+1
)
f(x
k
)
(b-a)/n
A continuaci on mostramos un posible algoritmo que adem as de calcular la integral, ofrece la posi-
bilidad de dibujar la gr aca.
function suma=trapecio(f,a,b,n=1000,graf="n")
%Por defecto divide [a,b] en 1000 subintervalos y no dibuja
L=(b-a)/n;
x0=a;suma=0;
x=a;fx=f(x);
for k=1:n
x1=x0+L;
x=[x,x1];
fx=[fx,f(x1)];
% Usaremos los valores almacenados en el vector fx para ahorrar calculos
suma=suma+(fx(k)+fx(k+1))/2
*
L;
x0=x1;
endfor
if graf=="s"
xx=linspace(a,b,1000);
clf;hold on;
area(x,fx,facecolor,[0,0.5,1]);
48
plot(xx,f(xx),r,linewidth,3);
for k=1:n
plot([x(k),x(k)],[0,fx(k)],k)
endfor
endif
endfunction
>>> trapecio(@(x)x. 3, 1, 1, 8, s)
ans = 0
-1
-0.5
0
0.5
1
-1 -0.5 0 0.5 1
49

Indice de comandos
abs, 3
acos, 3
all, 10
any, 11
area, 27
asin, 3
atan, 3
axis, 28
box, 29
break, 19
cd, 22
ceil, 14
char, 12
clear, 4
clf, 28
clock, 14
close, 28
colormap, 36
continue, 19
contour, 33
contour3, 33
contourf, 33
cos, 3
det, 8
diag, 7
disp, 13
do. . . until, 18
eig, 9
else, 16
elseif, 16
end, 6
exp, 3
eye, 7
ezcontour, 39
ezcontourf, 39
ezmesh, 37
ezplot, 30
ezplot3, 37
ezsurf, 38
factor, 15
gure, 28
x, 14
oor, 14
format, 3
fplot, 29
function, 22
grid, 29
hidden, 33
hold, 28
if, 16
image, 42
imread, 41, 45
imshow, 42, 46
imwrite, 42
index, 12
inline, 21
input, 13
inv, 8
legend, 30
length, 5
linspace, 5, 26
load, 40
log, 3
max, 23
mesh, 32
meshc, 33
meshgrid, 32
nargin, 24
nargout, 24
norm, 10
num2str, 12
ones, 7
path, 22
pie, 28
plot, 25
color, 25
linewidth, 25
markersize, 26
plot3, 36
polar, 28
poly, 9
print, 40
printf, 13
prod, 14
rand, 6, 40, 44
rem, 14
return, 24
round, 14
save, 40
shading, 35
sin, 3
size, 6
sqrt, 3
str2num, 12
subplot, 31
sum, 14
surf, 35
surfc, 35
switch, 19
tan, 3
text, 31
tic, 15
time, 14
title, 30
toc, 15
tril, 9
triu, 9
try. . . catch, 20
vectorize, 22
while, 18
who, 14
whos, 14
xlabel, 30
ylabel, 30
zeros, 7
zlabel, 30
50