Tema 1: Nociones bsicas sobre IDL a

Para entrar en IDL (Interactive Data Language) 1 desde la l nea de comandos debe ejecutarse idl o bien idlde (IDL Development Environment). En estas notas supondremos que entramos tecleando idl pero si preeres usar la otra opcin ser todo muy similar. Si todo va bien, al entrar debe aparecer o a nalmente la l nea de comandos siguiente: IDL> IDL posee ayuda dentro de su propio entorno que se obtiene escribiendo: IDL>? No dudes en consultarla cuando sea necesario. Para salir ejecutamos el comando: IDL>exit IDL puede usarse ejecutando programas previamente escritos (lo habitual en cuanto tengamos algo relativamente complicado que programar) o bien directamente, a travs de la l e nea de comandos. En este primer tema aprenderemos algunas nociones bsicas usando la l a nea de comandos directamente.

1.
bir:

Forma de los comandos

Para mostrar por pantalla el resultado de una operacin podemos escrio

IDL> print,3.1*5.1234 15.8825 Aqu print es el nombre del comando (llamado en IDL procedure, proce dimiento). Cada comando va siempre seguido de una coma (,). Finalmente 3.1*5.1234 (3.1 multiplicado por 5.1234) es el argumento. Cuando tengamos ms de un argumento los separamos mediante comas: a
IDL requiere de una licencia comercial. Existe una versin libre compatible (aunque o no 100 %) que funciona bajo LINUX: GDL - GNU Data Language. Puedes descargarla de: http://gnudatalanguage.sourceforge.net/
1

IDL> print,10^4,cos(0.) 10000 1.00000 Los comandos admiten tambin opciones denominadas keywords (palae bras claves). La forma general que tienen es: procedure,argumento_1,...,keyword_1=opcin,... o En los ejemplos anteriores puede especicarse el formato de salida mediante la opcin format. Si escribimos: o IDL> print,3.1*5.1234,format=(f7.3) 15.883 forzamos a que nos muestre el resultado del producto como un n mero real u (f) de 7 caracteres (5 d gitos ms el punto ms el signo menos si lo hubiera a a habido) con 3 decimales. Si usamos el formato (f20.16) veremos que nos aparecen 16 decimales aunque eso no signica que el resultado tenga esa precisin; en ning n caso debemos confundir la presentacin (que es lo que o u o nos da la opcin format) con la precisin del clculo. o o a Ejercicio 1. Considera la operacin: o

IDL> print,5./3. 1.66667 Cuntos decimales signicativos tiene el resultado? 2 a Otra forma usual de escribir el resultado es con potencias de diez. El formato es similar al anterior pero con e en lugar de f. Por ejemplo si escribimos: IDL> print,3.1*5.1234,format=(e11.4) 1.5883e+01 vemos que el resultado (1.5883 101 ), quince y pico, aparece con 4 decimales. El n mero 11 representa el n mero total de caracteres que contiene el resulu u tado, a saber: el signo inicial (en este caso al ser un + deja un blanco), el d gito antes del punto, el propio punto, los cuatro decimales, la letra e (que signica diez elevado a), el signo del exponente (en este caso un +) y los dos d gitos del exponente. Es decir 7 caracteres ms el n mero de decimales. a u Como regla general podemos usar 8+n mero de decimales que queramos (en u doble precisin el exponente puede tener tres d o gitos).
2

Puedes consultar la respuesta a los ejercicios al nal del documento.

2.

Variables

La forma ms sencilla de crear una variable es asignndole un valor. Por a a ejemplo, si escribimos: IDL> a=3*5 habremos creado la variable A (no se distingue entre may sculas y min scuu u las) y asignado el valor 3 5. Podemos usar cualquier combinacin de letras y n meros para los nomo u bres de las variables (tambin se admite el sub e ndice y el $) pero siempre deben empezar por una letra. Por ejemplo son vlidas las variables: mas, a a vec, a1, velo2, x 1, x$a. No es vlida 3b. Las variables tienen dos atributos importantes: 1. Tipo de datos. La variable A anterior es de tipo INTEGER (entero). Tambin pueden ser de tipo real, doble precisin, complejo, etc. e o 2. Tipo de estructura. La variable A anterior es un escalar. Hay tambin e vectores, arrays n x m (matrices), etc. En cada momento podemos ver el tipo de variable y estructura (en el caso de los escalares su valor) mediante el comando help. Por ejemplo: IDL> help,a A INT = 15

