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.
 

[CF] A forma geral do comando FUNCTION é:

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

sendo que:

- "tipo" é um dos tipos de variáveis permitidas no Fortran.
- "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.
 

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

    nome ([b[,b])

sendo que:

-"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

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

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

sendo que:

- "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.

[D] A função de comando é um comando não-executável e portanto deve ser declarada no início do programa, antes de qualquer comando executável.
 

[E] Exemplo:
    program exemplo
    implicit none
    real area,raio
    integer i
    area(raio) = 3.1415927*raio**2
    do i = 1, 10
    read(*,*) raio
    write(*,*) area(raio)
    enddo
    stop
    end

[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.
 

[CF] A forma geral do comando SUBROUTINE é:

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

sendo que:

- "nome" é o nome da subrotina.
- "a" é um argumento.
 

11.6.2. Comando CALL

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

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

sendo que:

- "nome" é um nome de subrotina.
- "b" é um argumento.
 

[E] Este é um exemplo simples, sendo que seria até desnecessário o uso de um subprograma do tipo SUBROUTINE para zerar 3 matrizes:

     program matriz1
! Objetivo: exemplo do uso de subrotinas
! Programador: FCLavarda
     implicit none
     integer n,i,j
     parameter(n=3)
     real a(n,n),b(n,n),c(n,n)
     call zerador(a,b,c,n)
     do i=1,n
          print *,(a(i,j),j=1,n)
     enddo
     stop
     end
     subroutine zerador(x,y,z,k)
     implicit none
     integer k,i,j
     real x(k,k),y(k,k),z(k,k)
     do i=1,k
          do j=1,k
               x(i,j)=0.0
               y(i,j)=0.0
               z(i,j)=0.0
          enddo
     enddo
     return
     end
 

11.7. Dimensões Ajustáveis

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