Disciplina:

FÍSICA COMPUTACIONAL I

Ministrada por:

Francisco Carlos Lavarda

Apostila de:

FORTRAN

NOTAS DE FÍSICA COMPUTACIONAL I

Elaboradas a partir do livro texto

LINGUAGEM DE PROGRAMAÇÃO ESTRUTURADA FORTRAN

(Editora McGraw-Hill, 1986)

M. E. Hehl

por

Francisco C. Lavarda

A maior parte destas notas é um resumo do livro texto citado acima, contendo aquilo que é mais necessário para o iniciante. Assim, nem todas as seções do livro estão presentes. Existem também muitas observações e exemplos incluídos pelo autor das notas.

Ano 2001

Capítulo 0: Notas Introdutórias

0.1. Assuntos Gerais

[D] Convenções usadas nestas notas:

[D] Definição.

[C] Comentário.

[CF] Comando Fortran.

[SO] Comando do Sistema Operacional usado.

[ET] Comando de edição do editor de texto usado.

[E] Exemplo.

[P] Problema.

[A] Atividade.

[G] Gíria.

[D] <tecla> significa uma dada tecla que deve ser pressionada.

[D] "comandos que você deve digitar" estarão sempre entre aspas.

[C] Ao iniciar as atividades da aula do dia, siga os seguintes passos para a utilização da sua conta:

Fazer a conexão com o computador que contém a sua conta, através do programa TELNET, com o computador ANU, através de seu nome completo, anu.fc.unesp.br ou do seu número, 200.145.159.142.
Ao prompt do Anu, digitar o seu username (ou login) e password(senha).
Editar os seus arquivos (de programas e dados) com o editor JOE digitando "joe nome.ext"+<enter>.
Compilar o seu programa nome.f90 usando o comando: ""f90 nome.f90 -o nomedoexecutável " + <enter>.
Se não for possível a compilação, volte ao passo 3, para corrigir erros.
Execute o seu programa com o comando "nomedoexecutável" + <enter>.
Se não for possível a execução, volte ao passo 3.
Após a execução de todas as suas tarefas, saia de sua conta usando o comando "logout".

0.2. O editor de textos "JOE"

[C] Em um sistema Unix, tal como no DOS e Windows, existem muitos editores de texto disponíveis. Vamos aqui nos referir a um dos mais simples editores de texto do Unix que, ao mesmo tempo, oferece uma quantidade boa de recursos (e se encontra instalado na máquina Anu). Trata-se do editor joe. O joe é baseado nas teclas de controle usados no Wordstar outros editores de textos de programas da Borland (turbopascal, turboc, etc.). Muitos dos comandos são invocados digitando-se Ctrl-k seguido por outra tecla. O editor, tanto para criar um arquivo novo como para editar um já existente, é evocado como:

joe nomedoarquivo

[C] Para obter uma janela com comandos do joe, após entrar no programa, digite Ctrl-kh e aparecerá uma listagem de comandos. Digite novamente Ctrl-kh para que a janela desapareça. Mais informações sobre o joe (por exemplo, como editar dois programas em duas janelas ano mesmo tempo) podem ser obtidas no endereço http://gopher.wh.whoi.edu/Unixhelp/joe.html.

[C] A seguir temos uma tabela com comandos do joe, onde o símbolo ^ significa Ctrl.

^kh mostra a tela da ajuda

^kx salva e sai

^kq sai e não salva

^c sai e pergunta se salva

Comandos para mover-se dentro do arquivo

^v desce uma tela

^u volta uma tela

^x vai para a próxima palavra

^z volta para a palavra anterior

^p volta para a linha anterior

^n vai para a linha seguinte

^e vai para o fim da linha

^a vai para o início da linha

^ku vai para o início do arquivo

^kv vai para o fim do arquivo

^kl vai para uma linha de número específico

Comandos para apagar texto

^d apaga um caracter

^w apaga uma palavra

^y apaga uma linha

^_ ou ^? desfaz a ultima apagada

Comandos para procura e troca

^kf procura e troca

^l procura a próxima ocorrência do mesmo texto

Comandos para trabalhar com blocos

^kb marca o início do bloco

^kk marca o fim do bloco

^kc copiar o bloco marcado para a localização atual

^km move o bloco marcado para a localização atual

^ky apaga o bloco marcado

[C] Para criar texto, usa-se o teclado do micro como se fosse uma máquina de escrever, onde a tecla <enter> faz o retorno de carro (ou seja: nova linha) e a tecla <backspace> apaga os erros que cometemos.

[C] Para "passear" pelo texto, use as teclas: <flecha para cima>, <flecha para baixo>, <flecha para o lado direito> e <flecha para o lado esquerdo>.

[C] SEMPRE deixe uma linha em branco no final do arquivo. Isto é necessário ao se usar o joe para arquivos de Fortran (programas e dados).

0.3. Sistema Operacional

[D] O "Sistema Operacional" (SO) é um programa que gerencia os arquivos armazenados em discos rígidos e flexíveis: armazenamento, recuperação e outras operações.

[C] Além de gerenciar os discos, o SO também pode alterar algumas características do computador em relação à tela de vídeo, teclado, impressoras, etc...

[D] Um "arquivo" é um documento qualquer (um programa, por exemplo) armazenado em dos dispositivos (discos) de armazenamento do computador. A tradução desta palavra do inglês para o português foi infeliz, pois para nós, um arquivo quer dizer um móvel que guarda uma coleção de pastas. Na linguagem de informática, porém, a tradução infeliz é arraigada e quer dizer uma coleção de dados armazenados juntos (o conjunto de todas as letras digitadas em um programa formam um arquivo).

[C] A "Estrutura de Diretórios". Da mesma forma que as pastas de um arquivo de escritório contém grupos de documentos afins, os diretórios podem conter grupos de arquivos afins, que são agrupados em "sub-diretórios". A estrutura de diretórios pode ser representada por um esquema:

"diretório raiz" diretórios sub-diretórios

|-----------------------fiscomp1

|-----------------------cartas

|-----------------------tarefas

|----------------------------------física

|----------------------------------biologia

[C] Um comando do SO pode possuir até 3 partes: o "nome do comando", os parâmetros (que são obrigatórios para alguns comandos) e as "opções" (que são opcionais para quase todos os comandos). Escreveremos um comando com a seguinte convenção:

nomedocomando [parâmetro1] [parâmetro2]...[parâmetroN] <-opção1> <-opção2>...<-opçãoN>

[C] Após entrar na conta, resulta uma sublinha piscando na tela, na qual chamamos de "linha de comando". Esta sublinha piscante chama-se "cursor". O cursor mostra onde os comandos podem ser digitados. Quando você digita um caracter, o cursor se move um espaço para a direita. Se você cometer um erro, pressione a tecla <¬> ou <backspace> para eliminar um caractere à esquerda. Terminada a digitação, basta pressionar a tecla <enter> ou <return> para que o comando seja executado.

[C] Para interromper a execução de um comando, tecle <ctrl+c>.

[C] Pode-se obter uma descrição completa de um comando digitando-se:

man nomedocomando

[SO] "cd": muda ou exibe o diretório atual. Exemplos:

cd tarefas : muda para o sub-diretório tarefas

cd .. : muda para o diretório de cima

[SO] "cp": faz uma cópia de um arquivo. Exemplos:

cp prog1.f prog1a.f : faz uma cópia de prog1.f que se chama prog1a.f

[SO] "rm": elimina arquivos especificados. Exemplos:

rm prog1.f : apaga o arquivo prog1.f

rm prog*.f : apaga todos os arquivos que comecem por prog e terminem com .f

[SO] "ls -la": exibe uma lista de arquivos e subdiretórios de um diretório (o apelido, na ANU é "dir").

[SO] "mv": modifica o nome de um arquivo. Exemplo:

mv prog1.f prog2.f : troca o nome de prog1.f para prog2.f

[SO] "cat": exibe o conteúdo de um arquivo de texto. Exemplo:

cat prog1.f

Capítulo 1: Noções Preliminares

1.1. Introdução

[C] "O que todo computador pode realmente fazer é seguir ordens muito simples, as quais foram cuidadosamente consideradas e refletidas por um programador e escritas em uma linguagem de programação, como o Fortran."

1.2. Computadores

[C] Há somente 4 tipos de instruções que um computador pode realizar:

Armazenamento e recuperação de informações da memória;
Cálculos;
Entrada e saída de dados;
controle de programa.

[C] Esquema de um computador:

1.3. Algoritmos

[D] Um "algoritmo" é um conjunto de instruções passo-a-passo para resolver um problema.

[D] Um algoritmo correto deve possuir 3 qualidades:

Cada passo no algoritmo deve ser uma instrução que possa ser realizada.
A ordem dos passos deve ser precisamente determinada.
O algoritmo deve ter fim.

1.4. Diagramas de Fluxo

[D] "Diagramas de Fluxo" fornecem uma representação gráfica de um algoritmo.

[D] Principais símbolos de diagramas de fluxo:

1.7. Linguagens de Programação

[D] Um "programa de computador" é um algoritmo escrito numa linguagem de programação, como o Fortran.

[C] Existem 3 níveis de linguagens de programação:

Linguagens de baixo nível (ou de máquina).
Linguagens de nível intermediário (ou simbólica montadora).
Linguagens de alto nível (ou de compiladores).

1.7.1 Linguagem de Máquina

[D] Cada instrução é constituída de 2 partes:

código de operação

operando(s)

[D] O "código de operação" instrui o computador para realizar uma função específica: adição, subtração, leitura, escrita, comparação, movimento de dados, etc...

[D] O(s) operando(s) especifica(m) o endereço do dado a ser operado, endereço do dispositivo de entrada/saída, etc...

