Guia do IDL - Cap?tulo B:

Tipos de Programas

IDL suporta três tipos de programas: principal, procedimentos e funções. Procedimentos e funções são a chave para modelar a programação estruturada.

Encorajamos você a escrever procedimentos e funções ao invés de escrever tudo no programa principal. Todos programas precisam ser compilados antes de serem executados. Compilar é o ato de interpretar as instruções do código fonte para um arquivo de código byte armazenado na memória. O código byte na memória que é executado quando você executa o programa.

 

Principal (Main Program)

Os programas principais estão incorporados a linha de comando do IDL, e são úteis quando você tem alguns comandos que você quer executar sem ter que criar um arquivo separado contendo-os. Programas principais não são explicitamente nomeados; consistem em uma série de instruções que não são precedidas por um cabeçalho como no procedimento ou na função. Entretanto, requerem uma instrução END. Por não ter um cabeçalho, o programa não pode ser chamado por outras rotinas e não pode ser passado como argumento. Quando o IDL encontra um programa principal como o resultado de um comando executivo .RUN, compila-o em um programa especial nomeado $MAIN$ e executa-o imediatamente. Mais tarde, ele poderá ser executado novamente usando o comando executivo .GO.

O exemplo a seguir cria um programa principal simples usando a linha de comando do ID

  1. Na linha de comando do IDL, digite:
    X=2

  2. Digite .RUN na linha de comando do IDL. A linha de comando muda de IDL> para - .

  3. Digite:
             X = X * 2
             PRINT, X
             END
  4. Esta instrução retorna o valor de X após a multiplicação, as instruções são compiladas e executadas pelo programa especial $MAIN$:
             % Compiled module: $MAIN$.

  5. Digite .GO na linha de comando. O Programa principal será executado novamente, retornando o novo valor do X:
             8

 

Procedimentos e Funções

Procedimentos e funções contem módulos que dividem grandes tarefas em pequenas, mais manejáveis. Programas modulares simplificam a correção de erros e a manutenção, pois eles podem ser usados novamente, eles diminuem a quantidade de código requerida por novas aplicações.

Novos procedimentos e funções podem ser escritos no IDL e serem chamados da mesma maneira que os procedimentos ou funções definidas pelo sistema. Quando um procedimento ou uma função acaba, é executada uma instrução RETURN.

Funções sempre retornam um resultado explicito. Um procedimento é chamado por uma instrução de chamada de procedimento, enquanto a função é chamada por uma referência da função.

 

Procedimento

O procedimento já está contido no programa do IDL. Um procedimento começa com a instrução de declaração do procedimento, que consiste em uma palavra-chave reservada PRO, depois o nome do procedimento, e qualquer instrução para o mesmo. Um procedimento estará terminado com uma instrução de END.

Um exemplo de um procedimento é apresentado logo abaixo, no arquivo que chamamos de procedimento.pro, que foi criado da seguinte maneira:

  1. Você deve abrir o IDLDE;

  2. File -> New -> Editor ou Ctrl+N;

  3. Digite o código abaixo
          Pro procedimento
                 Cd, current = c
                 Print, c
          End

  4. Salve o arquivo com o nome que desejar (exemplo: procedimento);

Veja que este procedimento retorna o diretório padrão do IDL.
Compile o procedimento usando apenas o comando de execução .COMPILE (se ele estiver no diretório do IDL, caso contrário faça da mesma forma que foi feito no programa principal):

IDL> .compile procedimento.pro

Execute o procedimento chamando pelo nome:

IDL> procedimento
C:\RSI\IDL61

Se o arquivo que contem este programa não estiver no diretório do IDL, poderia ser executado especificando o caminho até o arquivo após o comando de execução .COMPILE . Por exemplo, procedimento.pro pode estar armazenado no diretório C:\temp, com isso fora do diretório do IDL, o comando de execução .COMPILE pode ser:

IDL> .compile "C:\temp\procedimento.pro"

 

Função

