P. 1
fortran_90

fortran_90

|Views: 606|Likes:
Published by Fernando Oliveira
Disciplina: Métodos Computacionais / 1º Semestre de 2005 Parte 1 – Conceitos Fundamentais da Linguagem Fortran – Versão F90

1. Introdução 2. Linguagens de Programação 3. Uso da Linguagem Fortran em Computadores 4. Formatação de um Programa em Fortran 5. Estrutura de um Programa em Fortran 6. Constantes e Variáveis 6.1 Declaração de Constantes e Variáveis 6.2 Inicialização de Valores de Variáveis 6.3 Programa com Diferentes Tipos de Variáveis 7. Leitura e Impressão de Dados em Arquivo Externo.
Disciplina: Métodos Computacionais / 1º Semestre de 2005 Parte 1 – Conceitos Fundamentais da Linguagem Fortran – Versão F90

1. Introdução 2. Linguagens de Programação 3. Uso da Linguagem Fortran em Computadores 4. Formatação de um Programa em Fortran 5. Estrutura de um Programa em Fortran 6. Constantes e Variáveis 6.1 Declaração de Constantes e Variáveis 6.2 Inicialização de Valores de Variáveis 6.3 Programa com Diferentes Tipos de Variáveis 7. Leitura e Impressão de Dados em Arquivo Externo.

More info:

Published by: Fernando Oliveira on Aug 25, 2010
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

07/12/2013

pdf

text

original

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

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

1 1 3 3 4 5 6 6 7 8 9 9 11 11 12 12 13 14 15 15 16 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.
Vantagens
Resposta exata. Visualização de todo o processo. Realismo. Sem simplificações. Rapidez, relativamente barato.

Forma
Sol. Analítica Laboratório Computador

Desvantagens
Necessário fazer simplificações ( linearizações, homogeneização de materiais, simetrias ...). Inviável para problemas complexos (tempo). Disponibilidade e custos de materiais, equipamentos e mão de obra). Necessidade de grande quantidade de ensaios. 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 +1200274027 : linguagem de máquina

À 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

Métodos Computacionais / 1º Semestre de 2005

2

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 STORE Termo_C : linguagem assembly

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.

fazer as devidas correções e repassar as fases seguintes. através de sucessivas fases: • • • • Definição do Problema. coluna 6 para indicar continuação da linha anterior. Se houver erro. As linhas devem ter 80 colunas. será necessário retornar à fase correspondente. Desenvolvimento de um Algoritmo. e as colunas 2 a 72. É a descrição e a delimitação do problema a ser resolvido. 4. Os resultados obtidos pelas primeiras execuções de um programa num computador devem ser cuidadosamente analisados. Se a linha contiver um comentário. Formatação de um programa em Fortran: O texto de um programa em Fortran 77 deve ficar disposto em linhas. fazendo a resolução do problema e obtendo os resultados desejados. Programa Fonte ⇓ ( Compilador ) Programa Objeto + Biblioteca ⇓ ( Linkagem ) Programa Executável ⇓ ( Execução ) Resultados • Análise de Resultados. a coluna 1 deve ter a letra C. os dizeres do comentário. quando os programas eram digitados em cartões perfurados (cada linha em um cartã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). Obedecendo a um programa denominado compilador da linguagem Fortran. pois eles podem estar parcial ou totalmente comprometidos com erros cometidos nas quatro primeiras fases. Se a linha contiver um comando ou uma declaração. dígito ou sinal especial). 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.Métodos Computacionais / 1º Semestre de 2005 3 3. Cada linha de um programa pode conter um comentário. colunas 7 a 72 para conter o comando ou a declaração. como em outras linguagens de programação. Processamento do Programa pelo Computador. Em seguida este novo programa é executado e passa a controlar o computador através das suas instruções. estas colunas eram usadas para numerar os cartões e facilitar a sua reordenação caso acidentalmente ficassem desordenados. Transcrição do algoritmo para a Linguagem Fortran. Uso da Linguagem Fortran em Computadores: A utilização da linguagem Fortran para resolver um problema em um computador faz-se. geralmente desenvolvida por etapas (refinamentos). Antigamente. de acordo com as regras e recursos oferecidos pela linguagem. Objetiva a obtenção de um programa equivalente. e cada coluna só pode conter um caractere (letra. Objetiva a descrição. uma declaração ou um comando. As colunas 73 a 80 não são analisadas pelo compilador e geralmente são deixadas em branco. quando usado. do processamento a ser realizado para resolver o problema e obter os resultados desejados no computador. caracterizando-o de maneira clara e completa. .

Um programa simples em F90 é mostrado a seguir. Por exemplo. Eles são considerados apenas nas constantes literais.*) I. os seguintes comandos são idênticos: Output = input1 + input2 Output = input1 + input2 & Vale ressaltar que tanto no Fortran 77 quanto no Fortran 90. Neste caso.J. a coluna 7 de uma linha de continuação é considerada como sucessora da coluna 72 da linha anterior.*) ‘Result = ‘. . Estrutura de um Programa em Fortran: Cada programa em Fortran consiste de um agrupamento de declarações executáveis e não executáveis. conforme comentado anteriormente.for” ao passo que os programas fonte escritos na versão F90 devem possuir uma extensão “.*) ‘Enter the numbers to multiply: ‘ read (*. É através da extensão que o compilador reconhece em que versão o programa fonte foi escrito. caractere diferente de zero e de espaço em branco. graças ao chamado free source format. K end program Vale ressaltar que os programas fonte em Fortran escritos na versão F77 devem ter a extensão “.Métodos Computacionais / 1º Semestre de 2005 4 Um comando ou declaração pode continuar nas colunas 7 a 72 de várias linhas consecutivas que contiverem na coluna 6. ! Declare de variables used in this program: integer I.for”. os comandos e declarações podem ser digitados em qualquer lugar de uma linha e cada linha pode receber até 132 caracteres. pode-se continuar na linha seguinte digitando-se o símbolo & (ampersand) no final da linha corrente.f90”. 5. 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: Estrutura de um Programa Simples: * Nome * Declarações (não executáveis) * Linhas executáveis * End program Program exercise_1 ! Purpose: ! To illustrate some of the basic features of a Fortran program.K ! Read the numbers: write(*. O compilador não aceitará o free source format se o arquivo fonte for definido com a extensão “. No caso do Fortran 90.J ! Multiply the numbers: K = I*J ! Write out the result: write(*. Caso um comando ou declaração seja muito longo e não caiba em uma única linha. os espaços em branco são irrelevantes e ignorados pelo programa compilador. que devem ocorrer em uma ordem específica.

c. Embora uma variável possa assumir diferentes valores. não sendo permitido o uso de símbolos especiais: 26 letras do alfabeto (a. sem parte decimal. -1.y..w. 0.0e-2... 1. exemplos: 1000.2.0e-307]. Conforme o seu tipo. Var1. positivo ou negativo. 37.x.5. letras ou números. números reais. números reais.. lógicas ou literais. 1. ela só pode armazenar um valor a cada instante.5000. cujo conteúdo pode variar ao longo do tempo.0e-37]. exemplos: 1. são entidades cujos valores são fixos ao longo de todo o programa. -6. com parte decimal em precisão dupla... . Real*8: .9) barra inferior ( _ ) Exemplo: 1.. positivo ou negativo. ou seja.b.z) 10 números (0. -0.d. -0. +2147483647 ].. durante a execução do programa. 1. 1. exemplos: 1. letras maiúsculas e minúsculas são consideradas iguais pelo compilador: variable_1 = Variable_1 = VARIABLE_1. -6...0e-2. F90: identificador pode ter até 31 caracteres... O primeiro caractere de um identificador deve.1. 2. Real: 3.01. -1. Integer: armazena em forma exata até o limite. 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 – .0e+308. conforme o próprio nome diz. Já as variáveis podem sofrer alterações ao longo da execução do programa.8543.Métodos Computacionais / 1º Semestre de 2005 5 6.0e+38. total.0001.. A cada variável corresponde uma posição de memória. Os identificadores não são case sensitive. 37. A. ser uma letra e os demais. X5. Toda constante ou variável é identificada por um nome ou identificador. intervalo válido: [ -2147483648. .8543. 8.. -1. número de dígitos na mantissa: 15 intervalo válido: [1.. ou seja. 2. as constantes e variáveis podem ser classificadas como numéricas (inteiras ou reais). Observação: Não confundir o caractere “_ “ com o caractere “–“.... obrigatoriamente. sendo declaradas através do comando parameter. com parte decimal em precisão simples. step_1. A32B. ou seja.. cuja formação obedece a determinadas regras: • • • • F77: identificador pode ter no máximo 6 caracteres. não sendo possível alterar os seus valores durante a execução. entre outras. 999. número de dígitos na mantissa: 6 intervalo válido: [1..3. Constantes e Variáveis: As constantes. F1G3H5. Identificadores permitidos: Nota.

K.var7 character*n var8 ! declaração de variáveis do tipo inteiro.09 Juro2 = 0. usado em proposições lógicas.1415/ ! Observação: A = 1. sendo representadas pelas palavras true e false. B = 2 e C = 3. Pode-se inibir a declaração implícita com o comando: implicit none. var2 real var3.C /1. Character: 6. ! declaração de variáveis do tipo real com precisão simples. para maior clareza do programa é aconselhável que as variáveis sejam declaradas explicitamente. colocado antes da declaração de variáveis. constante literal que representa qualquer seqüência de caracteres. ‘Resultado : ‘. var4 real*8 var5 logical var6.B.. . só existem duas constantes deste tipo. J.1415 c) Entrar via teclado (recomendado para pequena quantidade de dados). d) Leitura de arquivo de entrada de dados (recomendado para grandes volumes). N) representavam variáveis inteiras (integer) e todas as variáveis que começassem com outra letra diferente destas representavam variáveis reais (real).2. conforme o tipo de variável: integer var1. segundo a qual qualquer variável que começasse com as letras (I. M. ! sendo “n” o número máximo de caracteres na variável var8. o que pode ser feito da seguinte forma.09 (real) Embora seja permitido este tipo de declaração implícita. ! declaração de variáveis do tipo real com precisão dupla. 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. também conhecida por string.09 ! Resultado: Juro1 = 0 (integer) ! Resultado: Juro2 = 0. deve estar entre apóstrofos.. . L.2 Inicialização de Valores de Variáveis: a) Explicitar: Contador = 1 Taxa = 0. no início do programa. ! declaração de variáveis do tipo lógica.. Logical: é um valor lógico.09 Word = ‘Met_Computacionais’ b) Utilizando declaração DATA: DATA A. que só pode ser verdadeiro ou falso. exemplos: ‘Met_Computacionais’. precedidas e seguidas por ponto decimal.true. a seqüência de caracteres.1 Declaração de Constantes e Variáveis: No F77 havia uma regra de declaração implícita de variáveis. a não ser que se declarasse diferente. 5. 6. de forma explícita..3.Métodos Computacionais / 1º Semestre de 2005 6 4. número máximo de caracteres = [255].false. e . ‘A5%(x): ‘.

