fortran_90

Disciplina: Métodos Computacionais / 1º Semestre de 2005 Parte 1 – Conceitos Fundamentais da Linguagem Fortran – Versão F90

1. Introdução 1 2. Linguagens de Programação 1 3. Uso da Linguagem Fortran em Computadores 3 4. Formatação de um Programa em Fortran 3 5. Estrutura de um Programa em Fortran 4 6. Constantes e Variáveis 5 6.1 Declaração de Constantes e Variáveis 6 6.2 Inicialização de Valores de Variáveis 6 6.3 Programa com Diferentes Tipos de Variáveis 7 7. Leitura e Impressão de Dados em Arquivo Externo 8 8. Comentários 9 9. Formatação de Dados de Entrada e Saída 9 10. Funções Internas 11 11. Expressões Aritméticas e Lógicas 11 11.1 Exemplos 12 12. Comandos IF e DO 12 13. Sub-rotinas e Funções 13 14. Arranjos ou Variáveis Compostas 14 14.1 Dimensionamento Dinâmico de Arranjos 15 14.2 Operações com Arranjos em F90 15 Anexo – Lista de Programas 16 Referências Bibliográficas 35

Autor: Renato César Gavazza Menin Brasília, 22 de Março de 2005

Métodos Computacionais / 1º Semestre de 2005 1

1. Introdução:

• Solução Analítica. • Laboratório. • Computador.

Forma Vantagens Desvantagens

Sol. Analítica Resposta exata. Visualização de todo o processo.

Necessário fazer simplificações ( linearizações, homogeneização de materiais, simetrias ...). Inviável para problemas complexos (tempo).

Laboratório Realismo. Disponibilidade e custos de materiais, equipamentos e mão de obra). Necessidade de grande quantidade de ensaios.

Computador Sem simplificações. Rapidez, relativamente barato.

Uso de softwares não confiáveis. Análise inadequada de resultados.

2. Linguagens de Programação: Os programadores escrevem instruções em várias linguagens de programação, algumas entendidas diretamente pelo computador e outras que exigem passos intermediários de tradução. Centenas de linguagens computacionais estão atualmente em uso. Estas podem ser divididas em três tipos gerais:

• Linguagens de máquina. • Linguagens assembly. • Linguagens de alto nível.

Qualquer computador pode entender apenas a sua própria linguagem de máquina, que está relacionada intimamente com o seu projeto de hardware. Geralmente as linguagens de máquina consistem em strings de números (reduzidos em última análise de 1s e 0s) que dizem ao computador para realizar uma de suas operações mais elementares de cada vez. As linguagens de máquina são dependentes da máquina (não padronizadas), ou seja, uma determinada linguagem de máquina só pode ser usada com um tipo de computador. As linguagens de máquina são complicadas para os humanos, como se pode ver no trecho de um programa em linguagem de máquina extraído de Deitel & Deitel [1994], que adiciona o Termo_B ao Termo_A e armazena o resultado no Termo_C. +1300042774 +1400593419 : linguagem de máquina +1200274027 À medida que os computadores se tornaram mais populares, ficou claro que a programação em linguagem de máquina era muito lenta e tediosa para a maioria dos programadores. Em vez de usar strings de números que os computadores podiam entender diretamente, os programadores começaram a usar abreviações parecidas com palavras em inglês para representar as operações elementares de um computador. Estas abreviações formam a base das linguagens assembly. Foram desenvolvidos programas tradutores, chamados assemblers, para converter programas de linguagem assembly para linguagem de máquina. O trecho de um programa em linguagem assembly a seguir, extraído de Deitel & Deitel [1994], também


adiciona o Termo_B ao Termo_A e armazena o resultado no Termo_C, porém isto é feito de uma forma mais clara que o programa equivalente em linguagem de máquina. LOAD Termo_A ADD Termo_B : linguagem assembly STORE Termo_C O uso do computador aumentou rapidamente com o advento das linguagens assembly, mais elas ainda exigiam muitas instruções para realizar mesmo as tarefas mais simples. Para acelerar o processo de programação, foram desenvolvidas linguagens de alto nível, nas quais podiam ser escritas instruções simples para realizar tarefas fundamentais. Os programas tradutores que convertiam linguagens de alto nível em linguagem de máquina são chamados compiladores. As linguagens de alto nível permitem aos programadores escrever instruções que se parecem com o idioma inglês comum e contém as notações matemáticas normalmente usadas. O mesmo trecho de programa comentado acima pode se escrito em uma linguagem de alto nível da seguinte forma: Termo_C = Termo_A + Termo_B : linguagem de alto nível Obviamente, as linguagens de alto nível são muito mais desejáveis do ponto de vista do programador do que as linguagens de máquina ou assembly. Dentre as linguagens de computador de alto nível mais comuns hoje em dia, destacam-se: Ada, Basic, Cobol, C, C++, Delphi, Fortran e Pascal. Destas linguagens, o Fortran tem sido uma das linguagens mais utilizadas nos últimos cinqüenta anos para cálculos científicos em geral, tendo sido empregada para uma grande variedade de aplicações: modelos computacionais de centrais nucleares, projetos de aeronaves, sistemas de processamento de sinais sísmicos, programação em supercomputadores, computação paralela de grande porte, etc... A linguagem Fortran foi a primeira linguagem de alto nível usada para programação de computadores. Foi proposta em 1953 por J. Backus, mas o seu primeiro compilador, feito para o computador IBM 704, só foi liberado em 1957. Seu nome é formado pelas letras iniciais das palavras FORmula TRANslation, que indicam sua principal inovação na época: a facilidade de transcrição de fórmulas matemáticas para serem usadas em computadores. Posteriormente, numerosos aperfeiçoamentos foram introduzidos em novas versões, sendo principais as denominadas Fortran II (1958), Fortran IV (1961), Fortran 66 (1966) e o Fortran 77 (1977), o qual resultou de um esforço para modernizar as versões anteriores e formar um padrão que foi aprovado pelo American National Standards Institute (ANSI). Dentre as modernizações destacam-se a introdução de estruturas de controle, (bloco IF) e facilidades na manipulação de variáveis literais. A próxima grande atualização da linguagem foi representada pelo Fortran 90. Dentre os avanços do Fortran 90 podem-se destacar: new free source format (na versão Fortran 77, as colunas 1 a 5 deveriam conter o número do comando ou declaração, quando usado, a coluna 6 era usada para indicar a continuação da linha anterior e os comandos deveriam estar compreendidos entre as colunas 7 a 72 ao passo que na versão Fortran 90, pode-se iniciar a digitação dos comandos na coluna 1); facilidades na criação e operações de manipulação de arrays (vetores e matrizes); interfaces mais amigáveis; etc... Nas próximas seções serão apresentadas algumas estruturas, palavras chaves, comandos de atribuição, comandos de entrada e saída de dados, ferramentas para modularização (subrotinas e funções) e aspectos em geral para construção de programas na linguagem Fortran, dando-se ênfase à versão F90, porém fazendo uma analogia à versão F77 quando necessário.


3. Uso da Linguagem Fortran em Computadores: A utilização da linguagem Fortran para resolver um problema em um computador faz-se, como em outras linguagens de programação, através de sucessivas fases:

• Definição do Problema. É a descrição e a delimitação do problema a ser resolvido, caracterizando-o de maneira clara e completa.

• Desenvolvimento de um Algoritmo. Objetiva a descrição, geralmente desenvolvida por etapas (refinamentos), do processamento a ser realizado para resolver o problema e obter os resultados desejados no computador.

• Transcrição do algoritmo para a Linguagem Fortran. Objetiva a obtenção de um programa equivalente, de acordo com as regras e recursos oferecidos pela linguagem.

• Processamento do Programa pelo Computador. Obedecendo a um programa denominado compilador da linguagem Fortran, o computador verifica a correção sintática do programa que lhe é apresentado e o traduz para um novo programa em linguagem de máquina. Em seguida este novo programa é executado e passa a controlar o computador através das suas instruções, fazendo a resolução do problema e obtendo os resultados desejados.

• Análise de Resultados. Os resultados obtidos pelas primeiras execuções de um programa num computador devem ser cuidadosamente analisados, pois eles podem estar parcial ou totalmente comprometidos com erros cometidos nas quatro primeiras fases. Se houver erro, será necessário retornar à fase correspondente, fazer as devidas correções e repassar as fases seguintes.

4. Formatação de um programa em Fortran: O texto de um programa em Fortran 77 deve ficar disposto em linhas. As linhas devem ter 80 colunas, e cada coluna só pode conter um caractere (letra, dígito ou sinal especial). As colunas 73 a 80 não são analisadas pelo compilador e geralmente são deixadas em branco. Antigamente, quando os programas eram digitados em cartões perfurados (cada linha em um cartão), estas colunas eram usadas para numerar os cartões e facilitar a sua reordenação caso acidentalmente ficassem desordenados. Cada linha de um programa pode conter um comentário, uma declaração ou um comando. Se a linha contiver um comentário, a coluna 1 deve ter a letra C, e as colunas 2 a 72, os dizeres do comentário. Se a linha contiver um comando ou uma declaração, as colunas devem ser agrupadas da seguinte maneira:

• colunas 1 a 5 para conter o número do comando ou da declaração (label ou rótulo), quando usado;

• coluna 6 para indicar continuação da linha anterior; • colunas 7 a 72 para conter o comando ou a declaração.

Programa Fonte ⇓ ( Compilador )

Programa Objeto + Biblioteca ⇓ ( Linkagem )

