Como determinar se um número é PAR ou ÍMPAR em FORTRAN

Acredito que a forma mais fácil de determinar se um número é PAR ou ÍMPAR em FORTRAN é utilizando a função intrínseca MOD(.), que retorna o resto de uma divisão. Se o resto de uma divisão por 2 é igual a zero, o número é par, se é igual a um, o número é ímpar.
Nesse caso, para determinar se X é par, tem-se:

!PARA O CASO DE X REAL:
IF ( MOD( X , 2.D0) == 0 ) THEN  !  ->  X é PAR!

!PARA O CASO DE X INTEIRO:

IF ( MOD( X , 2) == 0 ) THEN  !  ->  X é PAR!

Caso contrário, X é ÍMPAR.

COMO MODIFICAR ALGO QUE JÁ FOI ESCRITO NA TELA - MOSTRAR PORCENTAGEM DE PROCESSAMENTO...

"Modificar" algo que foi escrito na tela não é algo difícil. Neste post mostra-se como fazer isso em Windows, utilizando o Compaq Visual Fortran 6.6. O procedimento deve ser semelhante para outros compiladores e outros sistemas operacionais.
Basta declarar uso da biblioteca que permite manipular a saída padrão (Standard Output) obter o handle (identificador) da mesma, posicionar o cursor no local que se deseja modificar o que foi escrito, e escrever o que quiser.
Em outras palavras...

PROGRAM MAIN

USE DFLIB !PARA PODER UTILIZAR A FUNÇÃO SLEEP
USE DFWIN !PARA TER ACESSO ÀS FUNÇÕES RELACIONADAS AO CONSOLE
INTEGER :: I, HANDLE1 !UM INTEIRO PARA A PORCENTAGEM,
!OUTRO PARA O IDENTIFICADOR
TYPE(T_COORD) WPOS1 !PARA ARMAZENAR A POSIÇÃO
LOGICAL LSTAT1

!OBTENDO O IDENTIFICADOR DA SAÍDA PADRÃO
HANDLE1 = GETSTDHANDLE(STD_OUTPUT_HANDLE)

! POSIÇÃO ONDE SE VAI ESCREVER
WPOS1.X = 0 ! 0 CARACTERES PARA A ESQUERDA
WPOS1.Y = 0 ! 0 LINHAS PARA BAIXO

DO I=1,100
!POSICIONANDO
LSTAT1 = SETCONSOLECURSORPOSITION(HANDLE1, WPOS1)
!ESCREVENDO
WRITE(*,*) I,'%'
!ESPERANDO
CALL SLEEPQQ(200)
END DO

END PROGRAM MAIN

Convertendo CHARACTER para REAL ou INTEGER

Como esqueço o tempo todo como fazer essas conversões, decidi escrever aqui um resumo do processo.

Tomando-se as seguintes 3 variáveis:


CHARACTER(100) :: TEXTO
REAL*8 :: VALOR_REAL
INTEGER :: VALOR_INTEIRO


Se um "número" é armazenado no TEXTO, por exemplo:
TEXTO = '5.6987'
a conversão pode ser feita utilizando o READ() de forma bem simples.

READ(TEXTO,*) VALOR_REAL
READ(TEXTO,*) VALOR_INTEIRO.




Converter variáveis FORTRAN, conversão de variáveis, texto para número, caracter para real, caracter para inteiro.

Programa para renomear projetos: Compaq Visual Fortran 6.6

Depois de ter perdido muito tempo procurando como renomear um projeto dentro do Compaq Visual Fortran 6.6 e não conseguindo, terminei por descobrir uma forma de renomear o projeto fora do mesmo. O processo é bastante simples, mas decidi fazer um programa para torná-lo ainda mais fácil e rápido.

O pequeno programa, que trabalha em cima dos arquivos .dsw e .dsp, deve ser copiado para a pasta onde se encontram os arquivos .dsw e .dsp do projeto que se deseja renomear e lá executado. Depois de pedir o nome atual do projeto e o novo nome, o programa cria dois novos arquivos (um .dsw e um .dsp) com o novo nome. Verifique se está tudo ok com o projeto renomeado abrindo-o (abra o workspace '.dsw' no Developer Studio). Se tiver dado tudo certo você pode deletar os antigos arquivos .dsw e .dsp.

OBS.: É recomendável fazer um backup do projeto antes de utilizar este programa, pois o mesmo não foi testado exaustivamente, tendo sido feito apenas para suprir a necessidade do próprio autor.

Faça aqui do download do programa (450Kb), pelo rapidshare.

P.S.1: Caso você, leitor, se interesse pelo código fonte deste pequeno programa, deixe seu comentário neste post. Posso disponibilizar o projeto completo posteriormente.

ERROS COMUNS: Exponenciação - número negativo elevado a um potência real

Sabe-se que a expressão:

y = x ** n,

onde y e x são reais, e n é um inteiro, equivale a simplesmente multiplicar x por ele mesmo n vezes, e é isso exatamente que o computador faz ao encontrar uma expressão desse tipo.