Las variables pueden cambiar sus atributos como consecuencia de una operacin. Por ejemplo si hacemos: o IDL> a=sqrt(a) IDL> help,a A

FLOAT

3.87298

vemos que la variable A pasa a ser un n mero de tipo FLOAT (oating point u number o n mero con coma otante) correspondiente a los n meros reales de u u menor precisin en IDL, concretamente entre 6 y 7 decimales signicativos. o Las operaciones anteriores pueden escribirse en una sola l nea usando el s mbolo &: IDL> a=3*5 & A a=sqrt(a) & help,a FLOAT =

3.87298

En otros lenguajes de programacin que probablemente conozcas las vao riables se denen una vez, digamos al principio del programa, y luego siempre son del mismo tipo (las variables enteras pueden cambiar su valor pero siempre sern enteras, etc.). En IDL no. El hecho de que las variables se denan a de forma dinmica tiene sus ventajas: en el ejemplo anterior se calcula la a 3

ra cuadrada de un n mero como se hace usualmente y en consecuencia z u se transforma en real. Pero es importante no olvidarse de las desventajas, en concreto podemos terminar pensando que siempre va a funcionar como intuitivamente esperamos y hay excepciones. En este otro ejemplo: IDL> a=1 & b=3 IDL> print,a/b 0 1/3=0! La divisin de dos n meros enteros es la parte entera del cociente. o u Era eso lo que quer amos? posiblemente no. Si alguno de los n meros de un u cociente es real el resultado es un n mero real. As en el ejemplo anterior, u , si no queremos que tome slo la parte entera podemos escribir: o IDL> a=1. & b=3. IDL> print, a/b 0.33333 ;ahora, al a~adir el punto, A y B son reales. n

Hemos usado el punto y coma (;) para indicar que lo que sigue es un comentario. Puede estar al principio de la l nea o despus de un comando. Al e programar, los comentarios son muy importantes. Ms problemas con los INTEGER: En IDL por defecto estos son de 2 a bytes: los n meros positivos llegan hasta el 32767. Si nos pasamos ocurre u esto: IDL> ent=32760 IDL> i=ent+10 & print,i -32766 Con un disparate como este es muy posible que el programa termine por abortar y podamos darnos cuenta del error. No es tan infrecuente pasarnos de 32767, por ejemplo si la variable corresponde al n mero de datos de un u chero. As que en muchos casos puede ser una buena idea introducir un LONG INTEGER: IDL> ent=32760L ;la L del final distingue este tipo de enteros IDL> i=ent+10 & print,i ;10L estara bien igualmente 32770 IDL> help,i I LONG = 32770 Los n meros en doble precisin (14 decimales signicativos aproximadau o mente) pueden introducirse de una forma similar, en este caso a adiendo la n letra d: IDL> print,5.d/3.d,format=(f17.14) 1.66666666666667 4

que puede compararse con el resultado del primer ejercicio que se encuentra al nal del documento. Igual que usamos el comando & para poner dos sentencias en la misma l nea, podemos usar el signo $ para continuar un comando en la siguiente l nea: IDL> b=1+2-2+$ IDL> 4 IDL> print,b 5 Como indicamos en su momento, el comando $ se puede usar tambin como e parte del nombre de una variable (por ejemplo var$1); slo si est al nal o a de la l nea y va despus de un operador o similar (consulta la ayuda, ?$, e para ms detalles) indica continuacin de l a o nea. Si lo pones al principio de la l nea de comandos vers que te env al intrprete de UNIX/LINUX, sin a a e cerrar la sesin de IDL. Puedes volver a la sesin de IDL con el comando o o exit.

3.

Vectores

La forma mas sencilla (pero no la ms frecuente) de crear un vector o a array de una dimensin es escribiendo sus elementos entre corchetes: 3 o IDL> v=[1,2,4,2] IDL> help,v V INT