Programa Executável ⇓ ( Execução )

Resultados


Um comando ou declaração pode continuar nas colunas 7 a 72 de várias linhas consecutivas que contiverem na coluna 6, caractere diferente de zero e de espaço em branco. Neste caso, a coluna 7 de uma linha de continuação é considerada como sucessora da coluna 72 da linha anterior. No caso do Fortran 90, graças ao chamado free source format, conforme comentado anteriormente, os comandos e declarações podem ser digitados em qualquer lugar de uma linha e cada linha pode receber até 132 caracteres. Caso um comando ou declaração seja muito longo e não caiba em uma única linha, pode-se continuar na linha seguinte digitando-se o símbolo & (ampersand) no final da linha corrente. Por exemplo, os seguintes comandos são idênticos:

Output = input1 + input2

Output = input1 & + input2 Vale ressaltar que tanto no Fortran 77 quanto no Fortran 90, os espaços em branco são irrelevantes e ignorados pelo programa compilador. Eles são considerados apenas nas constantes literais. 5. Estrutura de um Programa em Fortran: Cada programa em Fortran consiste de um agrupamento de declarações executáveis e não executáveis, que devem ocorrer em uma ordem específica. Um programa simples em F90 é mostrado a seguir, no qual dois números inteiros são lidos digitando-se os números através do teclado e em seguida é efetuada a multiplicação de um pelo outro e a impressão do resultado da multiplicação dos números na tela do computador: Vale ressaltar que os programas fonte em Fortran escritos na versão F77 devem ter a extensão “.for” ao passo que os programas fonte escritos na versão F90 devem possuir uma extensão “.f90”. É através da extensão que o compilador reconhece em que versão o programa fonte foi escrito. O compilador não aceitará o free source format se o arquivo fonte for definido com a extensão “.for”.

Program exercise_1 ! Purpose: ! To illustrate some of the basic features of a Fortran program. ! Declare de variables used in this program: integer I,J,K ! Read the numbers: write(*,*) ‘Enter the numbers to multiply: ‘ read (*,*) I,J ! Multiply the numbers: K = I*J ! Write out the result: write(*,*) ‘Result = ‘, K end program

Estrutura de um Programa Simples: * Nome * Declarações (não executáveis) * Linhas executáveis * End program


6. Constantes e Variáveis: As constantes, conforme o próprio nome diz, são entidades cujos valores são fixos ao longo de todo o programa, não sendo possível alterar os seus valores durante a execução, sendo declaradas através do comando parameter. Já as variáveis podem sofrer alterações ao longo da execução do programa. A cada variável corresponde uma posição de memória, cujo conteúdo pode variar ao longo do tempo, durante a execução do programa. Embora uma variável possa assumir diferentes valores, ela só pode armazenar um valor a cada instante. Toda constante ou variável é identificada por um nome ou identificador, cuja formação obedece a determinadas regras:

• F77: identificador pode ter no máximo 6 caracteres. • F90: identificador pode ter até 31 caracteres. • Os identificadores não são case sensitive, ou seja, letras maiúsculas e minúsculas são

consideradas iguais pelo compilador: variable_1 = Variable_1 = VARIABLE_1. • O primeiro caractere de um identificador deve, obrigatoriamente, ser uma letra e os

demais, letras ou números, não sendo permitido o uso de símbolos especiais: Exemplo:

1. Identificadores permitidos: Nota, total, A, X5, Var1, A32B, F1G3H5, step_1,...

2. Identificadores não permitidos: 5B : começa pelo dígito 5 E(13) : contém os caracteres especiais ( ) A:B : contém o caractere especial : Var A : contém espaço em branco Var–A : contém o caractere especial – . Observação: Não confundir o caractere “_ “ com o caractere “–“.

Conforme o seu tipo, as constantes e variáveis podem ser classificadas como numéricas (inteiras ou reais), lógicas ou literais, entre outras.

26 letras do alfabeto (a,b,c,d,...,w,x,y,z) 10 números (0,1,2,3,..., 8,9) barra inferior ( _ )

1. Integer: armazena em forma exata até o limite, sem parte decimal. intervalo válido: [ -2147483648, +2147483647 ]. exemplos: 1000, 0, 1, -1, 999,...

2. Real: números reais, ou seja, com parte decimal em precisão simples. número de dígitos na mantissa: 6 intervalo válido: [1.0e+38, 1.0e-37], positivo ou negativo. exemplos: 1.5, -0.01, 37., -6.8543, -1.0e-2, ... 3. Real*8: números reais, ou seja, com parte decimal em precisão dupla. número de dígitos na mantissa: 15 intervalo válido: [1.0e+308, 1.0e-307], positivo ou negativo. exemplos: 1.5000, -0.0001, 37., -6.8543, -1.0e-2, ...


6.1 Declaração de Constantes e Variáveis: No F77 havia uma regra de declaração implícita de variáveis, segundo a qual qualquer variável que começasse com as letras (I, J, K, L, M, N) representavam variáveis inteiras (integer) e todas as variáveis que começassem com outra letra diferente destas representavam variáveis reais (real), a não ser que se declarasse diferente, de forma explícita. Desta forma obtém-se declarando a variável inteira Juro1 de forma implícita e a variável real Juro2 de forma explícita: Real Juro2 Juro1 = 0.09 ! Resultado: Juro1 = 0 (integer) Juro2 = 0.09 ! Resultado: Juro2 = 0.09 (real) Embora seja permitido este tipo de declaração implícita, para maior clareza do programa é aconselhável que as variáveis sejam declaradas explicitamente, o que pode ser feito da seguinte forma, conforme o tipo de variável: integer var1, var2 ! declaração de variáveis do tipo inteiro. real var3, var4 ! declaração de variáveis do tipo real com precisão simples. real*8 var5 ! declaração de variáveis do tipo real com precisão dupla. logical var6,var7 ! declaração de variáveis do tipo lógica. character*n var8 ! sendo “n” o número máximo de caracteres na variável var8. Pode-se inibir a declaração implícita com o comando: implicit none, colocado antes da declaração de variáveis, no início do programa. 6.2 Inicialização de Valores de Variáveis:

a) Explicitar: Contador = 1 Taxa = 0.09 Word = ‘Met_Computacionais’

b) Utilizando declaração DATA: DATA A,B,C /1,2,3.1415/ ! Observação: A = 1, B = 2 e C = 3.1415

c) Entrar via teclado (recomendado para pequena quantidade de dados). d) Leitura de arquivo de entrada de dados (recomendado para grandes volumes).

4. Logical: é um valor lógico, que só pode ser verdadeiro ou falso, usado em proposições lógicas. só existem duas constantes deste tipo, sendo representadas pelas palavras true e false, precedidas e seguidas por ponto decimal, .true. e .false.. 5. Character: constante literal que representa qualquer seqüência de caracteres. a seqüência de caracteres, também conhecida por string, deve estar entre apóstrofos. número máximo de caracteres = [255]. exemplos: ‘Met_Computacionais’, ‘Resultado : ‘, ‘A5%(x): ‘,...


6.3 Programa com Diferentes Tipos de Variáveis: Impressão de Resultados na Tela do Computador:

Program exercise_2 ! Objetivo: ! Ilustrar a utilização de diferentes tipos de variáveis. ! Declaração de variáveis do programa: integer I,J,K real var1,var2,var3 real*8 var4 logical flag1,flag2,flag3,flag4,flag5 character*7 const1 character*2 const2 character*9 const3 real*8, parameter :: const_4 = 2500.0 ! Declaração e inicialização de constante ! Inicialização explícita de variáveis: I = 17 J = 4 var1 = 2.000 var2 = 3.000 flag1 = .true. flag2 = .false. const1 = ‘Fortran’ const2 = ‘90’ ! Operações com variáveis: K = I/J ! Divisão de inteiro por inteiro = inteiro (arredondamento para baixo) var3 = var1*var2 var4 = var1*var2 flag3 = flag1.and.flag2 flag4 = flag1.or.flag2 flag5 = .not.flag1 const3 = const1//const2 ! Operação de concatenação de strings ! Imprimir os resultados na tela do computador: write(*,*) ‘Valor de K = ‘, K write(*,*) ’Valor de var3 (simple precision) = ‘,var3 write(*,*) ’Valor de var4 (double precision) = ‘,var4 write(*,*) ’Valor de flag3 = ‘,flag3 write(*,*) ’Valor de flag4 = ‘,flag4 write(*,*) ’Valor de flag5 = ‘,flag5 write(*,*) ‘String const3 = ‘,const3 write(*,*) 'Constante const_4 = ',const_4 end program

Valor de K = 4 Valor de var3 (simple precision) = 6.000000 Valor de var4 (double precision) = 6.000000000000000 Valor de flag3 = F Valor de flag4 = T Valor de flag5 = F String const3 = Fortran90 Constante const 4 = 2500.000000000000000


7. Leitura e Impressão de Dados em Arquivo Externo: No caso de uma grande quantidade de dados é sempre interessante a leitura e a impressão dos mesmos em arquivos externos. Antes de usar um arquivo externo é necessário que o mesmo seja aberto utilizando-se o comando OPEN. O comando OPEN abre um arquivo através das seguintes operações: associa o nome externo do arquivo à unidade que será usada nos comandos de entrada ou saída, e estabelece o atributo de estado do arquivo. A forma do comando é a seguinte:

Open (Unit = n, File = ‘nome-ext-arquivo’, Status = ‘estado’)

• n: variável ou constante, inteira e não negativa que identifica a unidade de entrada ou saída;