[E] Exemplo do trecho principal de um programa em linguagem de máquina para calcular , onde os valores de A, B, C, D e R estão armazenados nos endereços 1000, 1004, 1012, 1020 e 2050 da memória.

Código da Operação Operando Comentário

14 1000 carrega A no acumulador

12 =5 multiplica o acumulador por 5

15 3000 armazena conteúdo acumulado no endereço 3000

14 1004 carrega B no acumulador

12 =16 multiplica acumulador por 16

10 3000 adiciona acumulador com conteúdo de 3000

13 1012 divide acumulador pelo conteúdo de 1012

11 1020 subtrai acumulador do conteúdo de 1020

15 2050 armazena acumulador em 2050

[C] Na realidade, um programa real em linguagem de máquina, para ser compreendido por ela, geralmente é escrito no sistema binário.

1.7.2. Linguagem Simbólica Montadora

[C] As linguagens simbólicas procuram facilitar a tarefa do programador, criando mnemônicos para as operações.

[C] Os programas montadores traduzem um programa fonte (ou seja, em linguagem simbólica) em um programa objeto (ou seja, em linguagem de máquina).

[E] O trecho de programa visto acima, ficaria em uma linguagem simbólica parecido com:

Operação Operando Comentário

CAR A carrega A

MUL 5 multiplica por 5

ARM TMP armazena o resultado em TMP

CAR B carrega B

MUL 16 multiplica por 16

ADI TMP adiciona o resultado com o conteúdo de TMP

DIV C divide o resultado por C

SUB D subtrai o resultado de D

ARM R armazena o resultado em R

1.7.3. Linguagens de Compiladores

[C] Uma linguagem de compilador (ou de alto nível) tem por objetivo permitir ao programador se utilizar de uma linguagem muito próxima àquela utilizada no ambiente no qual se coloca a tarefa a ser realizada.

[C] Os programas compiladores traduzem um programa fonte, escritos em uma linguagem de alto nível, em um programa objeto em linguagem de máquina.

[E] O trecho de programa visto acima, ficaria na linguagem de alto nível Fortran idêntico a:

R = (5.0*A + 16.0*B) / C - D

[C] Etapas do processamento de um programa em linguagem de alto nível:

1.8.Passos no Desenvolvimento de Programas

Capítulo 2: A Linguagem Fortran: Conceitos Básicos

2.1 Introdução

[C] FORTRAN = FORmula TRANslation (em português: tradução de fórmulas).

[D] O Fortran é uma linguagem simples cujo vocabulário consiste de um conjunto de palavras, conhecidas como "palavras-chave" (para se ter uma idéia, no Fortran77 eram cerca de 450; atualmente o número é bem maior).

[D] Um "comando" Fortran é uma sentença escrita nesta linguagem. Um programa consiste numa seqüência de comandos, cada um escrito numa linha.

2.2. Definições da Linguagem

[D] Programa Principal é uma unidade que pode chamar outras unidades de programa, mas que não pode ser chamado por estas. O programa principal é quem recebe o controle da execução no início da fase de execução.

[D] Subprograma é uma unidade de programa que é chamada por outra unidade de programa. Pode ser de dois tipos: subrotina ou função. Usualmente um subprograma recebe parâmetros de entrada e retorna parâmetros de entrada e retorna parâmetros de saída.

[D] Função Intrínseca é uma função suprida pelo compilador e que realiza operações sobre números ou caracteres.

[D] Programa Executável é um programa já em linguagem de máquina que pode ser executado pelo computador. Consiste de um programa principal e subprogramas.

[D] Comando Executável é aquele que efetua cálculos, testes ou altera o fluxo de execução.

[D] Comando Não-Executável é aquele que descreve as características de uma unidade de programa, dos dados ou de informações de edição.

[D] Unidade de Programa é uma seqüência de comandos terminando com um comando END.

[D] Arquivos de Dados são unidades de entrada e saída de dados, passíveis de serem lidos/escritos por um programa.

2.3. Itens sintáticos do Fortran

[D] Sintaxe é a parte da gramática que estuda a disposição das palavras na frase e a das frases no discurso.

[D] Constantes são valores ou números que ocorrem num programa.

[D] Nome simbólico é uma seqüência de uma a seis letras ou dígitos, o primeiro dos quais deve ser uma letra.

[D] Variáveis são valores ou números ou conjuntos de caracteres que ocorrem num programa e que podem sofrer variações durante a execução do programa. Na realidade uma variável é o nome de uma localização da memória.

[D] Número de comando é um número de um a cinco dígitos, um dos quais deve ser diferente de zero e é usado para identificar um comando. Deve estar localizado no início da linha.

[D] Palavra chave é uma seqüência de letras que identificam exclusivamente comandos Fortran.

[D] Operador é um ente similar a um operador matemático.

[C] Valores são obtidos da memória quando eles são usados no lado direito do sinal de igual.

[C] Observe que o sinal de "=" não indica uma igualdade e sim uma atribuição.

[C] O Fortran permite que você defina diferentes tipos de variáveis. Usa-se variáveis inteiras para armazenar números inteiros, variáveis reais para números reais, variáveis complexas para números complexos, variáveis caracter para palavras e frases, etc.

[C] Você pode definir os tipos de variáveis no seu programa através de "comandos de definição de tipo".

[CF] Existem vários comandos Fortran para a definição de tipo de variável, entre os quais "CHARACTER", "INTEGER" e "REAL".

[C] Os cálculos podem ser feitos através de comandos de atribuição, escrevendo-se uma "expressão" no lado direito do sinal de igual.

[C] Símbolos de operações matemáticas (também conhecidos como "operadores matemáticos"): adição, "+"; subtração, "-"; multiplicação, "*"; divisão, "/"; exponenciação, "**".

[C] Pode-se usar parênteses para agrupar termos em expressões Fortran, como é feito em álgebra.

2.4. Caracteres usados no Fortran

[D] O conjunto de caracteres Fortran é constituído de: letras (ou caracteres alfabéticos), dígitos (ou caracteres numéricos) e símbolos especiais como =, +, -, /, *, etc.

[C] É preciso tomar cuidado em relação aos símbolos especiais, pois estes podem variar de função dependendo do fabricante do compilador.

2.5. Uma visão geral do Fortran

[E] Exemplo de um programa para calcular a média das notas de uma prova de uma turma. Vamos usar a fórmula abaixo para calcular a média da turma:

onde: MT = média da turma,

nota(i) = nota do aluno i,

NT = número total de alunos.

O código do programa poderia ser:

program media

! programa para calcular a media de uma turma

! programador: FCLavarda

implicit none

integer i

integer nt,ns5,ni5

real mt,nota,soma

soma=0.0

ns5=0

ni5=0

print *,'Digite o numero total de alunos: '

read *, nt

do i=1,nt

print *,'Digite a nota do aluno ',i

read *,nota

soma=soma+nota

if(nota>=5.0) then

ns5=ns5+1

else

ni5=ni5+1

endif

enddo

mt=soma/nt

print *,'*** Resultados ***'

print *,'Media da turma: ',mt

print *,'Notas superiores ou iguais a 5.0 = ',ns5

print *,'Notas inferiores a 5.0 = ',ni5

stop

end

[C] Veja figura a seguir contendo o fluxograma para o programa media.f90.

[C] Uma "variável" Fortran é um nome para uma localização de memória. Varáveis no exemplo acima: nt, ns5, ni5, mt, nota, soma, i.

[C] O "valor" de uma variável é o número armazenado na localização de memória que é representada pela variável.

[D] Um "comando de atribuição" é o tipo de comando que permite armazenar um valor em uma variável. Comandos de atribuição no exemplo acima:

soma=0.0

ns5=0

ni5=0

soma=soma+nota

ns5=ns5+1

ni5=ni5+1

mt=soma/nt

[C] Quando você atribui um valor a uma variável, o valor anteriormente armazenado é destruído.

[C] Os comandos num programa Fortran são, normalmente, executados na ordem em que são escritos. Entretanto, pode-se alterar esta ordem de execução através dos "comandos de controle".

[CF] Um comando de controle que representa uma decisão é a construção "IF-THEN-ELSE".

[C] Veja figura a seguir para uma tomada de decisão e desvio do fluxo de execução.

[E] Veja figura a seguir para o fluxograma para o algoritmo que decide aprovar ou reprovar um aluno, baseado na sua média final.

[C] Comandos Fortran para o fluxograma anterior:

if(mf>=5.0)then

situacao='aprovado'

else

situacao='reprovado'

endif

[CF] Um comando de controle que representa um laço é o comando "DO", que é sempre terminado por um comando ENDDO.

[C] Em Fortran77, um comando DO pode terminar por um comando numerado.

[C] Veja a seguir um fluxograma de um laço de repetição.

[E] Veja a seguir o fluxograma para o algoritmo para somar todos os números naturais de 1 a 10.

[C] Comandos Fortran para o fluxograma anterior:

soma=0

do i=1,10,1

soma=soma+i

enddo

[E] Veja a seguir o fluxograma para o algoritmo para somar todos os números naturais pares de 1 a 10.

[C] Comandos Fortran para o fluxograma anterior:

soma=0

do i=2,10,2

soma=soma+i

enddo

[CF] Para dizer ao computador para parar a execução de seu programa, você usa o comando "STOP".

[CF] A última linha em qualquer unidade de programa Fortran é sempre o comando "END".

2.6. Codificação de programas em Fortran

2.6.A. Formato Livre (Fortran90 e posteriores)

[D] Cada comando é escrito numa linha.

[C] Cada linha de comando possui até 132 colunas. O editor de texto é capaz de trabalhar com um número maior de colunas (cuidado!).