= Array[4]

Aqu INT quiere decir que V es una variable de tipo INTEGER mientras que Array[4] nos indica que es un array con cuatro componentes. En IDL muchos operadores y funciones trabajan directamente sobre arrays. Muchas veces el resultado es el que intuitivamente era de esperar: en el ejemplo que sigue sumamos a un vector, 2*v, un escalar, 1, entendiendo que lo que se quiere es sumar el escalar a cada uno de los elementos del vector. IDL> w=2*v+1 IDL> print,v,w 1 2 3 5
3

4 9

2 5

En las versiones antiguas de IDL (anteriores a la 5.0) se usaban los parntesis en e lugar de los corchetes para indicar los elementos de un array. Por compatibilidad, en las nuevas versiones esto sigue funcionando. Sin embargo, dado que los parntesis se usan e para indicar los argumentos de las funciones -sqrt(a), cos(a)- esto puede prestarse a confusin en particular cuando una funcin y un array poseen el mismo nombre. Por ello o o no es recomendable usar parntesis para indicar componentes de arrays aunque sea una e prctica muy extendida. a

La suma, el producto y la divisin entre dos vectores corresponde reso pectivamente a la suma, el producto y la divisin entre componentes: o IDL> z=v+w IDL> print,z 4 7 13 7 IDL> v1=[1.5,2.1,3.2] & v2=[3.0,4.2,6.5] IDL> p=v1*v2 & print,p 4.50000 8.82000 20.8000 IDL> d=v1/v2 & print,d 0.500000 0.500000 0.492308

3.1.

Sub ndices

Aunque la velocidad de clculo es muy superior si se trabaja con todos a los elementos de un array a la vez, esto no siempre es posible o deseable. Consideremos el vector: IDL> t=[1,2,3,4,5] Para identicar un elemento usamos la notacin t[i], siendo i el o ndice buscado (que es de tipo INTEGER o en su caso LONG). Como ejemplo si escribimos: IDL> print,t[1] 2 vemos que t[1] es el segundo elemento del vector t. El primero es t[0]. Por otra parte, podemos manejar un conjunto seguido de elementos usando los dos puntos. Por ejemplo: IDL> print,t[0:2] 1 2 3

corresponde a los elementos de t del 0 al 2. Conviene recordar que las variables pueden cambiar sus atributos, incluidas sus dimensiones, mediante una operacin. Por ejemplo, para a adir o n un elemento al nal del vector t escribimos: IDL> t=[t,6] & print,t 1 2 3 4 5 6

y si ahora queremos a adir un 7 como tercer elemento: n IDL> t=[t[0:1],7,t[2:5]] & print,t 1 2 7 3 4 5 6

Consideremos por ultimo algunas funciones bsicas que nos permiten a crear vectores de forma sencilla (usamos los comandos help y print para ver lo que hacen estas funciones): IDL> v1=findgen(4) & print,v1 0.00000 1.00000 2.00000 3.00000 IDL> v2=indgen(4) & print,v2 0 1 2 3 IDL> help,v1,v2 V1 FLOAT = Array[4] V2 INT = Array[4] IDL> v3=fltarr(4) & print,v3 0.00000 0.00000 0.00000 0.00000 IDL> v4=dblarr(4) & print,v4 0.0000000 0.0000000 0.0000000 0.0000000 IDL> help,v3,v4 V3 FLOAT = Array[4] V4 DOUBLE = Array[4] Cuando necesites una descripcin completa de las funciones que acabamos o de introducir usa la ayuda (por ejemplo ?findgen). Por otra parte recuerda que la precisin de los n meros FLOAT y DOUBLE (unos 7 decimales el o u primero y unos 14 el segundo) no se corresponde con los que nos muestra el compando print por defecto. Ejercicio 2. Crea un vector de 1000 elementos que cubra uniformemente el intervalo [0, 2.5]. A continuacin qu o tale los datos 344 y 567.

4.

Arrays de dos dimensiones