• nome-ext-arquivo: é o nome externo do arquivo que deve ser colocado entre apóstrofos ou então o nome de uma variável do tipo character colocada sem apóstrofos;

• estado: indica o estado do arquivo no momento da abertura. O valor do estado deve vir entre apóstrofos e pode ser um dos seguintes valores:

Old: indica que o arquivo externo já existe (normalmente arquivos de entrada). New: indica que um novo arquivo será criado (normalmente arquivos de saída). Unknown: quando não se sabe o estado do arquivo, podendo ser utilizado para

arquivos de entrada ou saída de dados.

Program exercise_3 ! Objetivo: Ilustrar a leitura e impressão de dados em arquivos externos. ! Declaração de variáveis do programa: integer I,J,K real var1,var2,var3 character*15 filein, fileout ! nomes dos arquivos de entrada (*.dat) e saída de dados (*.out) ! Abertura de arquivos externos para entrada e saída de dados: write(*,*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*.dat) read (*,*) filein open(unit=10, file=filein, status = ‘unknown’) write(*,*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*.out) read (*,*) fileout open(unit=20, file=fileout, status = ‘unknown’) ! Leitura de Dados do Arquivo de Entrada de Dados: read(10,*) I,J read(10,*) var1,var2 ! Operações com variáveis: K = I+J var3 = var1 * var2 ! Imprimir os resultados na tela do computador: write(*,*) ‘Valor de K = ‘, K write(*,*) ’Valor de var3 = ‘,var3 ! Imprimir os resultados no arquivo de saída: write(20,*) ‘Valor de K = ‘, K write(20,*) ’Valor de var3 = ‘,var3 end program

Arquivo de Entrada de Dados / Exercise_3.dat 2 3 ! integer I,J 5.00 6.00 ! real var1,var2 Arquivo de Saída de Dados / Exercise_3.out Valor de K = 5 Valor de var3 = 30.000000


8. Comentários: O comentário é um texto ou simplesmente uma frase utilizada para melhorar a clareza do programa. Na versão F77, a linha de comentário deve ter a letra C na primeira coluna e os dizeres do comentário colocados nas colunas 2 a 72. Na versão F90, para se colocar um comentário basta utilizar o caractere ! em qualquer coluna e colocar o comentário logo após o caractere que o compilador irá desconsiderar qualquer texto colocado desde o símbolo ! até o final da linha. 9. Formatação de Dados de Entrada ou Saída: Na linguagem Fortran, é através da especificação format, que é descrito como os dados estão dispostos em um meio de entrada e como eles deverão ser distribuídos em um meio de saída. Sua forma geral é dada por:

read(u,n) lista-de-identificadores write(u,n) lista-de-identificadores n format(especificação-de-edição)

• u: é uma constante positiva ou variável contendo um valor inteiro positivo, que

especifica qual a unidade de entrada ou saída que será utilizada. • n: é um número também chamado de rótulo ou label da especificação format, a qual

indica como os dados encontram-se distribuídos em um meio de entrada ou como eles devem aparecer em um meio de saída de dados.

• lista-de-indentificadores: são os nomes das variáveis, separados por vírgulas, nas quais serão armazenados os valores provenientes do meio de entrada ou cujos conteúdos serão mostrados através do meio de saída.

• especificação-de-edição: é um conjunto de informações sobre a distribuição dos dados em um meio de entrada/saída, conforme pode ser visto na tabela abaixo sendo w o tamanho total do campo de entrada/saída.

Vale ressaltar que caso seja digitado o caractere asterisco na unidade de entrada do comando read ou na unidade de saída do comando write, ou seja (u = *), isto significa que os dados de entrada (read) e de saída (write) são respectivamente lidos e impressos na tela do computador, não sendo utilizados arquivos externos de entrada ou saída de dados. No caso do rótulo da especificação format ser definido com o símbolo asterisco (n = *), não é necessário colocar o formato da entrada ou saída de dados, uma vez que os mesmos serão lidos ou impressos em formato livre. Recomenda-se que não seja utilizada formatação nos arquivos de entrada, uma vez que isto pode ocasionar a leitura de dados de forma inadequada por um usuário desavisado. Em um campo de saída, os números aparecem sempre alinhados à direita. Se o número for negativo, um sinal “–“ é colocado antes do número e se o número for positivo, nenhum sinal é colocado antes do número. Se o valor de um dado de saída precisar de mais posições do que as previstas no formato, este será preenchido com asteriscos.

Especificação Tipo de Variável Observação I w integer Entrada ou saída de inteiros Fw.d real Notação cientifica (d = parte decimal) Ew.d real Notação exponencial (d = parte decimal) Aw character Entrada ou saída de caracteres wX ------- Espaços em branco / ------- Pular para linha seguinte


Program exercise_4 ! Objetivo: Ilustrar a formatação de dados de saída ! Declaração de variáveis do programa: integer I,J,K real var1,var2,var3 character*7 programa character*15 filein, fileout ! nomes dos arquivos de entrada (*.dat) e saída de dados (*.out) ! Abertura de arquivos externos para entrada e saída de dados: write(*,*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*.dat) read (*,*) filein open(unit=10, file=filein, status = ‘unknown’) write(*,*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*.out) read (*,*) fileout open(unit=20, file=fileout, status = ‘unknown’) ! Leitura de Dados do Arquivo de Entrada de Dados: read(10,*) I,J ! Dados de entrada não formatados read(10,*) var1,var2 read(10,*) programa ! Operações com variáveis: K = I+J var3 = var1 * var2 ! Imprimir os resultados no arquivo de saída sem formatação: write(20,*) ‘Imprimir Resultados – no format: ‘ write(20,*) ‘Valor de K = ‘, K write(20,*) ’Valor de var3 = ‘,var3 write(20,*) ’Nome do programa = ‘,programa ! Imprimir os resultados no arquivo de saída com formatação: write(20,25) 25 format(//‘ Imprimir Resultados – format: ‘) write(20,30) K 30 format(‘Valor de K = ‘,2x,I8) write(20,40) var3,var3 40 format(‘Valor de var3 =’,2x,F8.2,/, ‘Valor de var3 =’,2x,E8.2) write(20,50) programa 50 format(‘Nome do programa =’,A10) end program

Arquivo de Entrada de Dados / Exercise_4.dat 10 15 ! integer I,J 7.00 6.00 ! real var1,var2 Fortran ! character*7 programa

Arquivo de Saída de Dados / Exercise_4.out Imprimir Resultados - no format: Valor de K = 25 Valor de var3 = 42.000000 Nome do programa = Fortran Imprimir Resultados - format: Valor de K = 25 Valor de var3 = 42.00 Valor de var3 = .42E+02 Nome do programa = Fortran


10. Funções Internas: Podem-se usar nas expressões aritméticas algumas funções muito comuns na matemática e que são supridas pelo compilador Fortran. Na tabela abaixo são apresentadas algumas das principais funções intrínsecas existentes no Fortran 90: 11. Expressões Aritméticas e Lógicas: Denomina-se expressão aritmética, àquela cujos operadores são aritméticos e cujos operandos são constantes e/ou variáveis numéricas. Por outro lado, denomina-se expressão lógica à expressão cujos operadores são lógicos e cujos operandos são relações, variáveis e/ou constantes do tipo lógico. Tabela 11.1 – Operadores aritméticos Tabela 11.2 – Prioridade da operações Tabela 11.4 – Operadores relacionais e lógicos Tabela 11.3 – Prioridade das operações

Função Definição Parâmetro Resultado ---------------------------------------------------------------------------------------------------------- abs(X) valor absoluto de x real/inteiro real/inteiro acos(X) cos-1(x) em rad real real asin(X) sen-1(x) em rad real real atan(X) tan-1(x) em rad real real cos(X) cos(x) sendo x em rad real real sin(X) sen(x) sendo x em rad real real tan(X) tan(x) sendo x em rad real real exp(X) ex real real log(X) loge(x) real real log10(X) log10(x) real real mod(X,Y) resto da divisão de X por Y inteiro inteiro float(X) conversão de inteiro para real inteiro real sqrt(X) raiz quadrada de x real real max(X1,...,Xn) seleciona o maior valor Xi real/inteiro real/inteiro min(X1,...,Xn) seleciona o menor valor Xi real/inteiro real/inteiro

operador operação -------------------------------- + adição – subtração * multiplicação / divisão ** potenciação

prioridade operação --------------------------------------------- 1ª potenciação 2ª multiplicação/divisão 3ª adição/subtração

F77 F90 definição ----------------------------------------------- .LT. < menor que .GT. > maior que .LE. <= menor ou igual a .GE. >= maior ou igual a .EQ. == igual a .NE. /= diferente de .AND. .AND. para conjunção .OR. .OR. para disjunção .NOT. .NOT. para negação

prioridade operador --------------------------------- 1ª aritmético 2ª relacional 3ª .NOT. 4ª .AND. 5ª .OR.


11.1 Exemplos: 1) Expressão matemática: Representação no Fortran: 1.1) ).( APP − (P*(P – A))**0.5 ou sqrt(P*(P – A))

1.2) GFE

DCBA +

−

++−

1. A – B*(C+D/(E+1) – F)+G