[D] Continuação de comandos: muitas vezes um comando não cabe nas colunas disponíveis em uma linha (ou não se quer escrever tudo numa linha). Uma "linha de continuação" pode então ser definida simplesmente colocando-se um caractere & no final da linha e continua-se na de baixo. Pode-se fazer isto até 39 vezes seguidas, de modo que um comando pode ter até 20 linhas. Como sugestão de boa programação, as colunas [1,5] podem ficar em branco.

[C] Para a codificação de arquivos de dados de entrada e saída, estes seguem a estrutura que porventura seja definida no próprio programa que vai ler/escrever neste arquivo.

2.6.B. Formato Fixo (Fortran77 e anteriores)

[D] Cada comando é escrito numa linha e cada linha, por sua vez, é dividida em "campos", que são conjuntos de colunas

[C] Cada linha de comando possui 80 colunas. O editor de texto é capaz de trabalhar com um número maior de colunas (cuidado!).

[D] Cada linha é dividida em 4 campos, que são formados pelos conjuntos de colunas [1,5], [6], [7,82] e [73,80].

[D] Campo de números de comando, colunas [1,5]: um número de comando (qualquer número inteiro e maior que zero, consistindo de 5 dígitos) pode ser escrito nas colunas de 1 a 5. Brancos e zeros à esquerda são ignorados.

[D] Campo de continuação de comandos, coluna [6]: muitas vezes um comando não cabe nas 66 colunas disponíveis em uma linha. Uma "linha de continuação" pode então ser definida simplesmente colocando-se um caractere qualquer diferente de branco e zero na coluna 6. Pode-se fazer isto até 19 vezes seguidas, de modo que um comando pode ter até 20 linhas. As colunas [1,5] devem ficar em branco.

[D] Campo de comandos, colunas [7,72]: somente nestas colunas pode-se escrever um comando Fortran.

[D] Campo de identificação, colunas [73,80]: este campo é usado somente para identificação do programa. Isto é uma herança muito velha, pouco usado hoje. Geralmente o compilador que ainda se importa com a identificação do programa, escreve os primeiros 8 caracteres do nome do programa nestas colunas.

[D] Linhas de comentário, coluna [1]: qualquer linha que contenha uma letra "c" ou um asterisco "*" na coluna 1 são ignoradas em Fortran. São usadas para inserir comentários dentro de um programa Fortran.

[C] Para a codificação de arquivos de dados de entrada e saída, estes seguem a estrutura que porventura seja definida no próprio programa que vai ler/escrever neste arquivo.

Capítulo 3: Constantes, Variáveis e Conjuntos

3.1 Introdução

[C] Este capítulo trata de definir corretamente os componentes básicos dos comandos Fortran. Alguns já vimos no capítulo anterior, como "itens de sintaxe".

[D] "Constantes" são valores fixos, tais como números. Estes valores não podem ser alterados pelos comandos do programa. Exemplos: 3.0, 3, 'palavra'.

[C] "Variáveis" são nomes simbólicos que representam valores armazenados na memória do computador. Estes valores podem ser alterados pelos comandos do programa.

[D] "Conjuntos" são grupos de variáveis, cujos valores são armazenados adjacentemente e podem ser referenciados individualmente através de um nome simbólico com um índice. São conhecidos também como "variáveis indexadas" (VI).

[D] Um "operador" é um símbolo específico para uma determinada operação. Exemplo: + (soma).

[D] "Expressões" são combinações de constantes, variáveis, elementos de conjuntos e operadores. Exemplo: 3.0*var1+var2.

[E] No "comando de atribuição" abaixo:

fat = a(3) * 4 * (B + 2.5)

temos a "expressão" a(3)*4*(B+2.5). Nesta expressão temos duas "constantes" (4 e 2.5), uma "variável" (B), uma variável indexada (a(3)), dois "operadores" (* e +) e parênteses. Vemos também que temos uma constante inteira (4) e uma real (2.5); as variáveis a(3) e B dependem de como tenham sido definidas.

[E] No trecho de programa abaixo:

print *, 'digite a velocidade inicial:'

read *, v0y

g=9.8

dt=0.1

do i =1,np

t(i)=i*dt

y(i)=v0y*t(i)-0.5*g*t(i)**2

enddo

...

do i=1,np

print *,t(i),y(i)

enddo

vemos o uso das "variáveis indexadas" t(i) e y(i).

3.2. Constantes

[D] Uma "constante" é uma quantidade fixa e invariável.

[D] O Fortran distingue três classes de constantes: numéricas, lógicas e cadeias de caracteres.

[D] As constantes numéricas que mais nos interessam são:

- Inteiras: para números inteiros decimais (escritos sem o ponto decimal).

- Reais: para números decimais (ou fracionários).

- Dupla precisão: para números reais com mais dígitos significativos que o normal.

- Complexos: para números complexos.

[D] As constantes lógicas podem ser:

- .true. : representa o valor "verdade".

- .false. : representa o valor "falso".

[D] As constantes "cadeias de caracteres" são uma seqüência de caracteres alfanuméricos e/ou especiais sempre entre aspas.

[C] O comando PARAMETER pode ser usado para associar um nome simbólico a uma constante.

3.2.1. Constantes Inteiras

[C] O intervalo máximo de valores possíveis para constantes inteiras varia de máquina para máquina. O menor intervalo é de [-9999,+9999].

3.2.2. Constantes Reais

[D] Uma constante real é uma cadeia de dígitos escrita com ponto decimal, com um expoente ou com ambos, expressando um número real. Ex.: 0.123, 123.0E-03, -123.0E-03 .

[C] O intervalo de valores possíveis para o expoente, bem como a precisão do número (quantidade máxima de dígitos significativos) varia de máquina para máquina. O menor intervalo conhecido é de 10^-28 a 10⁺²⁸. A precisão do número é tipicamente no mínimo de 7 dígitos.

3.2.11. Constantes Caracteres

[C] O comprimento máximo de uma cadeia de caracteres geralmente não é menor que 255.

3.3. Variáveis

[D] Uma variável possui um nome e um tipo, podendo assumir diversos valores.

[D] Regras para nomes de variáveis:

1) Os nomes devem começar com uma letra.

2) Os nomes podem conter letras e dígitos.

[D] Tipos de variáveis: inteiras, reais, dupla precisão, complexas, lógicas e caracteres, que possuem características similares às constantes.

3.3.1. Variáveis Inteiras

[D] Se não for usado o comando IMPLICIT NONE, por convenção, toda variável numérica cujo nome inicia por uma das letras i, j, k, l, m ou n, é uma variável inteira.

[C] As variáveis inteiras podem assumir valores na mesma faixa das constantes inteiras.

3.3.2 Variáveis Reais

[D] Se não for usado o comando IMPLICIT NONE, por convenção, toda variável numérica cujo nome não inicia por uma das letras i, j, k, l, m ou n, é uma variável real.

[C] As variáveis reais podem assumir valores na mesma faixa que as constantes reais.

3.3.6. Variáveis Caracteres

[D] Uma variável caractere é uma variável que é declarada como caractere através dos comandos de especificação explícita ou do comando IMPLICIT. A quantidade de caracteres numa variável caractere é especificada quando da declaração da variável caractere.

[E] Veja os seguintes exemplos de comandos de especificação de variáveis caractere:

1) implicit character*28 (y,z)

2) character*36 linha

3) character soma*15,matriz*64

Temos que linha, soma e matriz são especificadas como variáveis caractere contendo 36, 15 e 64 caracteres, respectivamente. Além disso, todas as variáveis cuja primeira letra é y ou z são também declaradas como variáveis caractere contendo 28 caracteres cada uma.

3.4. Conjuntos

[C] Nesta seção nos ocuparemos dos conjuntos de variáveis, ou variáveis indexadas (VI), já definidos no início deste capítulo.

[C] Uma VI possui um nome, um tipo e um conjunto de índices (ou um único índice).

[D] "Vetor" é uma VI que possui um único índice, e por isto é dito uma VI unidimensional.

[E] A variável t no trecho de programa abaixo é um vetor:

dimension t(10)

t(1)=0.1

t(2)=0.2

t(3)=0.3

...

t(10)=1.0

[D] "Matriz" é uma VI que possui dois conjuntos de índices e por isto é dita bidimensional.

[E] A variável a no trecho de programa abaixo é uma matriz:

dimension a(3,3)

do i = 1,3

do j = 1,3

a(i,j) = 0.0

enddo

- Representação Matricial da variável a:

- Forma de armazenamento na memória:

\/ > \/ > \/

a₁₁a₁₂ a₁₃

\/ /\ \/ /\ \/

a₂₁ a₂₂ a₂₃

\/ /\ \/ /\ \/

a₃₁a₃₂ a₃₃

> /\ > /\

[D] Dizemos que uma VI é uma matriz n-dimensional quando esta possui um conjunto de n índices.

[D] Em Fortran, uma VI não pode possuir mais do que 7 índices.

3.4.1 Declaradores de Conjuntos

[CF] Comando DIMENSION: permite especificar uma determinada variável como sendo uma variável indexada.

[E] Exemplos do uso do comando DIMENSION:

1) dimension a(8)

onde 8 é número máximo de diferentes a's.

2) dimension a(8),b(5,6)

onde 5 e 6 são os valores máximos do primeiro e segundo índices (que resultam em 30 diferentes b's).

3) integer a

real b

dimension a(8),b(5,6)

onde o vetor a é um vetor de números inteiros e b uma matriz de números reais.

4) dimension c(0:10),d(1:4,1:3,1:5)

onde: c = vetor de 11 elementos, sendo o primeiro c(0) e o último c(10);

d = matriz tridimensional de 60 elementos, onde o primeiro elemento é d(1,1,1) e o último é d(4,3,5)

Capítulo 4: Expressões