flag2.*) ‘Valor de K = ‘.*) ’Valor de var4 (double precision) = ‘.and.*) ’Valor de flag4 = ‘. const1 = ‘Fortran’ const2 = ‘90’ ! Operações com variáveis: K = I/J var3 = var1*var2 var4 = var1*var2 flag3 = flag1.3 Programa com Diferentes Tipos de Variáveis: Program exercise_2 ! Objetivo: ! Ilustrar a utilização de diferentes tipos de variáveis.flag4. ! Declaração de variáveis do programa: integer I.flag3 write(*. parameter :: const_4 = 2500.not.flag2 flag4 = flag1.*) ’Valor de flag5 = ‘.true.flag1 const3 = const1//const2 ! Divisão de inteiro por inteiro = inteiro (arredondamento para baixo) ! Operação de concatenação de strings ! Imprimir os resultados na tela do computador: write(*.const_4 end program Impressão de Resultados na Tela do Computador: Valor de K = 4 Valor de var3 (simple precision) = 6.Métodos Computacionais / 1º Semestre de 2005 7 6.var3 write(*.000 var2 = 3.var4 write(*.0 ! Declaração e inicialização de constante ! Inicialização explícita de variáveis: I = 17 J=4 var1 = 2.J.*) ’Valor de flag3 = ‘.flag4 write(*.K real var1. K write(*.var2.flag5 character*7 const1 character*2 const2 character*9 const3 real*8.flag5 write(*.flag3.var3 real*8 var4 logical flag1.or.false.*) ’Valor de var3 (simple precision) = ‘.000000000000000 Valor de flag3 =F Valor de flag4 =T Valor de flag5 =F String const3 = Fortran90 Constante const 4 = 2500.000 flag1 = .000000 Valor de var4 (double precision) = 6. flag2 = .flag2 flag5 = .*) 'Constante const_4 = '.const3 write(*.*) ‘String const3 = ‘.000000000000000 .