2) Variáveis Relação Resultado --------------------------------------------------------------- X =1, Y=2, Z=5 X**2+Y.GT.Z .false. X=4, Y=3, Z=1 X**2+Y>=Z .true. 12. Comandos IF e DO: Num programa escrito em linguagem Fortran, aparecem em primeiro lugar as declarações, seguidas por comandos que, se não houver indicação em contrário, deverão ser executadas numa seqüência linear, seguindo-se o texto em que estão escritos, de cima para baixo. O fim físico do programa é representado pela palavra chave END. Dentro da estrutura seqüencial do Fortran, comentada no parágrafo acima, podem existir estruturas condicionais ou de repetição. A estrutura condicional é representada pelo comando IF, sendo executada quando uma determinada condição for verdadeira ou falsa, conforme as suas diferentes formas apresentadas abaixo: Já a estrutura de repetição da linguagem Fortran é representada pela palavra-chave DO, permitindo que uma seqüência de comandos seja executada repetidamente até que uma determinada condição de interrupção seja satisfeita. As diferentes formas do comando DO são apresentadas abaixo: Nas duas primeiras estruturas mostradas acima o bloco de comandos é executado repetidamente com I=J, I=J+1, I=J+2, ... ,I=K, ao passo que na terceira estrutura o termo L representa o incremento na variável I, de modo que o bloco de comandos é executado repetidamente com I=J, I=J+L, I=J+2L, I=J+3L, ..., I=J+nL ≤ K.

if (condição) comando_1

if (condição) then bloco_1 endif

if (condição) then bloco_1 else bloco_2 endif

if (condição1) then bloco_1 elseif (condição2) then bloco_2 elseif (condição3) then bloco_3 . . . else bloco_n endif

do I = J,K bloco_de_comandos enddo

do n I = J,K bloco_de_comandos n continue

do I = J,K,L bloco_de_comandos enddo

Versão F77:


Vale ressaltar que é possível abrir uma série de laços IF ou DO, um dentro do outro, tomando-se o cuidado de sempre fechar os laços mais internos dentro dos laços mais externos. Tal construção é conhecida pelo nome de ninho de IF ou de DO: Para o caso de se querer usar uma estrutura de repetição, porém sem saber inicialmente quantas vezes o laço de DO deve ser executado, pode-se utilizar o comando DO WHILE: Exemplos: ver exercises_5,6,7,...,11,12 na lista de programas em anexo. 13. Sub-rotinas e Funções: Em relação à modularização de programas, a linguagem Fortran oferece facilidades através de sub-rotinas (subroutine) e funções (function), o que torna possível a implementação de programas modulares e estruturados, permitindo a construção de módulos subordinados a um programa principal, que pode ser chamado várias vezes, sempre que for necessário:

do I=1,5 do J=3,10 do K=2,9 bloco_de_comandos enddo enddo enddo

if (condição_1) then if (condição_2) then bloco_de_comandos_1 endif else if (condição_3) then bloco_de_comandos_2 endif endif

do while (expressão_lógica) bloco_de_comandos enddo

! Programa Principal .... ! Chamada da Sub-rotina S1: call S1(...) ! Chamada da Sub-rotina S2: call S2(...) ! Chamada da Função F1: A = F1(...) ... contains subroutine S1(...) bloco_de_comandos end subroutine S1 subroutine S2(...) bloco_de_comandos end subroutine S2 function F1(...) bloco_de_comandos end function F1 End program ! Término do programa principal


Vale ressaltar que é sempre conveniente dividir o programa principal em sub-rotinas de modo que cada sub-rotina contém um algoritmo independente que pode inclusive ser aproveitado para outros programas. Por exemplo, uma sub-rotina que resolve o sistema: Ax=y pode ter muitas aplicações, não estando limitada a um programa específico. Pode-se juntar uma série de sub-rotinas e funções para formar uma biblioteca de sub-rotinas, de forma semelhante à biblioteca de funções intrínsecas que vem com o compilador. Em F90, diferente das versões anteriores, todas as sub-rotinas e funções tem acesso à todas as variáveis globais, ou seja, todos os dados são public. Pode-se fazer com que uma variável se torne privativa (private) de uma sub-rotina ou função declarando ela novamente no corpo da sub-rotina ou função, resolvendo o problema do comando COMMON que não é mais necessário em F90. Portanto, é necessário que o usuário declare explicitamente no corpo da sub-rotina ou função todas as variáveis que são privativas. Assim como na versão F77, no F90 pode-se passar dados para sub-rotinas e funções usando argumentos. Exemplos: ver exercises_13,14,15...,18 na lista de programas em anexo. 14. Arranjos ou Variáveis Compostas: As variáveis compostas correspondem a posições de memória, identificadas por um único nome, individualizadas por índices e cujo conteúdo é de um mesmo tipo. O nome de uma variável composta é um identificador que obedece às mesmas regras de formação de identificadores de variáveis simples. O nome se refere, coletivamente, a todos os elementos da variável composta. Para referência a um elemento, é necessário colocar-se o nome da variável, seguida, entre parênteses, de um ou mais índices. Em Fortran, esses índices podem ser constantes inteiras ou variáveis inteiras. A maioria dos compiladores aceita também expressões inteiras. Segue abaixo exemplos de variáveis compostas: No Fortran, as variáveis compostas unidimensionais (vetores) são utilizadas para armazenar conjuntos de dados cujos elementos podem ser endereçados por um único índice. O conjunto de dados referenciado por um nome e que necessite de mais de um índice para ter seus elementos individualizados é dito composto multidimensional e a variável que o armazena é denominada variável composta multidimensional (matrizes e tensores de ordem superior). Nas variáveis compostas bi-dimensionais (matrizes ou tensores de segunda ordem), convenciona-se que o primeiro índice indique a linha e o segundo a coluna. Em geral, utilizam-se laços de DO para manipular os elementos de um arranjo.

! Declaração de variáveis: integer var_1 ! variável simples integer vector_1(5), vector_2(10) real vector_3(4), matriz_1(3,3) real*8 matriz_2(2,3),matriz_3(3,3,3) ! pode possuir até 7 dimensões em F90 ... vector_1(3) = 2 ! terceiro elemento da variável vector_1 matriz_1(1,2) = 3.0 ! elemento na primeira linha e segunda coluna de matriz_1 ... var_1 = 2*vector_1(4)+vector_2(10) ... ! tentar referenciar: vector_1(6), vector_1(0) ou vector_1(-2) produz erros ! tentar referenciar: vector_1(2.5) também produz erros


14.1 Dimensionamento Dinâmico de Arranjos: Em programas computacionais de médio e grande porte, de modo a evitar a perda de memória do computador, é bastante útil utilizar o dimensionamento dinâmico de arranjos, segundo o qual, pode-se:

• Manter um arranjo no tamanho zero, exceto quando estiver em uso. • Aumentar e diminuir o tamanho de arranjos. • Ler o tamanho de arranjos como dados em vez de fixar de antemão.

Porém, devem-se tomar certos cuidados: ao alterar o tamanho de um arranjo perde-se o seu conteúdo e portanto deve-se armazenar o seu conteúdo em outro local caso se queira uma cópia dos seus valores. Arranjos sem dimensões não podem ser passados para sub-rotinas como argumentos, ou seja, é necessário fixar antes a sua dimensão. A seguir é apresentado o funcionamento da alocação dinâmica de arranjos: 14.2 Operações com Arranjos em F90: No Fortran F90 é possível fazer uma série de operações em parte ou na totalidade dos elementos de um arranjo com expressões simples, sem a necessidade de se utilizar laços de DO, conforme ocorria para o caso da versão F77: Exemplos: ver exercises_19,20,21...,23 na lista de programas em anexo.

! declaração de variáveis: ! real*8, dimension(:), allocatable :: vector_1 ! vetor sem dimensão ! real*8, dimension(:,:), allocatable :: matriz_1 ! matriz sem dimensões ! integer n,m ... read(*,*) n,m allocate(vector_1(n)) ! definindo a dimensão do vetor allocate(matriz_1(n,m)) ! definindo as dimensões da matriz ...

! Declaração de Variáveis: real*8 x(10),y(10),z(10),a(4),b(5),M(10,10),M1(3,3), prod real*8 M2(3,2),M3(2,3), M4(3,3),M5(3,3) ... z = x+y ! efetua a soma de cada um dos termos x(i)+y(i) isoladamente z = x*3.0 ! efetua a multiplicação de cada um dos termos x(i) por 3.0 z =(x*y) ! efetua o produto de cada um dos termos x(i)*y(i) isoladamente prod=sum(z) ! efetua o produto escalar dos vetores x*y x = y ! arranjo x igual a y a=x(1:4) ! inicializa o vetor a com os quatro primeiros termos de x b(1:5)=x(1:5)+y(6:10) ! b(1)=x(1)+y(6), b(2)=x(2)+y(7), ... M(1:10,1:10)=0.0 ! atribui o valor 0.0 a todos os termos da matriz M. M1(1:3,1:3)=M(4:6,4:6) ! M1(1,1)=M(4,4), M1(1,2)=M(4,5),... M3=transpose(M2) ! efetua a transposta da matriz M5=M1+M4 ! soma de matrizes (mesma dimensão) x(1:10) = M(1,1:10) ! vetor x igual a primeira linha da matriz M MC=Matmul(MA,MB) ! multiplicação de matrizes: MA(n,m)*MB(m,k) = MC(n,k)


Anexo - Lista de Programas