4.1. Introdução

[D] Uma "expressão" Fortran é definida como uma combinação de itens sintáticos, isto é: uma expressão pode consistir de uma única constante, de uma única variável, de um único elemento de conjunto, ou uma combinação de constantes, variáveis, elementos de conjuntos, unidos com um ou mais operadores e, possivelmente, agrupados com parênteses.

[D] "Operadores" especificam as computações a serem realizadas sobre os valores dos elementos básicos.

[D] As expressões, no Fortran, são classificadas em aritméticas, caracteres, relacionais e lógicas.

4.2. Expressões Aritméticas

[D] Uma "expressão aritmética" é usada para expressar uma computação numérica. O cálculo desta expressão produz um valor numérico cujo tipo é inteiro, real, dupla precisão ou complexo.

[D] Os "operadores aritméticos" são definidos pela tabela abaixo:

Operador Definição Uso Significado

----------------------------------------------------------------------------------------------------

** potenciação a**b a elevado à potência b

* multiplicação a*b a multiplicado por b

/ divisão a/b a dividido por b

+ adição a+b a mais b

- subtração a-b a menos b

- menos unário -a a com sinal invertido

[C] Em expressões contendo um único operando, o tipo do operando define o tipo de expressão.

[C] Em expressões com mais de um tipo de operando, o tipo da expressão depende dos tipos dos operandos e dos operadores.

[D] Para todas as operações (com exceção da potenciação):

1) Se os operandos forem do mesmo tipo, este será o tipo da expressão.

2) Se os operandos forem de tipos diferentes, o tipo da expressão será o tipo do operando de maior precedência, dada pela tabela abaixo:

Tipo Precedência

-------------------------------------------

inteiro 1

real 2

dupla precisão 3

complexo 4

[D] Regras para ordem de computação:

1) Parênteses podem ser usados para agrupar operandos em uma expressão. Qualquer expressão entre parênteses é calculada antes do cálculo da expressão da qual ela é uma parte. Parênteses mais internos são calculados antes.

2) Com exceção do uso dos parênteses, as operações são realizadas na seguinte ordem de precedência:

Operação Precedência

--------------------------------------------------------------

+ e - mais baixa

* e / intermediária

** mais alta

3) Para operadores de mesma precedência, o cálculo se desenvolve da esquerda para a direita.

4) Potenciações consecutivas são realizadas da direita para a esquerda.

4.4 Expressões Relacionais

[D] Uma "expressão relacional" é usada para comparar os valores de duas expressões aritméticas (ou os valores de duas expressões caractere).

[D] A comparação entre duas expressões aritméticas é feita através dos "operadores relacionais".

[C] O cálculo de uma expressão relacional produz um resultado lógico, com um valor "verdade" ou "falso". A expressão é interpretada como "verdade" se os valores dos operandos satisfazem a relação matemática especificada pelo operador, e "falso" se eles não satisfazem a relação.

[D] "Operadores Relacionais" são aqueles definidos na tabela abaixo:

Operador Definição Uso Significado

(somente Fortran90 e posteriores)

== igual a A==B A é igual a B ?

/= diferente de A/=B A é diferente de B?

< menor que A<B A é menor a B?

<= menor ou igual A<=B A é menor ou igual a B?

> maior que A>B A é maior que B ?

>= maior ou igual A>=B A é maior ou igual a B?

(todos)

.eq. igual a (equal) A.eq.B A é igual a B ?

.ne. diferente de (not equal) A.ne.B A é diferente de B?

.lt. menor que (less than) A.lt.B A é menor a B?

.le. menor ou igual (less or equal) A.le.B A é menor ou igual a B?

.gt. maior que (greater than) A.gt.B A é maior que B ?

.ge. maior ou igual (greater or equal) A.ge.B A é maior ou igual a B?

4.5 Expressões Lógicas

[D] Uma expressão lógica é usada para realizar um cálculo lógico.

[D] Os "operadores lógicos" são (listamos somente os principais):

Operador Definição Uso Significado

-----------------------------------------------------------------------------------------------------

.not. negação .not.A se A é verdade, .not.A é falso

.and. conjunção A.and.B para a expressão ser verdade, A e B precisam ser verdade

.or. disjunção A.or.B para a expressão ser verdade, A ,ou B, precisa

ser verdade

[E] Exemplos:

1) if(x1.eq.x.and.x2.eq.x1) then …

2) fim=.false.

do while(.not.fim) …

bloco de comandos

enddo

[D] Regras para cálculos de expressões lógicas.

1) Parênteses podem ser usados e são calculados antes.

2) Os operadores aritméticos são calculados em segundo lugar.

3) Os operadores relacionais são calculados em terceiro lugar.

4) As operações lógicas são realizadas na seguinte ordem de precedência:

Operador Precedência

------------------------------------------------------------------

.not. mais alta

.and. intermediária

.or. mais baixa

Capítulo 5: Comandos de Atribuição

5.1 Introdução

[D] O "comando de atribuição" é usado para atribuir um valor a (ou definir) uma variável ou a um elemento de conjunto.

[C] Os comandos de atribuição calculam uma expressão e atribuem o valor resultante a uma variável ou elemento de conjunto.

[D] A forma de um comando de atribuição é:

variável=expressão

[D] Os comandos de atribuição são classificados como:

- aritmético;

- caractere;

- lógico.

[E] Exemplos:

- aritmético: varnum=3.0*a/b

- caractere: varcar='digite o valor de x:'

- lógico: varlog=.true.

[C] Após o cálculo da expressão, o valor é convertido, se necessário, para o tipo de variável de acordo com a seguinte regra:

Tipo da variável Valor atribuído

--------------------------------------------------

inteiro a parte inteira da expressão

real o valor real da expressão

dupla precisão o valor dupla precisão da expressão

complexo o valor complexo da expressão

Capítulo 6: Comandos de Especificação: Declaração de Tipos de Variáveis

6.1 Introdução

[D] Os comandos de declaração de tipo são: IMPLICIT, INTEGER, REAL, DOUBLE PRECISION, COMPLEX, LOGICAL e CHARACTER.

6.3. Comando IMPLICIT

[D] A forma geral do comando é:

IMPLICIT tipo (a[,a]...) [,tipo (a[,a]]

[C] O comando IMPLICIT permite que se defina o tipo de todas as variáveis que começam por uma determinada letra.

[e] Exemplos:

1) implicit real(i)

- faz com que todas as variáveis que comecem pela letra i sejam reais.

2) implicit real(i,j,k,l)

- faz com que as variáveis com iniciais de i a l sejam reais.

3) implicit real(i-l)

- idem.

4) implicit real(i-l),integer(a,b)

- faz a mesma coisa que o comando anterior mais a definição que as variáveis com iniciais a ou b sejam inteiras.

5) implicit none

- faz com que todas as variáveis do programa tenham que ter o seu tipo obrigatoriamente pré-definidas.

6.4. Comandos de Especificação Explícita

6.4.1. Comando Integer

[D] O comando INTEGER é usado para declarar variáveis inteiras.

[D] A forma geral do comando INTEGER é:

INTEGER nome [,nome]...

INTEGER nomevi[(d[,d]...)]

onde nomevi é o nome de uma variável indexada inteira.

[E] Exemplos:

integer soma,cont

integer a(0:10,0:8)

6.4.2. Comando REAL

[D] O comando REAL é usado para declarar variáveis reais.

[D] A forma geral do comando REAL é:

REAL nome[,nome]...

REAL nomevi[(d[,d]...)]

onde nomevi é o nome de uma variável indexada real.

[E] Exemplos:

real a,b,c

real d(1:10,1:8)

6.4.3. Comando DOUBLE PRECISION

[D] O comando DOUBLE PRECISION é usado para duplicar o número de algarismos significativos de uma variável ou de um conjunto.

[D] A forma geral do comando DOUBLE PRECISION é:

DOUBLE PRECISION nome[,nome]...

DOUBLE PRECISION nomevi[(d[,d]...)]

onde nomevi é o nome de uma variável indexada de dupla precisão.

6.4.4. Comando COMPLEX

[D] O comando COMPLEX é usado para declarar variáveis do tipo complexo.

6.4.5. Comando LOGICAL

[D] O comando LOGICAL é usado para declarar variáveis do tipo lógico.

6.4.6. Comando CHARACTER

[D] O comando CHARACTER é usado para declarar variáveis do tipo caractere.

[D] A forma geral do comando CHARACTER é:

CHARACTER*comp nome[,nome]...

CHARACTER nome*comp[,nome*comp]...

onde comp é o comprimento da(s) variável(eis) caractere.

[E] Exemplos:

character*12 a,b,c

character d*5,e*4,f*10

Capítulo 7: Comandos de Especificação: Designação de Áreas de Memória

7.1. Introdução

[C] Neste capítulo, aprenderemos a reservar áreas de memória, com os seguintes objetivos:

1) Determinar a quantidade de memória que deve ser reservada para variáveis indexadas.

2) Indicar áreas de memória que podem ser acessadas por diferentes unidades de programa.

[C] Os comandos de especificação de áreas de memória que veremos são: DIMENSION, COMMON e PARAMETER.

[C] Veremos também o comando PROGRAM (que não designa área de memória).

7.2. Comando DIMENSION

[D] O comando DIMENSION é usado para especificar nomes simbólicos como nomes de variáveis indexadas, define o número de dimensões (índices) de cada conjunto de vi´s e especifica os limites de cada dimensão.

[D] A forma geral do comando DIMENSION é:

DIMENSION c(d[,d]...)[,c(d[,d]...)]

onde:

- "c" é um nome de conjunto;

- "d" é um declarador de dimensão (que podem ser no máximo 7) e especifica os limites para cada índice do conjunto, em uma das formas: superior ou inferior:superior