Podemos crear un array 3 x 2 (3 las x 2 columnas) escribindolo colume na a columna, de la siguiente forma: IDL> ar=[[1,2,3],[4,5,6]] IDL> help,ar AR INT = Array[3, 2] Vemos que efectivamente se trata de una matriz 3 x 2. Para listarla por pantalla ponemos la transpuesta porque IDL escribe lo que convencionalmente se llaman las y columnas al revs: e IDL> print,transpose(ar) 1 4 2 5 3 6 7

Veamos como operar con arrrays. Para ello creamos dos matrices cuadradas a modo de ejemplo. La primera de la siguiente forma: IDL> a=findgen(9) IDL> a1=reform(a,3,3) IDL> help,a,a1 A FLOAT A1 FLOAT

= Array[9] = Array[3, 3]

La funcin reform(a,m,n) nos transforma el vector A en un array de m las o x n columnas. Para la segunda matriz tomamos la transpuesta: IDL> a2=transpose(a1) Probamos a sumar, multiplicar y dividir los dos arrays (los resultados del print estn quitados pues son demasiado largos): a IDL> IDL> IDL> IDL> IDL> print,a1 print,a2 b1=a1+a2 & print,b1 b1=a1*a2 & print,b2 b3=a1/(a2+1.) & print,b3

Vemos que se suma, multiplica y divide elemento a elemento. Estas son operaciones que nos interesar hacer frecuentemente. Cuidado con no confundir a la multiplicacin elemento a elemento con la multiplicacin de matrices; para o o obtener esta ultima debemos poner: IDL> b4=a1#a2 Usa el comando print, transpose(b4) para comprobar que obtienes lo esperado.

4.1.

Sub ndices

Supongamos que tenemos una matriz AR cuyos elementos se van conociendo secuencialmente. Por ejemplo supongamos que por el momento slo o sabemos que ar[1,2]=3.5. Entonces para poder asignar un valor a uno slo o de los elementos del array es necesario tener denida la matriz previamente. Una forma sencilla de conseguirlo es haciendo inicialmente cero todos sus elementos. As escribir amos (recuerda la funcin fltarr): o IDL> ar=fltarr(2,4) IDL> ar[1,2]=3.5 ;empezando por cero: fila 1, columna 2 IDL> print,transpose(ar) 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 3.50000 0.00000 8

Nuevamente listamos la transpuesta para que se visualice con la apariencia estndar. a Es importante recalcar que slo cuando asignamos el resultado de una o operacin a uno o a un conjunto de elementos de un array (es decir cuando o en el miembro izquierdo de una igualdad ponemos la variable con corchetes) es necesario tenerlo denida previamente. Por el contrario, las matrices b1, b2, b3 y b4 anteriores las introdujimos directamente pues trabajbamos con a todos sus elementos a la vez. Una de las cosas que cuesta ms acostumbrarse en IDL (y en otros lena guajes de caracter sticas similares) es a operar con trozos de un array. A modo de ejemplo supongamos que tenemos una serie de datos que representan distintas magnitudes (temperatura, presin, densidad). Como por o el momento no sabemos como leer cheros de datos, vamos a crear unos n meros aleatorios que hagan las veces de datos: u IDL>data=randomu(seed,300) La funcin randomu devuelve n meros aleatorios uniformemente distribuio u dos en el intervalo (0,1). Para conseguir el resultado deseado la variable que hemos llamado seed puede ser en realidad cualquier variable no denida previamente. Consulta la ayuda para completar la informacin. Supongao mos que estos n meros representan los datos indicados anteriormente. Por u tanto tenemos datos de temperatura, presin y densidad agrupados en 100 o instantes de tiempo distintos. En concreto supondremos que la temperatura, presin y densidad en el instante inicial corresponde a los tres primeros o datos del vector:4 IDL> print,data[0:2] 0.957516 0.740806 0.483755

Los siguientes 3 datos, data[3:5], son la temperatura, presin y densidad o en el instante siguiente: IDL> print,data[3:5] 0.304793 0.939899 0.735009