program exercise_5 ! Objetivo: Definir a menção de um aluno com base na sua nota ! Declaração de variáveis: real nota ! Entrada de Dados: write(*,*) 'Digitar a nota do aluno: ' read (*,*) nota if (nota<0.or.nota>10) then write(*,*)'Nota deve ser positiva entre 0 e 10' write(*,*)'Entre novamente com a nota:' read (*,*) nota endif ! Laços de IF: if (nota==0) then write(*,*)'Final Grade = SR' elseif (nota>0.and.nota<3) then write(*,*)'Final Grade = II' elseif (nota>=3.and.nota<5) then write(*,*)'Final Grade = MI' elseif (nota>=5.and.nota<7) then write(*,*)'Final Grade = MM' elseif (nota>=7.and.nota<9) then write(*,*)'Final Grade = MS' else write(*,*)'Final Grade = SS' endif end program __________________________________________________________________________________________ program exercise_6 ! Objetivo: Definir a menção de um aluno com base na sua nota e presença ! Declaração de variáveis: real nota,attendance ! Entrada de Dados: write(*,*) 'Digitar a nota do aluno: ' read (*,*) nota if (nota<0.or.nota>10) then write(*,*)'Nota deve ser positiva entre 0 e 10' write(*,*)'Entre novamente com a nota:' read (*,*) nota endif write(*,*) 'Digitar a presenca do aluno: ' read(*,*) attendance ! Laços de IF: if (attendance<=75) then write(*,*)'Final Grade = SR' else if (nota==0) then write(*,*)'Final Grade = SR' elseif (nota>0.and.nota<3) then write(*,*)'Final Grade = II' elseif (nota>=3.and.nota<5) then write(*,*)'Final Grade = MI' elseif (nota>=5.and.nota<7) then write(*,*)'Final Grade = MM'


elseif (nota>=7.and.nota<9) then write(*,*)'Final Grade = MS' else write(*,*)'Final Grade = SS' endif endif end program __________________________________________________________________________________________ program exercise_7 ! Objetivo: Rendimentos bancários ! Declaração de variáveis: integer i,meses real saldo,juros,taxa ! Entrada de Dados: write(*,*) 'Digitar saldo original: ' read (*,*) saldo write(*,*) 'Digitar taxa de juros (0-100%): ' read (*,*) taxa write(*,*) 'Digitar numero de meses: ' read (*,*) meses taxa=taxa/100.0 ! Laços de DO: do i=1,meses juros=taxa*saldo saldo=saldo+juros write(*,*)'Mes:',i,' Juros:',juros,' Saldo:',saldo enddo end program __________________________________________________________________________________________ program exercise_8 ! Objetivo: Rendimentos bancários ! Mostrar laço de DO aberto ! Declaração de variáveis: integer meses real saldo,juros,taxa ! Entrada de Dados: write(*,*) 'Digitar saldo original: ' read (*,*) saldo write(*,*) 'Digitar taxa de juros (0-100%): ' read (*,*) taxa saldo_inicial=saldo taxa=taxa/100.0 ! Laços de DO: do meses=meses+1 juros=taxa*saldo saldo=saldo+juros write(*,*)'Mes:',meses,' Juros:',juros,' Saldo:',saldo if (saldo>2*saldo_inicial) stop enddo end program __________________________________________________________________________________________


program exercise_9 ! Objetivo: Achar a raiz quadrada de um número por iterações ! Declaração de variáveis: real numero,raiz integer i ! Entrada de dados: write(*,*)'Entrar com o numero: ' read (*,*) numero raiz = 1 ! Chute inicial (Não importa que seja muito longe) do i=1,10 raiz = 0.5*(raiz+numero/raiz) write(*,*)'Iteration: ',i,' Raiz: ',raiz enddo write(*,*)'Raiz por iteracoes : ',raiz write(*,*)'Raiz pela funcao SQRT: ',sqrt(numero) end program __________________________________________________________________________________________ program exercise_10 ! Objetivo: Cálculo dos momentos fletores ao longo de uma viga biapoiada ! M = M(x): momento ao longo da viga (calculado a cada metro) ! Declaração de variáveis: real M,L,W,A,dx,distance integer i ! Características Geométricas: L = 10.0 ! comprimento total da viga W = 100.0 ! carregamento concentrado A = 8.0 ! distância do carregamento concentrado ao apoio esquerdo dx = L/10 ! Cálculo das reações de apoio R1 = W*(L-A)/L ! reação no apoio esquerdo R2 = W*A/L ! reação no apoio direito ! Cálculo dos momentos fletores write(*,*)'Momentos fletores ao longo da viga: ' do i=0,10 distance =i*dx if (distance<=A) then M=R1*distance else M=R1*distance-W*(distance-A) endif write(*,*)'X = ',distance,' M= ',M enddo end program __________________________________________________________________________________________


program exercise_11 ! Objetivo: * Cálculo do fatorial de um número. ! * O fatorial será calculado utilizando-se variáveis: integer ou real*8. ! É importante ressaltar que as variáveis inteiras só podem armazenar valores ! no intervalo [-2147483648,2147483647]. ! Declaração de variáveis: integer ifact ! cálculo do fatorial como integer real*8 rfact ! cálculo do fatorial como real*8 character*15 fileout ! Arquivo de saída de dados: write(*,*)'Nome do arquivo de saida de dados - Max(15char): ' read (*,*) fileout open(unit=10,file=fileout,status='unknown') ! Cálculo do Fatorial ifact=1 rfact=1.0d0 write(*,*) ' i ifact rfact' write(10,*)' i ifact rfact' do i=1,20 ifact=ifact*i rfact=rfact*i write(*,*)i,ifact,rfact write(10,*)i,ifact,rfact enddo end program Arquivo de Saída de Dados (exercise_11.out): i ifact rfact 1 1 1.000000000000000 2 2 2.000000000000000 3 6 6.000000000000000 4 24 24.000000000000000 5 120 120.000000000000000 6 720 720.000000000000000 7 5040 5040.000000000000000 8 40320 40320.000000000000000 9 362880 362880.000000000000000 10 3628800 3628800.000000000000000 11 39916800 3.991680000000000E+007 12 479001600 4.790016000000000E+008 13 1932053504 6.227020800000000E+009 ! Observação: 6.227e+09 = 6227000000 > 2147483647 14 1278945280 8.717829120000000E+010 15 2004310016 1.307674368000000E+012 16 2004189184 2.092278988800000E+013 17 -288522240 3.556874280960000E+014 18 -898433024 6.402373705728000E+015 19 109641728 1.216451004088320E+017 20 -2102132736 2.432902008176640E+018 __________________________________________________________________________________________


program exercise_12 ! Objetivo: Cálculo das raízes de uma equação de segunda ordem: ! Ax2 + Bx + C = 0 ! ---------------------------------------------------------------- ! Nota sobre números complexos: ! Z=X+YI >>> Z=(X,Y) ! X: parte real ! Y: parte imaginária ! CONJG(Z)=X-YI ! ---------------------------------------------------------------- ! Declaração de variáveis: real*8 A,B,C,DELTA,X1,X2,TOL complex*8 Z1, Z2 character*15 file_out ! Entrada de Dados: TOL=1.0E-05 !TOL: tolerância para evitar divisão por zero write(*,*)'Calculo das raizes de uma equacao de segunda ordem' write(*,*)'Valor de coeficiente quadratico: ' read (*,*) A if (ABS(A).LT.TOL) then write(*,*)'O coeficiente quadratico deve ser maior que 1.0E-05' stop endif write(*,*)'Valor do coeficiente linear: ' read (*,*) B write(*,*)'Valor do coeficiente independente: ' read(*,*) C write(*,*)'Nome do arquivo de saida de dados: ' read(*,*) file_out ! Calculo das raizes: DELTA=B*B-4.*A*C if (DELTA.GE.0.) then ! Caso 1: raízes reais X1=(-1.0*B+SQRT(DELTA))/(2.0*A) X2=(-1.0*B-SQRT(DELTA))/(2.0*A) open(unit=10, file=file_out, status='unknown') write(10,*) 'CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: ' write(10,*) write(10,*) 'COEFICIENTE QUADRÁTICO :',A write(10,*) 'COEFICIENTE LINEAR :',B write(10,*) 'COEFICIENTE INDEPENDENTE:',C write(10,50)'PRIMEIRA RAIZ - X1 :',X1 write(10,50)'SEGUNDA RAIZ - X2 :',X2 else ! Caso 2: raízes complexas Z1=(CMPLX(-1.0*B)-CSQRT(CMPLX(DELTA)))/(CMPLX(2.0*A)) Z2=(CMPLX(-1.0*B)+CSQRT(CMPLX(DELTA)))/(CMPLX(2.0*A)) open(unit=10, file=file_out, status='unknown') write(10,*) 'CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: ' write(10,*) write(10,*) 'COEFICIENTE QUADRÁTICO :',A write(10,*) 'COEFICIENTE LINEAR :',B write(10,*) 'COEFICIENTE INDEPENDENTE:',C write(10,100)'PRIMEIRA RAIZ - Z1 :',Z1 write(10,100)'SEGUNDA RAIZ - Z2 :',Z2 endif 50 format(1X,A25,2X,F10.6) 100 format(1X,A25,2X,'(',F10.6,',',F10.6,')') end program