- superior: o índice varia de 1 até superior.

- inferior:superior: o índice varia de inferior até superior.

[E] Exemplos:

dimension a(0:10),b(3,3),c(3,4,5)

7.5 Comando COMMON

[D] O comando COMMON é usado para especificar áreas de memória que são utilizadas em comum por várias unidades de programa, tal como o programa principal e subprogramas do tipo FUNCTION ou SUBROUTINE.

[C] Áreas de memória designadas por uma unidade de programa não são "enxergadas" pelas outras unidades. Assim, o que COMMON faz é permitir que diferentes unidades de programa "enxerguem" uma dada área de memória.

[D] A forma geral do comando COMMON é:

COMMON[/r/] lista

onde:

- "r" é um rótulo do bloco de variáveis que terão suas áreas de memória especificadas.

- "lista" é uma lista com nomes de variáveis que terão suas áreas de memória especificadas.

[E] Exemplos:

1) common m,a,x

2) dimension a(10),b(5,20)

common/bloco1/a,b

[C] O mesmo comando COMMON, escrito do mesmo jeito, deve aparecer em cada unidade de programa que pretende ter acesso às variáveis definidas num dado bloco.

7.8. Comando PARAMETER

[D] O comando PARAMETER fornece um meio de se representar uma constante por um símbolo, como na Matemática, em vez de representá-la por um valor.

[D] A forma geral do comando PARAMETER é:

PARAMETER(ns=e[,ns=e]...)

onde:

- "ns" é um nome simbólico.

- "e" é uma constante ou uma expressão constante.

[C] PARAMETER é um comando de especificação e deve ser escrito entre os comandos de especificação. Porém cada constante simbólica deve ser definida antes de qualquer referência a ela.

[C] Os novos símbolos das constantes definidas dentro de um comando PARAMETER seguem as mesmas regras para os nomes de variáveis (em relação ao tipo).

[C] O valor de uma constante definida em PARAMETER jamais é ou pode ser alterado durante a execução do programa.

[E] Exemplo:

…

real pi

parameter(pi=3.1415927)

…

7.9. Comando PROGRAM

[D] O comando PROGRAM é usado para identificar o programa principal.

[C] Todo programa possui um único programa principal.

[D] A forma geral de PROGRAM é:

program nome

onde:

- "nome" é um nome simbólico definido para o programa principal.

Capítulo 8: Comandos de Controle de Fluxo e Programação Estruturada

8.1. Introdução

[C] Normalmente, a execução dos comandos num programa é feita na ordem em que os comandos são escritos: de cima para baixo, linha por linha, de acordo com a estrutura seqüencial. Entretanto você pode usar comandos para transferir o controle de fluxo para outra parte da mesma unidade de programa ou para outra unidade de programa.

[C] O controle pode ser transferido somente para um comando executável.

[D] Por vezes, um comando pode ser identificado por um "número de comando", consistindo de um número inteiro, escrito antes do comando, no início da linha. Cada número de comando deve ser único dentro da unidade de programa. Eles servem principalmente para a especificação de formatos de entrada e/ou saída de dados. Evita-se hoje o uso antigo do número de comando, que servia de referência para uma transferência de controle de fluxo. Isto favorece a criação de códigos de programa "espaguete", onde o controle de fluxo é mudado de maneira absurda, dificultando e inviabilizando a manutenção dos programas.

8.2. Estruturas de Controle

[C] As estruturas básicas de controle são:

1. Estrutura seqüencial.

2. Estrutura se-então-senão (if-then-else).

3. Estrutura de laço faça-enquanto (while-loop).

Estrutura de laço repetição (repeat-loop).
Estrutura de seleção de caso (select case).

8.4. Comandos GO TO

[D] Os comandos GO TO transferem o controle de fluxo para um comando executável na mesma unidade de programa. Os três tipos de GO TO são:

1. GO TO incondicional.

2. GO TO computado.

3. GO TO assinalado.

8.4.1. Comando GO TO incondicional

[D] O comando GO TO incondicional transfere o controle para o comando identificado pelo número de comando especificado no GO TO.

[D] A forma geral do comando GO TO incondicional é:

go to n

onde "n" é um número de comando executável.

8.5. Comandos IF

[C] Os comandos IF transferem o controle do fluxo ou executam outro comando (ou um bloco de comandos) dependendo do resultado verdadeiro ou falso de uma expressão lógica contida no particular comando IF. Os três tipos de comandos IF são:

1. IF aritmético.

2. IF lógico.

3. IF bloco.

[C] Os comandos ELSE, ELSE IF e END IF são também apresentados nesta seção, pois eles são usados somente em conjunto com um comando IF bloco.

8.5.2. Comando IF lógico

[D] O comando IF lógico calcula uma expressão lógica/relacional e executa ou ignora um comando executável contido no próprio IF, dependendo do valor (falso ou verdadeiro) dessa expressão.

[D] A forma geral do comando IF lógico é:

if (e) c

onde:

- "e" é uma expressão lógica ou relacional.

- "c" é o comando que será executado caso a expressão seja verdade; "c" não pode ser um comando DO.

[E] Vejamos como fica o fluxo do programa quando este chega a estas três linhas:

x=a-b

if(a.eq.b) x=a+b

y=x**2

Observe que nas últimas 2 linhas temos três comandos:

1) if(a.eq.b)

2) x=a+b

3) y=x**2

a) Se de fato a=b, teremos a seguinte ordem de execução: 1 >> 2 >> 3.

b) Se, por outro lado, a é diferente de b, teremos a ordem de execução: 1 >> 3.

8.5.3. Comandos IF bloco

[D] O comando IF bloco permite a execução de um determinado bloco de comandos, dependendo do valor da(s) expressões lógica(s)/relacional(is) nele contido.

[D] A forma geral do comando IF bloco é:

if (e1) then

bloco1

else if (e2) then

bloco2

else if (e3) then

bloco3

...

else

bloco n

endif

onde e1, e2,e3, ... são expressões lógicas/relacionais.

[C] O menor IF bloco é a estrutura:

if (e) then

bloco

endif

Vemos que os comandos ELSE IF e ELSE são opcionais.

[D] O comando IF THEN permite a execução condicional de um bloco de comandos executáveis. É obrigatório usar em conjunção o comando ENDIF para fechar o comando.

[D] A forma geral do comando IF THEN é:

if (e) then

onde "e" é uma expressão lógica/relacional (portanto produzindo um resultado verdadeiro ou falso).

[C] Se a expressão "e" for verdadeira, a execução passa para o próximo comando executável e daí para o comando ENDIF. Se for falsa, o controle é transferido para o próximo comando: ELSE IF THEN, ELSE ou ENDIF.

[D] O comando ELSE fornece uma rota alternativa para um comando IF THEN ou ELSE IF THEN. Sua forma geral é simplesmente:

else

[D] O comando ELSE IF THEN combina as funções dos comandos ELSE e IF THEN, pois fornece uma rota alternativa e torna possível uma estrutura IF bloco com mais de uma alternativa.

[D] A forma geral do comando ELSE IF THEN é:

else if (e) then

onde "e" é uma expressão lógica/relacional.

[C] Se a expressão for verdadeira, o controle passa para o próximo comando executável e daí para o comando ENDIF. Se for falsa, passa para o próximo comando ELSE IF THEN, ELSE ou ENDIF.

[D] O comando ENDIF ou END IF finaliza uma estrutura IF bloco. Sua forma geral é simplesmente:

end if

[E] Exemplo:

...

print *,'Digite a nota do aluno: '

read *,nota

if(nota>=5.0) then

print *,'O aluno foi aprovado.'

elseif(nota>=3.5) then

print *,'O aluno foi reprovado mas podera cursar o RE.'

else

print *,'O aluno foi reprovado e nao podera cursar o RE.'

endif

…

8.5.5. Estruturas de IF bloco encaixados

[C] Um bloco de comandos executáveis dentro de um comando IF bloco pode conter outra estrutura IF bloco. E isto pode se repetir indefinidamente.

...

print *,'Digite a nota do aluno: '

read *,nota

if(nota>=5.0) then

if(nota>=9.5) then

print *,'O aluno foi aprovado com louvor.'

elseif(nota>=8.0) then

print *,'O aluno foi aprovado com distincao.'

else

print *,'O aluno foi aprovado.'

endif

elseif(nota>=3.5) then

print *,'O aluno foi reprovado mas podera cursar o RE.'

else

print *,'O aluno foi reprovado e nao podera cursar o RE.'

endif

…

8.6. Comando DO

[D] O comando DO é um comando de controle que permite que um bloco de comandos seja repetitivamente executado. O número de execuções depende da variável de controle.

[D] A forma geral do comando DO é:

do v = vi , vf [, incr]

onde:

- "v" é a variável do controle do laço DO.

- "vi" é o valor inicial de v.

- "vf" é o valor final ou máximo de v.

- "incr" é o incremento de v. Se for omitido, é suposto como de valor 1.

[E] Exemplo:

do i=1,100,5

bloco de comandos

enddo

[C] Existem duas estruturas DO:

1) A estrutura DO - END DO (repeat loop) repete um bloco de comandos condicionado ao valor de uma variável de controle que deve variar de modo fixo e pré-determinado:

do v=vi,vf,incr

bloco de comandos

end do

2) A estrutura DO WHILE - END DO (while loop) executa o laço DO enquanto uma expressão lógica/relacional for verdadeira:

do while (var.ge.0)

bloco de comandos

end do

8.6.2. Laços de DO encaixados

[C] É possível encaixar dois ou mais comandos DO.

[C] Para as estruturas DO encaixadas, o primeiro comando END DO após o comando DO, fecha o laço.