J.var2 Arquivo de Saída de Dados / Exercise_3. Status = ‘estado’) • • • n: variável ou constante.000000 . 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.dat) e saída de dados (*. K write(20.var3 end program Arquivo de Entrada de Dados / Exercise_3. inteira e não negativa que identifica a unidade de entrada ou saída.dat) read (*.*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*. Antes de usar um arquivo externo é necessário que o mesmo seja aberto utilizando-se o comando OPEN. file=fileout.out) ! Abertura de arquivos externos para entrada e saída de dados: write(*.*) fileout open(unit=20. e estabelece o atributo de estado do arquivo. 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.*) ‘Valor de K = ‘.*) ‘Valor de K = ‘. estado: indica o estado do arquivo no momento da abertura. status = ‘unknown’) ! Leitura de Dados do Arquivo de Entrada de Dados: read(10. Unknown: quando não se sabe o estado do arquivo. New: indica que um novo arquivo será criado (normalmente arquivos de saída). status = ‘unknown’) write(*.00 ! real var1.K real var1.*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*. file=filein.var2 ! Operações com variáveis: K = I+J var3 = var1 * var2 ! Imprimir os resultados na tela do computador: write(*.*) ’Valor de var3 = ‘.var2.J read(10. 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.var3 ! Imprimir os resultados no arquivo de saída: write(20.*) ’Valor de var3 = ‘.*) filein open(unit=10. podendo ser utilizado para arquivos de entrada ou saída de dados.dat 2 3 ! integer I.Métodos Computacionais / 1º Semestre de 2005 8 7. 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). ! Declaração de variáveis do programa: integer I.*) I. Program exercise_3 ! Objetivo: Ilustrar a leitura e impressão de dados em arquivos externos. File = ‘nome-ext-arquivo’.out) read (*. fileout ! nomes dos arquivos de entrada (*.J 5.*) var1. K write(*.var3 character*15 filein. A forma do comando é a seguinte: Open (Unit = n.00 6.out Valor de K = 5 Valor de var3 = 30.

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. especificação-de-edição: é um conjunto de informações sobre a distribuição dos dados em um meio de entrada/saída.Métodos Computacionais / 1º Semestre de 2005 9 8. um sinal “–“ é colocado antes do número e se o número for positivo. Recomenda-se que não seja utilizada formatação nos arquivos de entrada. isto significa que os dados de entrada (read) e de saída (write) são respectivamente lidos e impressos na tela do computador. este será preenchido com asteriscos. 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. Especificação Iw Fw. 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. nenhum sinal é colocado antes do número. n: é um número também chamado de rótulo ou label da especificação format. Formatação de Dados de Entrada ou Saída: Na linguagem Fortran. 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. separados por vírgulas. lista-de-indentificadores: são os nomes das variáveis. não é necessário colocar o formato da entrada ou saída de dados. conforme pode ser visto na tabela abaixo sendo w o tamanho total do campo de entrada/saída. Comentários: O comentário é um texto ou simplesmente uma frase utilizada para melhorar a clareza do programa.n) lista-de-identificadores n format(especificação-de-edição) • • • • u: é uma constante positiva ou variável contendo um valor inteiro positivo. ou seja (u = *). não sendo utilizados arquivos externos de entrada ou saída de dados.n) lista-de-identificadores write(u. uma vez que isto pode ocasionar a leitura de dados de forma inadequada por um usuário desavisado. Sua forma geral é dada por: read(u. Na versão F77. 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.d Ew. No caso do rótulo da especificação format ser definido com o símbolo asterisco (n = *). 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. que especifica qual a unidade de entrada ou saída que será utilizada. os números aparecem sempre alinhados à direita. é através da especificação format. uma vez que os mesmos serão lidos ou impressos em formato livre.d Aw wX / Tipo de Variável integer real real character ------------Observação Entrada ou saída de inteiros Notação cientifica (d = parte decimal) Notação exponencial (d = parte decimal) Entrada ou saída de caracteres Espaços em branco Pular para linha seguinte . Se o valor de um dado de saída precisar de mais posições do que as previstas no formato. Em um campo de saída. Na versão F90. Se o número for negativo.

out) read (*.*) ’Valor de var3 = ‘.*) ‘Imprimir Resultados – no format: ‘ write(20.00 Valor de var3 = .2x.no format: Valor de K = 25 Valor de var3 = 42. fileout ! nomes dos arquivos de entrada (*.Métodos Computacionais / 1º Semestre de 2005 10 Program exercise_4 ! Objetivo: Ilustrar a formatação de dados de saída ! Declaração de variáveis do programa: integer I.F8.J ! Dados de entrada não formatados read(10.E8.*) filein open(unit=10.dat 10 15 ! integer I.*) I.out) ! Abertura de arquivos externos para entrada e saída de dados: write(*.40) var3.*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*. file=filein.J.50) programa 50 format(‘Nome do programa =’./.var2 Fortran ! character*7 programa Arquivo de Saída de Dados / Exercise_4.25) 25 format(//‘ Imprimir Resultados – format: ‘) write(20.J 7.*) var1.I8) write(20.00 ! real var1. status = ‘unknown’) write(*.42E+02 Nome do programa = Fortran .format: Valor de K = 25 Valor de var3 = 42.2.30) K 30 format(‘Valor de K = ‘.*) 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. ‘Valor de var3 write(20.A10) end program =’.00 6.K real var1.var3 40 format(‘Valor de var3 =’.*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*.000000 Nome do programa = Fortran Imprimir Resultados .*) fileout open(unit=20.var3 character*7 programa character*15 filein.var2.dat) e saída de dados (*.dat) read (*.2x. status = ‘unknown’) ! Leitura de Dados do Arquivo de Entrada de Dados: read(10.out Imprimir Resultados .2) Arquivo de Entrada de Dados / Exercise_4. file=fileout. K write(20.*) ‘Valor de K = ‘.*) ’Nome do programa = ‘.2x.var3 write(20.programa ! Imprimir os resultados no arquivo de saída com formatação: write(20.var2 read(10.

. denomina-se expressão lógica à expressão cujos operadores são lógicos e cujos operandos são relações. 5ª .AND.GT.OR.. >= maior ou igual a . < menor que . F77 F90 definição ----------------------------------------------. para disjunção .AND...4 – Operadores relacionais e lógicos Tabela 11. <= menor ou igual a . Expressões Aritméticas e Lógicas: Denomina-se expressão aritmética.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.LT. Na tabela abaixo são apresentadas algumas das principais funções intrínsecas existentes no Fortran 90: Função Definição Parâmetro Resultado ---------------------------------------------------------------------------------------------------------abs(X) valor absoluto de x real/inteiro real/inteiro -1 acos(X) cos (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. para conjunção .NOT.2 – Prioridade da operações prioridade operação --------------------------------------------1ª potenciação 2ª multiplicação/divisão 3ª adição/subtração Tabela 11.EQ.OR.NE.. . 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. 4ª . . == igual a .AND.3 – Prioridade das operações prioridade operador --------------------------------1ª aritmético 2ª relacional 3ª .1 – Operadores aritméticos operador operação -------------------------------+ adição – subtração * multiplicação / divisão ** potenciação Tabela 11...NOT.Métodos Computacionais / 1º Semestre de 2005 11 10. àquela cujos operadores são aritméticos e cujos operandos são constantes e/ou variáveis numéricas. Por outro lado.Xn) seleciona o menor valor Xi real/inteiro real/inteiro 11.Xn) seleciona o maior valor Xi real/inteiro real/inteiro min(X1. > maior que . .OR.GE.LE.. Tabela 11.NOT. para negação . /= diferente de . variáveis e/ou constantes do tipo lógico.

. . I=J+2L. podem existir estruturas condicionais ou de repetição. comentada no parágrafo acima.. Z=1 X**2+Y>=Z . I=J+2. I=J+nL ≤ K.GT. sendo executada quando uma determinada condição for verdadeira ou falsa.K bloco_de_comandos n continue do I = J. deverão ser executadas numa seqüência linear.false. se não houver indicação em contrário. de modo que o bloco de comandos é executado repetidamente com I=J. A estrutura condicional é representada pelo comando IF.. 12. seguidas por comandos que.( P − A) Representação no Fortran: (P*(P – A))**0. I=J+1.I=K. I=J+3L. .. O fim físico do programa é representado pela palavra chave END. X=4.5 ou sqrt(P*(P – A)) D   1. C + −F+G E +1   A – B*(C+D/(E+1) – F)+G 2) Variáveis Relação Resultado --------------------------------------------------------------X =1. Comandos IF e DO: Num programa escrito em linguagem Fortran.true.1) P. permitindo que uma seqüência de comandos seja executada repetidamente até que uma determinada condição de interrupção seja satisfeita.Z . . Y=2. Z=5 X**2+Y.K. seguindo-se o texto em que estão escritos.. Y=3. .1 Exemplos: 1) Expressão matemática: 1.K bloco_de_comandos enddo do n I = J.L bloco_de_comandos enddo Nas duas primeiras estruturas mostradas acima o bloco de comandos é executado repetidamente com I=J.Métodos Computacionais / 1º Semestre de 2005 12 11. de cima para baixo. Dentro da estrutura seqüencial do Fortran. else bloco_n endif if (condição) then bloco_1 endif if (condição) then bloco_1 else bloco_2 endif Já a estrutura de repetição da linguagem Fortran é representada pela palavra-chave DO.2) A − B. aparecem em primeiro lugar as declarações. conforme as suas diferentes formas apresentadas abaixo: if (condição) comando_1 if (condição1) then bloco_1 elseif (condição2) then bloco_2 elseif (condição3) then bloco_3 . I=J+L. .. As diferentes formas do comando DO são apresentadas abaixo: Versão F77: do I = J. ao passo que na terceira estrutura o termo L representa o incremento na variável I.