Arquivos de Saída de Dados: 1. ( 2 raizes reais diferentes) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: COEFICIENTE QUADRÁTICO : 2.000000 COEFICIENTE LINEAR : 3.000000 COEFICIENTE INDEPENDENTE: 1.000000 PRIMEIRA RAIZ - X1 : -.500000 SEGUNDA RAIZ - X2 : -1.000000 2. ( 2 raizes reais iguais ) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: COEFICIENTE QUADRÁTICO : 1.000000 COEFICIENTE LINEAR : -4.000000 COEFICIENTE INDEPENDENTE: 4.000000 PRIMEIRA RAIZ - X1 : 2.000000 SEGUNDA RAIZ - X2 : 2.000000 3. ( 2 raizes complexas ) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: COEFICIENTE QUADRÁTICO : 2.000000 COEFICIENTE LINEAR : 2.000000 COEFICIENTE INDEPENDENTE: 2.000000 PRIMEIRA RAIZ - Z1 : ( -.500000, -.866025) SEGUNDA RAIZ - Z2 : ( -.500000, .866025) __________________________________________________________________________________________ program exercise_13 ! Objetivo: Escrever um programa que leia os comprimentos dos três lados a,b e c de um ! paralelepípedo, calcule e escreva o valor da sua diagonal e do seu volume: ! Volume = a*b*c e Diagonal = sqrt(sqrt(a^2+b^2)+c^2) ! Observação: Utilização de funções (function) ! Declaração de variáveis: real a,b,c,d,vol ! Entrada de Dados; write(*,*)'Entrar com os comprimentos dos lados (a,b,c):' read (*,*) a,b,c ! Cálculo do volume e diagonal do paralelepípedo: vol = volume(a,b,c) d = hipotenusa(hipotenusa(a,b),c) write(*,*) 'Volume = ',vol write(*,*) 'Diagonal = ',d contains function volume(x,y,z) real x,y,z,volume volume =x*y*z end function volume function hipotenusa(x,y) real x,y,hipotenusa hipotenusa =sqrt(x**2+y**2) end function hipotenusa end program __________________________________________________________________________________________


program exercise_14 ! Objetivo: Escrever um programa que calcule a distância entre dois pontos no espaço, ! sendo fornecidas as coordenadas X1,Y1,Z1 e X2,Y2,Z2. ! Observação: Utilização de funções (function) ! Declaração de variáveis: real x1,y1,z1,x2,y2,z2,dist ! Entrada de Dados; write(*,*)'Entrar com as coordenadas X1,Y1 e Z1 do primeiro ponto:' read (*,*) x1,y1,z1 write(*,*)'Entrar com as coordenadas X2,Y2 e Z2 do segundo ponto:' read (*,*) x2,y2,z2 ! Cálculo da distância entre os pontos no espaço: dist = distance(x1,y1,z1,x2,y2,z2) write(*,*) 'Distancia entre os pontos = ',dist contains function distance(x1,y1,z1,x2,y2,z2) real x1,y1,z1,x2,y2,z2,distance distance =sqrt((x2-x1)**2+(y2-y1)**2+(z2-z1)**2) end function distance end program __________________________________________________________________________________________ program exercise_15 ! Objetivo: Cálculo do fatorial utilizando-se sub-rotinas (subroutine) ! fatorial(n) = n! = 1*2*3*...*n ! Declaração de variáveis: real*8 fac_n integer n ! Cálculo do fatorial de 1,2,...,10: write(*,*)' n fatorial(n)' do n=1,10 call factorial(n,fac_n) write(*,10)n,fac_n 10 format(i3,3x,f10.2) enddo contains subroutine factorial(n,fac_n) real*8 fac_n integer n fac_n=1 do i=2,n fac_n=i*fac_n enddo end subroutine factorial end program __________________________________________________________________________________________


program exercise_16 ! Objetivo: Escrever um programa que calcule a função: ! exp(x)=1+x+(x^2/2!)+(x^3/3!)+... ! Observação: Na função acima deve-se incluir apenas os termos maiores que tol=1.0E0-6. ! Imprima os resultados e compare com a função interna exp ! Declaração de variáveis: integer i real*8 x,fexp,tol,parcela character*15 file_out ! Entrada de dados: write(*,*)'Calculo da funcao F=exp(x)' write(*,*) write(*,*)'Valor de x: ' read (*,*) x write(*,*)'Nome do arquivo de saida de dados (Max=15char): ' read (*,*) file_out ! Cálculo da função exponencial de x: tol = 1.0e-06 ! tolerâncial fexp = 0.0d0 ! inicializar a função parcela = 1.0d0 ! primeira parcela i = 0 do while (parcela>tol) fexp=fexp+parcela i=i+1 parcela=(x**i)/fact(i) enddo ! Imprimir dados de saída: open (unit=10, file=file_out, status='unknown') write(10,*)'Valor da funcao exponencial de X: ' write(10,*)'----------------------------------------' write(10,*) write(10,*)'Valor de x = ', x write(10,*)'F(x)=1+x+(x^2/2!)+(x^3/3!)+... = ',fexp write(10,*)'F(x)=exp(x) = ',exp(x) contains function fact(n) integer n,j real*8 fact,temp temp=1 do j=2,n temp=temp*j enddo fact=temp end function fact end program Arquivo de saída de dados (exercise_16.out): Valor da funcao exponencial de X: ---------------------------------------- Valor de x = 5.000000000000000 F(x)=1+x+(x^2/2!)+(x^3/3!)+... = 148.413158521647700 F(x)=exp(x) = 148.413159102576600 __________________________________________________________________________________________


program exercise_17 ! Objetivo: Dados dois números distintos,colocá-los em ordem crescente ! Declaração de variáveis: real*8 A,B ! Entrada de dados: write(*,*) 'Entrar com os valores de A e B:' read (*,*) A,B write(*,10)A,B 10 format(/' Ordem original dos numeros: ',/,f10.2,/,f10.2) ! Colocar números em ordem crescente: if (A>B) then call trocar(A,B) endif write(*,20)A,B 20 format(' Numeros em ordem crescente: ',/,f10.2,/,f10.2) contains subroutine trocar(A,B) real*8 A,B,aux aux = A A = B B = aux end subroutine trocar end program __________________________________________________________________________________________ program exercise_18 ! Objetivo: Encontrar uma das raizes de uma função f(x)=0 usando o método de Newton ! Método de Newton: x = x-f(x)/df(x) ! Declaração de variáveis; implicit none integer :: its = 0 ! contador de iterações integer :: maxits = 20 ! número máximo de iterações logical :: converged = .false. ! indicador de convergência real*8 :: toler = 1.0e-06 ! tolerância real*8 :: x = 2.0d0 ! chute inicial ! Determinação da raiz da equação: write(*,*)' x f(x) ' write(*,*)'-----------------------------------------------------' do while (.not.converged.and.its<maxits) ! true and true = true : executa x=x-f(x)/df(x) ! false and true = false: nao executa write(*,*)x,f(x) its=its+1 converged=abs(f(x))<=toler enddo if (converged) then write(*,*)' Metodo de Newton convergiu' else write(*,*)' Metodo de Newton Nao convergiu' endif write(*,*)' Raiz da funcao = ',x


contains function f(x) ! Função qualquer escolhida pelo usuário f(x) = x^3+x-d real*8 f,x f=x**3+x-3 end function function df(x) ! Derivada da função: df(x) = 3*x^2+1 real*8 df,x df = 3*x**2+1 end function df end program __________________________________________________________________________________________ program exercise_19 ! Objetivo: Calcular a média e o desvio padrão de uma série de números ! Declaração de Variáveis: integer i,n real std,media,x(100) character*15 file_in ! Entrada de Dados: write(*,*)'Nome do arquivo de entrada de dados (Max=15Char): ' read (*,*) file_in open (unit=10, file=file_in, status='unknown') media=0.0 std =0.0 read (10,*)n do i=1,n read(10,*)x(i) media=media+x(i) enddo ! Cálculo da Média e Desvio Padrão: media = media/n do i=1,n std=std+(x(i)-media)**2 enddo std=sqrt(std/(n-1)) write(*,*)'Valor Medio = ',media write(*,*)'Desvio Padrao = ',std end program __________________________________________________________________________________________ program exercise_20 ! Objetivo: Calcular a média e o desvio padrão de uma série de números. ! Usar subrotinas e passar arranjo usando argumentos. ! Declaração de Variáveis: integer i,n real std,media,x(100) character*15 file_in ! Entrada de Dados: write(*,*)'Nome do arquivo de entrada de dados (Max=15Char): ' read (*,*) file_in open (unit=10, file=file_in, status='unknown')


read (10,*)n do i=1,n read(10,*)x(i) enddo ! Chamar subrotina e imprimir resultados: call stats(x,n,media,std) write(*,*)'Valor Medio = ',media write(*,*)'Desvio Padrao = ',std contains ! Subrotina Stats: subroutine stats(x,n,media,std) ! passagem de argumentos real std,media,x(100) ! variáveis privativas da subrotina (private) integer i,n media=0.0 std =0.0 do i=1,n media=media+x(i) enddo media = media/n do i=1,n std=std+(x(i)-media)**2 enddo std=sqrt(std/(n-1)) end subroutine stats end program __________________________________________________________________________________________ program exercise_21 ! Objetivo: Calcular a média e o desvio padrão de uma série de números. ! Usar subrotinas e passar arranjo usando argumentos. ! Usar alocação dinâmica para definir o vetor contendo os números. ! Declaração de Variáveis: integer i,n real std,media character*15 file_in real,dimension(:), allocatable::x ! Importante: declaração de variável sem dimensão definida ! Entrada de Dados: write(*,*)'Nome do arquivo de entrada de dados (Max=15Char): ' read (*,*) file_in open (unit=10, file=file_in, status='unknown') read (10,*)n allocate (x(n)) ! definir dimensão do vetor do i=1,n read(10,*)x(i) enddo ! Chamar subrotina e imprimir resultados: ! Obs: sempre definir a dimensão do vetor ou matriz antes de passar para subrotina. call stats(x,n,media,std) write(*,*)'Valor Medio = ',media write(*,*)'Desvio Padrao = ',std contains


