fiscomp_fa-01_2011-1

5/10/2018 fiscomp_FA-01_2011-1 - slidepdf.com

http://slidepdf.com/reader/full/fiscompfa-012011-1 1/64

Instituto de Física Armando Dias TavaresDepartamento de Física Aplicada e Termodinâmica

Física Computacional A

DFAT/ FiscompFA

Primeiros Programas: constantes e variáveis tipo caractere

Professor: Anibal Leonardo Pereira última atualização: março 2011

Estagiários:2004/1 a 2005/2 Luciana Conceição Iecker Lima2010/1 Magali dos Santos Leodato2009/1 a 2010/2 Filipe da Fonseca Cordovil

Monitores:

2001/1 Diego Chagas Garcia2002/2 Erick Azevedo Meirelles2003/1 a 2003/2 Luciana Maria dos Santos Azevedo2003/1 a 2003/2 Tatiana Gonçalves Martins2003/1 a 2005/2 Renato Nascente Júnior 2004/1 a 2005/2 Públio Martins Romano M. Carreiro2006/1 a 2007/2 Luiz Fernando Rosalba Telles Souza2006/1 a 2007/2 Paulo Henrique Pfitzner 2008/1 a 2008/2 Filipe da Fonseca Cordovil2008/1 a 2009/2 Magali dos Santos Leodato2011/1 a Filipe da Fonseca Cordovil

1. IntroduçãoExistem inúmeras linguagem de programação disponíveis para uso, entre as quais podemos citar: Fortran, C,

Pascal, C++, Java, etc.. Cada linguagem de programação foi criada e desenvolvida para tornar fácil aimplementação de um certo tipo de tarefa. Cada linguagem de programação possui qualidades e fraquezas.

Dentre as várias linguagens de programação existentes, Fortran é importante para quem trabalha na áreacientífica, porque muitas atividades necessárias à ciência envolvem o uso de cálculo numérico. Além disto, alinguagem de programação Fortran é fácil de ser aprendida, muito eficiente para a realização de cálculosnuméricos, é orientada a objetos e (uma das razões mais importante) pode ser utilizada na computação em paralelo.Por estes motivos, o Fortran é uma linguagem muito importante, principalmente, para os físicos e engenheiros.

A linguagem de programação C, própria para controlar tarefas ligadas ao sistema operacional dos computadores,também pode ser utilizada para a realização de cálculos numéricos, mas apresenta um grau de dificuldade maiorde aprendizagem do que o Fortran. A linguagem de programação C++, que é uma linguagem orientada a objeto,também pode ser utilizada, mas também apresenta grande dificuldade de aprendizado.

A título de curiosidade, mas também porque permite evidenciar uma atitude bastante equivocada (não muitodifícil de ser encontrada), apresenta-se um texto tirado do livro Classical Fortran – Programming for engineeringand scientific applications de Michael Kupferschimd de 2002:

Colleges often invite faculty from other schools to evaluate the local curriculum. One such reviewer had almostfinished his visit to a computer science department, and was about to give the dean of the school a favorable

report, when someone carelessly mentioned having taught a course in numerical methods using Fortran.Incredulous, the visitor arched an eyebrow and looked down his nose with sudden contempt. "FORTRAN," hesneered, "is the language of peasants!" I was not present to enjoy this incident, so I can only assume the report Iheard was accurate, but even if apocryphal it makes a good story and several important points about Fortranprogramming. Hence the attitude of this book, and part of my motivation for writing it.



2 DFAT/Folha Atividades/FiscompFA – Primeiros Programas: constantes e variáveis tipo caractere

Tradução livre:Faculdades frequentemente convidam professores e administradores de outras escolas para avaliar o currículolocal. Um destes visitantes terminando sua visita no departamento de ciência computacional, estava quase aponto de emitir seu parecer favorável ao responsável pela escola, quando alguém descuidadamente mencionouque havia ministrado uma disciplina de método numérico utilizando Fortran. Incrédulo, o visitante arqueou umsobrancelha e olhando com ar superior, subitamente deixa escapar “FORTRAN”. Então com ar de desdémpronuncia “é a língua dos ignorantes”. Eu não estava presente para apreciar este incidente, então somenteposso assumir que o relato que ouvi é correto, mas mesmo sendo questionável ele dá uma boa estória e

destaca vários pontos importantes sobre o Fortran. Esta atitude motivou a escrita deste livro.

Resumidamente, pode-se dizer que as principais razões para o uso da linguagem de programação Fortran são:

• alta performance: poucas linguagem de programação têm performance comparável ao Fortran noscálculos numéricos

• linguagem moderna: permite trabalhar de forma bastante adequada as complexidades apresentadas

• forte nos problemas numéricos: mas, também possibilita implementar tarefas não numéricas

• muito utilizada no campo científico: especialmente pelos físicos e engenheiros (em 1996: 32% dos

usuários de estações de trabalho envolvidos com engenharia e ciência usavam o Fortran)• dispõe de muitas bibliotecas (grátis e comerciais) de alta qualidade contendo inúmeras funções e sub-

rotinas disponíveis para uso

• fácil de aprender e usar: mais fácil do que a linguagem C ou a linguagem C++

• linguagem orientada a objeto permite escrever programas sob o paradigma de Orientação a Objeto

• computação em paralelo: permite escrever programas para serem usados na computação em paralelo.Computação em paralelo é cada vez mais necessário para a programação de alta performance

2. Primeiro Programa em FortranA linguagem de programação utilizada em nossa disciplina é o Fortran: Fortran 2003.

IMPORTANTE

No momento, o compilador gfortran, utilizado na disciplina, não é considerado um compilador Fortran2003, mas sim um compilador Fortran 95 com extensões gnu (extensões disponibilizadas pela gnu).

Isto se deve ao fato de padrão Fortran 95 estar completamente implementado no compilador gfortranenquanto existem algumas especificações do padrão Fortran 2003 ainda não implementadas.

ENTRETANTO, as características do padrão Fortran 2003 ainda não implementadas no compilador gfortran não impedem que ele seja utilizado como um compilador Fortran 2003 para a maioria dos

programas escritos em Fortran 2003 (a menos, claro, que se utilize explicitamente alguma característica aindaausente).

Porque nossa disciplina não fará uso de nenhuma das características do Fortran 2003 que ainda estãoausentes no compilador gfortran e porque a implementação delas está sendo feito e deverá estar completa num futuro próximo, optamos por fazer uso do Fortran 2003 e não do Fortran 95.

Tudo isto, significa que o gfortran se comporta como um compilador Fortran 2003, a menos que senecessite de alguma característica ainda não implementada no compilador. Como elas (para nós) são de

uso pouco frequente, o compilador – NA PRÁTICA – se comporta como um compilador Fortran 2003.

Um detalhe a mais: na realidade o gfortran é um compilador gnu. O que isto significa? Significa que eleé um compilador



DFAT/Folha Atividades/FiscompFA – Primeiros Programas: constantes e variáveis tipo caractere 3

• Fortran 95 completo com extensão gnu disponíveis (as extensões do gnu) ou• Fortran 2003 ainda não finalizado com extensões gnu ou• Fortran 2008 ainda não finalizado com extensões gnu

Ainda não implementado

Conforme dito, o compilador gfortran (que utilizamos) usualmente compila os programas usando o padrão Fortran2003 (na realidade o Fortran 2008). Ele não é chamado de Fortran 2003 porque ainda restam algumas característicasdo padrão Fortran 2003 (e também do padrão Fortran 2008) não implementadas no compilador.