8.6.A. Comando EXIT

[D] O comando EXIT termina abruptamente um laço DO, direcionando o fluxo do programa para a primeira linha de comando após o ENDDO daquele respectivo comando DO envolvido.

8.7. Comando CONTINUE

[D] O comando CONTINUE é um comando executável que somente passa o controle para o próximo comando executável. A forma geral é:

continue

8.9 Comando STOP

[D] O comando STOP termina a execução do programa. Apesar de sua localização dentro do programa em geral ser a penúltima linha de comando, ele pode ser colocado em qualquer posição dentro do programa.

[D] A forma geral do comando STOP é:

stop [varcar]

onde "varcar" é uma variável caracter que será exibida na saída padrão (em geral, a tela do monitor do operador).

8.10. Comando END

[D] O comando END indica o final de uma unidade de programa para o compilador. Sua forma geral é:

end

e deve obrigatoriamente ser colocado na última linha do programa.

8.A. Comando SELECT CASE

[D] A estrutura SELECT CASE possui a seguinte forma:

select case (var)

case (um_valor_de_var)

bloco de comandos 1

case (outro_valor_de_var)

bloco de comandos 2

case (outro_ainda_valor_de_var)

bloco de comandos 3

...

end select

[E] Exemplo:

...

print *,'Digite um numero de 1 a 10: '

read *,nu

select case (nu)

case (:4)

print *,'A opcao foi um numero no intervalo [1,4]'

case (5)

print *,'A opcao pelo numero 5'

case (6:)

print *,'A opcao foi um numero no intervalo [6,10]'

end select

...

Capítulo 9: Comandos de Entrada/Saída

9.1. Introdução

[D] Os "Comandos de Entrada" fornecem um método de transferir dados de um dispositivo periférico (como um teclado) ou de um arquivo interno para a memória principal. Este processo é chamado de "leitura de dados".

[D] Os "Comandos de Saída" fornecem um meio de transferir dados da memória principal para um dispositivo periférico (como um monitor de vídeo ou impressora) ou um arquivo interno. Este processo é chamado de "escrita" ou "gravação" de dados.

[C] Alguns comandos de E/S permitem que se edite os dados durante a sua transferência.

[D] Neste capítulo somente serão apresentados os comandos de E/S que transferem dados (READ, PRINT, WRITE). Comandos auxiliares não serão discutidos.

9.2. Registros, Arquivos e Unidades

[D] Um "caractere" é um único símbolo, tal como a letra z, o dígito 4 ou um asterisco *.

[D] Um "campo" é uma sucessão de caracteres, que representa alguma informação, tal como ANTONIO ou 128.47.

[D] Um "registro" é um grupo de campos que reúne informações sobre um único item, tal como:

ANTONIO 26-01-1937 6543.21

(nome) (data nasc.) (salário)

[D] Um "arquivo" é um grupo de registros, tal como:

A N T O N I O 2 6 - 0 1 - 1 9 3 7 6 5 4 3 . 2 1

A R N A L D O 2 2 - 1 0 - 1 9 4 5 9 8 7 . 6 5

M . C R I S T I N A 0 7 - 0 9 - 1 9 4 2 1 2 3 4 . 5 6

Temos acima um arquivo, com três registros, cada registro com três campos e comprimento total de 27 caracteres.

[C] Cada comando de E/S opera sobre um único registro.

[D] Uma unidade de E/S é um meio de se referir a um arquivo. Usa-se números de unidades de E/S para distinguir um arquivo de outro.

[C] Certos números de unidades podem ser pré-definidos. Assim, por exemplo, o número 5 pode indicar o teclado e 6 pode indicar o monitor de vídeo.

[C] O comando OPEN estabelece a conexão entre o número da unidade e um particular arquivo.

9.3. Componentes dos Comandos de E/S

[C] Os comandos de E/S são constituídos de 3 partes:

comando (especificadores) [lista]

onde:

especificadores definem apropriadamente a execução do comando;
lista define a(s) variável(eis) sobre a(s) qual(is) opera o comando.

9.3.1. Lista de Especificadores de Controle de E/S

[C] Existem muitos especificadores de controle de entrada e saída. Veremos somente os mais importantes para o iniciante.

[D] UNIT: o especificador de unidade designa a unidade externa de E/S ou o arquivo interno a ser usado para o comando de E/S no qual ele aparece. Seu uso é:

[unit=]u ou [unit=]*

onde:

- "u" é uma expressão inteira que designa o número de E/S.

- "*" designa a unidade de entrada padrão em READ e saída padrão em PRINT ou WRITE.

[C] Os caracteres "unit=" somente podem ser omitidos no caso do especificador de unidade ser o primeiro na lista de especificadores.

[D] FMT: o especificador de formato designa o formato a ser usado para o comando de E/S formatado ou o comando de E/S com lista direta. Seu uso é

[fmt=]f ou [fmt=]*

onde:

- "f" é um identificador de formato;

- "*" designa uma formatação em lista direta.

[C] Os caracteres "fmt=" somente podem ser omitidos se o especificador de formato for o segundo especificador e ainda o primeiro especificador for o de unidade sem os caracteres "unit=" .

[D] O identificador de formato "f" pode ser um número de um comando FORMAT. Ou uma expressão inteira (que acaba por indicar um comando FORMAT). Ou especificações de formato (em forma de variável caractere).

[E] Exemplos. Todos eles fazem a mesma coisa e ainda o comando READ poderia ser substituído pelo comando WRITE.

Exemplo 1:

read(unit=1,fmt=100) a,b

100 format(i5,f10.3)

Exemplo 2:

read(1,100) a,b

100 format(i5,f10.3)

Exemplo 3:

read(1,*) a,b

9.3.2. Lista de E/S

[D] Uma lista de E/S tem a forma:

s[,s]…

onde "s" é uma lista de itens simples ou uma lista de DO implícito.

[C] Um item da lista pode ser um nome de variável, um nome de conjunto, um nome de elemento de conjunto, um nome de subcadeia caractere ou uma lista de DO implícito. No caso de lista de saída, ainda pode ser uma expressão.

[E] Exemplos de listas de E/S (sem DO implícito):

read(5,100) A,B,C,D

read(3,20) X,Y,C(J),D(3,4),E(I,K,7),T

read(4,121)I,A(I),J,B(I,J)

write(2,302) ALFA,BETA

write(6,122) GAMA(4*J+2,5*I+2,4*K),C,D(L)

[E] Registro de entrada contendo os dados L, M e N, que são definidos como números inteiros:

100223456789

que é lido pelos comandos:

read(5,60) L,M,N

60 format(I3,I2,I7)

apresentará os seguintes valores:

L=100

M=22

N=3456789 .

[D] Uma lista de DO implícito tem a seguinte forma:

(d , i = e1, e2 [,e3] )

onde:

- "d" é uma lista de E/S.

- i , e1, e2 e e3 têm as mesmas formas, funções e efeitos que num comando DO.

[E] Ao invés de usar:

print *, A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)

use

print *, (A(i), i = 1,9) .

9.4. Comandos READ

[D] Os comandos READ transferem dados de entrada para a memória de trabalho.

[C] IMPORTANTE: cada novo comando READ passa a ler dados em uma nova linha.

9.4.1. Comandos READ seqüenciais

[D] As formas aceitas dos comandos READ seqüencial são:

read([unit=]u,[fmt=]f) [lista]

read f [, lista]

onde "f" pode ser substituído por "*" para designar uma lista direta. Se "u" for substituído por "*" , a leitura será feita na unidade de entrada padrão.

[E] Exemplos:

read(unit=3,fmt=100) a,b,c

100 format(3f5.2)

é igual a:

read(3,100) a,b,c

100 format(3f5.2)

que ainda podem ser simplificados para:

read(3,*) a,b,c

(lista direta)

read(*,*) a,b,c

(aqui a leitura passa a ser feita a partir da entrada padrão)

9.5. Comandos WRITE (PRINT)

[D] Os comandos WRITE (PRINT) transferem dados armazenados na memória do computador para dispositivos de saída (vídeo, arquivos ou impressora).

[C] IMPORTANTE: cada novo comando WRITE (PRINT) passa a escrever dados em uma nova linha.

9.5.1. Comandos WRITE (PRINT) seqüenciais

[D] As formas aceitas dos comandos WRITE seqüencial são:

write([unit=]u,[fmt=]f) [lista]

onde "f" pode ser substituído por "*" para lista direta.

[E] Exemplos:

write(unit=7,fmt=200) a,b,c

200 format(3f5.2)

write(7,200) a,b,c

200 format(3f5.2)

(igual ao comando anterior)

write(7,200) a,b,c

200 format(3f5.2)

(praticamente igual aos comandos anteriores)

write(*,*) a,b,c

(escreve na saída padrão)

[C] A diferença entre WRITE e PRINT é que este último somente escreve na saída padrão (o vídeo, no nosso caso). Por isso PRINT dispensa o especificador de unidade.

[D] A forma aceita do comando PRINT é:

print f [, lista]

onde "f" pode ser substituído por "*" para lista direta.

[E] Exemplos:

print 200, a,b,c

200 format(3f5.2)

print *, a,b,c

(lista direta)

9.6. Comandos de Condição de Arquivos de E/S

9.6.1. Comando OPEN

[D] O comando OPEN serve para inicializar um arquivo.

[D] A forma geral simplificada do comando OPEN é:

open([unit=]u[,file='a'][,status='b'])

onde:

- "u" é o número da unidade.

- 'a' é uma expressão caractere que especifica o nome do arquivo;

- 'b' especifica a condição do arquivo, que pode ser:

-'NEW', para arquivos novos, que vão ser criados pelo programa;

-'OLD', para arquivos já existentes (em geral, arquivos de entrada de dados);