! Subrotina Stats: subroutine stats(x,n,media,std) ! passagem de argumentos real std,media ! variáveis privativas da subrotina (private) integer i,n real, dimension(:) :: x ! vetor alocado dinamicamente no programa principal media=0.0 std =0.0 do i=1,n media=media+x(i) enddo media = media/n do i=1,n std=std+(x(i)-media)**2 enddo std=sqrt(std/(n-1)) end subroutine stats end program __________________________________________________________________________________________ program exercise_22 ! Objetivo: Testar alocação dinâmica de matrizes: ! Declaração de Variáveis: integer tamanho,n real, dimension(:), allocatable::x ! Testando alocação dinâmica: tamanho = size(x) write(*,*)' Tamanho (antes de definir dimensao) = ',tamanho open (unit=10, file='exercise_22.dat', status='unknown') read (10,*)n allocate(x(n)) do i=1,n read(10,*)x(i) enddo tamanho=size(x) write(*,*)' Tamanho (depois de definir dimensao) = ',tamanho write(*,*)' Vetor x: ' do i=1,n write(*,*)x(i) enddo end program __________________________________________________________________________________________ program exercise_23 ! Objetivo: Multiplicação de Matrizes: A(n,m)*B(m,k)=C(n,k),utilizando diferentes técnicas ! Declaração de Variáveis: integer i,j,n,m,k integer in,io real, dimension(:,:), allocatable::A,B,C character*15 file_in,file_out


! Canais de Entrada e Saída de Dados: in = 10 io = 20 ! Entrada de Dados: write(*,*)'Nome do arquivo de entrada de dados (Max=15char): ' read (*,*) file_in open (in, file=file_in, status='unknown') write(*,*)'Nome do arquivo de saída de dados (Max=15char): ' read (*,*) file_out open (io, file=file_out, status='unknown') read (in,*) n,m,k allocate (A(n,m),B(m,k),C(n,k)) do i=1,n read(in,*)(A(i,j),j=1,m) enddo do i=1,m read(in,*)(B(i,j),j=1,k) enddo write(io,*)'Matriz A: ' do i=1,n write(io,*)(A(i,j),j=1,m) enddo write(io,*)'Matriz B: ' do i=1,m write(io,*)(B(i,j),j=1,k) enddo ! Testar possibilidade de multiplicação: t1=size(A,2) ! número de colunas da matriz A t2=size(B,1) ! número de linhas da matriz B if (t1/=t2) then write(*,*)' Impossibilidade de calcular C=A*B - Ajustar Dimensoes' stop endif ! Multiplicação de matrizes - versão F77: call prodF77(A,B,C) write(io,*)'Matriz C=A*B utilizando prodF77: ' do i=1,n write(io,*)(C(i,j),j=1,k) enddo ! Multiplicação de matrizes - versão F90: call prodF90(A,B,C) write(io,*)'Matriz C=A*B utilizando prodF90: ' do i=1,n write(io,*)(C(i,j),j=1,k) enddo ! Multiplicação de matrizes - comando Matmul: call prod_function(A,B,C) write(io,*)'Matriz C=A*B utilizando prod_function: ' do i=1,n write(io,*)(C(i,j),j=1,k) enddo contains


subroutine prodF77(A,B,C) real, dimension(:,:) :: A,B,C integer i,j,l do i=1,n do j=1,k C(i,j)=0.0 do l=1,m C(i,j)=C(i,j)+A(i,l)*B(l,j) enddo enddo enddo end subroutine prodF77 subroutine prodF90(A,B,C) real, dimension(:,:) :: A,B,C integer i,j C(1:n,1:k)= 0.0 do i=1,n do j=1,k C(i,j)=sum(A(i,1:m)*B(1:m,j)) enddo enddo end subroutine prodF90 subroutine prod_function(A,B,C) real, dimension(:,:) :: A,B,C C=Matmul(A,B) end subroutine prod_function end program Arquivo de Entrada de Dados (exercise_23.out) 3 3 3 ! n,m,k 1.0 2.0 3.0 2.0 3.0 4.0 3.0 4.0 5.0 1.0 1.0 1.0 2.0 2.0 2.0 3.0 3.0 3.0 Arquivo de Saída de Dados (exercise_23.out) Matriz A: 1.000000 2.000000 3.000000 2.000000 3.000000 4.000000 3.000000 4.000000 5.000000 Matriz B: 1.000000 1.000000 1.000000 2.000000 2.000000 2.000000 3.000000 3.000000 3.000000 Matriz C=A*B utilizando prodF77: 14.000000 14.000000 14.000000 20.000000 20.000000 20.000000 26.000000 26.000000 26.000000 Matriz C=A*B utilizando prodF90: 14.000000 14.000000 14.000000 20.000000 20.000000 20.000000 26.000000 26.000000 26.000000 Matriz C=A*B utilizando prod_function: 14.000000 14.000000 14.000000 20.000000 20.000000 20.000000 26.000000 26.000000 26.000000


Arquivo de Entrada de Dados (teste_23.out) (Matrizes não quadradas) 3 2 3 ! n,m,k 1.0 2.0 2.0 3.0 3.0 4.0 1.0 1.0 1.0 2.0 2.0 2.0 Arquivo de Saída de Dados (teste_23.out) (Matrizes não quadradas) Matriz A: 1.000000 2.000000 2.000000 3.000000 3.000000 4.000000 Matriz B: 1.000000 1.000000 1.000000 2.000000 2.000000 2.000000 Matriz C=A*B utilizando prodF77: 5.000000 5.000000 5.000000 8.000000 8.000000 8.000000 11.000000 11.000000 11.000000 Matriz C=A*B utilizando prodF90: 5.000000 5.000000 5.000000 8.000000 8.000000 8.000000 11.000000 11.000000 11.000000 Matriz C=A*B utilizando prod_function: 5.000000 5.000000 5.000000 8.000000 8.000000 8.000000 11.000000 11.000000 11.000000 __________________________________________________________________________________________


! ******************************************************* ! Programa: Matrix ! Operações com vetores e matrizes no F90 ! Author: Renato César Gavazza Menin ! ******************************************************* program matrix implicit double precision(a-h,o-z) implicit integer (i-n) real*8 A(3),B(3),Soma(3),Subt(3) real*8 MA(3,3),MB(3,3),MS(3,3),MT(3,3),MABST(6,6) real*8 aM(3,3),MM(3,3),MABT(3,3),matAB(3,3) real*8 Config_C0(3,10),E_0(3,3) real*8 V1(3),V2(3) real*8 MC(3,4),V3(4) real*8 PV(3),norma,m1,m2,m3,m4,m5,m6 integer io character*15 fileout io = 20 write(*,*)'Program: Matrix ' write(*,*)'--------------------------------' write(*,*) write(*,*)'Output File Name ? (Max 15 Char)' read (*,*) fileout open (io,file=fileout,status='unknown') write(*,*) ! 1. Soma e subtração de vetores: ! --------------------------------------- ! Vetor A: A(1)=1 A(2)=2 A(3)=3 ! Vetor B: B(1)=10 B(2)=20 b(3)=30 Soma = A + B Subt = A - B write(io,*)'Vetor Soma: ' do i=1,3 write(io,*)Soma(i) enddo write(io,*)'Vetor Subt: ' do i=1,3 write(io,*)Subt(i) enddo ! 2. Transposição e soma de matrizes: ! ------------------------------------------- ! Matriz MA: MA(1,1)=1.0 MA(1,2)=2.0 MA(1,3)=3.0 MA(2,1)=4.0 MA(2,2)=5.0 MA(2,3)=6.0 MA(3,1)=7.0 MA(3,2)=8.0 MA(3,3)=9.0 ! Matriz MB: MB(1,1)=1.0 MB(1,2)=0.0 MB(1,3)=0.0 MB(2,1)=0.0 MB(2,2)=1.0 MB(2,3)=0.0 MB(3,1)=0.0 MB(3,2)=0.0 MB(3,3)=1.0 ! Matriz Transposta: MT=Transpose(MA) write(io,*)'Matriz Transposta: ' do i=1,3 write(io,*)(MT(i,j),j=1,3) enddo