No entanto, quando se tem algo do tipo:

y = x ** z,

onde y, x e z são reais, z pode ser igual a, por exemplo, 2.5. É fisicamente impossível multiplicar um número por ele mesmo 2.5 vezes, e portanto é necessário recorrer a métodos indiretos para calcular x ** z. O método mais comum para este caso é o seguinte:

x ** z = exp(z*ln(x)).

Portanto, como não existe logaritmo natural de número negativo, o seguinte "ERRO" pode ocorrer:

(-2.0)**(2.5) = NaN (Not a number)

( 2.0)**(2.5) = 5.656854.

ERROS COMUNS: Divisão em "modo misto"

Um erro bastante comum, do qual eu e alguns colegas já fomos vítimas, é a divisão envolvendo reais e inteiros. De uma forma geral, as expressões em "modo misto" devem ser evitadas, visto que são relativamente difíceis de entender e podem levar a resultados diferentes dos desejados.

Em operações aritméticas entre um número real e um inteiro, o inteiro é convertido para real pelo computador e o resultado é do tipo real.
Isso explica porque:

(1 + 1/2) = 1

(1. + 1/2) = 1.0

(1 + 1./2) = 1.5

(1 + 1/2.) = 1.5

No primeiro e no segundo caso ocorre que 1/2 = 0, por se tratar de uma divisão entre dois números inteiros. No terceiro e no quarto casos, 1./2 = 1/2. = 0.5, o inteiro é convertido para real e a aritmética para números reais é utilizada.

Portanto, é necessário ter atenção redobrada para casos tais como:

(2**(1/2)), que resulta igual 1, diferentemente de

(2**(1./2)) ou (2**(1/2.)), cujo resultado é 1.414214...

Como utilizar a Derivação automática? - EXEMPLO COMPLETO

Um exemplo de derivação automática com alguns comentários. O projeto COMPLETO, desenvolvido em Compaq Visual Fortran 6.6, pode ser baixado AQUI.
São três arquivos diferentes denominados no meu projeto como sendo: MAIN.F90, que contem o código PROGRAM TEST dado abaixo, FUNCOES.F90, que contem o módulo FUNCOES, também dado abaixo, e DERIV_CLASS.F90, o módulo de derivação cujo link está disponível no post Derivação Automática.

----------------- CÓDIGO PARA O MAIN.F90 ----------------------

PROGRAM TEST
USE DERIV_CLASS ! torna o módulo de derivação disponível
USE FUNCOES
INTEGER, PARAMETER :: TAM_X=3 !tamanho do vetor x
REAL*8 :: F_, X_(TAM_X), DF(TAM_X) !variáveis p/ armazenar valores de f, x e derivada
REAL*8 :: DDF(TAM_X * (TAM_X + 1) / 2) !variável p/ armazenar valor da 2a derivada
TYPE (FUNC) :: X(TAM_X), F !Para usar o módulo é preciso utilizar estes tipos

!Valores de X para os quais se deseja calcular a derivada
X_(1) = 1.0D0
X_(2) = 1.3D0
X_(3) = 1.8D0

! Zerando o valor da derivada até então
DF = 0.0D0
CALL DERIVATIVE(2) !declara a ordem da derivada - 2 indica 1a e 2a derivadas
! DECLARAR AS VARIÁVEIS INDEPENDENTES(X) E SEUS VALORES (X_)
CALL INDEPENDENT(1, X(1), X_(1)) !primeira variável independente
CALL INDEPENDENT(2, X(2), X_(2)) !segunda variável independente
CALL INDEPENDENT(3, X(3), X_(3)) !terceira variável independente
F = F1(X,TAM_X) !definindo q a função é calculada pela função f1, presente no módulo funcoes

!Extraindo valores das derivadas e mostrando os mesmo na tela.
CALL EXTRACT(F, DF, DDF)
WRITE(*, *) 'DF',DF
WRITE(*, *) 'DDF',DDF

END PROGRAM TEST


----------------- CÓDIGO PARA O MÓDULO FUNCOES ----------------------

MODULE FUNCOES

USE DERIV_CLASS

CONTAINS

FUNCTION F1(X,TAM_X) RESULT(Y)
INTEGER :: TAM_X
TYPE (FUNC) :: X(TAM_X), Y

!AQUI PODE SER ESCRITA QUALQUER FUNÇÃO DE X(TAM_X)
Y = 2*X(1)**2 + X(2)**3 + COS(X(3))

END FUNCTION

END MODULE FUNCOES


-------------------------MUITO IMPORTANTE -----------------------------------
----------------- ALTERAÇÃO NO MÓDULO DERIV_CLASS ----------------------
MODULE deriv_class IMPLICIT NONE
PRIVATE
INTEGER, PARAMETER :: n = 3 ! <<< AQUI precisa-se colocar o valor de tam_x

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

Como o código é aberto, podem ser feitas as alterações que o usuário achar necessário. Por exemplo, pode-se colocar o parâmetro n do módulo Deriv_class em função do TAM_X já declarado anteriormente.

Até mais.