-'SCRATCH', para arquivos que são criados pelo programa e que devem ser

apagados no final da execução deste.

- 'UNKNOWN', para arquivos para os quais não se aplica nenhuma das condições

acima.

9.6.2. Comando CLOSE

[D] O comando CLOSE serve para finalizar um arquivo. É o oposto de OPEN.

[D] A forma geral simplificada do comando CLOSE é:

close([unit=]u)

onde "u" é o número da unidade.

Capítulo 10: Comando FORMAT e Especificações de Formato

10.1. Introdução

[D] FORMAT é o comando que contém uma lista de especificações de formato que permite ao programador ter controle sobre os dados de entrada e saída.

[E] Exemplo do uso de um comando de formatação:

PRINT 10 , N, X, Y

10 FORMAT ( I3, F8.3, F5.1)

onde:

- PRINT e FORMAT são comandos (ou palavras-chave);

- "10" é número de comando;

- "N,X,Y" é lista de saída;

- "I3,F8.3,F5.1" são especificações de formato.

10.2. Comando FORMAT

[D] A forma geral do comando FORMAT é:

n format (ef [,ef [,…,ef]])

onde:

- "n" é um número de comando;

- "ef" é uma especificação de formato (conversão ou edição).

[C] Pode-se usar o mesmo comando FORMAT em diversos READ, WRITE ou PRINT.

10.4. Especificações de Formato (EF) de Conversão

[D] As EF de conversão mais usadas são:

Especificação Converte dados

-------------------------------------------------------------------------------------

[a] I w inteiros decimais

[a] F w.d reais decimais, sem expoente

[a] E w.d reais decimais, com expoente

[a] D w.d reais decimais dupla precisão, com expoente

[a] G w.d reais decimais, com ou sem expoente

[a] L w lógicos

[a] A w caracteres

onde:

- "a" é uma constante inteira, sem sinal e não-nula, usada para indicar o número de vezes que a mesma EF é seguidamente usada.

- "w" é uma constante inteira, sem sinal e não-nula, usada para indicar a largura total do campo externo (incluindo dígitos, espaços, sinais algébricos + ou - , ponto decimal e expoente).

- "d" é uma constante inteira, sem sinal e que indica a quantidade de dígitos à direita do ponto decimal dentro do campo de largura w. Na saída, todos os valores são arredondados.

10.5. Especificações de Formato de Edição

[D] As especificações de edição mais usadas no Fortran77 são:

Especificação Função

---------------------------------------------------------------

w x espaçamento

/ nova linha

onde "w" representa o número de espaços desejados.

10.6. Especificações de Formato em Grupos Repetidos

[E] O comando:

520 format( i5, i5, f8.3, e16.7, f8.3, e16.7, f8.3, e16.7)

pode ser escrito de maneira mais reduzida:

520 format( 2i5, 3(f8.3, e16.7))

Capítulo 11: Subprogramas

11.1. Introdução

[D] Um "subprograma", como o próprio nome diz, é uma seqüência de comandos que fazem parte de um programa.

[C] Um programa executável consiste num único programa principal e subprogramas opcionais.

[D] Uma "função" é um tipo de subprograma que sempre retorna um valor único.

[D] Uma "subrotina" é um tipo de subprograma que retorna uma quantidade variável de valores ou não retorna nenhum valor.

[D] Uma "função intrínseca" é um subprograma do tipo função fornecido pelo compilador.

11.2. Argumentos de Subprogramas

[D] Um "argumento de subprograma" é uma entidade que transfere um valor para ou de um subprograma.

[D] Há duas espécies de argumentos: atuais e mudos.

[D] Os argumentos "atuais" são escritos no comando que chama o subprograma.

[D] Os argumentos "mudos" são especificados na definição do subprograma.

[C] Quando o controle de execução é transferido para o subprograma, os argumentos mudos são associados com os argumentos atuais na base de 1 para 1.

[E] Se (i, j(2), 5) é uma lista de argumentos atuais e (k, l, m) é uma lista associada de argumentos mudos, então k é igual a i, l é igual a j(2) e m é igual a 5.

11.3. Funções Intrínsecas (FI)

[C] As funções intrínsecas são procedimentos tão usados que achou-se por bem inclui-las como parte integrante do Fortran, e portanto, já vem definidas.

[D] Uma FI sempre é usada em uma expressão e retorna o valor calculado da função para o argumento, que se encontra entre parênteses:

FI(argumento)

[E] Exemplos:

y = cos(x) , FI = cos , nome: cosseno; argumento = x.

y = 2.0*cos(x**2) , FI = cos , nome: cosseno; argumento = x**2.

[C] Geralmente os livros de Fortran contém uma lista completa de todas as FI.

[C] ATENÇÃO: Um mesmo tipo de FI pode ter vários nomes, dependendo do tipo de argumento e do tipo do valor de retorno.

[C] A tabela abaixo contém algumas das funções intrínsecas mais usadas em Fortran. Para informações mais completas, veja o livro texto.

FUNÇÃO DESCRIÇÃO ARGUMENTO RESULTADO

int(x) converte para o tipo inteiro, truncando a mantissa real inteiro

real(x) converte para o tipo real inteiro real

nint(x) arredonda para o inteiro mais próximo real inteiro

aint(x) trunca a mantissa real real

anint(x) arredonda para o inteiro mais próximo real real

char(x) converte inteiro para caractere inteiro caractere

ichar(x) converte caractere para inteiro caractere inteiro

abs(x) valor absoluto (ou módulo) numérico mantém

mod(x,z) resto da divisão de x/z numérico mantém

max(x,z,w,...) encontra o maior valor entre os argumentos numérico mantém

min(x,z,w,...) encontra o menor valor entre os argumentos numérico mantém

len(x) comprimento de uma variável ou constante caractere caractere inteiro

index(x,z) localiza a variável ou constante caractere x dentro da variável ou constante z caractere inteiro

sqrt(x) raiz quadrada numérico real

exp(x) exponencial numérico real

log(x) logaritmo natural e neperiano numérico real

log10(x) logaritmo decimal numérico real

sin(x) seno radianos real

cos(x) cosseno radianos real

tan(x) tangente radianos real

cotan(x) cotangente radianos real

11.4. Funções Function

[D] Um subprograma função FUNCTION é usado do mesmo modo que se usa uma função intrínseca. A diferença é que o subprograma FUNCTION é escrito pelo próprio programador. Isto serve para resolver problemas como, por exemplo, para se ter uma função que obtenha o valor de y(x)=x²+3x+2. A função y(x) não teria que ser reescrita diversas vezes ao longo do programa, evitando-se erros.

[D] O subprograma FUNCTION sempre começa com o comando não-executável FUNCTION, seguido por uma seqüência de comandos e termina com um comando END. O controle de execução é retornado para o programa principal através de um comando RETURN (que também é um comando obrigatório).

[D] Regras para o uso de subprogramas FUNCTION:

1. Deve haver concordância entre os argumentos passados e recebidos, no programa principal e no subprograma.

2. Se um argumento é uma variável indexada, o número de seus elementos no subprograma pode ser menor ou igual, mas não maior, que no programa principal.

3. O único valor retornado ao programa principal está armazenado no nome da função.

4. Para retornar para o programa principal é preciso usar o comando RETURN.

5. Os subprogramas geralmente são escritos após o programa principal, quando editados no mesmo arquivo.

6. Podem ser usados números de comandos e nomes de variáveis usados também no programa principal. São tratados como coisas diferentes e independentes.

7. O tipo do valor retornado pelo subprograma FUNCTION depende do nome da função.

11.4.1. Comando FUNCTION

[D] O comando FUNCTION deve aparecer como o primeiro comando no subprograma.

[D] A forma geral do comando FUNCTION é:

[tipo] function nome ([a[,a]…])

onde:

- "tipo" é um dos tipos permitidos no F77.

- "nome" é o nome da função e obedece às regras para os nomes das variáveis.

- "a" é um argumento que é passado para ser processado pela função.

[D] A forma de chamar um subprograma FUNCTION é a seguinte (aparecendo obrigatoriamente numa expressão):