.. Tal construção é conhecida pelo nome de ninho de IF ou de DO: do I=1. Sub-rotinas e Funções: Em relação à modularização de programas.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 Para o caso de se querer usar uma estrutura de repetição.) bloco_de_comandos end subroutine S2 function F1(.. porém sem saber inicialmente quantas vezes o laço de DO deve ser executado.12 na lista de programas em anexo. o que torna possível a implementação de programas modulares e estruturados. um dentro do outro.....7...) . pode-se utilizar o comando DO WHILE: do while (expressão_lógica) bloco_de_comandos enddo Exemplos: ver exercises_5. que pode ser chamado várias vezes.) bloco_de_comandos end subroutine S1 subroutine S2(.10 do K=2..11.6.. tomando-se o cuidado de sempre fechar os laços mais internos dentro dos laços mais externos. sempre que for necessário: ! Programa Principal .) ! Chamada da Função F1: A = F1(......Métodos Computacionais / 1º Semestre de 2005 13 Vale ressaltar que é possível abrir uma série de laços IF ou DO.) ! Chamada da Sub-rotina S2: call S2(.. 13. contains subroutine S1(.. permitindo a construção de módulos subordinados a um programa principal. ! Chamada da Sub-rotina S1: call S1(. a linguagem Fortran oferece facilidades através de sub-rotinas (subroutine) e funções (function)..5 do J=3..) bloco_de_comandos end function F1 End program ! Término do programa principal ..

. a todos os elementos da variável composta.3) real*8 matriz_2(2. vector_2(10) real vector_3(4). convenciona-se que o primeiro índice indique a linha e o segundo a coluna.2) = 3..matriz_3(3. identificadas por um único nome.. Em Fortran. é necessário colocar-se o nome da variável.14. Assim como na versão F77. esses índices podem ser constantes inteiras ou variáveis inteiras.. todos os dados são public. é necessário que o usuário declare explicitamente no corpo da sub-rotina ou função todas as variáveis que são privativas.3). Pode-se juntar uma série de sub-rotinas e funções para formar uma biblioteca de sub-rotinas. de um ou mais índices. entre parênteses. Em geral. var_1 = 2*vector_1(4)+vector_2(10) . no F90 pode-se passar dados para sub-rotinas e funções usando argumentos. coletivamente. ou seja. Para referência a um elemento.18 na lista de programas em anexo.15.. Portanto.Métodos Computacionais / 1º Semestre de 2005 14 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. Em F90.. 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.5) também produz erros No Fortran. todas as sub-rotinas e funções tem acesso à todas as variáveis globais. não estando limitada a um programa específico.3. matriz_1(3. Por exemplo. Segue abaixo exemplos de variáveis compostas: ! Declaração de variáveis: integer var_1 ! variável simples integer vector_1(5). de forma semelhante à biblioteca de funções intrínsecas que vem com o compilador. Nas variáveis compostas bi-dimensionais (matrizes ou tensores de segunda ordem). . ! tentar referenciar: vector_1(6). A maioria dos compiladores aceita também expressões inteiras. as variáveis compostas unidimensionais (vetores) são utilizadas para armazenar conjuntos de dados cujos elementos podem ser endereçados por um único índice. vector_1(0) ou vector_1(-2) produz erros ! tentar referenciar: vector_1(2. Exemplos: ver exercises_13. utilizam-se laços de DO para manipular os elementos de um arranjo.. Arranjos ou Variáveis Compostas: As variáveis compostas correspondem a posições de memória. 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). O nome de uma variável composta é um identificador que obedece às mesmas regras de formação de identificadores de variáveis simples. uma sub-rotina que resolve o sistema: Ax=y pode ter muitas aplicações.. resolvendo o problema do comando COMMON que não é mais necessário em F90.3) ! pode possuir até 7 dimensões em F90 .. diferente das versões anteriores. seguida. O nome se refere. 14. individualizadas por índices e cujo conteúdo é de um mesmo tipo.0 ! elemento na primeira linha e segunda coluna de matriz_1 . vector_1(3) = 2 ! terceiro elemento da variável vector_1 matriz_1(1.

allocatable :: matriz_1 ! matriz sem dimensões ! integer n.3). exceto quando estiver em uso. allocatable :: vector_1 ! vetor sem dimensão ! real*8. Aumentar e diminuir o tamanho de arranjos.1)=M(4..3).k) = MC(n. M1(1:3. read(*.1:3)=M(4:6.21..b(5). conforme ocorria para o caso da versão F77: ! Declaração de Variáveis: real*8 x(10). M4(3.0 ! efetua a multiplicação de cada um dos termos x(i) por 3. Porém.2)=M(4.M1(3.m . .k) Exemplos: ver exercises_19.M5(3.MB) ! multiplicação de matrizes: MA(n.1 Dimensionamento Dinâmico de Arranjos: Em programas computacionais de médio e grande porte. dimension(:.m)*MB(m.2).3). dimension(:). é necessário fixar antes a sua dimensão.a(4). prod real*8 M2(3. .y(10). pode-se: • • • Manter um arranjo no tamanho zero. de modo a evitar a perda de memória do computador.5)..1:10) ! vetor x igual a primeira linha da matriz M MC=Matmul(MA.3) .. 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... b(2)=x(2)+y(7).m)) ! definindo as dimensões da matriz . M3=transpose(M2) ! efetua a transposta da matriz M5=M1+M4 ! soma de matrizes (mesma dimensão) x(1:10) = M(1.1:10)=0.z(10).. z = x+y ! efetua a soma de cada um dos termos x(i)+y(i) isoladamente z = x*3. sem a necessidade de se utilizar laços de DO.M(10.:).10).0 a todos os termos da matriz M.4:6) ! M1(1.. 14. segundo o qual.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).. M(1:10.M3(2. Ler o tamanho de arranjos como dados em vez de fixar de antemão. Arranjos sem dimensões não podem ser passados para sub-rotinas como argumentos. A seguir é apresentado o funcionamento da alocação dinâmica de arranjos: ! declaração de variáveis: ! real*8. M1(1..0 ! atribui o valor 0.m allocate(vector_1(n)) ! definindo a dimensão do vetor allocate(matriz_1(n.Métodos Computacionais / 1º Semestre de 2005 15 14.20.23 na lista de programas em anexo.. é bastante útil utilizar o dimensionamento dinâmico de arranjos..*) n...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. ou seja.4).

*)'Entre novamente com a nota:' read (*.Métodos Computacionais / 1º Semestre de 2005 Anexo .*) nota endif ! Laços de IF: if (nota==0) then write(*.*)'Nota deve ser positiva entre 0 e 10' write(*.and.nota>10) then write(*.*) nota if (nota<0.*) attendance ! Laços de IF: if (attendance<=75) then write(*.*) 'Digitar a presenca do aluno: ' read(*.and.attendance ! Entrada de Dados: write(*.*)'Final Grade = SR' elseif (nota>0.and.nota<3) then write(*.and.*) nota endif write(*.nota<9) then write(*.and.*)'Final Grade = MM' elseif (nota>=7.nota<7) then write(*.*)'Final Grade = SR' elseif (nota>0.nota<7) then write(*.*)'Final Grade = MI' elseif (nota>=5.nota>10) then write(*.*)'Final Grade = MM' .*)'Final Grade = SS' endif 16 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.or.and.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(*.or.*)'Final Grade = MI' elseif (nota>=5.*) 'Digitar a nota do aluno: ' read (*.*) nota if (nota<0.nota<3) then write(*.and.*)'Final Grade = II' elseif (nota>=3.nota<5) then write(*.*) 'Digitar a nota do aluno: ' read (*.*)'Entre novamente com a nota:' read (*.*)'Final Grade = SR' else if (nota==0) then write(*.*)'Final Grade = II' elseif (nota>=3.*)'Final Grade = MS' else write(*.*)'Nota deve ser positiva entre 0 e 10' write(*.nota<5) then write(*.

juros.*)'Final Grade = SS' endif endif 17 end program __________________________________________________________________________________________ program exercise_7 ! Objetivo: Rendimentos bancários ! Declaração de variáveis: integer i.*)'Mes:'.0 ! Laços de DO: do meses=meses+1 juros=taxa*saldo saldo=saldo+juros write(*.*) saldo write(*.*) 'Digitar saldo original: ' read (*.i.*) 'Digitar numero de meses: ' read (*.juros.*)'Final Grade = MS' else write(*.*) meses taxa=taxa/100.*) 'Digitar taxa de juros (0-100%): ' read (*.' Saldo:'.*)'Mes:'.*) saldo write(*.*) 'Digitar taxa de juros (0-100%): ' read (*.juros.juros.taxa ! Entrada de Dados: write(*.saldo if (saldo>2*saldo_inicial) stop enddo end program __________________________________________________________________________________________ .' Juros:'.taxa ! Entrada de Dados: write(*.nota<9) then write(*.meses.*) taxa write(*.meses juros=taxa*saldo saldo=saldo+juros write(*.' Juros:'.and.*) taxa saldo_inicial=saldo taxa=taxa/100.' Saldo:'.*) 'Digitar saldo original: ' read (*.meses real saldo.0 ! Laços de DO: do i=1.Métodos Computacionais / 1º Semestre de 2005 elseif (nota>=7.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.

5*(raiz+numero/raiz) write(*.*)'Raiz por iteracoes : '.*)'X = '.L.0 ! carregamento concentrado A = 8.raiz write(*.*)'Iteration: '.' M= '.distance integer i ! Características Geométricas: L = 10.*)'Entrar com o numero: ' read (*.distance.' Raiz: '.sqrt(numero) 18 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.raiz enddo write(*.dx.*)'Momentos fletores ao longo da viga: ' do i=0.*)'Raiz pela funcao SQRT: '.i.0 ! comprimento total da viga W = 100.M enddo end program __________________________________________________________________________________________ .10 distance =i*dx if (distance<=A) then M=R1*distance else M=R1*distance-W*(distance-A) endif write(*.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(*.W.raiz integer i ! Entrada de dados: write(*.*) numero raiz = 1 ! Chute inicial (Não importa que seja muito longe) do i=1.Métodos Computacionais / 1º Semestre de 2005 program exercise_9 ! Objetivo: Achar a raiz quadrada de um número por iterações ! Declaração de variáveis: real numero.10 raiz = 0.A.

! * O fatorial será calculado utilizando-se variáveis: integer ou real*8.file=fileout.000000000000000 5 120 120.000000000000000 2 2 2.000000000000000 11 39916800 3.092278988800000E+013 17 -288522240 3.20 ifact=ifact*i rfact=rfact*i write(*.227e+09 = 6227000000 > 2147483647 14 1278945280 8.ifact.717829120000000E+010 15 2004310016 1.*)i.790016000000000E+008 13 1932053504 6.402373705728000E+015 19 109641728 1. ! É importante ressaltar que as variáveis inteiras só podem armazenar valores ! no intervalo [-2147483648.227020800000000E+009 ! Observação: 6.rfact enddo end program Arquivo de Saída de Dados (exercise_11.Métodos Computacionais / 1º Semestre de 2005 program exercise_11 ! Objetivo: * Cálculo do fatorial de um número.rfact write(10.216451004088320E+017 20 -2102132736 2.000000000000000 3 6 6.000000000000000 4 24 24.*) fileout open(unit=10.*)i.*) ' i ifact write(10.000000000000000 8 40320 40320.991680000000000E+007 12 479001600 4.status='unknown') ! Cálculo do Fatorial ifact=1 rfact=1.0d0 write(*.ifact.*)' i ifact do i=1.out): 19 rfact' rfact' i ifact rfact 1 1 1.000000000000000 9 362880 362880. ! 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(*.556874280960000E+014 18 -898433024 6.432902008176640E+018 __________________________________________________________________________________________ .307674368000000E+012 16 2004189184 2.000000000000000 7 5040 5040.2147483647].000000000000000 10 3628800 3628800.*)'Nome do arquivo de saida de dados .000000000000000 6 720 720.Max(15char): ' read (*.

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

000000 COEFICIENTE LINEAR : 3.*) a.866025) __________________________________________________________________________________________ program exercise_13 ! Objetivo: Escrever um programa que leia os comprimentos dos três lados a. .c ! Cálculo do volume e diagonal do paralelepípedo: vol = volume(a.b.y) real x.vol write(*. ( 2 raizes complexas ) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: 21 COEFICIENTE QUADRÁTICO : 2.000000 COEFICIENTE INDEPENDENTE: 2.c):' read (*. -.b).volume volume =x*y*z end function volume function hipotenusa(x.*)'Entrar com os comprimentos dos lados (a.500000. 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.d.*) 'Volume = '.y. write(*.c.z) real x.c) write(*.hipotenusa hipotenusa =sqrt(x**2+y**2) end function hipotenusa end program __________________________________________________________________________________________ .Z1 : ( -.vol ! Entrada de Dados.500000 SEGUNDA RAIZ .866025) SEGUNDA RAIZ .y.000000 2.000000 COEFICIENTE INDEPENDENTE: 4.X1 : 2.X1 : -.500000.000000 SEGUNDA RAIZ .000000 PRIMEIRA RAIZ .X2 : -1.000000 COEFICIENTE INDEPENDENTE: 1.000000 PRIMEIRA RAIZ .*) 'Diagonal = '.z. ( 2 raizes reais iguais ) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: COEFICIENTE QUADRÁTICO : 1.000000 COEFICIENTE LINEAR : -4.b e c de um ! paralelepípedo.y.Z2 : ( -.000000 PRIMEIRA RAIZ .X2 : 2.000000 COEFICIENTE LINEAR : 2.b. ( 2 raizes reais diferentes) CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: COEFICIENTE QUADRÁTICO : 2.Métodos Computacionais / 1º Semestre de 2005 Arquivos de Saída de Dados: 1.d contains function volume(x.c) d = hipotenusa(hipotenusa(a.000000 3.b.b.

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

*)'----------------------------------------' write(10.413158521647700 F(x)=exp(x) = 148.tol.fexp write(10.exp(x) contains function fact(n) integer n. status='unknown') write(10.*)'Valor de x: ' read (*. = '.0d0 ! inicializar a função parcela = 1. ! Observação: Na função acima deve-se incluir apenas os termos maiores que tol=1.*) write(10.*)'Valor de x = '.000000000000000 F(x)=1+x+(x^2/2!)+(x^3/3!)+.. = 148.*) file_out ! Cálculo da função exponencial de x: tol = 1..*)'F(x)=exp(x) = '.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. ! Imprima os resultados e compare com a função interna exp ! Declaração de variáveis: integer i real*8 x.j real*8 fact...parcela character*15 file_out ! Entrada de dados: write(*.*) x write(*.*) write(*..out): Valor da funcao exponencial de X: ---------------------------------------- 23 Valor de x = 5..0e-06 ! tolerâncial fexp = 0.fexp.n temp=temp*j enddo fact=temp end function fact end program Arquivo de saída de dados (exercise_16.temp temp=1 do j=2. x write(10.*)'F(x)=1+x+(x^2/2!)+(x^3/3!)+.*)'Nome do arquivo de saida de dados (Max=15char): ' read (*.Métodos Computacionais / 1º Semestre de 2005 program exercise_16 ! Objetivo: Escrever um programa que calcule a função: ! exp(x)=1+x+(x^2/2!)+(x^3/3!)+.*)'Calculo da funcao F=exp(x)' write(*.*)'Valor da funcao exponencial de X: ' write(10.413159102576600 __________________________________________________________________________________________ . file=file_out.0E0-6.

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

file=file_in.*) file_in open (unit=10.*)'Desvio Padrao = '.media.Métodos Computacionais / 1º Semestre de 2005 contains function f(x) real*8 f. ! Declaração de Variáveis: integer i.n real std. status='unknown') .*) file_in open (unit=10.*)n do i=1.x df = 3*x**2+1 end function df ! Função qualquer escolhida pelo usuário f(x) = x^3+x-d 25 ! Derivada da função: df(x) = 3*x^2+1 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.x f=x**3+x-3 end function function df(x) real*8 df.n std=std+(x(i)-media)**2 enddo std=sqrt(std/(n-1)) write(*.*)'Valor Medio = '.*)x(i) media=media+x(i) enddo ! Cálculo da Média e Desvio Padrão: media = media/n do i=1.0 read (10.media write(*.x(100) character*15 file_in ! Entrada de Dados: write(*.media.*)'Nome do arquivo de entrada de dados (Max=15Char): ' read (*.*)'Nome do arquivo de entrada de dados (Max=15Char): ' read (*.x(100) character*15 file_in ! Entrada de Dados: write(*.n read(10. status='unknown') media=0.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. file=file_in.0 std =0.n real std.

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

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

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

000000 26.000000 2.000000 14.000000 14.0 4.0 4.out) 3 3 3 ! n.0 2.000000 1. dimension(:.C C=Matmul(A.B.000000 4.000000 14.000000 2.000000 26.0 3.k 1.j)) enddo enddo end subroutine prodF90 subroutine prod_function(A.k C(i.000000 Matriz C=A*B utilizando prodF77: 14.000000 26.j.000000 3.000000 20.Métodos Computacionais / 1º Semestre de 2005 subroutine prodF77(A.B.j) enddo enddo enddo end subroutine prodF77 subroutine prodF90(A.C integer i.000000 26.000000 3.:) :: A.j)=C(i.n do j=1.000000 5.C integer i.000000 Matriz C=A*B utilizando prod_function: 14.000000 26.000000 20.B.0 2.000000 Matriz C=A*B utilizando prodF90: 14.0 do l=1.C) real.B.l)*B(l.C) real.B) end subroutine prod_function end program Arquivo de Entrada de Dados (exercise_23.0 3.000000 20.:) :: A.0 5.0 2.000000 20.0 2.000000 20.C) real.0 2.000000 20.m. dimension(:.000000 3.0 1.000000 26.000000 26.000000 2.n do j=1.000000 20.000000 26.1:k)= 0.:) :: A.0 3.k C(i.000000 3.000000 14.out) Matriz A: 1. dimension(:.000000 14.j)=sum(A(i.000000 29 .1:m)*B(1:m.000000 20.000000 3.000000 20.000000 14.B.000000 Matriz B: 1.000000 2.j)+A(i.0 3.0 3.000000 26.0 do i=1.000000 1.l do i=1.0 3.000000 2.000000 4.0 Arquivo de Saída de Dados (exercise_23.m C(i.000000 3.j C(1:n.0 1.j)=0.0 1.B.

000000 1.000000 11.000000 Matriz C=A*B utilizando prod_function: 5.000000 11.0 1.000000 Matriz B: 1.000000 11.000000 8.000000 5.000000 8.000000 2.000000 8.000000 11.000000 4.0 2.0 1.000000 Matriz C=A*B utilizando prodF90: 5.0 2.0 3.000000 2.000000 5.000000 8.000000 3.m.000000 11.000000 1.0 4.0 1.000000 2.0 2.000000 Matriz C=A*B utilizando prodF77: 5.000000 11.000000 8.out) (Matrizes não quadradas) Matriz A: 1.0 ! n.000000 8.Métodos Computacionais / 1º Semestre de 2005 Arquivo de Entrada de Dados (teste_23.000000 11.000000 2.000000 8.000000 8.000000 5.out) (Matrizes não quadradas) 3 2 3 1.000000 3.000000 2.0 3.k 30 Arquivo de Saída de Dados (teste_23.0 2.000000 11.000000 8.000000 5.000000 11.000000 5.0 2.000000 5.000000 __________________________________________________________________________________________ .

B write(io.m4.MABT(3.3)=3.*)'Output File Name ? (Max 15 Char)' read (*.0 MB(2.3 write(io.3).3 write(io.MM(3.0 MB(3.*)'Program: Matrix ' write(*.0 ! Matriz Transposta: MT=Transpose(MA) write(io.1)=7.6) real*8 aM(3.1)=0.0 MA(3.V3(4) real*8 PV(3).3) real*8 Config_C0(3.m1.3) real*8 V1(3).3)=0.2)=5.3 write(io.*) fileout open (io.3)=1.*)'--------------------------------' write(*.MABST(6.j).0 MB(2.3).m6 integer io character*15 fileout io = 20 write(*.*)Soma(i) enddo write(io.j=1.0 MB(1.2)=2.*)'Matriz Transposta: ' do i=1.m2.0 MB(3.1)=1.status='unknown') write(*.2)=1.0 MB(1.matAB(3.3).*)'Vetor Soma: ' do i=1.3)=6.*) write(*.3)=0.0 MA(1.1)=0.Soma(3).2)=0.m3.0 MA(2.*)(MT(i.*) ! 1.3).B(3).0 MA(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 .0 ! Matriz MB: MB(1.0 MA(2.*)'Vetor Subt: ' do i=1.MS(3.0 MA(2.V2(3) real*8 MC(3.3) enddo 31 .3).file=fileout.Métodos Computacionais / 1º Semestre de 2005 ! ******************************************************* ! Programa: Matrix ! Operações com vetores e matrizes no F90 ! Author: Renato César Gavazza Menin ! ******************************************************* program matrix implicit double precision(a-h.1)=4.MB(3.E_0(3.10).Subt(3) real*8 MA(3.*)Subt(i) enddo ! 2.0 MA(3.0 MB(3.0 MA(3.0 MB(2.2)=8.o-z) implicit integer (i-n) real*8 A(3).1)=1.3).3).m5.norma.3)=9.2)=0.4).MT(3. Transposição e soma de matrizes: ! ------------------------------------------! Matriz MA: MA(1.

4:6) E_0(1:3.f4.*)'Matriz Config_C0: ' do i=1.j).Função Interna "MATMUL" MM=MATMUL(MA.X.3 do j=1.3 write(io.MM=MA*MB*MT: ' do i=1.j).4:6)=MB MABST(4:6.f4.1)=Config_C0(1.X.1.MB) write(io.A) write(io.*)'Matriz MABST: ' do i=1.*)(MS(i.j).3 write(io.1) enddo ! Configuração Inicial: do i=1. Composição de matrizes: ! --------------------------------MABST(1:3.j).X.4:6)=MT write(io.4 Multiplicação de Vetor e Matriz: ! Obs: [V2]1x3 = [A]1x3 * [MA]3x3 V2=MATMUL(A.1.1.f4.j=1.1.*)V1(i) enddo ! 4.j=1.MA*MB: ' do i=1.3) 15 format(f4.*)(MABT(i.*)V2(i) enddo 32 .1:3)=MA MABST(1:3.3) enddo MM=MATMUL(MM.f4.j=1.MA) write(io.j).7:9) write(io.3) enddo MABT=MATMUL(MM.10 Config_C0(i.3) enddo ! 3.3 write(io.Métodos Computacionais / 1º Semestre de 2005 ! Soma de Matrizes Quadradas: MS=MA+MB write(io.6) 10 format(f4.j=1.2)=Config_C0(1.2 Multiplicação de matrizes .j=1.j).10)(MABST(i.*)'Multiplicar matrizes .MT) write(io.3 Multiplicação de Matriz e Vetor: ! Obs: [V1]3x1 = [MA]3x3 * [A]3x1 V1=MATMUL(MA.j=1.X.j=1.1.3 write(io.6 write(io.*)'Multiplicar vetor e matriz: ' do i=1.*)'Multiplicar matriz e vetor: ' do i=1.f4.1.*)'Multiplicar matrizes .*)'Multiplicar matrizes .j)=i+j enddo enddo E_0(1:3.f4.*)(aM(i.3) enddo ! 4.0*MA write(io.*)'Multiplicar matriz por escalar: ' do i=1.1:3) E_0(1:3.3 write(io.X.15)(E_0(i.MA*MB*MT: ' do i=1.3 write(io.MT) write(io.1.*)'Soma de Matrizes: ' do i=1.*)(MM(i.3)=Config_C0(1.X.1 Multiplicação de Matriz Quadrada por Escalar: aM=2.j).3) enddo ! 4.X.3 write(io.3 write(io.*)(MM(i.1:3)=MS MABST(4:6.1) enddo ! 4.f4. Multiplicação de matrizes: ! -----------------------------------! 4.

*)'Encontrar valor maximo de sequencia: ' m1=max(1.j).norma ! 7.m2 write(io.Function Norm: ' write(io.4)=A V3=MATMUL(A.3 write(io.*)(matAB(i.0 MA=Matmul(MA.MC) write(io.2).2.3.3)) write(io.4 write(io.MA(1.*)'Multiplication of vector by non quadratic matrix: ' do i=1. Multiplicação de matriz e transposta: ! ----------------------------------------------! Reestabelecer Matriz MA: MA(1.2) = '.Subrotina Cross: ' do i=1.5) = '.*)'[MA] = ([MA]+[MA]t)/2: ' do i=1.3)=6.m3 write(io.5 Multiplicação de Vetor e Matriz Não Quadrada: ! Obs: [V3]1x4 = [A]1x3 * [MC]3x4 MC(1:3.B) write(io.-2.0) m6=max(MA(1.1)=7.3) enddo ! 10.0.*)V3(i) enddo ! 5.1.MA(1.5*MA write(io.*)'m3=max(-3.1) = '.0 MA(1.*)'[matAB] = vecmul(A.5.5.0.5.2.1.-3) = '.*)PV(i) enddo ! 6.3) = '.Métodos Computacionais / 1º Semestre de 2005 33 ! 4.0 MA(1.1).3) enddo ! 9.m4 write(io.1:3)=MA MC(1:3.0.*)'m5=max(-3.-2.3 write(io.j).3)=3.*)'Norm = '.*)'Produto Vetorial .MA(1.0 MA(3.0 MA(3.PV) write(io.1). Simetrização de uma matriz: ! -------------------------------------MA=MA+transpose(MA) MA=0.3) enddo .2)=5.j=1.0 MA(2.*)'m4=max(1.m1 write(io.V1.2).3))= '.3.0 MA(2.*)(MA(i.0 MA(2.5.3 write(io. Subrotina para o cálculo do produto vetorial: ! -------------------------------------------------------call cross(A.m5 write(io.m6 ! 8.B): ' do i=1.3 write(io.0.1) m4=max(1. Função para o cálculo da norma do vetor: ! ------------------------------------------norma=norm(A) write(io.*)'[MA] = [MA]*transpose[MA]: ' do i=1. Multiplicação de vetor(3.2)=8.transpose(MA)) write(io.MA(1.2)=2.3)=9.0.-3) m3=max(-3.0 MA(3.1) e vetor(1.j=1. Encontrar o valor máximo de uma sequência: ! -------------------------------------------write(io.5.*)'m1=max(1.1)=4.1)=1.5.*)'m6=max(MA(1.*)(MA(i.3): ! ----------------------------------------------------matAB=vecmul(A.5) m5=max(-3.j=1.2.j).*)'m2=max(-1.3) m2=max(-1.*)'Norma de Vetor .

000000000000000 50.000000000000000 6.0 .000000000000000 6.0 3.000000000000000 8.000000000000000 32.0 Multiplicar matriz por escalar: 2.000000000000000 50.000000000000000 2.0 .000000000000000 122.B) real*8 A(3).000000000000000 16.000000000000000 18.000000000000000 32.000000000000000 -18.0 8.0 1.0 3.0 5.000000000000000 4.0 4.0 10.3 do j=1.000000000000000 33.000000000000000 122.000000000000000 5.000000000000000 77.000000000000000 32.MM=MA*MB*MT: 14.000000000000000 3.0 2.0 9.000000000000000 4.0 1.000000000000000 7.000000000000000 7.000000000000000 32.0 4.0 7.000000000000000 4.000000000000000 12.000000000000000 3.0 6.3) integer i.j)=A(i)*B(j) enddo enddo vecmul=mat end function vecmul End ! Término do Programa Principal 34 Arquivo de Saída de Dados (matrix.000000000000000 7.0 7.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).000000000000000 50.000000000000000 Multiplicar matrizes .0 4.000000000000000 4.000000000000000 77.000000000000000 8.000000000000000 2.B(3).000000000000000 Matriz Transposta: 1.0 7.0 .0 9.000000000000000 Multiplicar matrizes .0 4.0 8.0 8.0 .000000000000000 122.000000000000000 Soma de Matrizes: 2.0 3.0 7.3).000000000000000 50.000000000000000 50.000000000000000 Multiplicar matriz e vetor: 14.MA*MB*MT: 14.0 5.000000000000000 3.0 10.0 1.0 5.PV) real*8 A(3).0 8.0 Matriz Config_C0: 2.0 9.000000000000000 194.MA*MB: 1.000000000000000 -27.000000000000000 8.000000000000000 .000000000000000 194.vecmul(3.000000000000000 Vetor Subt: -9.0 2.000000000000000 122.0 6.B(3).000000000000000 10.000000000000000 6.000000000000000 Multiplicar matrizes .0 3.000000000000000 Matriz MABST: 1.000000000000000 9.3 mat(i.0 2.000000000000000 5.out): Vetor Soma: 11.000000000000000 6.Métodos Computacionais / 1º Semestre de 2005 CONTAINS Subroutine cross(A.j do i=1.norm norm=dsqrt(V(1)*V(1)+V(2)*V(2)+V(3)*V(3)) end function norm Function vecmul(A.000000000000000 22.000000000000000 6.000000000000000 9.000000000000000 2.0 1.0 6.B.0 6.0 .000000000000000 10.0 6.mat(3.0 2.000000000000000 14.000000000000000 8.0 .000000000000000 32.

“Notas de aula do curso: Métodos Computacionais / 1º Semestre de 2002”. “Como programar em C”.3. A. Faria.M. “Fortran Estruturado”.000000000000000 122. 2002.Deitel. P. 1998.000000000000000 20.2) = 2.J. .000000000000000 m6=max(MA(1.1) = 1. Fourth Edition.000000000000000 [MA] = ([MA]+[MA]t)/2: 1.B): 10.0. Deitel & P.000000000000000 5.000000000000000 36.000000000000000 32. W.1.5.Huerta.-3) = -1.G. A. Sarrate.3))= 3.C. Chapman.000000000000000 194.000000000000000 20. aplicaciones y programacion”.5)= 5.2. Farrer. “SAMS Teach Yourself C++ in 21 Days”.000000000000000 Norma de Vetor .000000000000000 5.J.MA(1. Partridge.000000000000000 4.000000000000000 122.5.000000000000000 7.741657386773941 Encontrar valor maximo de sequencia: m1=max(1.3) = 3.000000000000000 __________________________________________________________________________________________ 35 REFERÊNCIAS BIBLIOGRÁFICAS: • • • • • • H.000000000000000 50.000000000000000 14.000000000000000 Multiplication of vector by non quadratic matrix: 30.R.000000000000000 Produto Vetorial .2).000000000000000 60. 1998.000000000000000 77. E.000000000000000 50.000000000000000 42.Function Norm: Norm = 3.000000000000000 90.000000000000000 7. 1994. Barcelona.1). J. J. Universiat Politécnica de Catalunya.000000000000000 40. USA. C.000000000000000 3.000000000000000 [matAB] = vecmul(A.000000000000000 30.000000000000000 m4=max(1.000000000000000 32. Becker. Introducion.0.MA(1.000000000000000 9.000000000000000 [MA] = [MA]*transpose[MA]: 14.Subrotina Cross: 4.000000000000000 3.000000000000000 42.. Rio de Janeiro.A. WCB/McGraw-Hill. H.-2. Livros Técnicos e Científicos Editora.500000000000000 m5=max(-3. Brasília. Ferran. “Fortran 90/95 for Scientists and Engineers”.000000000000000 60.5.000000000000000 m3=max(-3.000000000000000 5.000000000000000 30. Rio de Janeiro .000000000000000 m2=max(-1.Métodos Computacionais / 1º Semestre de 2005 Multiplicar vetor e matriz: 30. S.000000000000000 36. “Métodos numéricos. Indiana / USA. 1992. Editora Guanabara Koogan. S. 2001. Liberty. SAMS Publishing.000000000000000 -8.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->