Transformando letras maiúsculas em minúsculas... e vice-versa

Aqui se encontra uma forma de transformar letras maiúculas em minúsculas e vice-versa, baseada no fato de que a diferença entre os números de que representam as letras é uma constante (igual a 32), conforme pode ser visto na tabela abaixo (clique para ver a tabela no site da msdn - microsoft):

As funções principais utilizadas na subrotina são:
LEN_TRIM - Retorna o tamanho de um argumento de caracteres, sem contar os caracteres em branco após o último caractere não branco. (Tradução grosseira do help...).
IACHAR - Retorna o número (decimal) equivalente à letra.
ACHAR - Inverso de IACHAR. Retorna a letra equivalente ao número.

Uma subrotina que realiza a operação (para minúsculas e para maiúsculas):

SUBROUTINE LETRAS
CHARACTER(100) NOME
INTEGER :: I, J

WRITE(*,*) 'DIGITE SEU NOME:'
1 FORMAT (A$) !PERMITE LER TAMBÉM ESPAÇOS ENTRE OS NOMES. (EX.: PAULO SANTANA)
READ(*,1) NOME
WRITE(*,*) 'NOME INICIAL:',NOME

!MAIUSCULAS PARA MINUSCULAS:
DO I=1,LEN_TRIM(NOME)
J = IACHAR(NOME(I:I))
IF ((J>=65) .AND. (J<=90)) THEN !SE SE TRATAR DE LETRA MAIUSCULA
J = J + 32 !TRANFORMANDO EM MINÚSCULA
NOME(I:I) = ACHAR(J) !RETORNANDO A LETRA MINÚSCULA REFERENTE
END IF
END DO
WRITE(*,*) 'NOME EM MINUSCULAS:',NOME

!MINUSCULAS PARA MAIUSCULAS:
DO I=1,LEN_TRIM( NOME )
J = IACHAR(NOME(I:I))
IF ((J>=97) .AND. (J<=122)) THEN !SE SE TRATAR DE LETRA MINUSCULA
J = J - 32 ! TRANFORMANDO PARA LETRA MINÚSCULA
NOME(I:I) = ACHAR(J) !RETORNANDO A LETRA CORRESPONDENTE
END IF
END DO
WRITE(*,*) 'NOME EM MAIUSCULAS:',NOME

END SUBROUTINE

Espero que o código seja útil para vocês. Qualquer dúvida pode ser postada nos comentários...

Executando comandos DOS (ou programas externos) em Fortran

Demorei um tempo procurando isso, então decidi deixar arquivado aqui o como fazer, apesar de ser simples. É possível rodar um programa externo também utilizando a mesma sintaxe.

Basta declarar uso da biblioteca DFPORT:
USE DFPORT
E utilizar o código :
result = SYSTEM ('string contendo o comando')
OBS.: Não é necessário declarar a variável result.

Exemplo:
result = SYSTEM ('copy arq1.TXT arq2.TXT') !copia o arquivo arq1.txt sobre o arquivo arq2.txt

Para quem sabe pouco sobre DOS e quer aprender mais:
http://www.ziggi.com.br/downloads/apostila-msdos.asp - apostila grátis muito boa!.

Porque aprender FORTRAN?

Baseado nos escritos de John Mahaffy, da "Pennsylvania State University".

Outras coisa interessantes sobre FORTRAN podem ser encontradas em:
http://www.personal.psu.edu/jhm/f90/lectures/quickref.html

PORQUE aprender FORTRAN?


Primeiro aqui coloco minha tradução, e logo depois eu postarei o original, visto q meu inglês está em desenvolvimento. O texto é antigo (1997), mas interessante.

"Muitos de você têm ouvido falar hoje em dia que Fortran é uma linguagem obsoleta. Me disseram a mesma coisa quando eu comecei em 1968. A razão maior dessa noção é que as linguagens de programação são geralmente desenvolvidas e ensinadas por cientistas da computação. Fortran definitivamente não é a melhor linguagem para os tipos de aplicações encontrados na Ciência da Computação. A linguagem C foi desenvolvida para escrever sistemas operacionais, compiladores, e ourtas aplicações relacionadas. Como resultado, muitos que focaram nesses tópicos veem-na (a linguagem C) e suas relativas (C++) como as linguagens de escolha. Muitas outras linguagens tem vindo e ido através dos anos, com vários seguimentos.

FORTRAN foi desenvolvido pela IBM, especificamente para cálculos científicos. Padrões internacionais têm sido desenvolvidos e expandidos ao longo dos anos para prover uma sintax uniforme e um conjunto de funções de suporte para as necessidades de cálculo desses campos. Como resultado, a qtde de aplicações científicas e de engenharia desenvolvidas nos últimos 30 anos é imensa. Se nenhum novo programa científico fosse escrito em FORTRAN, o número de oportunidades de trabalho para suporte das aplicações existentes ainda seria imenso. Entretanto, com o desenvolvimento do padrão FORTRAN 90, Fortran continua a ser a primeira escolha para novos programas científicos..."

Até mais...