O Fortran possui uma vasta gama de opções de Entrada/Saída (I/O em inglês), as quais permitem diferentes tipos de arquivos se conectarem ao programa principal tanto para leitura quanto para gravação.

Em Fortran, um arquivo é conectado a uma unidade lógica definida por um rótulo (numero inteiro).

Cada unidade geralmente possui diversas propriedades conforme a Tabela 1.

Tabela 1. Propriedades de Unidades em Fortran

PropriedadeDescrição
ArquivoNome do arquivo conectado
AçãoLeitura, Gravação, Leitura e Gravação
StatusOLD, NEW, REPLACE
Método de AcessoSequencial ou Direto

NOTA – Neste texto, na descrição de sintaxe geral, os argumentos entre colchetes ‘[ ]’ são opcionais e entre ” são obrigatórios.

Comando OPEN

O comando OPEN é utilizado para conectar um arquivo em disco à uma unidade lógica e definir algumas características de conexão.

A sintaxe genérica do comando open tem a forma geral:

open(lista-de-especificadores)

OPEN([UNIT=], FILE=, ERR=, STATUS=, ACCESS=, ACTION=, RECL=)

Tabela 2. Características de conexão de unidades lógicas.

ArgumentosDescrição
UNITEspecifica um número de referência ao nome do arquivo
FILEEspecifica (entre aspas) o nome do arquivo que será conectado
ERREspecifica uma posição lógica de controle caso haja algum erro na abertura do arquivo
STATUSEspecifica (entre aspas) o estado do arquivo:
– ‘OLD’ – O arquivo já existe
– ‘NEW’ – O arquivo não existe, será criado 
– ‘REPLACE’ – O arquivo será sobrescrito
– ‘SCRATCH’ – O arquivo será temporários e será apagado quando fechado (CLOSE)
– ‘UNKNOWN‘ – Desconhecido, é a forma mais utilizada por padrão.
ACCESSEspecifica (entre aspas) o método de acesso:
– ‘DIRECT’ – Acesso direto a registros individuais, obriga o uso da opção RECL
– ‘SEQUENTIAL’ – Acesso sequencial, linha por linha
ACTIONEspecifica (entre aspas) o modo de acesso do arquivo:
– ‘READ’ – Abre somente para leitura
– ‘WRITE’ – Abre somente para gravação
– ‘READWRITE’ – Abre para leitura e gravação
RECLEspecifica o tamanho máximo de um registro aberto para acesso direto.

Exemplo:

OPEN(10,FILE=’arquivo_saida.txt’,ERR=100,STATUS=’REPLACE’,&
ACCESS=’SEQUENTIAL’,ACTION=’WRITE’)

OPEN(11,FILE=’arquivo_entrada.txt’,ERR=100,STATUS=’OLD’,&
RECL=exp,ACCESS=’DIRECT’,ACTION=’READ’)

Comando READ

A sintaxe genérica do comando read tem a forma geral:

read(lista-de-especificadores)

READ([UNIT=], [FMT=], IOSTAT=, ERR=, END=, EOR= ADVANCE=, REC=, SIZE=)

Existem algumas características de conexão que não podem ser utilizadas juntas.

Tabela 3. Características de conexão de leitura em unidades lógicas.

ArgumentoDescrição
UNITEspecifica um número de referência à unidade de leitura declarada em OPEN
FMTEspecifica (entre aspas) o formato da leitura dos dados
IOSTATCódigo de retorno. Qualquer valor diferente de Zero (0) significa erro
ERREspecifica uma posição lógica de controle caso haja algum erro na abertura do arquivo
ENDEspecifica uma posição lógica de controle caso ocorra erro de fim de arquivo
EOREspecifica uma posição lógica de controle casa ocorra erro de fim de registro
RECEspecifica o número do registro que deve ser lido no modo de acesso direto.
ADVANCEEspecifica ‘YES’ ou ‘NO’ se deve ou não iniciar a leitura em um novo registro
SIZERetorna para uma variável o numero de caracteres lidos