Uma função outro programa que está contido no IDL; entretanto, uma função retorna informações. Uma função começa com a instrução de declaração da função, que consiste na palavra-chave reservada FUNCTION, o nome da função, e todos os seus parâmetros. O corpo da função, incluindo por ultimo a instrução RETURN. Uma função é terminada com a instrução END.

Um exemplo de uma função é apresentado logo abaixo, no arquivo que chamamos de funcao.pro, que foi criado para este exemplo (siga os passos que foram descritos no exemplo do procedimento, apenas substituindo o código).

Function funcao, f
          Return, f gt 1
End

Para compilar a função use o comando de execução .COMPILE

IDL> .compile funcao

A sintaxe para chamar esta função é:

IDL> f = funcao (10)
IDL> print, f
              1

Da mesma forma que no procedimento, se o arquivo contendo a função não estiver no diretório do IDL, ele poderá ser compilado especificando todo o caminho até o arquivo após o comando de execução .COMPILE.

 

Arquivos de Lote

Um arquivo de lote contém uma ou mais instruções ou comandos do IDL. Cada linha do arquivo de lote é lida e executada antes de prosseguir para à linha seguinte. Os arquivos de lote não podem ser considerados exatamente um programa, pois diferente dos programas estes não são compilados apenas executados.

Um exemplo de um arquivo de lote é apresentado logo abaixo, no arquivo que chamamos de lote.pro, que foi criado para este exemplo (siga os passos que foram descritos no exemplo do procedimento, apenas substituindo o código).

      print, systime()
      procedimento

Veja que o exemplo acima alem de retornar a Data/Hora do sistema, também executa o procedimento visto no exemplo acima.

Para executar um arquivo de lote:

     IDL> @lote
     Wed Jun 22 16:25:40 2005
     C:\RSI\IDL61

Se o arquivo lote.pro não estiver diretório do IDL, o caminho completo do arquivo deve ser especificado antes do símbolo @.

 

Parâmetros de posição e de palavra-chave

Parâmetros são usados para passar informações entre os programas. No IDL temos dois tipos de parâmetros: de posição e por palavra-chave. Embora os dois tipos podem ser usados para enviar ou receber informações, parâmetros de posições são tipicamente usado para requerer informações, enquanto palavras-chave são usadas para informações opcionais. Como os parâmetros são empregados, embora, seja uma escolha do programador.

A ordem dos parâmetros de posição em uma chamada à um programa importante. Por exemplo, se x e y são vetores, então:

IDL> x = findgen (20)
IDL> y = x ^ 2

Então esta instrução PLOT

IDL> plot, x, y

É diferente desta outra

IDL> plot, y, x

Parâmetros de palavra-chave, por outro lado, podem ser listados em qualquer ordem. Por exemplo, as seguintes instruções de um procedimento tem o mesmo resultado:

IDL> plot, x, y, xtitle = 'Tempo', ytitle = 'Velocidade'
IDL> plot, x, y, ytitle = 'Velocidade', xtitle = 'Tempo'

Parâmetros de palavras-chave, podem ser abreviado. Isto é útil ao usar IDL interativamente pela Linha de Comando, mas não é recomendado que se faça isto no código de um programa, pode confundir o próprio programador.
Palavras-chave boleanas podem ser determinadas com uma " / " antes da palavra-chave. Por exemplo, as seguintes instruções de um procedimento tem o mesmo resultado:

IDL> plot, x, y, /nodata
IDL> plot, x, y, nodata = 1

 

Passando por Parâmetros

Quase todos os programas em IDL usam parâmetros. Esta sessão descreve os dois mecanismos distintos para passagem de parâmetro.

Examine a diferença entre os argumentos usados nestas duas chamadas para o procedimento PLOT:

IDL> x = findgen (10)
IDL> plot, x                        ; Primeira chamada
IDL> plot, findgen (10)      ; Segunda chamada

Ambas chamadas tem os mesmos dados e o mesmo resultado, uma linha retilínea indo de 0 até 9. A diferença encontra-se na maneira que os dados são passados para o PLOT: uma variável é passada na primeira chamada, uma expressão (o que retornar da chamada da função) na segunda chamada.