y as sucesivamente. Nuestro objetivo nal, a modo de ejemplo, es pasar la temperatura de grados cent grados a Kelvin. En general, si vamos a operar por separado con cada una de las magnitudes, puede ser una buena idea crearnos una matriz que nos separe por las o por columnas cada una de las variables. Para ello escribimos:
Dado que se trata de nmeros aleatorios, los valores concretos que tome el vector data u en cada sesin de IDL pueden ser distintos y no tienen porqu coincidir con los mostrados o e aqu .
4

IDL> tpd=reform(data,3,100) IDL> help, tpd TPD FLOAT = Array[3, 100] Vemos que la funcin reform nos transforma el vector data en un array de 3 o las y 100 columnas de forma que en la primera la tenemos la temperatura, en la segunda la presin y en la tercera la densidad. Seguro? o tendr o amos que haber tomado 3 columnas y 100 las? Vamos a comprobar que lo hemos hecho bien usando el comando print adecuadamente. En concreto la temperatura (primera la, es decir, la 0) en los dos primeros instantes (columnas 0 y 1) corresponder a: a IDL> print,tpd[0,0:1] 0.957516 0.304793 Vemos que efectivamente coinciden con los datos mostrados anteriormente. Por otra parte, la temperatura, presin y densidad en el instante inicial o correspondern a la primera columna de la matriz tpd. Entonces le decimos: a las 0 a 2, columna 0: IDL> print,tpd[0:2,0] 0.957516 0.740806 0.483755

que efectivamente coincide con lo mostrado al principio. Para indicar todas tambin podemos usar el s e mbolo *. La sentencia anterior: todas las las, la primera columna es equivalente a: IDL> print,tpd[*,0] Supongamos que tenemos la temperatura en grados cent grados y la queremos pasar a Kelvin. Con la separacin en las de los datos que hemos hecho o es muy fcil: a IDL> tpd[0,*]=tpd[0,*]+273.15 es decir sumamos 273.15 a los elementos de la primera la (la cero) y todas las columnas (*).

4.2.

Subarrays

Supongamos ahora que tenemos el array tpd pero que nos interesa usar (por ejemplo para guardar) solo la presin y la densidad entre los instante o 50 y 60. Entonces creamos un subarray con las las 1,2 (presin y densidad o respectivamente) y las columnas desde la 49 a la 59, de la siguiente forma: IDL> sub_tpd=tpd[1:2 , 49:59]

10

Si, por el contrario, queremos almacenar la presin desde el instante 50 hasta o el nal podemos hacer lo siguiente: IDL> p=tpd[1,49:99] o bien: IDL> p=tpd[1,49:*] donde el * en este contexto signica hasta el nal. Esto es util si el n mero u de datos puede variar lo que ocurrir frecuentemente. a

5.

Grcas a

Veremos en este apartado lo ms elemental. A lo largo del curso iremos a aprendiendo algunas cosas ms sobre grcas. Busquemos algo que dibujar. a a Por ejemplo la suma de dos sinusoides: Creamos un vector con 100 datos uniformemente espaciados en el intervalo [0, 6]: IDL> x=findgen(100)*6.*!pi/99. F jate como hemos introducido el n mero en precisin simple, en doble u o precisin es !dpi. Creamos un vector con la se al (f1 y f2 son las frecuencias; o n a1 y a2 las amplitudes; las fases las ponemos igual a 0): IDL> f1=0.15 & f2=0.2 IDL> a1=4. & a2=2. IDL> y=a1*sin(2.*!pi*f1*x)+a2*sin(2.*!pi*f2*x) Dibujamos y(x): IDL> plot,x,y,xtitle=tiempo (s),ytitle=velocidad (m/s) Aqu hemos usado el procedimiento plot con los argumentos x, y junto con dos opciones para dibujar los carteles en cada eje. Consulta la ayuda (?plot) cuando sea necesario para ver el resto de opciones. El nombre de las opciones pueden abreviarse mientras no exista ambig edad, por ejemplo tambin es u e vlido: a IDL> plot,x,y,xtit=tiempo (s),ytit=velocidad (m/s) pero no: IDL> plot,x,y,xt=tiempo (s),yt=velocidad (m/s) Si queremos dibujar otra funcin sobre esta grca lo podemos hacer de o a la siguiente forma: 11