! Soma de Matrizes Quadradas: MS=MA+MB write(io,*)'Soma de Matrizes: ' do i=1,3 write(io,*)(MS(i,j),j=1,3) enddo ! 3. Composição de matrizes: ! --------------------------------- MABST(1:3,1:3)=MA MABST(1:3,4:6)=MB MABST(4:6,1:3)=MS MABST(4:6,4:6)=MT write(io,*)'Matriz MABST: ' do i=1,6 write(io,10)(MABST(i,j),j=1,6) 10 format(f4.1,X,f4.1,X,f4.1,X,f4.1,X,f4.1,X,f4.1) enddo ! Configuração Inicial: do i=1,3 do j=1,10 Config_C0(i,j)=i+j enddo enddo E_0(1:3,1)=Config_C0(1,1:3) E_0(1:3,2)=Config_C0(1,4:6) E_0(1:3,3)=Config_C0(1,7:9) write(io,*)'Matriz Config_C0: ' do i=1,3 write(io,15)(E_0(i,j),j=1,3) 15 format(f4.1,X,f4.1,X,f4.1) enddo ! 4. Multiplicação de matrizes: ! ------------------------------------ ! 4.1 Multiplicação de Matriz Quadrada por Escalar: aM=2.0*MA write(io,*)'Multiplicar matriz por escalar: ' do i=1,3 write(io,*)(aM(i,j),j=1,3) enddo ! 4.2 Multiplicação de matrizes - Função Interna "MATMUL" MM=MATMUL(MA,MB) write(io,*)'Multiplicar matrizes - MA*MB: ' do i=1,3 write(io,*)(MM(i,j),j=1,3) enddo MABT=MATMUL(MM,MT) write(io,*)'Multiplicar matrizes - MA*MB*MT: ' do i=1,3 write(io,*)(MABT(i,j),j=1,3) enddo MM=MATMUL(MM,MT) write(io,*)'Multiplicar matrizes - MM=MA*MB*MT: ' do i=1,3 write(io,*)(MM(i,j),j=1,3) enddo ! 4.3 Multiplicação de Matriz e Vetor: ! Obs: [V1]3x1 = [MA]3x3 * [A]3x1 V1=MATMUL(MA,A) write(io,*)'Multiplicar matriz e vetor: ' do i=1,3 write(io,*)V1(i) enddo ! 4.4 Multiplicação de Vetor e Matriz: ! Obs: [V2]1x3 = [A]1x3 * [MA]3x3 V2=MATMUL(A,MA) write(io,*)'Multiplicar vetor e matriz: ' do i=1,3 write(io,*)V2(i) enddo


! 4.5 Multiplicação de Vetor e Matriz Não Quadrada: ! Obs: [V3]1x4 = [A]1x3 * [MC]3x4 MC(1:3,1:3)=MA MC(1:3,4)=A V3=MATMUL(A,MC) write(io,*)'Multiplication of vector by non quadratic matrix: ' do i=1,4 write(io,*)V3(i) enddo ! 5. Subrotina para o cálculo do produto vetorial: ! -------------------------------------------------------- call cross(A,V1,PV) write(io,*)'Produto Vetorial - Subrotina Cross: ' do i=1,3 write(io,*)PV(i) enddo ! 6. Função para o cálculo da norma do vetor: ! ------------------------------------------- norma=norm(A) write(io,*)'Norma de Vetor - Function Norm: ' write(io,*)'Norm = ',norma ! 7. Encontrar o valor máximo de uma sequência: ! -------------------------------------------- write(io,*)'Encontrar valor maximo de sequencia: ' m1=max(1,2,3) m2=max(-1,-2,-3) m3=max(-3,0,1) m4=max(1.1,3.5,5.5) m5=max(-3.5,0.0,2.0) m6=max(MA(1,1),MA(1,2),MA(1,3)) write(io,*)'m1=max(1,2,3) = ',m1 write(io,*)'m2=max(-1,-2,-3) = ',m2 write(io,*)'m3=max(-3,0,1) = ',m3 write(io,*)'m4=max(1.1,3.5,5.5) = ',m4 write(io,*)'m5=max(-3.5,0,2) = ',m5 write(io,*)'m6=max(MA(1,1),MA(1,2),MA(1,3))= ',m6 ! 8. Simetrização de uma matriz: ! -------------------------------------- MA=MA+transpose(MA) MA=0.5*MA write(io,*)'[MA] = ([MA]+[MA]t)/2: ' do i=1,3 write(io,*)(MA(i,j),j=1,3) enddo ! 9. Multiplicação de matriz e transposta: ! ----------------------------------------------- ! Reestabelecer Matriz MA: MA(1,1)=1.0 MA(1,2)=2.0 MA(1,3)=3.0 MA(2,1)=4.0 MA(2,2)=5.0 MA(2,3)=6.0 MA(3,1)=7.0 MA(3,2)=8.0 MA(3,3)=9.0 MA=Matmul(MA,transpose(MA)) write(io,*)'[MA] = [MA]*transpose[MA]: ' do i=1,3 write(io,*)(MA(i,j),j=1,3) enddo ! 10. Multiplicação de vetor(3,1) e vetor(1,3): ! ----------------------------------------------------- matAB=vecmul(A,B) write(io,*)'[matAB] = vecmul(A,B): ' do i=1,3 write(io,*)(matAB(i,j),j=1,3) enddo


CONTAINS Subroutine cross(A,B,PV) real*8 A(3),B(3),PV(3) PV(1)=A(2)*B(3)-A(3)*B(2) PV(2)=A(3)*B(1)-A(1)*B(3) PV(3)=A(1)*B(2)-A(2)*B(1) end subroutine cross Function norm(V) real*8 V(3),norm norm=dsqrt(V(1)*V(1)+V(2)*V(2)+V(3)*V(3)) end function norm Function vecmul(A,B) real*8 A(3),B(3),mat(3,3),vecmul(3,3) integer i,j do i=1,3 do j=1,3 mat(i,j)=A(i)*B(j) enddo enddo vecmul=mat end function vecmul End ! Término do Programa Principal Arquivo de Saída de Dados (matrix.out): Vetor Soma: 11.000000000000000 22.000000000000000 33.000000000000000 Vetor Subt: -9.000000000000000 -18.000000000000000 -27.000000000000000 Matriz Transposta: 1.000000000000000 4.000000000000000 7.000000000000000 2.000000000000000 5.000000000000000 8.000000000000000 3.000000000000000 6.000000000000000 9.000000000000000 Soma de Matrizes: 2.000000000000000 2.000000000000000 3.000000000000000 4.000000000000000 6.000000000000000 6.000000000000000 7.000000000000000 8.000000000000000 10.000000000000000 Matriz MABST: 1.0 2.0 3.0 1.0 .0 .0 4.0 5.0 6.0 .0 1.0 .0 7.0 8.0 9.0 .0 .0 1.0 2.0 2.0 3.0 1.0 4.0 7.0 4.0 6.0 6.0 2.0 5.0 8.0 7.0 8.0 10.0 3.0 6.0 9.0 Matriz Config_C0: 2.0 5.0 8.0 3.0 6.0 9.0 4.0 7.0 10.0 Multiplicar matriz por escalar: 2.000000000000000 4.000000000000000 6.000000000000000 8.000000000000000 10.000000000000000 12.000000000000000 14.000000000000000 16.000000000000000 18.000000000000000 Multiplicar matrizes - MA*MB: 1.000000000000000 2.000000000000000 3.000000000000000 4.000000000000000 5.000000000000000 6.000000000000000 7.000000000000000 8.000000000000000 9.000000000000000 Multiplicar matrizes - MA*MB*MT: 14.000000000000000 32.000000000000000 50.000000000000000 32.000000000000000 77.000000000000000 122.000000000000000 50.000000000000000 122.000000000000000 194.000000000000000 Multiplicar matrizes - MM=MA*MB*MT: 14.000000000000000 32.000000000000000 50.000000000000000 32.000000000000000 77.000000000000000 122.000000000000000 50.000000000000000 122.000000000000000 194.000000000000000 Multiplicar matriz e vetor: 14.000000000000000 32.000000000000000 50.000000000000000


Multiplicar vetor e matriz: 30.000000000000000 36.000000000000000 42.000000000000000 Multiplication of vector by non quadratic matrix: 30.000000000000000 36.000000000000000 42.000000000000000 14.000000000000000 Produto Vetorial - Subrotina Cross: 4.000000000000000 -8.000000000000000 4.000000000000000 Norma de Vetor - Function Norm: Norm = 3.741657386773941 Encontrar valor maximo de sequencia: m1=max(1,2,3) = 3.000000000000000 m2=max(-1,-2,-3) = -1.000000000000000 m3=max(-3,0,1) = 1.000000000000000 m4=max(1.1,3.5,5.5)= 5.500000000000000 m5=max(-3.5,0,2) = 2.000000000000000 m6=max(MA(1,1),MA(1,2),MA(1,3))= 3.000000000000000 [MA] = ([MA]+[MA]t)/2: 1.000000000000000 3.000000000000000 5.000000000000000 3.000000000000000 5.000000000000000 7.000000000000000 5.000000000000000 7.000000000000000 9.000000000000000 [MA] = [MA]*transpose[MA]: 14.000000000000000 32.000000000000000 50.000000000000000 32.000000000000000 77.000000000000000 122.000000000000000 50.000000000000000 122.000000000000000 194.000000000000000 [matAB] = vecmul(A,B): 10.000000000000000 20.000000000000000 30.000000000000000 20.000000000000000 40.000000000000000 60.000000000000000 30.000000000000000 60.000000000000000 90.000000000000000 __________________________________________________________________________________________ REFERÊNCIAS BIBLIOGRÁFICAS:

• H.M. Deitel & P.J.Deitel, “Como programar em C”, Livros Técnicos e Científicos Editora, S.A., Rio de Janeiro , 1994.

• S.J. Chapman, “Fortran 90/95 for Scientists and Engineers”, WCB/McGraw-Hill, USA, 1998. • J. Liberty, “SAMS Teach Yourself C++ in 21 Days”, Fourth Edition, SAMS Publishing, Indiana / USA,

2001. • A.Huerta, J. Sarrate, A.R. Ferran, “Métodos numéricos, Introducion, aplicaciones y programacion”,

Universiat Politécnica de Catalunya, Barcelona, 1998. • H. Farrer, C.G. Becker, E.C. Faria, “Fortran Estruturado”, Editora Guanabara Koogan, Rio de Janeiro,

1992. • P. W. Partridge, “Notas de aula do curso: Métodos Computacionais / 1º Semestre de 2002”, Brasília,

2002.

Documents

fortran_90