No IDL existe dois mecanismos de passagem de parâmetros: passagem por valor e passagem por referência. Passagem por valor significa que cada parâmetro pega uma copia do valor dos argumentos, de modo que as mudanças ao parâmetro não afetem os argumentos, mesmo se as variáveis tiverem o mesmo nome, e as mudanças serão perdidas quando retornar para o programa.
Com a passagem por referência, um argumento não será copiado para os parâmetros. Qualquer modificação do parâmetro no programa muda o argumento pois os dois referenciam-se a mesma memória.

Muitas rotinas do IDL utilizam parâmetros para passar informações de volta para quem as chamou. Pegue, como exemplo, esta chamada a função WHERE:

IDL> x = 0
IDL> index = where(x lt 5, count)
IDL> print, index, count
              0
         1

O segundo argumento no WHERE (count) é usado para retornar o número de vezes que a expressão condicional no primeiro argumento é compatível. Este argumento precisa ser passado por referência, ou as informações não serão retornadas.

As regras para determinar como um parâmetro deve ser passado no IDL são:

Por valor: Expressões, incluindo sobrescrever os elementos de uma matriz ou vetor, campos de uma estrutura, variáveis de sistema e constantes.

Por referência: Variáveis nomeadas, estruturas completas.

Atenção: A passagem de parâmetros de uma estrutura pode ser feita por referência apenas quando vamos passar toda a estrutura, caso a intenção seja a passagem de apenas algum campo desta estrutura será passado por valor.

O mecanismo de passagem por referência torna possível a informação de uma variável ser modificada quando ela é passada para o programa.

 

Chamada de Programas

O mecanismo de chamada de programas do IDL é uma seqüência de etapas que localizam, solvem e executam um procedimento ou função, quando o procedimento ou função é chamado por nome, da linha de comando ou dentro de um programa do IDL. Por exemplo, quando chamamos o procedimento LOADCT pela linha de comando:

IDL> loadct, 5
% Compiled module: LOADCT.
% Compiled module: FILEPATH.
% Compiled module: PATH_SEP.
% LOADCT: Loading table STD GAMMA-II

O mecanismo chamado é usado para localizar, solver e executar LOADCT, carregando a tabela de cor número 5 na sessão do IDL.

O mecanismo de chamada consiste em quatro etapas.

  1. Procura por uma rotina nomeada na tabela de rotinas do sistema do IDL. Se a rotina estiver listada na tabela do sistema, executa ela; senão, processa a próxima etapa.

  2. Verifica se a rotina se encontra em um estado compilado na sessão atual do IDL. Isto pode ser diagnosticado usando o HELP com a palavra chave ROUTINE. Se o programa já estiver compilado, então roda ele. Se ele não estiver vai para a próxima etapa.

  3. Procura por um arquivo ou um arquivo de sistema que tenha o mesmo nome base que a rotina chamada, com a extensão .pro ou .sav. A procura começa no diretório atual do IDL, então ele prossegue através dos diretórios listados na variável de sistema !path. Se o arquivo for encontrado, o IDL compila qualquer unidade de programa encontrada no arquivo, começando pelo topo, até que a rotina chamada seja encontrada. A rotina chamada é então compilada e executada. Se um arquivo com o mesmo nome da rotina chamada não for encontrado, ou se um arquivo com o mesmo for encontrado, porém ele não contiver a rotina chamada, então iremos para última etapa.

  4. Emite uma mensagem de erro, informando que a função ou procedimento solicitado não pode ser achado.

No exemplo anterior foi chamado o procedimento LOADCT, na terceira etapa do mecanismo de chamada. LOADCT não é uma rotina do sistema, por isso não foi compilado mais cedo. Entretanto, o arquivo loadct.pro existe no subdiretório lib, do qual é parte do diretório de busca padrão do IDL. O IDL abre o arquivo, compila o procedimento LOADCT interiormente e executa ele.

Note que as rotinas FILEPATH e PATH_SEP foram executados também na chamada do LOADCT.

 

 
Contato: Rua Felipe Neri, 444 - Porto Alegre/RS - Brasil | Fone: (51) 3333-1581 / (51) 3026-3920 | Todos direitos reservados.