IDL> w=abs(y) IDL> oplot,x,w,linestyle=2 El procedimiento oplot (overplot) permite pintar encima de lo que hay. Consulta la ayuda para ver las posibilidades seg n te vaya haciendo falta. u En el ejemplo anterior el procedimiento plot nos abri automticamente o a una ventana grca. En realidad esto ocurri porque no ten a o amos ninguna abierta en ese momento. Si ahora queremos un dibujo en otra ventana debemos especicarlo. Para abrir ventanas podemos usar el comando: IDL> window,1 donde en lugar de 1 podemos poner cualquier n mero entero entre 0 y 31. 5 u En la cabecera de la ventana puedes ver el n mero de cada una (el dibujo u anterior est en la 0, no?). Dibujemos algo en la pantalla nueva, por ejemplo: a IDL> z=x*y IDL> plot,x,z,tit=NUEVO La ventana grca no siempre sale en la posicin y con el tama o que a o n queremos. A parte de usando el cursor de la forma estndar, para cambiar a los valores por defecto podemos usar las siguientes opciones: IDL> window, 1, xsize=200, ysize=300 IDL> window, 2, xpos=75, ypos=150 ;tama~o en pixeles n ;posicin origen o

A la hora de crear documentos es muy frecuente incluir guras que muestren los resultados de un clculo. En general la mejor forma de introducirlos a en los procesadores de texto es guardando previamente las guras en un chero postScript o similar. Supongamos que queremos guardar la grca a que generamos en la ventana 0 como un chero postScript encapsulado en un chero de nombre (por ejemplo) figura.prueba.eps. Lo podemos hacer de la siguiente forma: IDL> IDL> IDL> IDL> IDL> IDL> set_plot,ps device,filename=figura.prueba.eps,/encapsulated plot,x,y,xtit=tiempo (s),ytit=velocidad (m/s) oplot,x,w,linestyle=2 device,/close set_plot,x

El primer comando pasa de modo ventana a chero postScript, luego abrimos el chero con el nombre que queramos, dibujamos con los mismos comandos que antes: plot, oplot, etc., cerramos el chero y por ultimo volvemos al modo pantalla para los siguientes dibujos (suponiendo que eso sea lo que nos interese). La Figura 1 muestra el resultado.
No existe un l mite para el nmero de ventanas. Para abrir la que tenga el u ndice menor por encima de 31 todav sin usar en la sesin debe escribirse la sentencia window,/free. a o
5

12

Figura 1: Este es el resultado de a adir el chero figura.prueba.eps que n A acabamos de generar al procesador de texto (L TEX 2 concretamente). Para decir verdad la opcin /encapsulated que pusimos antes nos permite o cambiar el tama o de la grca a posteriori con el procesador de texto. Enn a tonces si, como suele ocurrir frecuentemente, nos interesa reducir el tama o n de la grca en el texto, conviene aumentar previamente con IDL el tama o a n de las letras y n meros de los ejes para que se vean bien, esto se hace con u la opcin charsize que nos multiplica el tama o de los caracteres por un o n factor, concretamente la gura tiene: plot,...,chars=1.5

6.

Respuesta a los ejercicios

Ejercicio 1: Por defecto el comando print nos ensea un nmero determinado n u

de decimales pero la precisin puede ser mayor. Para ver ms decimales ponemos: o a IDL> print,5./3.,format=(f15.12) 1.666666626930 y sabiendo que el resultado debe ser uno con seis periodo resultan como mucho 7 decimales signicativos.

Ejercicio 2: Al tener decimales, el vector debe ser real. Como el comando

findgen empieza en 0, el ultimo nmero ser el 999. Entonces para que sea 2.5 u a lo reescalamos adecuadamente. Luego para quitar los puntos tenemos en cuenta que el elemento 344 es a[343] y el 567 es a[566]. As : IDL> a=findgen(1000)*2.5/999. IDL> print, a[0],a[999] 0.00000 2.50000 IDL> b=[a[0:342],a[344:565],a[567:999]] IDL> help,a,b A FLOAT = Array[1000] B FLOAT = Array[998]

13