Exemplo

READ(10,FMT='(3(F10.7,1X))’,REC=exp) a,b,c

READ(*,'(A)’,ADVANCE=’NO’,EOR=12,SIZE=nch) str

Comando WRITE

A sintaxe genérica do comando write tem a forma geral:

write(lista-de-especificadores)

WRITE([UNIT=], [FMT=], IOSTAT=, ERR= ADVANCE=, REC=)

As características da conexão são as mesmas descritas na Tabela 3.

Exemplo

WRITE(10,FMT='(I4)’,IOSTAT=stat,ERR=100) valor

WRITE(*,'(I4)’,ADVANCE=’NO’)’Programador’

Comando CLOSE

O comando close() tem a seguinte sintaxe geral

close ([UNIT=]u)

Exemplo

close(unit = 10)

Fonte bibliográfica: Introdução ao Fortran 90 – Ricardo Almeida de Mendonça Küssel – Vers: Abril/2008 – Centro Nacional de Processamento de Alto Desempenho – SP – Universidade Estadual de Campinas


RESUMO

Arquivos: Escrita e Leitura

O Fortran permite ler e escrever em um ou mais arquivos através do uso dos comandos: OPEN, READ,WRITE, e CLOSE.

Abrindo e fechando arquivos

Antes de usar um arquivo, devemos abrir tal arquivo. O comando open é responsável para abrir arquivos para leitura e escrita.


O comando mais simples para abrir um arquivo é:

Exemplo

! Abrindo um arquivo
open (unit = 10, file = "dados.txt").

! Escrevendo no arquivo
write(10,*) "Oi Mundo"

! Depois de usar o arquivo, devemos fechar

! Fechando um arquivo
close(10)
JavaScript

Material Auxiliar

Código criado em aula do dia 18/05/2016

Exemplo

f(x)=sin(x)*(1-cos(x/3.0))

Esse exemplo demonstra a abertura de um arquivo para escrever dentro dele alguns dados. Esses dados serão os resultados de uma expressão matemática.

program outputdata
implicit none

real, dimension(100) :: x, y
real, dimension(100) :: p, q
integer :: i

! data

do i=1,100
    x(i) = i * 0.1
    y(i) = sin(x(i)) * (1-cos(x(i)/3.0))
end do

! output data into a file

open(1, file='data.txt', status='new')

do i=1,100
  write(1,*) x(i), y(i) 
end do

close(1)

end program outputdata
JavaScript

Quando o código fonte acima é implementado, compilado e executado, ele cria um arquivo chamado data.txt e escreve os valores de x e de y dentro dele e depois fecha o arquivo.

Gráfico para f(x)=sin(x)*(1-cos(x/3.0))

Lendo e escrevendo em um arquivo

Os comando read e write são usados respectivamente para ler em um arquivo e para escrever em uma arquivo.
Sintaxe geral:

read([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)
write([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)

em que os argumentos (especificadores) já foram mostrados nas tabelas no inicio deste documento.

Obs: O especificador END=s é um comando que especifica um rótulo para onde o programa deve se deslocar (jumps), quando ele encontra o final do arquivo.

Exemplo

Este exemplo demonstra a leitura e escrita em um arquivo. Neste programa vamos fazer a leitura do arquivo que geramos no exemplo anterior, data.txt, e mostrá-lo na tela.

program lerdados
real, dimension(100) :: x, y
real, dimension(100) :: p, q
integer :: i

! Gerando dados
do i=1,100
x(i) = i * 0.1
y(i) = sin(x(i)) * (1-cos(x(i)/3.0))
end do

! saída (escrevendo) de dados em um arquivo
open(1, file=’data.txt’, status=’new’)
do i=1,100
write(1,*) x(i), y(i)
end do
close(1) ! Fechando o arquivo 1

! abrindo o arquivo para leitura
open (2, file=’data.txt’, status=’old’)

do i=1,100
read(2,*) p(i), q(i)
end do

close(2) ! Fechando o arquivo 2

do i=1,100
write(*,*) p(i), q(i)
end do

end program lerdados

Saída na tela:

0.100000001  5.54589933E-05
0.200000003  4.41325130E-04
0.300000012  1.47636665E-03
0.400000006  3.45637114E-03
0.500000000  6.64328877E-03
0.600000024  1.12552457E-02
0.699999988  1.74576249E-02
0.800000012  2.53552198E-02
0.900000036  3.49861123E-02
1.00000000   4.63171229E-02
1.10000002   5.92407547E-02
1.20000005   7.35742599E-02
1.30000007   8.90605897E-02
1.39999998   0.105371222    
1.50000000   0.122110792    
1.60000002   0.138823599    
1.70000005   0.155002072    
1.80000007   0.170096487    
1.89999998   0.183526158    
2.00000000   0.194692180    
2.10000014   0.202990443    
2.20000005   0.207826138    
2.29999995   0.208628103    
2.40000010   0.204863414    
2.50000000   0.196052119    
2.60000014   0.181780845    
2.70000005   0.161716297    
2.79999995   0.135617107    
2.90000010   0.103344671    
3.00000000   6.48725405E-02
3.10000014   2.02930309E-02
3.20000005  -3.01767997E-02
3.29999995  -8.61928314E-02
3.40000010  -0.147283033    
3.50000000  -0.212848678    
3.60000014  -0.282169819    
3.70000005  -0.354410470    
3.79999995  -0.428629100    
3.90000010  -0.503789663    
4.00000000  -0.578774154    
4.09999990  -0.652400017    
4.20000029  -0.723436713    
4.30000019  -0.790623367    
4.40000010  -0.852691114    
4.50000000  -0.908382416    
4.59999990  -0.956472993    
4.70000029  -0.995793998    
4.80000019  -1.02525222    
4.90000010  -1.04385209    
5.00000000  -1.05071592    
5.09999990  -1.04510069    
5.20000029  -1.02641726    
5.30000019  -0.994243503    
5.40000010  -0.948338211    
5.50000000  -0.888650239    
5.59999990  -0.815326691    
5.70000029  -0.728716135    
5.80000019  -0.629372001    
5.90000010  -0.518047631    
6.00000000  -0.395693362    
6.09999990  -0.263447165    
6.20000029  -0.122622721    
6.30000019   2.53026206E-02
6.40000010   0.178709000    
6.50000000   0.335851669    
6.59999990   0.494883657    
6.70000029   0.653881252    
6.80000019   0.810866773    
6.90000010   0.963840425    
7.00000000   1.11080539    
7.09999990   1.24979746    
7.20000029   1.37891412    
7.30000019   1.49633956    
7.40000010   1.60037732    
7.50000000   1.68947268    
7.59999990   1.76223695    
7.70000029   1.81747139    
7.80000019   1.85418403    
7.90000010   1.87160957    
8.00000000   1.86922085    
8.10000038   1.84674001    
8.19999981   1.80414569    
8.30000019   1.74167395    
8.40000057   1.65982044    
8.50000000   1.55933595    
8.60000038   1.44121361    
8.69999981   1.30668485    
8.80000019   1.15719533    
8.90000057   0.994394958    
9.00000000   0.820112705    
9.10000038   0.636327863    
9.19999981   0.445154816    
9.30000019   0.248800844    
9.40000057   4.95488606E-02
9.50000000  -0.150278628    
9.60000038  -0.348357052    
9.69999981  -0.542378068    
9.80000019  -0.730095863    
9.90000057  -0.909344316    
10.0000000  -1.07807255    

DESAFIO:
1. Implemente o código anterior para:
a. Ler os dados de x no formato com uma casa decimal e y com 3 casas decimais.
b. Mostrar os dados de x no formato com uma casa decimal e y com 3 casas decimais.
c. Escrever no arquivo dados.txt x no formato com uma casa decimal e y com 3 casas decimais.


IDPGPF-1817

Verified by MonsterInsights