nome ([b[,b]…)

onde:

-"nome" é o nome de um subprograma.

- "b" é um argumento.

[E] Exemplo.

program volcil

implicit none

real volume,area,raio,h

print *,'Digite o raio e a altura do cilindro: '

read *,raio,h

volume=area(raio)*h

print *,volume

stop

end

real function area(x)

implicit none

real x

area=3.1415927*x**2

return

end

11.5. Funções de Comando

[D] Quando uma função envolve uma única linha de computação, não é necessário escrever um subprograma.

11.5.1. Definição de Função de Comando

[D] Uma função de comando é definida por um comando da forma:

nome ([a[,a]…]) = e

onde:

- "nome" é o nome de uma função e segue as mesmas regras para nomes de variáveis.

- "a" é um argumento.

- "e" é uma expressão.

[D] Usa-se uma função de comando como se usa uma função intrínseca.

[E] Exemplo:

area(raio) = 3.1415927*raio**2

do i = 1, 10

read(*,*) raio

write(*,*) area(raio)

enddo

11.6. Subprogramas Subrotinas

[D] Uma subrotina difere de uma função nos seguintes modos:

1. Uma subrotina não retorna um valor.

2. Para chamar (executar) uma subrotina usa-se o comando CALL.

3. A lista de argumentos da subrotina é uma via de duas mãos: leva e traz valores.

4. Uma subrotina pode retornar muitos valores, um valor, ou nenhum valor.

11.6.1. Comando SUBROUTINE

[D] O comando SUBROUTINE deve aparecer como o primeiro comando num subprograma tipo subrotina.

[D] A forma geral do comando SUBROUTINE é:

SUBROUTINE nome [([a[,a]…])]

onde:

- "nome" é o nome da subrotina.

- "a" é um argumento.

11.6.2. Comando CALL

[D] Uma subrotina é executada através de um comando CALL, que possui a seguinte forma geral:

CALL nome [([b[,b]…])]

onde:

- "nome" é um nome de subrotina.

- "b" é um argumento.

11.13. Dimensões Ajustáveis

[C] Uma variável indexada (vi) dimensionada no programa principal pode ser repassada para uma subrotina. Só que na subrotina, os índices de dimensão (a vi pode ser redimensionada) podem ser menores (nunca maiores) que aqueles definidos no programa principal.

Índice

Capítulo 0: Notas Introdutórias 2

0.1. Assuntos Gerais 2

0.2. O editor de textos 2

0.3. Sistema Operador de Discos 4

Capítulo 1: Noções Preliminares 6

1.1. Introdução 6

1.2. Computadores 6

1.3. Algoritmos 6

1.4. Diagramas de Fluxo 6

1.7. Linguagens de Programação 7

1.7.1 Linguagem de Máquina 7

1.7.2. Linguagem Simbólica de Máquina 8

1.7.3. Linguagens de Compiladores 8

1.8. Passos no Desenvolvimento de Programas 9

Capítulo 2: A Linguagem Fortran: Conceitos Básicos 10

2.1 Introdução 10

2.2. Definições da Linguagem 10

2.3. Itens sintáticos do Fortran 10

2.4. Caracteres usados no Fortran 11

2.5. Uma visão geral do Fortran 11

2.6. Codificação de programas em Fortran 14

2.6.A. Formato Livre 14

2.6.B. Formato Fixo 14

Capítulo 3: Constantes, Variáveis e Conjuntos 16

3.1 Introdução 16

3.2. Constantes 16

3.2.1. Constantes Inteiras 17

3.2.2. Constantes Reais 17

3.2.11. Constantes Caracteres 17

3.3. Variáveis 17

3.3.1. Variáveis Inteiras 18

3.3.2 Variáveis Reais 18

3.3.6. Variáveis Caracteres 18

3.4. Conjuntos 18

3.4.1 Declaradores de Conjuntos 19

Capítulo 4: Expressões 21

4.1. Introdução 21

4.2. Expressões Aritméticas 21

4.4 Expressões Relacionais 22

4.5 Expressões Lógicas 22

Capítulo 5: Comandos de Atribuição 24

5.1 Introdução 24

Capítulo 6: Comandos de Especificação: Declaração de Tipos de Variáveis 25

6.1 Introdução 25

6.3. Comando IMPLICIT 25

6.4. Comandos de Especificação Explícita 25

6.4.1. Comando Integer 25

6.4.2. Comando REAL 25

6.4.3. Comando DOUBLE PRECISION 26

6.4.4. Comando COMPLEX 26

6.4.5. Comando LOGICAL 26

6.4.6. Comando CHARACTER 26

Capítulo 7: Comandos de Especificação: Designação de Áreas de Memória 27

7.1. Introdução 27

7.2. Comando DIMENSION 27

7.5 Comando COMMON 27

7.8. Comando PARAMETER 28

7.9. Comando PROGRAM 28

Capítulo 8: Comandos de Controle de Fluxo e Programação Estruturada 29

8.1. Introdução 29

8.2. Estruturas de Controle 29

8.4. Comandos GO TO 29

8.4.1. Comando GO TO incondicional 29

8.5. Comandos IF 29

8.5.2. Comando IF lógico 30

8.5.3. Comandos IF bloco 30

8.5.5. Estruturas de IF bloco encaixados 32

8.6. Comando DO 32

8.6.2. Laços de DO encaixados 33

8.6.A. Comando EXIT 33

8.7. Comando CONTINUE 33

8.9 Comando STOP 33

8.10. Comando END 34

8.A. Comando SELECT CASE 34

Capítulo 9: Comandos de Entrada/Saída 35

9.1. Introdução 35

9.2. Registros, Arquivos e Unidades 35

9.3. Componentes dos Comandos de E/S 36

9.3.1. Lista de Especificadores de Controle de E/S 36

9.3.2. Lista de E/S 37

9.4. Comandos READ 38

9.4.1. Comandos READ seqüenciais 38

9.5. Comandos WRITE (PRINT) 38

9.5.1. Comandos WRITE (PRINT) seqüenciais 38

9.6. Comandos de Condição de Arquivos de E/S 39

9.6.1. Comando OPEN 39

9.6.2. Comando CLOSE 40

Capítulo 10: Comando FORMAT e Especificações de Formato 41

10.1. Introdução 41

10.2. Comando FORMAT 41

10.4. Especificações de Formato (EF) de Conversão 41

10.5. Especificações de Formato de Edição 42

10.6. Especificações de Formato em Grupos Repetidos 42

Capítulo 11: Subprogramas 43

11.1. Introdução 43

11.2. Argumentos de Subprogramas 43

11.3. Funções Intrínsecas (FI) 43

11.4. Funções Function 44

11.4.1. Comando FUCTION 45

11.5. Funções de Comando 46

11.5.1. Definição de Função de Comando 46

11.6. Subprogramas Subrotinas 46

11.6.1. Comando SUBROUTINE 46

11.6.2. Comando CALL 47

11.13. Dimensões Ajustáveis 47

^kh	mostra a tela da ajuda
^kx	salva e sai
^kq	sai e não salva
^c	sai e pergunta se salva
Comandos para mover-se dentro do arquivo
^v	desce uma tela
^u	volta uma tela
^x	vai para a próxima palavra
^z	volta para a palavra anterior
^p	volta para a linha anterior
^n	vai para a linha seguinte
^e	vai para o fim da linha
^a	vai para o início da linha
^ku	vai para o início do arquivo
^kv	vai para o fim do arquivo
^kl	vai para uma linha de número específico
Comandos para apagar texto
^d	apaga um caracter
^w	apaga uma palavra
^y	apaga uma linha
^_ ou ^?	desfaz a ultima apagada
Comandos para procura e troca
^kf	procura e troca
^l	procura a próxima ocorrência do mesmo texto
Comandos para trabalhar com blocos
^kb	marca o início do bloco
^kk	marca o fim do bloco
^kc	copiar o bloco marcado para a localização atual
^km	move o bloco marcado para a localização atual
^ky	apaga o bloco marcado

Código da Operação	Operando	Comentário
14	1000	carrega A no acumulador
12	=5	multiplica o acumulador por 5
15	3000	armazena conteúdo acumulado no endereço 3000
14	1004	carrega B no acumulador
12	=16	multiplica acumulador por 16
10	3000	adiciona acumulador com conteúdo de 3000
13	1012	divide acumulador pelo conteúdo de 1012
11	1020	subtrai acumulador do conteúdo de 1020
15	2050	armazena acumulador em 2050

Operação	Operando	Comentário
CAR	A	carrega A
MUL	5	multiplica por 5
ARM	TMP	armazena o resultado em TMP
CAR	B	carrega B
MUL	16	multiplica por 16
ADI	TMP	adiciona o resultado com o conteúdo de TMP
DIV	C	divide o resultado por C
SUB	D	subtrai o resultado de D
ARM	R	armazena o resultado em R

A	N	T	O	N	I	O				2	6	-	0	1	-	1	9	3	7	6	5	4	3	.	2	1
A	R	N	A	L	D	O				2	2	-	1	0	-	1	9	4	5		9	8	7	.	6	5
M	.	C	R	I	S	T	I	N	A	0	7	-	0	9	-	1	9	4	2	1	2	3	4	.	5	6

FUNÇÃO	DESCRIÇÃO	ARGUMENTO	RESULTADO
int(x)	converte para o tipo inteiro, truncando a mantissa	real	inteiro
real(x)	converte para o tipo real	inteiro	real
nint(x)	arredonda para o inteiro mais próximo	real	inteiro
aint(x)	trunca a mantissa	real	real
anint(x)	arredonda para o inteiro mais próximo	real	real
char(x)	converte inteiro para caractere	inteiro	caractere
ichar(x)	converte caractere para inteiro	caractere	inteiro
abs(x)	valor absoluto (ou módulo)	numérico	mantém
mod(x,z)	resto da divisão de x/z	numérico	mantém
max(x,z,w,...)	encontra o maior valor entre os argumentos	numérico	mantém
min(x,z,w,...)	encontra o menor valor entre os argumentos	numérico	mantém
len(x)	comprimento de uma variável ou constante caractere	caractere	inteiro
index(x,z)	localiza a variável ou constante caractere x dentro da variável ou constante z	caractere	inteiro
sqrt(x)	raiz quadrada	numérico	real
exp(x)	exponencial	numérico	real
log(x)	logaritmo natural e neperiano	numérico	real
log10(x)	logaritmo decimal	numérico	real
sin(x)	seno	radianos	real
cos(x)	cosseno	radianos	real
tan(x)	tangente	radianos	real
cotan(x)	cotangente	radianos	real

A	N	T	O	N	I	O				2	6	-	0	1	-	1	9	3	7	6	5	4	3	.	2	1
A	R	N	A	L	D	O				2	2	-	1	0	-	1	9	4	5		9	8	7	.	6	5
M	.	C	R	I	S	T	I	N	A	0	7	-	0	9	-	1	9	4	2	1	2	3	4	.	5	6

A	N	T	O	N	I	O				2	6	-	0	1	-	1	9	3	7	6	5	4	3	.	2	1
A	R	N	A	L	D	O				2	2	-	1	0	-	1	9	4	5		9	8	7	.	6	5
M	.	C	R	I	S	T	I	N	A	0	7	-	0	9	-	1	9	4	2	1	2	3	4	.	5	6