Do site do gnu (http://gcc.gnu.org/wiki/Fortran2003 – em 08/02/2011) as seguintes características são citadascomo ainda não implementadas no compilador gfortran:

• Assíncronos IO implementa assíncronos real I/O, atualmente isto é síncrono• Extensão de especificadores de formato I/O especificadores i/o do tipo não default• Exceções IEEE (TR15580)• Finalização de sub-rotinas• Opção KIND= especificando MACLOC, MINLOC e SHAPE•

Alguns tipos de expressões de inicialização• Expressões não inicializadas no seletor de caso• I/O de tipo definido pelo usuário• Polimorfismo completo (incluindo polimorfismo ilimitado)

Esta folha de atividades inicia a apresentação e uso da linguagem de programação Fortran (Fortran 2003). Por este motivo ela contém conceitos básicos do Fortran e também os conhecimentos necessários à execução de um

programa Fortran, em nosso ambiente de trabalho (ambiente Linux – o uso do ambiente MS-Windows não é muitodiferente).

Todas as atividades desta folha de atividades foram especialmente projetadas para facilitar o processo deaprendizado, portanto não deixe de ler cuidadosamente o material apresentado, pratique e (principalmente) procure entendê-los. A maior parte dos conceitos serão abordados novamente em folhas subsequentes, mas nemtodos, por isto não acumule dúvidas.

Leitura prévia: é muito conveniente que se faça uma leitura prévia desta folha como um todo antes de iniciar otrabalho. Leia completamente a folha de atividade sem se preocupar em decorar ou entender todos os detalhesapresentados, durante a leitura prévia. A intenção de fazer uma leitura prévia é a de obter uma visão global doassunto, o que ajudará bastante quando for iniciar o trabalho

O parágrafo que segue, que modifiquei fazendo a troca de duas palavrasscripting → programming e scripts → programs

escrito por Mendel Cooper, representam bem a filosofia adotada em nossa folha de atividades. Não poderiaescrever, sucintamente, algo tão bom quanto ele o fez:

The exercises and heavily-commented examples invite active reader participation, under the premise that the onlyway to really learn programming is to write programs.

Paragrafo modificado do livro:Advanced Bash-Scripting Guide – An in-depth exploration of the art of shell scriptingMendel Cooper

Tradução Livre: Os exercícios e exemplos detalhadamente comentados convida à participação do leitor ativo sob apremissa de que a única forma de realmente aprender programação é escrevendo programas.

Programas exemplosNão deixe de escrever e executar todos os programas exemplos.

Esta e as outras folhas de atividades contêm vários exemplos. Você tem que escrevê-los e executá-los para vê-los funcionando. Ao fazer isto, você estará estudando e treinado o uso da linguagem de programação Fortran.

pode copiar e colar – (o famoso ctrl-c e ctrl-v) mas não deixe de lado a tarefa de estudar os conceitos e alógica utilizada nos programas das atividades




Atividades sob sua responsabilidadeAlgumas atividades estarão sob sua inteira responsabilidade, claro, elas não podem deixar de ser feitas. Elas sãoimportantes.

Esta Folha contém17 Atividades

11 atividades exemplos

02 atividades exemplos com ajustes e/ou acréscimos04 atividades para serem feitas00 atividades para serem ajustadas e/ou acrescidas

Seu professor de laboratório (e/ou teoria) poderá alterar esta relação !

Atividade 01Nossa primeira atividade consiste em escrever o código fonte de um programa Fortran, compilar e

executar o programa.

Entregar em meio magnético:

1. programa: mensagem_01 mensagem_01.f03

Exemplo:Este será nosso primeiro programa em Fortran, por isto ele é bastante simples.

Usando o editor de texto, escreva o programa.Depois usando um terminal, compile-o.A seguir execute-o.

Não deixe de ler as informações disponibilizadas pois elas servirão de apoio para a implementação de todos os passosnecessários à realização da atividade

O processo para escrever, compilar e executar um programa envolve os seguintes passos:

• Criar um diretório de trabalho • Escrever o programa fonte em Fortran

salvar o programa no diretório de trabalho• Abrir um terminal

fazer o diretório de trabalho ser o diretório onde o programa foi salvo• Compilar o programa• Executar o programa

O passo-a-passo que segue ajudará na implementação da tarefa.

1. Criando o diretório de trabalhoPara manter o trabalho organizado você tem que criar um diretório de trabalho (uma pasta) na sua conta.Pode ser na sua área de trabalho (desktop) ou então onde você julgar mais conveniente, mas não deveser no seu pendrive, pois trabalhar no HD do computador é mais rápido e seguro.O nome do diretório que está sendo criado segue a regra indicada na sequência:

turma nome folha-atividades (sem espaços entre eles)

O nome do diretório criado será similar a: 03filipe01

03filipe01Turma: 03Aluno: filipe (use somente letras minúsculas)Folha de Atividades: 01

Claro que você usará sua turma, seu nome e o número da folha de atividades que está sendo feita.




A home page da disciplina contém o link Datas-e-Atividades onde é disponibilizada umatabela com os códigos utilizados para identificar as folhas de atividades. Consulte estelink para obter o código referente à folha de atividades em uso.

Para criar o diretório de trabalho, abra o navegador de arquivo:

No painel da esquerda, clique em Área de trabalho.Isto abrirá a área de trabalho (desktop) no painel direito.Coloque o ponteiro do mouse dentro do painel direito e clique no botão direito do mouse.Escolha a opção criar Criar pasta.

Escreva o nome do diretório (por exemplo: 03anibal01).




2. Escrevendo o programa Fortran

Para escrever o programa abra o editor de texto gedit.

Após o editor gedit estar disponível para uso, escreva o código fonte do programa mensagem_01 (textomostrado a seguir ):

program mensagem_01!--------------------------------------------------------------------! Propósito: Escrever uma mensagem na tela do micro!--------------------------------------------------------------------! Arquivo:mensagem_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:

!--------------------------------------------------------------------

print* print*," ==========================" print*," Programa mensagem_01 print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentário " print* print*," o programa contém 7 linhas de comentários: " print*," elas são as linhas que iniciam com o caractere exclamação: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," também chamado de string " print*," são os textos envolvidos por aspas: "" " print* print*," (*) instrução PRINT" print* print*,"o código fonte do programa contém 23 instruções print " print*

end program mensagem_01

3. Salvando o arquivo No editor gedit: depois de escrever o texto, clique em: Salvar como …




Depois que a janela referente a Salvar como … abrir, navegue pelos diretório até entra no diretórioque criou (exemplo: 03anibal01). Escreva o nome do arquivo que será salvo na caixa chamada nome:

Nesta primeira atividade o nome do arquivo é: mensagem_01.f03 (assim mesmo como está escrito, tudoem letras minúsculas).Depois clique no botão salvar.Pronto ! Você salvou o programa da atividade 1 no diretório que criou, com o nome mensagem_01.f03

4. Abrindo o TerminalAbra o terminal para poder realizar a compilação do programa.




Depois que a janela do terminal aparece é necessário ( na maioria das vezes é necessário) mudar odiretório de trabalho para o diretório que contém o programa (neste caso o arquivo mensagem_01.f03)Os seguintes conhecimentos são relevantes:

• comando pwd no prompt do terminal execute o comando pwd no terminal, escreva pwd seguido de um espaço em branco e pressione a tecla <enter>(pwd significa print working directory) este comando mostra no terminal o diretório de trabalho

• se não estiver no diretório certose o diretório de trabalho não for o diretório que contém o arquivo mensagem_01.f03, no terminal,escreva o comando cd <diretório> para mudar o diretório de trabalho para láexemplo: supondo que o programa está no diretório 03anibal01 você deve digitar o seguinte:cd 03anibal01 ou então digitar o comando que fornece o caminho completo para se chegar até o diretório desejado:

cd "/home/anibal/Área de trabalho/03anibal01"

• listando o conteúdo do diretório de trabalho

no prompt do terminal, digite o comando ls -l (-l é menos letra ele, não menos um )escreva ls seguido de um espaço em branco seguido de -l para então pressionar a tecla <enter>isto mostrará o conteúdo do diretório de trabalho, num formato longo (se preferir use o comando ls)se estiver no diretório correto, você verá na lista que mostra o conteúdo do diretório o nome doarquivo mensagem_01.f03




5. Compilando o programa Depois de ter escrito e salvo o programa fonte, aberto o terminal e colocado o diretório de trabalho nodiretório onde o programa se encontra você pode compilar o programa.O processo de compilação cria um programa em linguagem de máquina que o computador podeexecutar (rodar ). Para isto, no prompt do terminal digite o comando:

gfortran -o mensagem_01 mensagem_01.f03 e pressione a tecla <enter>Atenção: escreva o comando exatamente como mostrado:

gfortran -o mensagem_01 mensagem_01.f03

Se tudo correu bem, o terminal simplesmente retorna ao aviso de comando ( prompt) sem emitir nenhuma mensagem.Caso exista(m) erro(s) nos códigos fontes do módulo, uma mensagem será emitida. Se isto ocorreu, vá

para o editor de texto e corrija o(s) erro(s), salve o arquivo e repita o processo de compilação.Depois da compilação do programa contido no arquivo mensagem_01.f03 você terá o programaexecutável (arquivo mensagem_01) que estará no diretório de trabalho. Verifique isto executando ocomando

ls -lno terminal ou então usando o navegador de arquivo.

6. Execução do programaA execução do programa mensagem_01 é feita assim: ./mensagem_01

isto é, no prompt do terminal, digite um ponto seguido de uma barra seguido do nome do arquivo edepois pressione a tecla <enter>.Observe: o nome do programa é mensagem_01 e do arquivo que contem o programa executável é mensagem_01 enquanto o nome do arquivo que contém o programa fonte é mensagem_01.f03

A execução do programa irá mostrar na tela do micro a seguinte saída:

Saída no terminal do computadoranibal@anibaldsk:/home/anibal/03anibal01/$ ./mensagem_01

==========================Programa mensagem_01

==========================

O programa escreve, na tela do micro, o conjunto de mensagens abaixo:

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

(*) Linha de comentário

o programa contém 7 linhas de comentários:

elas são as linhas que iniciam com o caractere exclamação: !

(*) Constante Literal do tipo caractere

também chamado de stringsão os textos envolvidos por aspas: "

(*) instrução PRINT

o código fonte do programa contém 23 instruções print

anibal@anibaldsk:/home/anibal/03anibal01/$




3. O processo de compilaçãoO texto a seguir fornece informações ligada ao processo de compilação.

Em nosso laboratório o comando gfortran roda o compilador gfortran.

O compilador gfortran desenvolvido pela Fundação Software Livre (FSF = Free Software Foundation),usualmente conhecida como Projeto Gnu, é um compilador Fortran (Fortran 95 completo e Fortran 2003 comalgumas características do padrão Fortran 2003 ainda em implementação – em 10-03-2011) que pode ser instaladoe utilizado tanto no Linux quanto no MS-Windows.

O compilador gfortran pode ser obtido no endereço: http://gcc.gnu.org/wiki/GFortran

Depois de ter escrito e salvo o programa num arquivo, a criação do programa executável se faz pelo processo decompilação.

Programa executável é o programa que o computador utiliza para rodar (executar ) as tarefas especificadas nocódigo fonte do programa (também se usa a expressão inglesa run).

Atualmente a maioria dos compiladores adota a estratégia de utilizar somente um comando para realizar acompilação e o carregamento (link-edição) do programa fonte. As duas tarefas ( que são diferentes) são realizadassequencialmente, dando a impressão de serem uma só.

Na realidade a compilação é a execução somente da etapa um do processo mostra na figura que segue.

Etapas na compilação

Se na etapa um (compilação) não for encontrado erro, o compilador passa imediatamente para a etapa dois(carregamento ou link-edição) e gera o programa executável.

Caso exista um erro no código fonte (ou mais de um erro) o processo não passa ao carregamento (link-

edição) euma ou mais mensagens de erros são escritas na tela do microcomputador indicando ( ou tentando indicar ) o tipo deerro e onde ele ocorreu.

Algumas vezes a referência do erro (ou erros) que o compilador faz não ajuda muito, porque ela indica que háum erro numa declaração que não está errada. O que realmente aconteceu é que o compilador não conseguiuidentificar precisamente a causa do erro (a sua origem) e portanto não pode ajudar. Neste caso, você deve procurar oerro nas instruções anteriores da instrução indicada pela mensagem de erro do compilador, desconsiderar o tipo doerro indicado porque a indicação do erro não está correta. Um erro existe, mas a sua indicação, pelo compilador,não feita de forma correta. Apesar disto e erro tem que ser identificado e eliminado. Este processo, as vezes, édifícil mesmo.

A melhor solução para lidar com indicações de erros não muito clara (ou enganosa

) é adotar o conceito de programação estruturada. Dividir e subdividir o programa que se está escrevendo em unidades menores que permitirão mais facilmente identificar o erro.




O que fazer quando o compilador encontra erro(s)

Se existe um erro no programa (ou mais de um), o compilador indica isto. Leia a mensagem emitida pelocompilador. Ela identifica a origem (unidade de programa), o tipo de erro, linha e coluna em que o erro aconteceu.

Dê atenção especial ao primeiro erro encontrado pelo compilador. Retorne ao programa fonte e localize o primeiro erro para sua correção. Não se preocupe com os erros subsequentes (segundo em diante). Elimine o primeiro erro.

Após ter feito a correção do primeiro erro salve o programa fonte e execute novamente a compilação

Caso ainda existam erros, a compilação será novamente interrompida e nova(s) mensagen(s) de erro(s) será(ão)mostrada(s). O que fazer? Retorne ao programa fonte para a correção do primeiro erro ( novo primeiro erro). Salve o

programa fonte corrigido e depois compile novamente o programa.

Repita estes procedimentos tantas vezes quanto necessários, até que o programa compile sem erros criando o programa executável.

A compilação do programa

O compilador Fortran utilizado em nosso laboratório trabalha no modo texto, isto é, não tem interfacegráfica, por isto ele necessita ser executado num terminal.

Editor gedit e um terminalSe trabalhou com o editor gedit, abra um terminal e no prompt do terminal entre com o comando:

gfortran -o mensagem_01 mensagem_01.f03

Reforçando o entendimento do processo de compilação

No comando gfortran -o mensagem_01 mensagem_01.f03

o "gfortran" refere-se ao compilador Fortran

depois do gfortran foi escrita a chave "-o".

A opção "-o mensagem_01" é usado para que o programa executável receba o nome mensagem_01. Se estaopção não for usada o programa criará um executável de nome a.out (no Linux) ou então a.exe (no MS-Windows).

O sinal menos ( - ) indica uma opção; a letra "o" indica que é a saída (output) e o nome que segue a letra "o"especifica o nome que será dado ao programa executável que está sendo criado. Em nosso caso será criado um




programa executável com o nome mensagem_01.

O " mensagem_01.f03" especifica o nome do arquivo que contém os códigos fonte (programa) em Fortran queserá lido pelo compilador.

Observe a diferença:

nome do arquivo que contém os códigos fontes ( o programa escrito ) em Fortran que será lido pelo compilador .O nome do arquivo que contém o programa escrito em Fortran, não o nome do programa

Se o programa fonte não contiver erro(s) o comando gfortran -o mensagem_01 mensagem_01.f03 criará o programa executável mensagem_01 no diretório atual.

Executando o programa

No prompt do terminal digite o nome do arquivo e pressionar a tecla <enter>

./mensagem_01 <enter>

No Linux, o ponto barra ("./" ) é utilizado para indicar o diretório atual. Então ./mensagem_01 significa:

“ execute o programa executável mensagem_01 que está no diretório em que me encontro nomomento ”

3.1. Para treinar

Para ver na prática como o compilador se comporta quanto existem erros, deliberadamente, introduza um erroconhecido no programa e veja o que ocorre no processo de compilação.

Usando o programa mensagem_01:

Remova a letra "p" de uma instrução print.

Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa.

Remova o asterisco ( *) do instrução print em vez de remover a letra " p ".


Remova uma das aspas (").Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa.

Troque o nome do programa somente na instrução end program.


Além destas trocas, escolha outro tipo de alteração e veja o comportamento do compilador.




4. Programa FortranUm programa (programa em Fortran) pode ser construído utilizando-se quatro tipos de unidades de programa

(program-units). As unidades de programa existentes no Fortran são:

• unidade programa principal (main-program unit)

• unidade programa módulo (module unit)

• unidade subprograma externo (external-subprogram unit)

• unidade programa dados em bloco (block-data program unit)

Um programa Fortran consiste de um programa principal e qualquer número ( inclusive zero) dos outros tipo deunidades de programa. É possível utilizar qualquer combinação, desde que exista somente um programa principal.

A figura ao lado, mostra o caso geral

entretanto, a melhor forma de se pensar um programaFortran é que ele é composto por um programa principale tantos módulos quanto se queira ou necessite ( inclusivenenhum módulo).

A figura que segue evidencia as melhores formas de se pensar um programa em Fortran.

Programa Principal(caso mais simples)

Programa Principal e um Módulo(caso comum)

Programa Principal e vários Módulos(muito útil)

Melhores formas de se pensar um programa Fortran

Unidade de programa dados em blocoA unidade de programa dados em bloco (block data program unit) pode ser utilizada para prover valores

iniciais para objetos de dados em blocos comuns nomeados (named common blocks). Esta unidade de programa foimuito utilizada nos padrões anteriores (até o padrão FORTRAN 77). O padrão atual dispõe de formas mais adequada

para realizar esta tarefa, portanto,não utilize unidade de programa dados em bloco

. Este tipo de unidade de programa está no padrão para manter compatibilidade com as versões anteriores.




Subprograma externoAs principais características de um subprograma externo, no Fortran 2003, são:

• subprograma externo escrito em Fortranaté o padrão FORTRAN 77, subprograma externo era a única forma que o programador podia utilizar

para escrever uma função e uma sub-rotina (coletivamente identificadas pelo termo procedimento). A partir

do Fortran 90, o padrão criou maneiras mais eficiente para se dispor de procedimentos. Atualmente,um subprograma externo escrito em Fortran é completamente desnecessário. Esta forma de criar procedimentos externos ainda existe no Fortran para manter compatibilidade com as versõesanteriores, portanto não utilize subprogramas externos escritos em Fortran

• subprograma externo escrito em outra língua de programaçãosubprograma função externa e subprograma sub-rotina externa podem ser utilizadas para acessar códigos de programação escrito em outra língua de programação (por exemplo, na linguagem deprogramação C). Isto permite que outra língua de programação possa ser utilizada junto com um

programa Fortran. Esta é a forma recomendada de uso para os subprogramas externos no Fortran.Entretanto, é pouco provável que um usuário comum (em nosso caso, nós) necessite fazer uso desterecurso, porém ele está disponível.

5. Programa Principal Nossa primeiro atividade realizou uma tarefa bastante simples, por causa disto o programa Fortran escrito

utilizou apenas uma unidade de programa: o programa principal.

O programa Fortran mensagem_01 (arquivo: mensagem_01.f03) é um programa principal Fortran, ou comousualmente chamamos, um programa.

Veja a diferença:• programa

programa é “aquilo” que irá fazer a tarefa global desejada. Por estar escrito na linguagem de

programação Fortran, o mais adequado seria chamá-lo de programa Fortran, mas acaba-se chamandoapenas de programa

• programa mensagem_01 o programa principal recebeu o nome “mensagem_01”, por isto ele é o programa mensagem_01

• programa executável mensagem_01a compilação do programa com a chave “ -o “ possibilita escolher um nome para o arquivo que conteráo programa executável que será criado. Nós usamos “-o mensagem_01” portanto o arquivo chama-semensagem_01 Observe que o programa executável mensagem_01 está guardado no arquivo mensagem_01

•

arquivo mensagem_01.f03o arquivo que contém o código fonte do programa mensagem_01 chama-se mensagem_01.f03enquanto o arquivo que contém os códigos em linguagem de máquina (programa executável) chama-semensagem_01

Observe que temos :• programa• programa mensagem_01• programa mensagem_01 (ou programa executável mensagem_01 ou programa executável

ou programa executável mensagem_01)• arquivo mensagem_01• arquivo mensagem_01.f03

Não há obrigatoriedade do nome do programa ser igual ao nome do arquivo que contém os códigos fontes doprograma.




Recordando: o programa Fortran mensagem_01, foi criado utilizando-se apenas uma unidade de programa: o programa principal. O código fonte do programa mensagem_01 é reapresentado a seguir:

program mensagem_01!--------------------------------------------------------------------! Propósito: Escrever uma mensagem na tela do micro!--------------------------------------------------------------------

! Arquivo:mensagem_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------

print* print*," ==========================" print*," Programa mensagem_01 " print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentário "

print* print*," o programa contém 7 linhas de comentários: " print*," elas são as linhas que iniciam com o caractere exclamação: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," também chamado de string " print*," são os textos envolvidos por aspas: "" " print* print*," (*) instrução PRINT" print* print*,"o código fonte do programa contém 23 instruções print " print*


As seguintes características devem ser observadas:

• instrução PROGRAM e instrução END PROGRAM No Fortran, um programa principal é identificado por estas instruções.O programa principal utiliza a instrução program como primeira instrução (abertura) e a instrução end program como última instrução (fechamento).Os códigos do programa (programa principal) são escritos entre estas duas instruções.

program mensagem_01. . . . . .. . . . . .

. . . . . .end program mensagem_01

escreve-se o nome do programa tanto na instrução de abertura program quanto na instrução defechamento end program .

• comentáriodepois da instrução de abertura ( program mensagem_01 ) as próximas 7 linhas são comentários.Comentários são identificadas pelo caractere exclamação ( ! ) .

program mensagem_01!--------------------------------------------------------------------! Propósito: Escreve mensagens na tela do micro

!--------------------------------------------------------------------! Arquivo:mensagem_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------




comentários são inseridos no programa para fornecer informação para quem está lendo os códigosfontes (um humano). O cabeçalho serve para explicar o propósito do programa e disponibilizar outrasinformações. O cabeçalho (e os comentários dentro do programa) deve ser visto como parte integrante do

programa. É essencial que se tenha o hábito de escrever comentários nos códigos fontes dos programas.

• instrução PRINTa instrução

print*mostra (escreve, imprime) na tela do micro uma mensagem.

Tudo aquilo que estiver escrito entre aspas na instrução print será escrito (impresso) na tela docomputador

program mensagem_01!--------------------------------------------------------------------! Propósito: Escreve mensagens na tela do micro!--------------------------------------------------------------------! Arquivo:mensagem_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------

print*

print*," ==========================" print*," Programa mensagem_01 print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentário " print* print*," o programa contém 7 linhas de comentários: " print*," elas são as linhas que iniciam com o caractere exclamação: ! " print* print*," (*) Constante Literal do tipo caractere " print*

print*," também chamado de string " print*," são os textos envolvidos por aspas: "" " print* print*," (*) instrução PRINT" print* print*,"o código fonte do programa contém 23 instruções print " print* Nestas instruções os textos (sem as aspas) serão escritas na tela do computador (uma depois da outra)quando as instruções print forem executadas.

A instrução print possibilita escrever informações na tela do computador para o usuário do programa.Esta característica é muito importante e será utilizada na construção da documentação em tempo deexecução

Observe que o texto que será escrito pela instrução PRINT deve aparacer entre aspas ( " ) ou entreapóstrofo ( ' ). Não importa qual, o importante é que o símbolo utilizado na abertura tem que ser omesmo utilizado no fechamento. Por exemplo, as duas instruções que seguem são similares

print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: "

print*,'O programa escreve, na tela do micro, o conjunto de mensagens abaixo: '

Além disto, observe também, o uso de duas aspas seguidas ( "" ) para que apenas uma aspas apareça namensagem escrita na tela do micro.

print*," são os textos envolvidos por aspas: "" "

Caso se utilize apenas uma aspas, o compilador irá interpretar que a aspas está terminando a mensagem(o que não está) e indicará uma mensagem de erro. Ao utilizar duas aspas juntas, o compilador interpretaque elas na realidade são uma aspas única e escreve a aspas na tela do micro, o que realmente édesejado.




Uma forma de se evitar o uso de duas as apas seguidas seria utilizar o apóstrofo como mostrado nainstrução que segue:

print*,' são os textos envolvidos por aspas: "" '

isto funciona, porque a constante literal caractere está marcada (delimitada) pelo apóstrofo e portanto asaspas não irá sinalizar para o compilador o término (fechamento) da constante literal caractere.

• instruções PRINT sem constante literal caractere as instruções print* que não contém nenhum texto entre aspas (ou entre apóstrofos) imprime uma linhaem branco na tela do computador.

• instrução END PROGRAMa instrução end program marca o termino do programa principal.a instrução end program mensagem_01 marca o termino do programa principal mensagem_01

program mensagem_01!--------------------------------------------------------------------! Propósito: Escreve mensagens na tela do micro

!--------------------------------------------------------------------! Arquivo:mensagem_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------

print* print*," ==========================" print*," Programa mensagem_01 print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print*

print*," (*) Linha de comentário " print* print*," o programa contém 7 linhas de comentários: " print*," elas são as linhas que iniciam com o caractere exclamação: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," também chamado de string " print*," são os textos envolvidos por aspas: "" " print* print*," (*) instrução PRINT" print* print*,"o código fonte do programa contém 23 instruções print " print*


6. Conjunto de Caracteres do Fortran 2003O conjunto de caracteres que o Fortran 2003 utiliza é dependente do processador, mas a estrutura do conjunto

tem que ser a seguinte:

1. caracteres de controle2. caracteres gráficos

• letras• dígitos• sublinha• caracteres especiais• outros caracteres




As letras, dígitos, sublinha e os caracteres especiais formam o conjunto de caracteres do Fortran (Fortrancharacter set).

LETRASas 52 letras são: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

a b c d e f g h i j k l m n o p q r s t u v w x y z

as letras minúsculas são equivalentes as letras maiúsculas, exceto no contexto caractere.

Stringa palavra string significa: corda, fio, cordão, conjunto de objetos, correnteentretanto é muito utilizada como: cadeia de caracteres - sequência de caracteres

Contexto caracterecontexto caractere são os caracteres que estão sendo empregados (usados) dentro de

• constante literal caractere ou• dentro de um string que define um descritor de edição

DIGITOSos 10 dígitos são: 0 1 2 3 4 5 6 7 8 9

SUBLINHAunderscore, em inglês ( _ )

o caractere sublinha é utilizado como caractere significativo em um nome

CARACTERES ESPECIAISos 32 caracteres especiais (no Fortran 2003) são:

Caractere Nome do caractere Caractere Nome do caractere

branco ; ponto e vírgula= igual ! ponto de exclamação

+ mais " aspas

- menos % porcento

* asterisco & e-comercial (ampersand)

/ barra ~ til

\ Barra invertida < menor que

( abre parênteses > Maior que

) fecha parênteses ? ponto de interrogação[ abre colchetes ' apóstrofo

] fecha colchetes ` acento grave

{ abre chaves ^ acento circunflexo

} fecha chaves | barra vertical

, vírgula $ símbolo de moeda

. ponto decimal ou ponto final # símbolo númerico

: dois pontos @ at comercial




OUTROS CARACTEREScaracteres adicionais que o processador pode representar, só podem aparecer em:

• comentários• constantes caractere• registros de entrada/saída• string usado nos descritores de edição

Na prática, pode-se considerar que os caracteres e símbolos que o Fortran 2003 utiliza são os contidos na tabelaASCII.

TABELA ASCII baseada na tabela existente em:

http://www.hobbyprojects.com/ascii-table/ascii-table.html (em 27/07/2010)

7. Nomes Nomes são utilizados por várias entidades tais como variáveis, unidades de programa, argumento mudos,

constantes com nome e tipos derivados.

No Fortran 2003, um nome só pode conter letras, números e o caractere sublinha. Além disto, ( obrigatoriamente)deve iniciar com uma letra e ter no máximo 63 caracteres.




Exemplos: velocidademassa15massa_do_corponome_muito_longo_que_nao_esta_errado (tem 37 caracteres)

Atividade 02Entregar em meio magnético:

1. programa: ano_bissexto_01 ano_bissexto_01.f03

Exemplo:Nesta atividade, o programa escrito irá escrever na tela do micro a seguinte mensagem.

--------------------------------------------------------------------------------- A regra para saber se um ano é ou não bissexto é:

(*) Todo ano divisível por 4 é um ano bissexto

(*) exceção : quando o ano também for divisível por 100 não é um ano bissextoentretanto: todo ano divisível por 400 é sempre um ano bissexto

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

Os seguintes anos são bissextos : 1600 2000 2400

Os seguintes anos não são bissextos: 1700 1800 1900

Escreva o programa ano_bissexto_01, salvando-o no arquivo ano_bissexto_01.f03.Compile e execute o programa.

Não esqueça, o processo para escrever, compilar e executar o programa envolve os seguintes passos:

• Escrever o programa fonte • Compilar o programa• Executar o programa

Você pode copiar e colar os códigos fontes para que não tenha que escrever os códigos disponibilizados,mas isto não evita o trabalho de ajuste da diagramação dos códigos fontes segundo o estilode programação adotado na disciplina

Momentaneamente, você deve fazer com que os códigos que está escrevendo (copiando) fiquem visualmente

parecidos com os códigos fontes disponibilizados. Para você se sentir um pouco mais confortável, considere que, noestilo de programação que adotamos, todo programa tem:

• nome• cabeçalho

Não deixe de atualizar o cabeçalho do programa de forma adequada, ou seja, não deixe deacrescentar seu nome como revisor e a data em que isto aconteceu.

________________________________________________________________________________________ ► arquivo: ano_bissexto_01.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program ano_bissexto_01!!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro identificação de anos Bissextos!------------------------------------------------------------------------------! Arquivo: ano_bissexto_01.f03




! Autor: Anibal L. Pereira 27/11/2010!Revisões:!------------------------------------------------------------------------------

print* print*,"---------------------------------------------------------------------------------" print*,"A regra para saber se um ano é ou não bissexto é:" print*,

print*," (*) Todo ano divisível por 4 é um ano bissexto " print*," (*) exceção : quando o ano também for divisível por 100 não é um ano bissexto" print*," entretanto, todo ano divisível por 400 é sempre um ano bissexto" print*,"---------------------------------------------------------------------------------" print* print*,'Os seguintes anos são bissextos : 1600 2000 2400 ' print* print*,'Os seguintes anos não são bissextos: 1700 1800 1900 ' print*

end program ano_bissexto_01

As características importantes a serem destacadas são:

• caractere sublinhao nome do programa é ano_bissexto_01

espaço em branco não pode aparecer dentro de nomes, por isto o uso do caractere sublinha ( underline)unindo o nome ano com os nomes bissexto e 01 espaço em branco é utilizado como separador, portanto se for escrito ano bissexto 01 no lugar deano_bissexto_01 o compilador vai entender que o nome do programa é apenas ano e vai interpretar

bissexto como sendo o início de uma nova instrução, o que gera uma condição de erro

Recorde que um nome, no Fortran 2003, pode conter até 63 caracteres. Portanto você pode usar nomescompostos unidos com o caractere sublinha sem problema, desde que use, no máximo, 63 caracteres

• PRINTa instrução print* escreve uma linha em branco na tela do computador

A instrução

print*,"-------------------------------------------------------------------------"

escreve uma linha de traços (que está colocada entre as aspas) na tela do computador.

Tudo o que estiver colocado entre aspas é considerado uma constante literal caractere ou constantecaractere (é usual utilizar-se o termo string) e o compilador trata a constante caractere como um string e

imprime o string exatamente como ele foi escrito pelo programador

as aspas nas constantes literais caracteres (strings) não fazem parte da constante, estão ali apenas paramarcar o início e o fim da constante (da mesma forma os apóstrofos se eles forem usados no lugar das aspas)

• comentáriouma linha completamente em branco é considerada uma linha de comentário

Tudo o que for escrito depois de uma caractere de exclamação ( ! ) é considerado um comentário, portanto as linhas que seguem são comentários

!!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro identificação de anos Bissextos!------------------------------------------------------------------------------! Arquivo: ano_bissexto_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!------------------------------------------------------------------------------





1. programa: quadro_01 quadro_01.f03

Exemplo:Esta atividade utiliza constantes literais caractere (strings) para criar um quadro e escreve uma mensagem na tela do micro.

Observe que a arrumação, a distribuição da mensagem na tela do micro e a decoração do quadro, é feita dentro do string,isto é, toda a distribuição das letras e símbolos utilizados são arrumados com espaços em branco dentro do string, que temque ser diagramado pelo programador (quem escreve os códigos fontes).

O compilador não modifica o string. Ele simplesmente escreve o string na tela do micro, sem nenhum tipo de interferência oumodificação na disposição que o programador utilizou no string

Portanto, qualquer arrumação (disposição dos símbolos) deve ser feita pelo programador dentro do string que está utilizando

Escreva o programa quadro_01, salvando-o no arquivo quadro_01.f03.

Compile e execute o programa.


________________________________________________________________________________________ ► arquivo: quadro_01.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program quadro_01!!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro um quadro com mensagem !------------------------------------------------------------------------------

! Arquivo: quadro_01.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!------------------------------------------------------------------------------

print* print*,"(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)" print*,"(*) (* print*,"(*) Primeiro quadro (*)" print*,"(*) (* print*,"(*) Observe a decoração da moldura do quadro (*)" print*,"(*) (* print*,"(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)" print*

end program quadro_01

As características importante:

• a aparência (arrumação) é feita pelo programador, escrevendo o string (dentro do string)• o compilador não modifica ou altera o string especificado pelo programador • espaço em branco é usado para dispor de forma conveniente os símbolos utilizados nos strings






Exemplo:Decoração de mensagem na tela do micro

________________________________________________________________________________________ ► arquivo: quadro_02.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program quadro_02!!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro um quadro com mensagem !------------------------------------------------------------------------------! Arquivo: quadro_02.f03! Autor: Anibal L. Pereira 27/11/2010

!Revisões:!------------------------------------------------------------------------------

print* print*,"(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)" print*,"(:) (: print*,"(:) Segundo quadro (:)" print*,"(:) (: print*,"(:) Observe a decoração da moldura do quadro (:)" print*,"(:) (: print*,"(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)" print*





________________________________________________________________________________________ ► arquivo: quadro_03.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program quadro_03!!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro um quadro com mensagem !------------------------------------------------------------------------------! Arquivo: quadro_03.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!------------------------------------------------------------------------------

print* print*,"x*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*x" print*,"x*x x* print*,"x*x Terceiro quadro x*x" print*,"x*x x* print*,"x*x Observe a decoração da moldura do quadro x*x" print*,"x*x x* print*,"x*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*x"




print*


Atividade 06

Entregar em meio magnético:1. programa: quadro_04 quadro_04.f03


________________________________________________________________________________________ ► arquivo: quadro_04.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program quadro_04!

!------------------------------------------------------------------------------! Propósito: Escreve na tela do micro um quadro com mensagem !------------------------------------------------------------------------------! Arquivo: quadro_04.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!------------------------------------------------------------------------------

print* print*,"\>\>\>\>\>\>\>\>\>\>>::</</</</</</</</</</</" print*,">>>>>>>>> <<<<<<<<<" print*,">->->->->->->> Q U A D R O <<-<-<-<-<-<-<" print*,">>>>>>>>> <<<<<<<<<" print*,"+>+>+>+>+>+>+>+>+>+>>::<+<+<+<+<+<+<+<+<+<+<+"

print*end program quadro_04


1. programa: frase_Willian frase_Willian.f03

Exemplo:Escreve frase (pensamento - citação) de Willian Shakespeare

________________________________________________________________________________________ ► arquivo: frase_willian.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program frase_Willian!!----------------------------------------------------------------------------------! Propósito: Escreve na tela do micro uma frase de autoria de William Shakespeare!----------------------------------------------------------------------------------! Arquivo: frase_willian.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!----------------------------------------------------------------------------------

print* print*," Enquanto houver um louco, " print*," um poeta e um amante " print*," haverá sonho, amor e fantasia. " print* print*," E enquanto houver sonho, amor e fantasia, "




print*," haverá esperança. " print*," -- William Shakespeare -- " print*

end program frase_Willian

Utilizar strings (constantes literal caractere) para escrever mensagem na tela do micro é útil, mas usualmentenecessitamos mais do que isto. Portanto o passo seguinte é aprender a utilizar variáveis.

• Constanteentidade (objeto de dado) – é um valor que não pode ser alterado durante a execução do programa

• Variávelobjeto de dado (entidade) – valor que pode ser alterado durante a execução do programa


1. programa: meu_nome primeiro.f03

Exemplo:Programa que define e utiliza uma variável do tipo caractere e utiliza constantes literais do tipo caractere (strings).

O programa também utiliza as instruções: IMPLICIT NONE, PRINT e READ

________________________________________________________________________________________ ► arquivo: meu_nome.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit nonecharacter(len=20):: nome! print* print*,"Escreva seu nome: (máximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apóstrofo (')"read*, nome

print* print*, nome print*!end program meu_nome

1. Compilando o programa Para isto, no prompt do terminal digite o comando:

gfortran -o primeiro primeiro.f03 e pressione a tecla <enter>

Depois da compilação do programa contido no arquivo primeiro.f03 você terá o programa executável(arquivo primeiro) que estará no diretório de trabalho.

2. Execução do programaA execução do programa meu_nome é feita assim: ./primeiro




Observe: o nome do programa é meu_nome e do arquivo que contem o programa executável é primeiroenquanto o nome do arquivo que contém o programa fonte é primeiro.f03

A execução do programa irá mostrar na tela do micro o nome que o usuário fornecer. Admitindo que o nomefornecido pelo usuário tenha sido Paulo César (nome composto, contendo espaço em branco tem que serfornecido pelo usuário entre aspas ou apóstrofos) a saída no terminal será similar a mostrada dentro do

quadro que segue.

Saída no terminal do computador

anibal@anibaldsk:/home/anibal/01anibal03$ ./primeiro

Escreva seu nome: (máximo de 20 caracteres) Nomes compostos escreva entre aspas (") ou apóstrofo (')'Paulo César'

Paulo César

anibal@anibaldsk:/home/anibal/01anibal03$

• instrução IMPLICIT NONE a instrução implicit none é utilizada para anular a definição implícita de tipo. É um bom hábito de

programação utilizar esta declaração nos programas Fortran, pois seu uso permite que o compilador detecte erros que de outra forma seriam muito trabalhoso e/ou difíceis de serem achados.Um detalhe importante é que a instrução implicit none tem que ser escrita antes das instruções dedefinição de tipo no programa.

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit none

porque o compilador não considera os comentários existentes no programa, ele enxerga os códigosmostrados acima como sendo composto somente por duas linhas, ou seja:

program meu_nomeimplicit none

o que mostra que IMPLICIT NONE está colocada imediatamente depois da instrução program meu_nome

• declaração de tipo caracterea instrução

character(len=20):: nome

é uma instrução de declaração de tipo (tipo caractere)

program meu_nome

!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------




implicit nonecharacter(len=20):: nome

O programa meu_nome define e utiliza uma única variável do tipo caractere.

Tipo de dados (ou simplesmente tipo) é uma maneira que a linguagem de programação tem de saber quevalores podem ser guardados na entidade e quais operações podem ser realizadas com estes valores.

Por exemplo, um dado do tipo caractere não tem a operação adição disponível. Então, se o valor davariável tipo caractere nome for Anibal, o Fortran sabe que a operação adicionar o número 5 à variávelcaractere nome ( ou seja, a operação de adição: Anibal + 5 ) não é permitida, porque variáveis do tipocaractere não possuem a operação de adição disponível

A instrução de definição de variável de tipo caractere estabelece que a variável nome pode conter 20 posições, ou seja, nome pode conter no máximo 20 caracteres

Definição de tipo é feita assim: tipo,atributos::lista-variáveis

onde:tipo pode ser : character, integer, real, complex ou logical

atributos define um ou mais de um atributos do tipo que está sendo definido.Para o tipo caractere o atributo comprimento (comprimento em inglês: lenght → len) é sempre utilizadoe especifica o número de caracteres para a variável que está sendo definida.

lista-variáveis é uma lista de variáveis separadas por vírgula. Neste exemplo, nossa lista possuísomente uma variável

character(len=20):: nome

• instrução PRINTa instrução print* mostra (escreve, imprime) na tela do micro uma mensagem.Tudo aquilo que estiver escrito entre aspas na instrução print será escrito (impresso) na tela docomputador

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit nonecharacter(len=20):: nome! print* print*,"Escreva seu nome: (máximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apóstrofo (')"

Nestas instruções o texto "Escreva seu nome: (máximo de 20 caracteres)" (sem as aspas) e"Nomes compostos escreva entre aspas("") ou apóstrofo (')" serão escritas na tela docomputador (uma depois da outra) quando as duas instruções print forem executadas.

A instrução print possibilita escrever informações na tela do computador para o usuário do programa.Isto é muito importante. Esta característica é chamada de documentação em tempo de execução

Observe que o texto que será escrito pela instrução PRINT deve aparacer entre aspas ( " ) ou entreapóstrofo ( ' ). Não importa qual, o importante é que o símbolo utilizado na abertura tem que ser omesmo utilizado no fechamento.




Além disto, observe também, o uso de duas aspas seguidas ( "" ) para que apenas uma aspasapareça na mensagem escrita na tela do micro . Caso se utilize apenas uma aspas, o compilador iráinterpretar que a aspas está terminando a mensagem ( o que não está) e indicará uma mensagem de erro.Ao utilizar duas aspas juntas, o compilador interpreta que elas na realidade são uma aspas única eescreve a aspas na tela do micro, o que realmente é desejado.

• instrução READé uma instrução de entrada de dados.A instrução read* lê (recebe) dados fornecidos ao programa pelo teclado.

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit nonecharacter(len=20):: nome

! print* print*,"Escreva seu nome: (máximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apóstrofo (')"read*, nome

O que for digitada usando o teclado será atribuído à variável nome (guardado na variável depois de sepressionar a tecla <enter> )

porque o espaço em branco é utilizado para separar valores do tipo caractere (string) valorescompostos (por exemplo: Antônio Carlos, Maria José) que possuem espaço em branco devem ser envolvidos (protegidos) por aspas ( " ) ou apóstrofo ( ' ). Ao escrever os valor dentro de aspas ouapóstrofo ele será considerado como sendo uma entidade única, o que realmente é desejado.Por exemplo se o valor entrado for Maria José (sem as aspas) o valor que a variável nome conterá

será Maria, não Maria José (execute o programa, entre com um nome composto sem as aspas e veja ocomportamento do programa)

• instruções PRINTa instrução print* que não contém nenhum texto entre aspas imprime uma linha em branco na tela docomputador.

por sua vez, a instrução print*, nome imprime na tela do computador o valor que está guardadona variável caractere nome

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit nonecharacter(len=20):: nome! print* print*,"Escreva seu nome: (máximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apóstrofo (')"read*, nome print* print*, nome

print*!




• instrução END PROGRAMa instrução end program marca o termino do programa principal.a instrução end program meu_nome marca o termino do programa principal meu_nome

program meu_nome!--------------------------------------------------------------------! Propósito: escreve um nome fornecido pelo usuário na tela do micro

!--------------------------------------------------------------------! Arquivo:primeiro.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!--------------------------------------------------------------------implicit nonecharacter(len=20):: nome!

• print* print*,"Escreva seu nome: (máximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apóstrofo (')"read*, nome print* print*, nome print*!end program meu_nome


1. programa: ano_bissexto ano_bissexto.f03

Exemplo:

Esta atividade define e utiliza uma variável do tipo caractere e uma variável do tipo inteira

Os seguintes anos podem ser utilizados como dado de entrada para o programa:1600 2000 2400 (são anos bissextos)1700 1800 1900 (não são bissextos)

A regra para saber se um ano é bissexto ou não é:Todo ano divisível por 4 é um ano bissexto

• exceção: quando o ano também for divisível por 100 não é um ano bissexto• entretanto, todo ano divisível por 400 é sempre um ano bissexto

Escreva o programa ano_bissexto, salvando-o no arquivo ano_bissexto.f03.Compile e execute o programa.


________________________________________________________________________________________ ► arquivo: ano_bissexto.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program ano_bissexto!!------------------------------------------------------------------------------! Propósito: Solicita que o usuário entre com dois valores inteiros (números)! e depois escreve na tela do micro duas mensagem !------------------------------------------------------------------------------! Arquivo: ano_bissexto.f03! Autor: Anibal L. Pereira 05/10/2010!Revisões: Anibal L. Pereira 27/11/2010!!------------------------------------------------------------------------------implicit noneinteger:: ano_bi, ano_usual




print* print*,"Entre com ano bissexto "read*, ano_bi

print* print*,"Agora entre com ano não bissexto "read*, ano_usual

print* print*, "o ano ", ano_bi, " é bissexto" print*, "o ano ", ano_usual, " não é ano bissexto" print*

end program ano_bissexto

As características importantes a serem destacadas são:

• caractere sublinhao nome do programa é ano_bissexto

espaço em branco não pode aparecer dentro de nomes, por isto o uso do caractere sublinha (underline)

• variáveis inteirasduas variáveis do tipo inteiro foram definidas: ano_bi e ano_usual

observe que os nomes das variáveis estão colocados numa listainteger:: lista-de-variáveis

a lista está separada da instrução de especificação por dois dois pontos ( :: )a separação das variáveis na lista é feita por vírgula: integer:: ano_bi, ano_usual

• PRINT

a instrução print* escreve uma linha em branco na tela do computador A instrução print*,"Entre com ano bissexto " escreve o texto entre aspas na tela do computador

• comentáriouma linha completamente em branco é uma linha de comentário

• READa instrução read (ler ) quando escrita com um asterisco ( * ) read* faz a leitura do valor que foiescrito pelo usuário usando o teclado do computador

a instrução read*, ano_bi

lê o que o usuário entra pelo teclado e escrever o valor fornecido na variável inteira ano_bi a instrução read*, ano_usual por sua vez, coloca o valor lido na variável inteira ano_usual

• lista utilizada no PRINTa instrução print*, "o ano ", ano_bi, " é bissexto" pode ser entendida assim:

print*, lista-de-saídaonde lista-de-saída é uma lista composta (neste caso) de 3 entidades separadas por vírgula, ou seja:string → "o ano "variável inteira → ano_bistring → " é bissexto"

todas separadas por vírgulas. Numa lista (usualmente) as entidades estão separadas por vírgula

as aspas nas constantes literais caracteres (strings) não fazem parte da constante, estão ali apenas paramarcar o início e o fim da constante




8. ProgramandoAs informações colocadas aqui são bastante resumidas, mas importantes, portanto leia com atenção.

Aprender a programar envolve duas tarefas distintas e simultâneas que podem ser colocadas sob a seguintedenominação: linguagem de programação e planejamento.

1. linguagem de programaçãoem nosso caso a linguagem de programação Fortran 2003

2. planejamentoanalise e projeto

Apesar de serem duas tarefas distintas (para projetos grandes, estas atividades, muito frequentemente, são realizadaspor pessoas distintas), no nosso caso, elas são realizadas por uma única pessoa. Por este motivo somos levados aenfrentar algumas dificuldades. É muito importante ter clareza e delimitar corretamente cada uma destastarefas para que o processo todo não se torne confuso e mais difícil do que o necessário.

Para tornar o processo de aprendizagem o mais fácil possível, momentaneamente, nossa atenção sevoltará para o item 1: linguagem de programação.Por isto iniciamos nossos trabalhos com a aproximação codifica-conserta. Posteriormente iremosfazer uso da aproximação protótipo evolutivo, muito mais produtiva

Aproximação ponha-para-funcionar

Aprender uma linguagem de programação significa aprender as regras de sintaxe e a lógica das estruturasutilizadas na linguagem estudada (nossa disciplina utiliza linguagem estruturada). Portanto, a atenção está,essencialmente, voltada para as regras de sintaxe e de utilização das estruturas da linguagem. É assim mesmo, nadahá de errado com isto.

Uma das formas mais rápida e direta utilizadas no processo de aprendizagem da linguagem de programação éestudar o “conceito” e imediatamente implementar o que foi estudado escrevendo códigos fontes. Isto é o que sechama aproximação ponha-para-funcionar.

A aproximação ponha-para-funcionar é bastante eficiente paraevidenciar e exemplificar um conceito, uma informação, uma regra,uma implementação, ou seja, boa para aprender uma linguagem deprogramação, portanto serve de suporte ao item 1:item 1 – linguagem de programação

Nos primórdios da computação a aproximação ponha-para-funcionar era a única forma conhecida e por isto foiutilizada na criação de programas (desenvolvimento de programas e de softwares). Entretanto, a aproximação ponha-

para-funcionar quando utilizada para escrever programas mostrou suas limitações, o que fez com que outro tipo deabordagem surgisse.

A aproximação ponha-para-funcionar não serve para ser utilizada no item 2 (planejamento),porque esta aproximação acaba gerando um produto final pouco útil (pela baixa qualidade dosoftware criado) quando se pensa no desenvolvimento de um sistema




Aproximação codifica-conserta

A aproximação codifica-conserta (Code-Fix Approach) não émais do que uma pequena melhora na aproximação ponha-

para-funcionar.

na realidade é a mesma aproximação ponha-para-funcionar com a diferença de possibilitar aespecificação de mais de um propósito ou requisito

(aqui identificado como especificação do sistema)

Nesta aproximação, inicialmente faz-se a especificação do que se deseja ( identificação dos requisitos do sistema),depois o desenvolvedor inicia a codificação e realiza ( executa) vários ciclos da aproximação codifica-conserta. Detempo em tempo, ele verifica se o programa escrito atende as especificações desejadas. Quando atender, o

programa está pronto.

A aproximação codifica-conserta também tem problemas graves, tais como:

• baixa qualidade do produto final, pois o produto final gerado neste processo acaba como um ajuntamentode códigos

• produto final difícil de ser mantido e estendido (e muitas vezes até mesmo de ser entendido)

Observe que um produto final (software ou programa) pode ser classificado como:• muito baixa complexidade• baixa complexidade• média complexidade

• alta complexidade.A aproximação ponha-para-funcionar pode ser utilizado com sistemas de muito baixacomplexidade (essencialmente um único propósito). A aproximação codifica-conserta pode serutilizada para trabalho com sistemas de baixa complexidade (essencialmente uns poucospropósitos ou requisitos)

Conforme dito, neste momento, você trabalhará utilizando a aproximação codifica-conserta. Esta aproximaçãoé utilizada porque ela permite não desviar a atenção para assuntos e conhecimentos correlatos, isto é, minimiza aamplitude do assunto, procurando dirigir a atenção, essencialmente, para o assunto tratado.

A aproximação codifica-conserta será substituída pela aproximação protótipo evolutivo, que é mais produtiva e por isto é a forma de trabalho adotada em nosso disciplina. A aproximação protótipo evolutivo será apresentada posteriormente.





1. programa: numero_dias numero_dias.f03

Fazer:Atividade com intenção de utilizar variáveis do tipo caractere e do tipo inteira e entrar dados pelo teclado

Esta é a primeira atividade que você escreverá sozinho.Ela é (obviamente) uma atividade simples, que utiliza os conceitos apresentados até este momento. Use osprogramas anteriores como modelo.

DÚVIDA ? Na dúvida, TENTE ! Não fique imobilizado.

Você vai ver que o compilador não deixa você seguir adiante se houver erro de sintaxe nos seus códigosfontes. Erro de lógica o compilador não encontra. Eles irão aparecer quando da execução do programa.

Será necessário consertar todos os erros de sintaxe antes de prosseguir. Não tem jeito. Para o compilador étudo errado ou tudo certo.

Detalhe importante:Quando o compilador escreve várias mensagens de erro na tela do micro, você tem que ler a mensagemreferente ao primeiro erro. Não dê importância aos erros depois do primeiro, porque eles podemdesaparecer depois da correção do primeiro erro.

Leia a mensagem referente ao primeiro erro, vá até o arquivo que contém o código fonte do programa ecorrija o erro. Salve o programa depois da(s) correção(ões) e repita o processo de compilação do programa.

Se os erros posteriores ao primeiro persistirem eles reaparecerão quando for feita a nova compilação doprograma. Se isto acontecer, novamente, considere apenas o primeiro erro (se houver mais de um) e repita oprocesso de correção do erro, para então fazer nova compilação.

É assim mesmo, repete-se este processo várias vezes até que nenhuma mensagem de erro seja emitida pelocompilador. Com a prática, a quantidade de erros diminuem bastante e o processo todo passa a ser feito

rapidamente.

Você tentou, mas não está conseguindo. Ainda tem dúvida, ok,Não se desespere ! ( o famoso NO PANIC ! ) .Releia todas as informações disponibilizadas nesta atividade e se isto não for suficiente, releia oconteúdo apresentado nesta folha de atividades até aqui.Pergunte ao seu professor ( um colega também pode ajudar, pergunte! ).

Escreva o programa numero_dias e guarde-o no arquivo numero_dias.f03

O programa numero_dias deve ser escrito de forma que:

•

defina uma variável do tipo caractere com comprimento de 10 posições (ou 10 caracteres) chamada mes• defina uma variável do tipo inteira chamada dia

• solicite ao usuário do programa que entre com um valor para a variável mes (nome completo do mês do ano)

• solicite ao usuário a quantidade de dias existente no mês que ele forneceu

Auxílio: (ano não bissexto tem a seguinte quantidade de dias nos meses)janeiro 31fevereiro 28março 31abril 30maio 31 junho 30

julho 31agosto 31setembro 30outubro 31novembro 30dezembro 31




A saída do programa deverá ter mostrar o mês, a quantidade de dias e outras informações que você julgar necessário.

As atividades anteriores servirão de modelo para você escrever esta atividade. Lembre-se de:

• escrever o nome do programa nas instruções de abertura e fechamento do programa principal

• escrever o cabeçalho do programa

• não deixe de utilizar a instrução IMPLICIT NONE

• use as instruções PRINT* e READ*

• se necessário, use constantes literais caractere (strings): tantas quantas necessárias

compile e execute o programa

Atividade 11

Entregar em meio magnético:1. programa: calor calor.f03

Fazer:Nesta atividade será utilizado apenas constantes literais caractere (strings caractere ou como usualmente falamos strings).Não será necessário definir nenhum tipo de variável. Tudo o que tiver que ser escrito na tela do micro estará colocado emconstantes literais do tipo caractere (string).

O programa, ao ser executado, deverá mostrar na tela do micro o texto escrito dentro do quadro que segue:

Você sabe o que é calor ?

Calor é energia térmica que flui de um corpo para outro em virtude da diferença de temperatura entre eles.

Calor pode ser adicionado ou removido de uma substância.

Calor é medido em joules no sistema internacional de medida – S.I..

AUXÍLIO:• o texto a ser escrito (ver o quadro) pode ser considerado como sendo composto de 7 linhas:

4 linhas contendo texto e3 linhas em branco separando as linhas com texto

• as linhas com texto são constantes literais caractere (strings), portanto elas serão colocada dentro de aspasrecorde que as aspas (ou apóstrofos, se os utilizou no lugar das aspas) não fazem parte da constanteliteral caractere. Eles são utilizados apenas para delimitar a constante literal caractere

• tudo o que você escrever entre as aspas é uma constante literal caractere (string), portanto um contextocaractere

tudo o que compõe o contexto caractere é mostrado exatamente como ele foi escrito peloprogramador. O compilador não modifica o string (a constante literal caractere). Ele mostra o string,com tudo o que foi escrito, do jeito que foi escrito

• linha em branco pode ser escrita com a instrução print* ou seja, com a instrução print com a lista vazia

Escreva o programa calor e salve-o no arquivo calor.f03compile e execute o programa

REFORÇANDO: Constantes literais caractere (strings) é tudo aquilo que está colocado entre aspas ou entre apóstrofos.Um string (a forma, os caracteres utilizados e a sua disposição) é mantido pelo compilador. O compilador não modifica o string





1. programa: saudacao saudacao.f03

Fazer:Esta atividade utiliza uma variável caractere e várias constantes literais caractere (vários strings).

Escreva o programa Fortran saudacao de forma que ele:

• solicite o nome do usuário e guarde o valor que o usuário fornece pelo teclado numa variável caractere

característica a ser considerada:na definição de uma variável caractere define-se também o tamanho (quantidade de caracteres) que a variávelcaractere pode conter. Como não sabemos a quantidade de caracteres existente no nome do usuário que utilizará oprograma, a solução é especificar um valor grande para o comprimento da variável caractere

isto evitará o corte do nome do usuário se ele for maior que o comprimento da variável caractere que estásendo definida. Este procedimento trará inconvenientes (que você verá na saída produzida pelo seuprograma. Futuramente aprenderemos a tratar este inconveniente).

No momento, para lidar com o problema do possível corte do valor fornecido pelo usuário, defina umtamanho da variável caractere grande o suficiente para guardar a maioria dos nomes das pessoas

• depois o programa escreve na tela do micro, uma saudação ao usuário. A mensagem que deve ser mostrada na telado micro é

Olá <nome> seja bem vindo.Infelizmente não vamos poder trabalha juntos.Eu só sei escrever esta mensagem na tela do micro.Tenha um bom dia.Tchau !

onde <nome> será substituído pelo nome fornecido pelo usuário

AUXÍLIO:• o programa utiliza uma variável caractere

• e tantas constantes literais caractere (strings) quantas forem necessárias

Escreva o programa saudacao, salve no arquivo saudacao.f03compile e execute o programa

1. observe que o nome do programa é saudacao, isto mesmo, sem cê-cedilha e sem o acento til, porque o Fortran2003 utiliza um conjunto de caracteres (na prática este conjunto pode ser considerado o ASCII) que não possui estescaracteres. Por isto a instrução que será utilizada no programa será: program saudacao

2. por sua vez o nome do arquivo (saudacao.f03) pode ser escrito corretamente saudação.f03 porque quem trabalhacom o arquivo é o sistema operacional Linux e ele permite o uso de acentos e outros caracteres que o Fortran nãoutiliza (o Linux utiliza o conjunto de caracteres UTF-8). Mas para manter uma certa consistência (evitar complicações: escrever corretamente aqui, errado ali – aqui assim, ali assado ...) iremos adotar uma forma única deescrever, por isto o arquivo será identificado por saudacao.f03 não saudação.f03




9. Constante CaractereConstante caractere aparece no Fortran sob duas formas:

• constante literal caracterevalor do tipo caractere escrito literalmente no programa (usualmente é chamada apenas de string)

• constante com nome caracterevalor caractere constante identificado por um nome (chamada constante, mas é uma constante com nome)

CONSTANTE LITERAL ou constante literal caractere. Por exemplo, os caracteres escritos entre aspas ( " ) ou entre apóstrofos ( ' )

definem constantes literais tipo caractere. Então, quando analisamos o seguimento de programa mostrado a seguir

print*,"Entre com ano bissexto "read*, ano_bi

print* print*,"Agora entre com ano não bissexto "

read*, ano_usual print* print*, "o ano ", ano_bi, " é bissexto" print*, "o ano ", ano_usual, " não é ano bissexto"

vemos que

• Entre com ano bissexto• Agora entre com ano não bissexto• o ano• é bissexto• o ano• não é ano bissexto

são seis constantes literais caractere usadas para fornecer informações para o usuário do programa. Relembreque as aspas não fazem parte das constantes literais caractere.

Observe que o valor "o ano " (sem as aspas) foi utilizada duas vezes no programa, portanto são duasconstantes literais caractere diferentes, apesar delas terem exatamente os mesmo valor ( conteúdo).Tem-se duasconstantes diferentes não uma única repetida duas vezes.

Para altera o valor de qualquer constante literal caractere (string) é necessário alterar o valor na constantedesejada (aquela que se deseja alterar ).

Uma constante literal caractere não tem nome. É um objeto sem nome. Cada constante literal caractere é única,

existe individualmente. Várias constantes literais caractere (mesmo que contenham o mesmo valor ) são váriasconstantes literais caractere diferentes, não uma única.

O seguimento de programa:

print*,"Olá Anibal" print*,"Olá Anibal" print*,"Olá Anibal" print*,"Olá Anibal" print*,"Olá Anibal"

utiliza cinco constantes literais caractere diferentes. Todas com o mesmo valor, mas são 5 constantes diferentes.




CONSTANTE COM NOME ou constante com nome caractere. Outro tipo de constante caractere que se pode utilizar é a constante com

nome caractere. A constante com nome caractere é declarada utilizando-se o atributo PARAMETER.

O atributo PARAMETER utilizado na declaração de tipo caractere cria uma constante com nome.

A constante torna-se definida com o valor especificado na expressão de inicialização que aparece a direita dosinal de igual . A forma geral para declara uma constante com nome caractere é:

character(len=*), parameter:: constante = expr-inicialização

Na declaração da constante com nome caractere o comprimento é sempre feito igual a * e neste caso ocomprimento da constante com nome é exatamente igual ao comprimento da expr que define a constante.

Então:

• character(len=*),parameter:: meu_nome = "Anibal"

define a constante com nome meu_nome que tem um tamanho igual a 6 e valor igual a Anibal

• character(len=*),parameter:: nome_dela = "Ana"

define a constante com nome nome_dela que tem um tamanho igual a 3 e valor igual a Ana

O seguimento de programa:

print*,"Olá", meu_nome print*,"Olá", meu_nome print*,"Olá", meu_nome print*,"Olá", meu_nome print*,"Olá", meu_nome

Utiliza cinco constantes literais caractere diferentes com o mesmo valor ( "Olá") e uma única constantes comnome caractere chamada meu_nome que contém o valor "Anibal". Observe que a constante com nome foiutilizada 5 vezes, não são cinco constantes com nome diferentes.

Estes códigos fazem a mesma tarefa que o anterior, isto é, mostra cinco vezes a mensagem Olá Anibal na telado computador.

Caso se queira alterar a mensagem a ser mostrada, por exemplo, para Bom dia Anibal será necessário alteraas cinco constantes literais. Por outro lado, se o valor da constante com nome meu_nome for alterado na definiçãoda constante com nome para, por exemplo, Paulo, as cinco mensagem mostradas na tela do computador seráalterada automaticamente. Altera-se apenas a definição da constante com nome as cinco mensagens serão

automaticamente atualizadas quando o programa for executado.

character(len=*),parameter:: meu_nome="Anibal"

print*,"Olá ", meu_nome print*,"Olá ", meu_nome print*,"Olá ", meu_nome print*,"Olá ", meu_nome print*,"Olá ", meu_nome

escreve 5 vezes a mesma mensagem Olá AnibalOlá Anibal

Olá AnibalOlá AnibalOlá Anibal

tem que ser escrito assim:

character(len=*),parameter:: saud="Olá "character(len=*),parameter:: meu_nome="Anibal"

print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome

escreve 5 vezes a mesma mensagem Olá AnibalOlá Anibal

Olá AnibalOlá AnibalOlá Anibal

se escrito assim:




character(len=*),parameter:: meu_nome="Anibal"

print*,"Bom dia ", meu_nome print*,"Bom dia ", meu_nome print*,"Bom dia ", meu_nome print*,"Bom dia ", meu_nome print*,"Bom dia ", meu_nome

escreve 5 vezesBom dia AnibalBom dia AnibalBom dia AnibalBom dia AnibalBom dia Anibal

character(len=*),parameter:: saud="Bom dia "character(len=*),parameter:: meu_nome="Paulo"

print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome print*,saud, meu_nome

escreve 5 vezesBom dia PauloBom dia PauloBom dia PauloBom dia PauloBom dia Paulo

Uma constante literal caractere não pode ter seu valor alterado durante a execução do programa. Não háforma disto acontecer. Para alterar o valor de uma constante literal caractere é necessário alterar o código fonte do

programa e depois compilar o programa alterado.

Numa constante com nome caractere o valor da constante com nome também não pode ser alterado durante aexecução do programa. Então qual a diferença, qual a vantagem de se utilizar constantes com nome?

Constante com nome caractere:

• facilita a escrita do programa

• torna o programa mais claro (fácil de ser lido e entendido)

• para trocar (se necessário) o valor de uma constante com nome caractere, troca-se o valor na suadefinição (um único local) e o novo valor será automaticamente usado pelo programa todo


1. programa: arrumando_com_strings arrumando_com_strings.f03

Exemplo:

Escreva o programa arrumando_com_strings, salve no arquivo arrumando_com_strings.f03compile e execute o programa

O programa utiliza variáveis caractere e constantes literais caractere

O programa destaca como é possível alterar a apresentação na tela das variáveis usando constantes literaiscaractere. Neste exemplo utilizou-se espaços em branco para alterar a aparência do que é mostrado na tela domicro.

RELEMBRE: uma constante literal do tipo caractere (string) é mantida exatamente como foi escrita, isto é,preservando todos os caracteres utilizados ( inclusive os espaços) e as suas disposições

Você pode copiar e colar os códigos fontes, mas não deixe de ajustar a diagramação dos códigosfontes segundo o estilo de programação adotado na disciplina

No estilo de programação que utilizamos, todo programa:• tem um nome• tem um cabeçalho• utiliza a instrução implicit none • destaca instruções que trabalham juntas para realizar certas tarefas




Não deixe de atualizar o cabeçalho do programa de forma adequada. ________________________________________________________________________________________ ► arquivo: arrumando_com_strings.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program arrumando_com_strings!!-----------------------------------------------------------------------

! Propósito: Apresenta saída na tela do micro de variáveis caractere.! A aparência na tela do micro das variáveis caractere é! modificada pelo uso de constantes literais caractere!-----------------------------------------------------------------------! Arquivo: arrumando_com_strings.f03! Autor: Anibal L. Pereira 27/11/2010!Revisões:!-----------------------------------------------------------------------implicit nonecharacter(len=5):: s1 ! s1 a s8 são 8 palavras isoladascharacter(len=3):: s2 !character(len=2):: s3 !-- OBSERVAÇÃO: aqui cada variável foi escrita numa instrução decharacter(len=4):: s4 !-- definição separada. Entretanto, aquelas que possuem mesmocharacter(len=5):: s5 !-- tamanho poderiam ter sido escritas numa mesma declaração.

character(len=3):: s6 !-- Por exemplo:character(len=1):: s7 !-- character(len=5):: s1, s5character(len=10)::s8

!---------------------------------------------! entra com valores nas variáveis caractere!---------------------------------------------s1 = "Entre" !-- são variáveis, mas como estão definidas diretamente nos2 = "com" !-- programa elas dão a impressão de serem constantess3 = "um"s4 = "nome"s5 = "menor"s6 = "que"s7 = "9"s8 = "caracteres"

!--------------------------------------------------------------------------------------! primeira impressão!------------------------------------------------------------------------------------- print* print*,"=================================" print*,s1,s2,s3,s4,s5,s6,s7,s8 print*,"================================="

!-------------------------------------------------------------------------------------! segunda impressão!------------------------------------------------------------------------------------- print* print*,"========================================"

print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"========================================"

!-------------------------------------------------------------------------------------! terceira impressão!------------------------------------------------------------------------------------- print* print*,"======================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"======================================================"

!-------------------------------------------------------------------------------------! quarta impressão!------------------------------------------------------------------------------------- print*

print*,"=================================================================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6,"",s7," ",s8 print*,"================================================================================================="




end program arrumando_com_strings

Observação sobre a questão de linha quebrada

No programa arrumando_com_strings aparecem duas linhas similares a esta

print*,"===============================================================================

=================="

• no Fortran uma linha física pode ter até 132 caracteres

• a linha mostrada contém 107 caracteres

• entretanto nosso texto, por causa do tipo de fonte e do tamanho utilizado permite escrever linhascom um máximo de 95 colunas, portanto a linha com 107 colunas aparece quebrada como sefossem duas linhas (como mostrado)

Você deve considerar a linha como sendo uma única ( porque a linha é uma linha do Fortran e neste caso:107 colunas podem estar dentro das 132 colunas utilizadas pelo Fortran)

Este inconveniente, deve ser ser tratado por você, porque (por decisão nossa) a linha não será modificada para caber em uma linha única no texto. Se isto fosse feito o tamanho do fonte dificultaria a leitura do textoe mesmo assim ainda teríamos casos em que (como mostrado a seguir ) teríamos que diminuir ainda mais otamanho do fonte.

FONTE tamanho 7:

print* print*,"=================================================================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7,"",s8 print*,"================================================================================================="

FONTE tamanho 6: print* print*,"=================================================================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"================================================================================================="

esta última impressão das 4 linhas é como ficará no seu código fonte as linhas citadas. Observe como ficoudifícil (desconfortável) ler as linhas com fonte não pequenas. Por isto não usamos este tamanho de fonte.

10. Entidade do Tipo CaractereUma entidade caractere (objeto de dado tipo caractere) pode ser visualizada como sendo uma caixa contendo

várias divisões, onde cada divisão pode guardar um caractere. Por exemplo, considere a variável tipo caractere abcdefinida assim:

• character(len=4):: abc = "raiz"

esta instrução cria (separa; reserva) uma parte da memória do computador e atribui a esta porção damemória um nome, neste caso o nome abc. Agora toda vez que se utilizar o nome abc estamos nosreferindo a (trabalhando com) esta parte da memória.A memória do computador reservada para a variável caractere pode ser visualizada como sendo umacaixa subdividida da seguinte forma:

posição de memória que

está sendo chamada de abc r a i z

Observe que a instrução de definição da variável caractere reserva 4 posições para abc, isto é, estavariável caractere poderá conter até quatro caracteres (ela tem exatamente um tamanho de 4 caracteres).




Cada posição na entidade caractere é numerada para que os valores guardados nela possam ser individualmente acessados. A numeração é feita de forma que a posição mais a esquerda é a posiçãonúmero 1. Então:

abc

abc r a i z

valor: r a i z

posição: 1 2 3 4

ENTRANDO VALORES MAIORES QUE O TAMANHO DA VARIÁVELO que ocorre quando o tamanho do conteúdo (valor) e o tamanho da variável são diferentes?

Quando o tamanho da variável caractere é menor que o tamanho do que se quer guardar nela, o valor guardadoé cortado. Veja o exemplo:

program ent_01!-----------------------------------------!Exemplo de entrada de valor caractere com !tamanho maior que a variável caractere!AUTOR: Anibal L. Pereira 26/06/2010!-----------------------------------------implicit nonecharacter(len=4):: var1

print*,"Entre nome com tamanho maior que 4"read*, var1

print*,"var1 contém o valor: ", var1

end program ent_01

O programa ent_01 cria uma variável caracterechamada var1 que tem um tamanho igual a 4

solicita que o usuário entre com um nomecontendo mais de 4 caracteres

guarda o nome fornecido pelo usuário na variávelcaractere var1

depois mostra na tela do micro o valor contido(guardado) na variável caractere

Copie o programa e execute-o para ver sua saída.

Quando se entra, por exemplo, com o valor encontrar a saída do programa será: enco

len=4var1 = "encontrar"

e n c o n t r a r

observe que os caracteres excedentes foram cortados, ficando apenas os caracteres enco.

ENTRANDO VALORES MENORES QUE O TAMANHO DA VARIÁVELPara o caso do valor que será guardado na variável caractere ser menor que o tamanho da variável, as posições

da variável que não receberem caracteres serão preenchidas com o caractere branco. Por exemplo, veja o caso davariável var2 de tamanho 12 que receba um valor de tamanho 9:

len=12var2 = "encontrar"

e n c o n t r a r

Observe que existem 9 caracteres diferentes de branco e 3 brancos para perfazer o tamanho 12 da variável.




CONTANTE LITERAL CARACTEREAs constantes literais caracteres tem sempre exatamente o tamanho que for especificado, isto é, o tamanho entre

as aspas ou apóstrofos que delimitam a constante.

Então: "Entre nome com tamanho maior que 4"

tem exatamente 34 caracteres, contando com os caracteres brancos existentes na constante.

"Escreva seu nome: "

contém 18 caracteres (contando com o brando colocado no final do string)

CONTANTE COM NOME CARACTEREA constante com nome caractere também tem sempre exatamente o tamanho da expr-inicialização utilizada na

sua definição.

Então: character(len=*), parameter:: mes="abril"

mes tem um tamanho de 5 caracteres, enquanto

character(len=*), parameter:: mes9="setembro"

mes9 contém 8 caracteres

11. SubstringPorque um substring (subcadeia de caractere), e também uma variável caractere, é uma cadeia de caracteres

numerada da esquerda para a direita é possível trabalhar com cada caractere individualmente.

A forma geral de um substring é: string-origem(intervalo-substring)

onde: string-origem especifica o string origem, isto é, o string que fornecerá os caracteres para osubstring

intervalo-substring é do tipo i:f onde i e f são inteiros positivos que especifica o ponto inicial e o pontofinal do substring

Um substring é uma porção de um caractere. Usando um substring é possível trabalhar com parte de umavariável ou constante caractere.

Recorde que um substring é referenciado utilizando-se o nome do string origem seguido pela indicação, entre parênteses, da posição inicial e posição final.

Por exemplo:

implicit nonecharacter(len=34):: var

var="Entre nome com tamanho maior que 4"

print*, var(1:5)

a variável var tem tamanho de 34 caracteres e o valor Entre nome com tamanho maior que 4

a instrução print irá imprimir na tela do micro apenas a palavra

Entre

porque o substring utilizado está usando apenas as 5 primeiras posições da variável caractere var, que gera ovalor Entre




E n t r e n o m e c o m .. .. .. .. q u e 4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 .. .. .. .. 30 31 32 33 34

print*, var(12:14) mostra na tela do micro: com

print*, var(7:14) mostra na tela do micro: nome com

print*, var(3:5) mostra na tela do micro: tre

print*, var(34:34) mostra na tela do micro: 4 (o valor guardado na posição 34)

print*, var(10:10) mostra na tela do micro: e (valor na posição 10)

print*, var mostra na tela do micro: Entre nome com tamanho maior que 4 porque não é um substring é a própria variável

12. Operador ConcatenaçãoO único operador que existe para se trabalhar com objetos do tipo caractere é o operador concatenação.Concatenar significa colocar ao lado, juntar.

No Fortran, o operador concatenação é representado por “ // ” (duas barras juntas). O que ele faz?Simplesmente junta os strings.

O segmento de programa que segue, gera a saída mostrada nos quadros:

character(len=5):: primeiro = "Maria"character(len=9):: segundo = "Antonieta"character(len=15):: duplo1, duplo2

duplo1 = primeiro//segundoduplo2 = primeiro//" "//segundo

print*,'duplo1 ==> ', duplo1 print*,'duplo2 ==> ', duplo2

As instruções e o resultado que elas geram na tela do micro:

print*,'duplo1 ==> ', duplo1

duplo1 ==> MariaAntonieta

Observe que o operador concatenação não coloca espaços entre o que está sendo concatenado. Se isto for necessário, o programador tem que providenciar isto.

print*,'duplo2 ==> ', duplo2

duplo2 ==> Maria Antonieta

13. Descritor de Formato AlfanuméricoUsa-se os descritores de edição de formato para controlara a aparência dos dados. Por exemplo, a instrução

print* é uma das formas mais simples de utilizar um formato. Neste caso é o formato “lista dirigida à” queusualmente chamamos de “formato livre”, que é indicado por um asterisco ( * ).




A instrução print tem a seguinte forma: print formatos, lista

onde: formatos especifica os formatos que serão utilizados com as entidades na lista

lista Identifica as entidades (objetos) que serão escritas

O descritor de edição de formato para dados do tipo caractere é o descritor alfanumérico, que tem a seguinteforma:

A[w]

a de alfanumérico este descritor de edição de formato é utilizado para formatar o dado do tipo caractere ( controlar a suaaparência). Ele é indicado pela letra a (ou a letra maiúscula A).

Aw a letra A tanto pode ser escrita maiúscula quanto minúscula, o w indica o tamanho do campo utilizado,isto é, um número inteiro que indica quantos caracteres o campo pode conter

Exemplo: o descritor de formato a10 ou A10 identificam um campo de 10 caracteres (10 posições).

FATOR DE REPETIÇÃOO descritor de edição alfanumérico pode ser multiplicado por um número inteiro que representa a quantidade de

repetições do descritor. Este número deve aparecer antes do descritor.

Exemplo: 5A3 → é o mesmo que escrever cinco vezes o descritor de formato A3: A3, A3, A3, A3, A3

program exemplo_f!-----------------------------------------!-- Programa exemplo de formatação!-- AUTOR: Anibal L. Pereira 19/07/2010

!-----------------------------------------implicit nonecharacter(len=20):: nome1character(len=13):: nome2character(len=6)::numero

nome1="Entre com um número"nome2=" maior que 20"

print"(a33)", nome1//nome2read*, numero

print"(2a6)", numero,numero

end program exemplo_f

Ao executar o programa e entrar com o número 2345, asaída será igual a mostrada abaixo:

Entre com um número maior que 2023452345 2345

Inconveniente A contagem dos caracteres deve levar em conta a seguinte peculiaridade:Porque a língua inglesa não usa acentos e cê-cedilha (o Fortran não disponibiliza estes caracteres no seu

conjunto de caracteres), a tabela ASCII (o conjunto de caracteres default do Fortran) possuí todos oscaracteres necessários à língua inglesa. Entretanto, este não é o nosso caso.Para o Fortran, os caracteres são guardados internamente como números binários de 32 bits. Porexemplo: o caractere k (a letra k minúscula) na tabela ASCII é o número 107 (decimal) queescrito em binário é: 00000000000000000000000001101011

que usualmente escrevemos assim: 1101011Como o maior valor existente na tabela ASCII padrão é o valor decimal 127 ( em binário: 1111111 )e porque o padrão Fortran estabelece que os caracteres usados por um programa devem utilizaruma codificação compatível com o conjunto de caracteres default do Fortran (na prática o ASCII), oscaracteres utilizados pelo Fortran são sempre números menores que 127.




E o nosso caso?Resumindo uma história longa, nosso símbolos (acentos, cedilha, e outros caracteres que nãoexistem na tabela ASCII) são escritos usando mais de um octeto (1 byte) [a codificação utilizada échamada de UTF-8, que usa de 1 a 4 octetos (1 a 4 bytes): detalhes podem ser vistos em:http://en.wikipedia.org/wiki/UTF-8 ].

Por exemplo, os caracteres í, õ, é e ç são representados pelas seguintes pares de valores:í 195 173→

õ 195 181→

é 195 169→

ç 195 167→

Observe que estes caracteres usam dois números (dois octetos – dois bytes). Como o compiladorFortran usa apenas 1 número (um octeto) para cada caractere, ele vai trabalhar os números 195 e173 como dois caracteres (2 octetos) não um único caractere. Por isto o compilador vai terproblema com o udo do 195 e do 173 para representar um único caractere. Ele vai trabalharestranhamente ou então, em certos casos, acusará erro.

Solução: O padrão Fortran 2003 que permite o uso de caracteres da tabela unicode (caracteres

não pertencentes à língua inglesa) nas variáveis e constantes literais do tipo caractere, resolve(resolve parcialmente) este problema.No momento não vamos abordar o uso da tabela unicode, porque isto envolveria vários detalhesque desviariam a atenção do que é mais importante para nós, no momento. Então, para lidar comeste evento, vamos adotar um truque:

Truque:

encontrando um caracteres não ASCII, (nossos caso) ele é (geralmente) escrito usando 2 octetos(2 bytes – mas, dependendo do caractere representado pode conter até 4 octetos – entretanto,para nós 2 octetos é o caso mais comum), por isto conte uma posição a mais para cada caractere

não padrão encontrado. Assim você poderá usar um campo de tamanho adequado para a entidade.Exemplo:

"Entre com um número" <== este string contém 19 caracteres

print"(a19)", "Entre com um número"

gera uma saída truncada ==> Entre com um númer

print"(a20)", "Entre com um número"

gera a saída correta ==> Entre com um número porque o u acentuado conta como dois octetos não um

como só tem um caractere não ASCII, a contagem aumentou apenas de umaunidade. Portanto a20 é suficiente para não truncar a saída

14. Descritores de Formato Tabulador As formas gerais dos descritores de tabulação são:

TcTR nTLn

T representa o tabulador (absoluto)c indica a colunaTR tabulador a direita da posição atual (relativo)TL tabulador a esquerda da posição atual (relativo)n quantas posições ou colunas

Com o tabulador é possível andar para a direita e para a esquerda dentro da linha.

Para modificar a forma como os dados irão aparecer numa linha (aparência do dado) pode-se usar os tabuladores. Éimportante lembrar que:




• cada declaração print (ou write) imprime uma linha

portanto andar na vertical é feito com a declaração print

• os tabuladores permitem andar na horizontal (dentro da linha)

Tudo ficará mais fácil se você tratar a tela do micro como uma tabela contendo linhas e colunas (Quadro 1).

c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 c20 . . . . . . . . .

Linha 1 E n t r e c o m u m n ú m e r o

Linha 2 ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

Linha 3 ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

Linha 4 ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

Linha 5 ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

. . . . . . ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

. . . . . .

● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●. . . . . . ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

Quadro 1 – Visualização da tela do micro em linhas e colunas

Exemplo:

print"(a)","primeira cadeia de caracteres" print"(4a)","pri ","seg ","ter ","quar" print"(4a4)","pri ","seg ","ter ","quar" print"(4a)","um ","dois ","trezentos ","quar" print"(a3,a4,a10,a4)","um ","dois","trezentos ","quar"

Resultado: primeiro cadeia de caracteres pri seg ter quar pri seg ter quarum dois trezentos quarum dois trezentos quar

15. Descritor de Formato PosicionalA forma geral deste descritor é:

nX

onde:

X insere espaços a direita da posição atualn quantidade de espaços

Exemplo:

print"(5X,a,5X,a)", "primeira","segunda" print"(6X,a,6X,a)", "primeira","segunda" print"(7X,a,7X,a)", "primeira","segunda" print"(8X,a,8X,a)", "primeira","segunda" print"(9X,a,9X,a)", "primeira","segunda"

Resultado:

primeira segundaprimeira segundaprimeira segundaprimeira segundaprimeira segunda




16. Funções Intrínsecas CaractereAs funções intrínsecas caractere são as funções do Fortran 2003 que permitem implementar várias ações quando

se trabalha com caracteres. Elas estão listadas no quadro que segue.

Função Descriçãoachar(i) retorna o caractere na posição i da sequência de caracteres ASCII

i é um número inteiro → inteiro para caractere

adjustl(string) ajusta a esquerda brancos vão para o final (direita) do campo

adjustr(string) ajusta a direita brancos vão para o início (frente) do campo

char(i[,kind]) retorna o caractere na posição i da sequência de caracteres do processador i é um número inteiro → inteiro para caractere

iachar(c) retorna a posição do caractere na sequência ASCII

c é um caractere → caractere para inteiroichar(c) retorna a posição do caractere na sequência do processador

c é um caractere → caractere para inteiro

index(string,substring[,back]) retorna a posição inicial do substring no string back, faz a procura do substring iniciando do fim para o início

len(string) retorna o comprimento de uma entidade caracteretamanho do campo do string ou número de caracteres existentes naconstante literal caractere

len_trim(string) retorna o comprimento sem caracteres brancos posterioreslge(string_A, string_B) lexicalmente maior que ou igual a

string_A ≥ string_Blgt(string_A, string_B) lexicalmente maior que

string_A > string_Blle(string_A, string_B) lexicalmente menor que ou igual a

string_A ≤ string_B

llt(string_A, string_B) lexicalmente menor questring_A < string_B

repeat(string,ncopies) faz concatenação repetidaconcatena n cópias do string

scan(string, set[,back]) retorna a primeira posição no string de um dos caractere existente em

settrim(string) remove caracteres brancos posteriores

verify(string,set[,back]) retorna a primeira posição no string para um caractere que não existeem set

17. Instrução IF

A instrução if é muito útil na escrita de programas, porque permite ao programa executar ou não uma instrução,conforme o resultado de uma avaliação.




Instrução IF

Executando ou não uma instrução program escreve_isto_ou_aquilo!-------------------------------------!Exemplo de controle de fluxo!AUTOR: Anibal L. Pereira 29/07/2010

!-------------------------------------implicit nonecharacter(len=5):: var1="Olá,"character(len=8):: var2="Bom dia,"character(len=1):: escolha

print*,"Entre com A ou B:"read*, escolha

!------------------------------------------! escolhe o que imprimir na tela do micro!------------------------------------------ print*if(escolha == "A") print*,var1//" para você"if(escolha == "B") print*,var2//" para você" print*

end program escreve_isto_ou_aquilo

Este programa solicita um dado do usuário (a letra Amaiúscula ou a letra B maiúscula) e baseado no valor fornecido pelo usuário executa uma instrução ou

não.Ao executá-lo, entrando com a opção A o programaescreve na tela o seguinte:

Entre com A ou B: A

Olá, para você

executando novamente o programa e escolhendo aopção B obtém-se:

Entre com A ou B:B

Bom dia, para você

A instrução if:

• o testeo teste está colocado entre parêntesesa variável escolha é comparada com a constante literal Aa comparação é indicada pelo operador == (dois sinais de igual juntos)

if(escolha == "A") then

se o teste gerar o valor verdadeiro (T = true = verdadeiro), isto é, se a variável caractere escolhacontiver o caractere A a instrução print*,var1//" para você" é executada

• se o teste for falsose o teste gerar o valor falso (F = false = falso), isto é, se a variável caractere escolha contiver um valor diferente do caractere A a instrução print*,var1//" para você" não é executada

Após a execução da instrução if (conforme a condição seja verdadeira ou falsa) o fluxo do programa segue paraa próxima instrução no programa.




18. ArquivoEscrever dados em um arquivo ou ler dados de um arquivo, é uma tarefa bastante comum.

O procedimento a ser seguido para ler ou escrever em um arquivo é:

1. conectar (abrir

) o arquivo com as especificações desejadas2. ler (read) ou escrever (write) dados no arquivo

3. fechar (close) o arquivo, quando ele não mais é necessário

A instrução para conectar (abrir ) um arquivo tem a seguinte forma:

open(unit=U, file="arq", status="S", action="A")

onde:U é um número inteiro, geralmente maior ou igual a 10 e menor que 99

O programador deve, arbitrariamente, escolher o número inteiro que vai utilizar.Este inteiro deve ser único, isto é, não pode ser utilizado em outra instrução open, no mesmo programa, enquanto esta unidade não foi fechada (liberada para uso).

arq o nome do arquivo, que deste momento em diante será identificada pelo unidadeespecificada.Quando existir a necessidade de referencia ao arquivo, utiliza-se a unidade.

S pode ser:OLD → para arquivo já existente

NEW → para arquivo novo (arquivo será criado; arquivo não pode existir )REPLACE → para sobrescrever o arquivo (conteúdo original será perdido; se o arquivo

não existir será criado)

A pode ser:READ → arquivo será conectado apenas para leituraWRITE → arquivo será conectado apenas para escritaREADWRITE → arquivo será conectado para leitura e escrita

Exemplo: Considere a existência do arquivo de dados chamado poema.dados que contém o seguinte texto:

POEMA: Amor é fogo que arde sem se ver

Amor é fogo que arde sem se ver;

É ferida que dói e não se sente;É um contentamento descontente;É dor que desatina sem doer;

É um não querer mais que bem querer;É solitário andar por entre a gente;É nunca contentar-se de contente;É cuidar que se ganha em se perder;

É querer estar preso por vontade;É servir a quem vence, o vencedor;É ter com quem nos mata lealdade.

Mas como causar pode seu favor Nos corações humanos amizade,

Se tão contrário a si é o mesmo Amor?

Luís de Camões




Então a abertura (conexão) do arquivo pode ser feita assim:

open(unit=30, file="poema.dados", status="old", action="read")

19. Instrução Write

O Fortran possui a instrução print e e a instrução write.

A instrução print possibilita escrever na tela do micro. Só na tela do micro.

A instrução write escreve na tela do micro e também escreve em outro dispositivo.Na tela ou em outro dispositivo.

Escrevendo na tela do micro:Por exemplo, as instruções:

print*, "Entre com um número"

write(unit=*, fmt=*) "Entre com um número"

implementam a mesma ação, isto é, escreve na tela do micro a mesma mensagem: "Entre com um número"

Quando a unidade unit= é identificada por um asterisco (*) a tela do micro será utilizada.

Portanto print* e write(unit=* tem o mesmo significado e podem ser utilizados indistintamente.

print*, "Entre com um número" !<-- mais simples de escrever

write(unit=*, fmt=*) "Entre com um número" !<-- um pouco mais complexo para escrever

Após um arquivo de dados ter sido conectado (aberto) é possível se trabalhar com o arquivo, ou seja, pode-se ler dados do arquivo ou escrever dados no arquivo.

A instrução para ler dados num arquivo é a instrução read . Enquanto a instrução de escrita no arquivo é ainstrução write.

Escrevendo num arquivo:depois da conexão do arquivo poema.dados

open(unit=50, file="poema.dados", status="replace", action="readwrite")

é possível escrever uma linha no arquivo poema.dados, que está sendo (neste caso) identificado pela unidade 50.O valor (conteúdo) da linha que será escrita está guarda na variável caractere linha_sendo_escrita.

write(unit=50, fmt=*) linha_sendo_escrita

Observe que o formato (abreviado por fmt=) utilizado é o formato livre, o que está caracterizado pelo caractere* (asterisco).




20. Instrução ReadO Fortran possui a instrução read utilizada para leitura de dados. Tanto do teclado quanto de um dispositivo.

Lendo do teclado:

As instruções:read*, linha

read(unit=*, fmt=*) linha

implementam a mesma ação: lê dado fornecido pelo teclado

Quando a unidade unit= é identificada por um asterisco (*) o teclado é o dispositivo que está sendo utilizado.

Portanto read* e read(unit=* tem o mesmo significado e podem ser utilizados indistintamente.

read*, linha !<-- mais simples de escrever

read(unit=*, fmt=*) linha !<-- um pouco mais complexo para escrever

Após um arquivo de dados ter sido conectado (aberto) é possível se trabalhar com o arquivo, ou seja, pode-se ler dados do arquivo.

Lendo de um arquivo: por exemplo, depois da conexão do arquivo poema.dados

open(unit=30, file="poema.dados", status="old", action="read")

é possível ler uma linha no arquivo poema.dados, que está sendo (neste caso) identificado pela unidade 30. O

valor (conteúdo) da linha lida será guarda na variável caractere linha_do_arquivo.read(unit=30, fmt=*) linha_do_arquivo

Observe que o formato (abreviado por fmt=) utilizado é o formato livre, o que está caracterizado pelo caractere* (asterisco).

21. Instrução CloseQuando todas as ações necessários e/ou desejadas foram realizadas com o arquivo conectado, pode-se

desconectar (fechar – liberar ) o arquivo. Para isto usa-se a instrução close.

close(unit=50)

Depois de fechado o arquivo não pode mais ser acessado.

Depois de fechado (da unidade ter sido liberada) a unidade pode ser utilizada para conectar o mesmo ou entãooutro arquivo.

program ex_01!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso de arquivo!---------------------------------------------------------------------------------------! Arquivo: ex_01.f03

! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=40)::linha1, linha2, linha3, linha4, linha5, linha6character(len=11)::arquivo="poema.dados"




!------------------------------------------------------------------! conecta o arquivo com o poema para leitura!------------------------------------------------------------------open(unit=10, file="poema.dados", status="old", action="read")

!------------------------------------------------------------------! lê as 6 primeira linha do arquivo

!------------------------------------------------------------------read(unit=10, fmt="(a40)") linha1read(unit=10, fmt="(a40)") linha2read(unit=10, fmt="(a40)") linha3read(unit=10, fmt="(a40)") linha4read(unit=10, fmt="(a40)") linha5read(unit=10, fmt="(a40)") linha6

!------------------------------------------------------------------! fecha o arquivo!------------------------------------------------------------------close(unit=10)

!----------------------------------------------------------------------

! mostra na tela do micro as 4 primeiras linhas do poema, usando PRINT!---------------------------------------------------------------------- print* print*,"QUATRO LINHAS DO "//linha1 print*,linha2 print*,linha3 print*,linha4 print*,linha5 print*,linha6 print*,"----------------------------------------------" print*,"----------------------------------------------"

!----------------------------------------------------------------------! mostra na tela do micro as 4 primeiras linhas do poema, usando WRITE!----------------------------------------------------------------------

write(unit=*,fmt=*)write(unit=*,fmt="(t12,a57)")"QUATRO LINHAS DO "//linha1write(unit=*,fmt="(t12,a40)")linha2write(unit=*,fmt="(t12,a40)")linha3write(unit=*,fmt="(t12,a40)")linha4write(unit=*,fmt="(t12,a40)")linha5write(unit=*,fmt="(t12,a40)")linha6write(unit=*,fmt="(t12,a40)")write(unit=*,fmt=*)

end program ex_01

EXEMPLOS DE USO DAS FUNÇÕES INTRÍNSECAS

Execute os exemplos para ver seu funcionamento.

Consulte detalhes sobre as funções intrínsecas no link da Home Page.

Alguns destes exemplos utilizam o descritor de formato para número inteiro:

quando se utiliza o descritor de formato I, isto significa que se está formatandoum número inteiro. Então:

I2 significa usar,→ no máximo, 2 posições no número inteiro

I3 significa usar,→ no máximo, 3 posições no número inteiro




Consulte a tabela ASCII para conferir a saída do programa

program ex_02!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas achar e char

! achar ==> SEQUÊNCIA ASCII char ==> SEQUÊNCIA PROCESSADOR !---------------------------------------------------------------------------------------! Arquivo: ex_02.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit none

print* print*,"I achar char" print"(4a)","33 --> ", achar(33), " ", char(33) print"(4a)","34 --> ", achar(34), " ", char(34) print"(4a)","35 --> ", achar(35), " ", char(35) print"(4a)","36 --> ", achar(36), " ", char(36) print"(4a)","37 --> ", achar(37), " ", char(37)

print"(4a)","38 --> ", achar(38), " ", char(38) print"(4a)","39 --> ", achar(39), " ", char(39) print"(4a)","40 --> ", achar(40), " ", char(40) print*

end program ex_02

Consulte a tabela ASCII para conferir a saída do programa

program ex_03!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas iachar e ichar! iachar ==> SEQUÊNCIA ASCII ichar ==> SEQUÊNCIA DO PROCESSADOR !---------------------------------------------------------------------------------------! Arquivo: ex_03.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit none

print* print*,"C iachar ichar" print"(a,i2,a,i2)","A --> ", iachar("A"), " ", ichar("A") print"(a,i2,a,i2)","B --> ", iachar("B"), " ", ichar("B") print"(a,i2,a,i2)","C --> ", iachar("C"), " ", ichar("C") print"(a,i2,a,i2)","D --> ", iachar("D"), " ", ichar("D") print"(a,i2,a,i2)","a --> ", iachar("a"), " ", ichar("a")

print"(a,i2,a,i2)","b --> ", iachar("b"), " ", ichar("b") print"(a,i2,a,i2)","c --> ", iachar("c"), " ", ichar("c") print"(a,i3,a,i3)","d --> ", iachar("d"), " ", ichar("d") print*

end program ex_03

program ex_04!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas adjustl e adjustr!---------------------------------------------------------------------------------------! Arquivo: ex_04.f03

! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=50):: linha




linha="Entre com uma letra"

print* print"(a50)"," 1 2 3 4 5" print"(a50)","12345678901234567890123456789012345678901234567890" print"(a50)",linha print"(a50)",adjustr(linha) print*

print*,"A régua foi colocada apenas para facilitar a visualização das colunas" print*,"observe como a linha está ajustada a esquerda e depois a direita" print* print*,"Veja agora a manipulação da constante literal 'de' " print*

print*,"Casa ", " de ", " madeira!" print*,"Casa ", adjustr(" de "), " madeira!" print*,"Casa ", adjustl(" de "), " madeira!" print*

end program ex_04

program ex_05!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas index!---------------------------------------------------------------------------------------! Arquivo: ex_05.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=19):: linha

linha="Entre com uma letra"

print* print"(a)"," 1111111111" print"(a)","1234567890123456789" print"(a19)",linha print* print"(a,i2)"," 'uma' inicia na posição ",index(linha,"um") print* print"(a,i2)"," 'com' inicia na posição ",index(linha,"com") print*

end program ex_05

program ex_06!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas len e len_trim !---------------------------------------------------------------------------------------! Arquivo: ex_06.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=19):: linha1character(len=40):: linha2

linha1="Entre com uma letra"linha2="Nova linha agora com tamanho 31"

print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a19)",linha1 print"(a40)",linha2 print*




print"(a,i2)","tamanho de linha1 = ", len(linha1) print"(a,i2)","tamanho de linha2 = ", len(linha2) print* print"(a,i2)","posições usadas na linha1 = ", len_trim(linha1) print"(a,i2)","posições usadas na linha2 = ", len_trim(linha2) print*

end program ex_06

program ex_07!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas trim !---------------------------------------------------------------------------------------! Arquivo: ex_07.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=19):: nome

print*,"Entre com seu nome"read*,nome

print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)","olá, "//nome//", como vai?" print"(a)","olá, "//trim(nome)//", como vai?" print*

end program ex_07

Ordem de arrumação – Sequência de arrumação – Ordenação

As funções LLE, LGE, LGT e LLT são funções que permitem verificar a arrumação dos caracteres do Fortran(a arrumação dos caracteres: quando os caracteres forem somente letras é o que chamamos de ordem alfabética).

sequência de arrumação: em inglês: collating sequence

Cada caractere do conjunto de caracteres do Fortran está arrumado numa lista onde cada caractere tem um peso(uma ordem – um número de posição). Não existem dois pesos iguais. O Fortran utiliza apenas95 caracteres (95 → 52 letras + 10 dígitos + 1 caractere sublinha + 32 caracteres especiais), entretanto o computador quevocê está usando, provavelmente tem mais caracteres disponíveis ( o código ASCII possuí 128 caracteres sendo quesomente 94 são caracteres imprimíveis. Se outro código for usado mais valores podem estar disponíveis). Nas máquinas queutilizam 95 caracteres os pesos dos caracteres variam de 0 a 94.

Geralmente o conjunto de caracteres utilizado é o ASCII, mas para as máquinas que utilizam o conjunto padrãodefault do Fortran a regra é a seguinte:

• as funções intrínsecas char e ichar provêm o mecanismo para a conversão entre os caracteres e osinteiros (pesos) usados na sequência do processador (computador em uso)Exemplo: ichar('d') retorna o valor inteiro referente ao caractere d

• para a sequência padrão default do Fortran (collating sequence) as regras que se aplicam são:1. ichar('A')<ichar('B')<... <ichar('Z') para as 26 letras maiúsculas2. ichar('0')<ichar('1')<... <ichar('9') para os 10 dígitos3. ichar(' ')<ichar('0')<... <ichar('9')<ichar('A') ou

ichar(' ')<ichar('A')<ichar('Z')<ichar('0')

4. ichar('a')<ichar('b')<... <ichar('z') para as 26 letras minúsculas5. ichar(' ')<ichar('0')<ichar('9')<ichar('a') ou

ichar(' ')<ichar('a')<ichar('z')<ichar('0')

Exceto para o caractere branco, não há restrições para a localização dos caracteres especiais e o sublinha.




Na prática o conjunto de caracteres adotado pelo Fortran é o ASCII. A partir do padrão Fortran 2003, oconjunto de caracteres adotado pode ser o UNICODE o que torna muito mais amigável o uso do Fortran.

program ex_08!!---------------------------------------------------------------------------------------

! Propósito: exemplo simples de uso das funções lle, lge, lgt e llt!---------------------------------------------------------------------------------------! Arquivo: ex_08.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=3):: st1="one", st2="two"

print* print*,"Lexicamente maior ou igual a ==> lge" print*,"Lexicamente maior que ==> lgt" print*,"Lexicamente menor ou igual a ==> lle" print*,"Lexicamente menos que ==> llt"

print* print*,"T = TRUE e F = FALSE" print* print* , "o resultado de lle('a','b') é ", lle('a','b') print* , "o resultado de lle('b','a') é ", lle('b','a') print* , "o resultado de lle('B','a') é ", lle('B','a') print* , "o resultado de lle('a','a') é ", lle('a','a') print* print* , 'o resultado de llt("one","two") é ', llt("st1","st2") print* , "o resultado de llt('ONE','TWO') é ", llt('ONE','TWO') print* , "o resultado de llt('one','TWO') é ", llt('one','TWO') print* , "o resultado de llt('s','m') é ", llt('s','m') print* print* , "o resultado de lge('sa','ma') é ", lge('sa','ma') print* , "o resultado de lgt('sag','sbg') é ", lgt('sag','sbg')

print*

end program ex_08

program ex_09!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas repeat!---------------------------------------------------------------------------------------! Arquivo: ex_09.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=19):: nome

print*,"Entre com seu nome"read*,nome

print* print"(a)","olá, "//nome//". "//"Como"//" Vai ?" print"(a)","olá, "//nome//". "//repeat("Como ",3)//repeat("Vai ",3)//"?" print* print"(a)","olá, "//trim(nome)//". "//"Como"//" Vai ?" print"(a)","olá, "//trim(nome)//". "//repeat("Como ",3)//repeat("Vai ",3)//"?" print*

end program ex_09




program ex_10!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas scan!---------------------------------------------------------------------------------------! Arquivo: ex_10.f03

! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=33)::texto="Escreva uma frase, contendo carro"

print* print*,"Identifica a primeira posição em que uma dos caracteres listados aparece no string" print*,"A frase que está sendo usada é :===> ""Escreva uma frase, contendo carro"" " print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)", texto print* print"(a,i2)", "yaq -->",scan(texto, "yaq")

print* print"(a,i2)", "eyz -->",scan(texto, "eyz") print* print"(a,i2)", "yqE -->",scan(texto, "yqE") print* print"(a,i2)", "m --> ",scan(texto, "m") print*

end program ex_10

program ex_11!!---------------------------------------------------------------------------------------! Propósito: exemplo simples de uso das funções intrínsecas verify!---------------------------------------------------------------------------------------! Arquivo: ex_11.f03! Autor: Anibal L. Pereira 08/02/2011!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=33)::texto="Escreva uma frase, contendo carro"

print* print*,"Identifica a primeira posição em que uma dos caracteres listados NÃO aparece nostring" print*,"Frase usada :===> ""Escreva uma frase, contendo carro"" " print*," Veja se há diferença entre letra maiúscula e minúscula" print*

print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)", texto print* print"(a,i2)", "aeiou -->",verify(texto, "aeiou") print* print"(a,i2)", "AEIOU -->",verify(texto, "AEIOU") print* print"(a,i2)", "AEIOUscrv -->",verify(texto, "AEIOUscrv") print*

end program ex_11





1. programa: decoracao_01 decoracao_01.f03

Exemplo:

O programa decoracao_01 mostra como um texto pode ser modificado e decorado

Você pode copiar e colar os códigos fontes, mas não deixe de ajustar a diagramação dos códigosfontes segundo o estilo de programação adotado na disciplina

Não deixe de atualizar o cabeçalho do programa de forma adequada.

________________________________________________________________________________________ ► arquivo: decoracao_01.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program decoracao_01!!---------------------------------------------------------------------------------------! Propósito: Programa simples que faz uso de:!! constante com nome caractere! variável caractere! operador concatenação! as funções intrínsecas caractere! -- repeat! -- trim ! descritor de formato alfanumérico! repetição do descritor A ! tabulador absoluto

! instrução IF!---------------------------------------------------------------------------------------! Arquivo: decoracao_01.f03! Autor: Anibal L. Pereira 29/07/2010!Revisões: Anibal L. Pereira 15/02/2011!!---------------------------------------------------------------------------------------implicit nonecharacter(len=15):: a1_n1, & ! primeira parte do nome do aluno 1

a1_n2, & ! segunda parte do nomea1_n3, & ! terceira ...a1_n4, & ! ...a1_n5, & ! ...a1_n6 ! sexta parte do nome

character(len=3)::deco ! decoração em usocharacter(len=*),parameter::pp1="===", & ! decoração 1

pp2="*=*", & ! decoração 2 pp3="(*)", & ! decoração 3 pp4="GGG", & ! decoração 4 pp5="&&&" ! decoração 5

!------------------------------------------------------------------------------------! escolha do tipo de decoração a ser usada na mensagem de instrução!------------------------------------------------------------------------------------!deco=pp1 ! faça a escolha do tipo de decoração a ser usada removendo o!deco=pp2 ! comentário em apenas uma das instrução de atribuição da variável deco!deco=pp3 ! execute o programa algumas vezes, escolhendo decorações diferentesdeco=pp4!deco=pp5

!-------------------------------------------------------------------------------! mensagem inicial!------------------------------------------------------------------------------- print* print"(a)", repeat(deco,26) print"(2a,t77,a)",deco," Você deve entrar com um nome composto de 6 partes:",deco




print"(a,t76,a)", deco,deco print"(2a,t77,a)",deco," Ao entrar com o nome de um aluno, caso não existam",deco print"(2a,t76,a)",deco," seis entradas no nome, complete com w ",deco print"(2a,t77,a)",deco," tantos w's quanto necessário para ter 6 partes", deco print"(a,t76,a)", deco,deco print"(2a,t77,a)",deco," Exemplo: João da Silva", deco print"(2a,t77,a)",deco," João da Silva w w w ",deco print"(a)", repeat(deco,26)

print*

!-------------------------------------------------------------------------------! Entrada do nome do aluno!------------------------------------------------------------------------------- print*,"Entre com o nome do primeiro aluno:"read*, a1_n1, a1_n2, a1_n3, a1_n4, a1_n5, a1_n6

!-------------------------------------------------------------------------------! Mostrando na tela do micro!-------------------------------------------------------------------------------

! Observe que a saída apresenta uma aparência desagradável quando:! (1) não se elimina os brancos dos nomes

! (2) não se elimina os W's dos nomes print* print"(a)", repeat(pp1,26) print*,"Escrevendo a mesma mensagem várias vezes com tratamento diferentes" print"(a)", repeat(pp1,26) print*! print"(a,a)","Entre com as notas P1 e P2 do aluno: ",a1_n1//a1_n2//a1_n3//a1_n4//a1_n5//a1_n6! print* print"(a,a)","Entre com as notas P1 e P2 do aluno: ",&

trim(a1_n1)//trim(a1_n2)//trim(a1_n3)//trim(a1_n4)//trim(a1_n5)//trim(a1_n6)! print* print"(a,a)","Entre com as notas P1 e P2 do aluno: ",&

trim(a1_n1)//" "//trim(a1_n2)//" "//trim(a1_n3)//" "//trim(a1_n4)&&//" "//trim(a1_n5)//" "//trim(a1_n6)

!--------------------------------------------------------! fazendo as variáveis ficarem vazias: para o w minúsculo!! a comparação entre os objetos é feita com os! dois sinais de iguais: ==! os dois iguais representam um teste, uma pergunta! por exemplo: A == B! significa A é igual a B ?!--------------------------------------------------------if(a1_n3 == "w") a1_n3 = ""if(a1_n4 == "w") a1_n4 = ""

if(a1_n5 == "w") a1_n5 = ""if(a1_n6 == "w") a1_n6 = ""!--------------------------------------------------------! para o W maiúsculo!--------------------------------------------------------if(a1_n3 == "W") a1_n3 = ""if(a1_n4 == "W") a1_n4 = ""if(a1_n5 == "W") a1_n5 = ""if(a1_n6 == "W") a1_n6 = ""! print* print"(2a)","Entre com as notas P1 e P2 do aluno: ",&

trim(a1_n1)//" "//trim(a1_n2)//" "//trim(a1_n3)//" "//trim(a1_n4)&&//" "//trim(a1_n5)//" "//trim(a1_n6)

print*

end program decoracao_01





1. programa: decoracao_02 decoracao_02.f03

Exemplo/Acréscimo/Ajuste:

O programa decoracao_02 mostra como um texto escrito na tela do micro com um arranjo tal que os nomes doselementos aparecem alinhados a esquerda na tabela.

<=><=><=><=><=><=><=><=><=><=><=><=><=><=> <=> 123456789012345 123456789012345 <=> <=> cobre 60% <=> <=> magnésio 2% <=> <=> hidrogênio 13% <=> <=> zircônio 5% <=> <=> molibdênio 10% <=> <=> radônio 10% <=> <=><=><=><=><=><=><=><=><=><=><=><=><=><=>

Escreva os códigos (modificando o programa) que:

1. mostre o mesmo quadro, mas utilizando o tabulador relativo TR

2. utilize a função intrínseca caractere adjustr de forma que a saída seja similar a

<=><=><=><=><=><=><=><=><=><=><=><=><=><=> <=> 123456789012345 123456789012345 <=> <=> cobre 60% <=> <=> magnésio 2% <=> <=> hidrogênio 13% <=> <=> zircônio 5% <=> <=> molibdênio 10% <=>

<=> radônio 10% <=> <=><=><=><=><=><=><=><=><=><=><=><=><=><=>

isto é, a coluna com os nomes dos elementos fique justificada a direita (alinhada à direta)

Observação: a decoração utilizada pode ser a de sua escolha

3. mostre o mesmo quadro, mas utilizando o descritor de formato posicional X

Não deixe de atualizar o cabeçalho do programa de forma adequada. ________________________________________________________________________________________

► arquivo: decoracao_02.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄ ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program decoracao_02!!---------------------------------------------------------------------------------------! Propósito: Programa simples que escreve uma tabela e faz uso de:!! variáveis caracteres! constante com nome caractere! substring! função intrínsecas caractere adjustr, repeat!!---------------------------------------------------------------------------------------! Arquivo: decoracao_02.f03

! Autor: Anibal L. Pereira 29/07/2010!Revisões:!---------------------------------------------------------------------------------------implicit nonecharacter(len=15):: n1="cobre", & ! 6 nomes

n2="magnésio", & !n3="hidrogênio", & !




n4="zircônio", & !n5="molibdênio", & !n6="radônio", & !num1="60%", & ! 6 númerosnum2=" 2%", & !num3="13%", & !num4=" 5%", & !num5="10%", & !

num6="10%" !

character(len=3)::deco ! decoração em usocharacter(len=*),parameter::u10="1234567890"character(len=*),parameter::pp1="===", & ! decoração 1

pp2="*=*", & ! decoração 2 pp3="(*)", & ! decoração 3 pp4="<=>", & ! decoração 4 pp5="xxx", & ! decoração 5 pp6="FFF" ! decoração 6

!------------------------------------------------------------------------------------! escolha do tipo de decoração a ser usada!------------------------------------------------------------------------------------

!deco=pp1!deco=pp2!deco=pp3deco=pp4!deco=pp5!deco=pp6!-------------------------------------------------------------------------------! mensagem inicial!------------------------------------------------------------------------------- print* print"(a)", repeat(deco,14) print"(a,t5,a,t15,a,t22,a,t32,a,t40,a)", deco,u10,u10(1:5),u10,u10(1:5),deco print"(a,t5,a,t22,a,t40,a)",deco,n1,num1,deco print"(a,t5,a,t23,a,t41,a)",deco,n2,num2,deco print"(a,t5,a,t23,a,t41,a)",deco,n3,num3,deco

print"(a,t5,a,t23,a,t41,a)",deco,n4,num4,deco print"(a,t5,a,t23,a,t41,a)",deco,n5,num5,deco print"(a,t5,a,t23,a,t41,a)",deco,n6,num6,deco print"(a)", repeat(deco,14) print*

!-------------------------------------------------------------------------------! Usando a tabulação relativa TR !-------------------------------------------------------------------------------

!(*)remova estas linhas!(*)escreva aqui os códigos que reproduza a mesma saída, mas usando o tabulador relativo

!-------------------------------------------------------------------------------! Usando a função intrínseca caractere adjustr!-------------------------------------------------------------------------------

!(*)remova estas linhas!(*)escreva aqui os códigos referentes a mesma saída, mas usando o adjustr

!-------------------------------------------------------------------------------! Usando o descritor de formato posicional X!-------------------------------------------------------------------------------

!(*)remova estas linhas!(*)escreva aqui os códigos que reproduza a mesma saída, mas usando o descritor de formato! posicional X

end program decoracao_02





1. programa: dia_semana dia_semana.f03

Fazer:

Escreva um programa que:

1. solicite que o usuário entre com um dos seguinte nome• segunda• terça• quarta• quinta• sexta• sábado• domingo

2. escreva na tela do micro uma mensagem similar a:• O dia da semana que você entrou foi: segunda-feira

O programa deve escrever o dia da semana que o usuário escolheu. Todos, menos sábado e domingo, terãoagregado a expressão “-feira” ao nome escolhido. Use o operador concatenação.

Obrigatório: A expressão “-feira” tem que estar definida numa constante com nome caractere.

Atividade 17

Entregar em meio magnético:1. programa: funcoes_caractere funcoes_caractere.f03

Exemplo/Acréscimo/Ajuste:

Modifique o programa funcoes_caractere de forma que:

os códigos acrescentados permitam ao programa realizar a mesma tarefa, mas utilizando funções intrínsecascaractere diferentes:

• verify• achar • iachar •

char • ichar

O programa deve fazer a mesma coisa sempre, mas utilizando funções intrínsecas diferentes.

Não deixe de atualizar o cabeçalho do programa de forma adequada.

________________________________________________________________________________________ ► arquivo: funcoes_caractere.f03 ◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄►◄

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ program funcoes_caractere!!----------------------------------------------------------------------------------------! Propósito: Programa simples que intenciona mostra o uso de algumas funções intrínsecas! caractere!----------------------------------------------------------------------------------------! Arquivo: funcoes_caractere.f03! Autor: Anibal L. Pereira 29/07/2010




!Revisões:!----------------------------------------------------------------------------------------implicit nonecharacter(len=21)::frase, & ! frase do usuário

c1="impossível possível", & ! primeira combinaçãoc2="possível impossível", & ! segunda combinaçãoce ! combinação fornecida

!------------------------------------------------------------------------------------! Define um valor default para a variável caractere ce!------------------------------------------------------------------------------------ce = c2

!------------------------------------------------------------------------------------! entrada da combinação escolhida pelo usuário!------------------------------------------------------------------------------------ print* print*,"--------------------------------------------------------" print*,"Como existe um espaço em branco entre as duas palavras" print*,"você tem que entrar o texto todo " print*,"entre aspas ( "" ) ou então entre apóstrofo ( ' )" print*,"--------------------------------------------------------"

print* print*,"Entre com o texto: impossível possível" print*," ou então: possível impossível" print*read*, frase

!------------------------------------------------------------------------------------! identifica qual combinação foi fornecida pelo usuário! se foi a primeira combinação, troca o valor de ce!! aqui se utiliza a função intrínseca caractere scan para localizar a! posição do caractere i no valor fornecido. A combinação fornecida pelo! teclado pode ser identificada pela posição do i: se ela for a posição 1! a combinação só pode ter sido: impossível possível!

! claro que aqui admite-se que não houve erro na digitação! do valor que está sendo fornecido!------------------------------------------------------------------------------------if(scan(frase,"i") == 1) ce=c1

!------------------------------------------------------------------------------------! mostra o resultado na tela do micro!------------------------------------------------------------------------------------ print*,"Você entrou com: ", ce

!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@!!!!!!!!!!!! escreva e coloque a partir daqui os códigos necessários para a utilização!!!!!!!!!!!! das funções intrínsecas caractere especificadas!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

!------------------------------------------------------------------------------------! usando a função verify!------------------------------------------------------------------------------------

<coloque aqui os códigos>

!------------------------------------------------------------------------------------! usando a função achar!------------------------------------------------------------------------------------


!------------------------------------------------------------------------------------! usando a função iachar

!------------------------------------------------------------------------------------


!------------------------------------------------------------------------------------! usando a função char!------------------------------------------------------------------------------------





!------------------------------------------------------------------------------------! usando a função ichar!------------------------------------------------------------------------------------


end program funcoes_caractere

fiscomp_fa-01_2011-1

Documents