FORTRAN BR

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

2011-10-11T06:16:00.000-07:00

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...

2010-04-04T13:48:00.000-07:00

"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

Inserindo um CRONÔMETRO no seu programa - MEDIÇÃO DO TEMPO DE EXECUÇÃO

2010-03-23T09:11:00.001-07:00

Neste post é apresentado um cronômetro simples com interface gráfica mais simples ainda, que permite mostrar o tempo (em segundos) decorrido desde o início da execução de um código qualquer. A figura abaixo dá uma idéia do cronômetro supracitado (pequena caixa de diálogo que aparece no canto superior esquerdo da figura).

OBSERVAÇÃO: Primeiro de tudo, não esqueça que o acoplamento deste cronômetro ao seu código deixará sua aplicação um pouco mais lenta!

ACOPLANDO O CRONÔMETRO À SUA APLICAÇÃO

O primeiro passo é baixar o código fonte (um projeto completo utilizando o cronômetro, mostrado na figura acima), para isto basta clicar aqui e baixar o arquivo .zip hospedado no rapidshare!

No exemplo, o cronômetro foi inserido em um projeto FORTRAN CONSOLE APPLICATION. Tudo foi desenvolvido em Compaq Visual Fortran 6.6.

Após baixar os arquivos, copie ATUALIZA_CRON.F90, CRONOMETRO_DIALOG.rc e RESOURCE.fd para a pasta do seu projeto.

(Procedimento verificado apenas em CVF 6.6)

Com seu projeto aberto no CVF, clique no menu Project, vá em Add to Project e clique em Files. Adicione os arquivos CRONOMETRO_DIALOG.rc e RESOURCE.fd.

Na subrotina que você quer cronometrar, insira as definições para utilizar o cronômetro:

!******************************************************************
! DEFINIÇÕES PARA UTILIZAR O CRONÔMETRO
USE DFPORT !PARA USAR A FUNÇÃO TIMEF
USE DFLOGM
INCLUDE 'RESOURCE.FD'
TYPE (DIALOG) DLG
LOGICAL RETLOG
REAL*8 :: TEMPO
!******************************************************************

E logo após a definição das variáveis de sua subrotina, insira o código para inicializar o cronômetro:

!*******************************************************************
!INICIALIZANDO O CRONÔMETRO
RETLOG = DLGINIT(101,DLG) !INICIALIZANDO A CAIXA DE DIÁLOGO
IRET = DLGMODELESS(DLG) !IMPRIMINDO A CAIXA NA TELA (NÃO MODAL)
TEMPO = TIMEF() !INICIALIZANDO A CONTAGEM DO TEMPO
!*******************************************************************

PRONTO!!!

Agora é só chamar a subrotina que atualiza o tempo dentro dos principais loops da subrotina a ser cronometrada:

CALL ATUALIZACRON(DLG) !ATUALIZAR TEMPO MOSTRADO NA CAIXA DE DIÁLOGO

O CRONÔMETRO PODE SER MODIFICADO E MELHORADO CONFORME SUAS NECESSIDADES.

Para modificá-lo, vá em ResourceView e clique duas vezes em IDD_DIALOGTEMPO. A aba ResourceView fica imediatamente abaixo de onde aparecem os nomes dos arquivos do seu projeto.

Uma ótima referência sobre Interfaces Gráficas em CVF 6.6 é encontrada no post Desenvolver interfaces gráficas.

Comparação: MATMUL versus DGEMM (Multiplicação de Matrizes)

2010-03-22T09:28:00.000-07:00

Neste post é feita uma comparação de tempo de processamento (utilizando a função CPU_TIME) entre multiplicações de matrizes quadradas utilizando a função intrínseca MATMUL e a subrotina DGEMM da biblioteca IMSL.

Os dois casos explicados a seguir foram feitos para TAM = 1000, ou seja, para matrizes de tamanho 1000 x 1000.

PRIMEIRO CASO
Para o primeiro caso, as matrizes a serem multiplicadas (A*B) são definidas como:
DO i=1,TAM
DO j=1,TAM
A(i,j) = i + j
B(i,j) = i + j
END DO
END DO

SEGUNDO CASO
Para o segundo caso, as matrizes a serem multiplicadas (A*B) são definidas como:
DO i=1,TAM
DO j=1,TAM
A(i,j) = i - j
B(i,j) = i + j
END DO
END DO

RESULTADOS

Os resultados estão resumidos no seguinte gráfico:

Para os dois casos estudados, MATMUL foi cerca de 5 vezes mais lento que DGEMM.

CONCLUSÕES

Caso você tenha acesso à biblioteca IMSL, vale a pena gastar um pouco de tempo substituindo a função MATMUL pela DGEMM em todos os seus programas que utilizem multiplicação de matrizes.

Caso não tenha acesso a esta biblioteca, vale a pena ver se há outra subrotina que você possa utilizar no lugar da MATMUL e fazer uma breve comparação entre elas.

Comparação (de velocidade de processamento): mesclando código .FOR + .F90, usando ou não subrotinas (funções)...

2010-03-21T06:57:00.000-07:00

O QUE É COMPARADO?

Neste post são comparados alguns resultados (de tempo de processamento) para a realização de um conjunto determinado de operações, englobando os casos a seguir. Todos os exemplos foram desenvolvidos utilizando o Compaq Visual Fortran 6.6.

1. F90
O código é todo escrito em Fortran 90. São feitos dois arquivos, MAIN.F90 e FUNC.F90. O programa MAIN chama a função presente em FUNC.F90 um total de NUM_ITE vezes, e repete o procedimento um total de NUM_REPETICOES vezes, obtendo a média do tempo de processamento.

2. F90 + FOR
Semelhante ao caso .F90, sendo que o arquivo MAIN é um .F90, e o arquivo FUNC é um .FOR (formato fixo).

3. F90 Direto
O arquivo FUNC deixa de existir, as operações são inseridas no arquivo MAIN diretamente. O código é todo escrito em F90.

4. FOR Direto
Semelhante ao F90 Direto, mas o código é todo escrito em formato fixo (.FOR).

5. F90 mesclado
Todo o código do arquivo FUNC é inserido após o fim do programa MAIN, de forma que se trabalha com uma subrotina (função) à parte, mas tanto o programa quanto a função ficam presentes no mesmo arquivo. Todo o código é escrito em formato livre (.F90).

6. FOR mesclado
Semelhante ao F90 mesclado, mas o código é escrito em formato fixo.

QUAIS SÃO AS OPERAÇÕES EFETUADAS?

Foram executados três exemplos com diferentes conjuntos de operações, para todos os casos NUM_REPETICOES = 3 (para efetuar a média de tempo de processamento).

PRIMEIRO CONJUNTO DE OPERAÇÕES
Y = X**2
Y = Y + 0.02D0
NUM_ITE = 1E9

SEGUNDO CONJUNTO DE OPERAÇÕES
Y = X**2
Y = Y + 0.02D0
Y = SQRT(Y)
Y = Y/2.25D0
NUM_ITE = 5E8

TERCEIRO CONJUNTO DE OPERAÇÕES
Y = X**2.2D0
Y = Y + 0.0225D0
Y = SQRT(Y)
Y = SIN(Y)
Y = Y/2.25673D0
Y = COS(Y)
NUM_ITE = 5E7

QUAIS FORAM OS RESULTADOS?

O tempo de processamento para cada caso é mostrado na figura abaixo.

CONCLUSÕES

Para os casos estudados:

1 - Mesclar códigos escritos em .FOR com códigos em .F90 não leva a grandes diferenças de custo computacional.

2 - Utilizar subrotinas (funções) em diferentes arquivos ou mescladas num mesmo arquivo não leva a grandes diferenças também.

3 - Efetuar as operações diretamente no código principal é mais rápido do que efetuar as operações em subrotinas (funções) à parte. No entanto, à medida que a complexidade das operações aumenta, o custo de chamada da função perde importância.

Portanto, para grandes problemas (com operações complexas) a clareza de código obtida utilizando subrotinas supera de longe o acréscimo de custo computacional.

4 - Para problemas mais complexos (conjunto de operações 3) todos os seis casos apresentaram praticamente o mesmo custo computacional.

-------------------- x ----------------------- x -----------------------

MATLAB versus FORTRAN - 1 - somatório simples

2009-12-13T03:55:00.000-08:00

Pretendo fazer algumas comparações entre MATLAB e FORTRAN, e este é o primeiro post com tal objetivo. Dois aspectos principais serão verificados: a quantidade de linhas do código fonte, que se relaciona com a facilidade de escrita na linguagem, e o tempo de processamento, que está diretamente vinculado ao tempo de execução. Como se sabe, o MATLAB, por ser uma linguagem interpretada (sem geração de código executável) tende a ser mais lento, no entanto, existem muitas facilidades no mesmo que diminuem o tempo de programação requerido.

No intuito de medir o tempo nos dois ambientes sem que haja muita diferença no método de medição, optou-se por utilizar as funções tic e toc, no MATLAB, e a função TIMEF() do FORTRAN (biblioteca DFPORT). A descrição destas funções é a seguinte:

O primeiro exemplo é um somatório simples, para i variando de 1 a 1 bilhão, conforme o código abaixo (em MATLAB):

j=0;
tic
for i=1:1000000000
j=j+1;
end
toc

O número de linhas do código fonte foi de 6 linhas para o MATLAB contra 10 linhas do FORTRAN (sem contar cabeçalho e finalização da função).

O tempo médio de execução para 10 repetições é mostrado a seguir:

Verificou-se que, para este exemplo, o MATLAB foi quase duas vezes mais lento que o FORTRAN.

VISITAS... Onde se programa em FORTRAN no Brasil?

2009-10-29T11:42:00.000-07:00

Este post traz apenas uma curiosidade: as visitas a este blog no mês de outubro (na verdade de 28 de setembro a 28 de outubro) divididas por cidade. Dá pra se ter uma idéia superficial de lugares nos quais o FORTRAN tem sido utilizado no Brasil... Rio de Janeiro aparece em primeiro lugar com 25 visitas, seguido por Salvador com 20 visitas e São Paulo com 19 visitas.

O Blog recebeu ainda 20 visitas internacionais este mês.

Agradeço a todos que visitaram o Fortran-BR, e peço que deixem mais comentários nos posts ou, pelo menos, digam o que acharam por meio das reações ao final de cada post (péssimo, ruim, bom, interessante...). Até mais!

OBS.: Os dados das visitas foram obtidos por meio do serviço Google Analytics.

Convertendo CHARACTER para REAL ou INTEGER

2009-10-29T10:10:00.000-07:00

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.

Overflow condition - números inteiros em Fortran

2009-10-19T08:10:00.000-07:00

Uma pequena explicação sobre números inteiros e "overflow condition".
A chamada overflow condition ocorre quando se tenta armazenar numa variável do tipo inteiro um número maior que o valor máximo possível ou menor que o valor mínimo possível.
Esses limites existem pois, quando declaramos uma variável, um determinado espaço de memória é reservado para guardar o valor da tal variável.
Considerando um inteiro de n bits, usualmente o menor número que pode ser armazenado é dado por:
menor_valor_inteiro = -2**(n-1)
e o maior valor é dado por:
maior_valor_inteiro = 2**(n-1) -1 !(O '-1' é o espaço reservado ao zero) .

O tipo mais comum de inteiros nos computadores de hoje em dia são os inteiros de quatro bytes (1 byte = 8 bits; 4 bytes = 32 bits), que, portanto, podem armazenar qualquer número inteiro entre -2,147,483,648 e 2,147,483,647.

Portanto, se você tiver problemas com overflow condition, a solução pode ser simplesmente ter que trocar um INTEGER por um INTEGER*8.

Programa para renomear projetos: Compaq Visual Fortran 6.6

2009-08-04T06:21:00.000-07:00

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

2009-07-31T11:49:00.000-07:00

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"

2009-07-31T11:22:00.000-07:00

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...

Comparação - ACESSANDO MATRIZES... (RANK 2 ARRAYS)

2009-07-06T12:44:00.000-07:00

Acho que muitos já devem saber (ou ter ouvido falar) que o fortran guarda matrizes na memória "coluna por coluna". Dessa forma, o acesso às mesmas deve ser feito também coluna por coluna, para maior velocidade de execução. O conceito de coluna varia um pouco quando se trabalha com matrizes de mais de duas dimensões, mas de uma forma geral os loops mais internos devem se referir à dimensão mais à esquerda da matriz.
Por exemplo, com uma matriz de três dimensões se teria:

!LOOP mais rápido
DO K=1,N3
DO J=1,N2
DO I=1,N1
A(I,J,K) = ...
END DO
END DO
END DO

Qualquer alteração da ordem desses LOOPs resulta num código mais lento.

Tomando-se o caso de duas dimensões apenas, qual seria a diferença de velocidade do loop mais rápido para o mais lento?

Na busca por respostas para essa pergunta, foi desenvolvido um pequeno projeto no Compaq Visual Fortran 6.6 ( 288Kb). Para uma matriz A de dimensão NxN, onde N=5000, foram rodados 20 vezes os códigos que permitiram colocar o valor de cada elemento da matriz como sendo
A(I,J) = A(I,J) + I**2 + J**2,
acessando linha por linha (mais lento) e coluna por coluna (mais rápido).
O tempo médio e o tempo médio relativo foram obtidos para comparação.
Os resultados foram os seguintes:

Ou seja, para este caso específico a diferença já mostrou ser muito grande. O acesso coluna por coluna chega a ser quase 5 vezes mais rápido que o acesso linha por linha. Um bom motivo para varrer seus códigos-fonte e excluir os loops coluna por coluna deles sempre que possível.

CONCLUSÃO da comparação - LOOPs (DO x DO WHILE x DO "INFINITO")

2009-06-19T11:04:00.000-07:00

Após a exposição do caso (http://fortranbr.blogspot.com/2009/06/comparacao-loops-do-x-do-while-x-do.html) e a apresentação de um resultado, seguiu-se longa discussão na comunidade Fortran Brasil. O mesmo projeto foi testado com diferentes casos e diferentes compiladores. Agradecimentos ao pessoal que participou da discussão na comunidade, em especial ao Alexandre, que foi o "causador" da mesma.

ALGUMAS CONCLUSÕES...
O tipo de loop mais rápido varia com os códigos executados no loop e depende também do compilador. De qualquer forma, nos casos em que o DO WHILE foi melhor que os outros, os outros ficaram muito próximos. E no geral o loop do tipo DO foi o que se saiu melhor, pois ele é o mais rápido em alguns casos, e nas vezes que não é ainda assim fica bem próximo do melhor.

Esse loop seria definido genericamente por:
CASO 1 : LOOP DO
DO I=1,N
.
.
.
END DO

E seria "o mais rápido" dos três casos verificados.

Comparação - LOOPs (DO x DO WHILE x DO "INFINITO")

2009-06-18T12:46:00.000-07:00

Efetuei uma pequena comparação entre Loops utilizando DO, DO WHILE e DO "INFINITO", baseada na afirmação de Francisco Franco, proprietário da comunidade do orkut Fortran Brasil [], de que o DO WHILE é mais lento que os outros dois.
Os Loops em estudo são definidos genericamente da seguinte forma, onde N é um inteiro:

CASO 1 : LOOP DO
DO I=1,N
.
.
.
END DO

CASO 2 : LOOP DO WHILE
DO WHILE (I<=N) .
.
.
I = I + 1
END DO

CASO 3 : LOOP DO "INFINITO"
LOOP1 : DO
.
.
.
I = I + 1
IF (I==N) EXIT LOOP1
END DO LOOP1

Os resultados INICIAIS encontrados, apresentados na tabela abaixo, confirmaram que o DO WHILE é mais lento que os outros loops acima mostrados.

A tabela mostra os valores obtidos para uma função qualquer, comprovando que a mesma coisa estava sendo calculada nos três casos. Foram feitos dois loops, um dentro do outro, com N=25000, ou seja, 625 milhões de cálculos da função (X = X + (-1**J)*X/N, onde J varia em um dos loops). Tomou-se um tempo relativo ao tempo do Loop Do "Infinito".
Constatou-se PARA ESTE N ESPECÍFICO que o caso 2 demora cerca de 2% a mais de tempo do que a referência, enquanto que o caso 3 leva cerca de 0,7%.

O estudo foi feito utilizando o Compaq Visual Fortran 6.6, e o projeto completo está disponível para download aqui (294Kb).

ATUALIZAÇÃO:
Este mesmo post gerou discussões e mais discussões na comunidade supracitada. Algumas conclusões podem ser vistas AQUI.

Apostila Visual FORTRAN - Desenvolver interfaces

2009-06-12T07:04:00.000-07:00

Apostila que aborda desde o básico até aspectos de desenvolvimento de Interfaces Gráficas de Usuário (GUIs) em FORTRAN, desenvolvida por Wilton Pereira da Silva, Cleiton e Cleide Maria D. P. S. e Silva. A apostila em formato PDF pode ser baixada diretamente neste link num único arquivo zipado (1934KB), ou, se preferir, você pode baixar a versão dos autores neste link, em formato hlp, e que necessita instalação de um pequeno aplicativo.
Os códigos fonte desenvolvidos podem ser baixados AQUI. E a página dos autores sobre o tutorial é a seguinte:
http://br.geocities.com/pextensao/vf.html .

Até mais.

Otimização de códigos FORTRAN

2009-06-11T10:31:00.000-07:00

Guia RÁPIDO de OTIMIZAÇÃO de códigos FORTRAN visando maior VELOCIDADE de execução...
Detalhes muito interessantes que encontrei no site da Pós Graduação em Engenharia Civil da UFRGS. Vale a pena dar uma lida:
http://www.cpgec.ufrgs.br/masuero/otimizacao/otimizacao.htm .

Apostilas básicas de FORTRAN.

2009-06-09T06:12:00.000-07:00

Cinco apostilas de FORTRAN básico para download em um arquivo zipado (950KB):

http://rapidshare.com/files/242607414/Apostilas-FORTRAN_fortranbr.blogspot.com.zip .

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

2009-06-05T06:26:00.000-07:00

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.

Derivação automática

2009-06-03T04:55:00.000-07:00

Qual a melhor forma para derivar uma função? Pensando sobre essa questão, a primeira referência que me veio à cabeça foi a das notas de aula da disciplina de Metódos Numéricos (ou no link em memória cache do google), acredito que seja da Pós-Graduação, do departamento de engenharia química da UFRGS. Infelizmente não sei quem foi que escreveu a apostila.

A solução que mais me chamou a atenção foi a da Derivação automática. Pelas razões encontradas na tabela das notas de aula:

e pela existência de um código fonte disponível para FORTRAN que efetua tal operação.
Trata-se do AUTO_DERIV, desenvolvido por S. Stamatiadis, R. Prosmiti e S. C. Farantos, da "University of Crete" (Grécia) e do "Institute of Electronic Structure and Laser Foundation for Research and Technology - Hellas".

O código permite calcular a primeira e a segunda derivadas parciais de qualquer função contínua com muitas variáveis independentes. Além disso, a função a ser derivada pode depender de outras várias subrotinas ou funções escritas em linguagem Fortran 90 ou 77.
Um artigo completo sobre o código fonte está disponível.

O código fonte (+ exemplos) pode ser baixado direto por este link retirado deste site, ou pelo site http://cpc.cs.qub.ac.uk/summaries/ADLS, que parece estar fora do ar por algum tempo.

Qualquer dúvida sobre a utilização do programa pode ser colocada em comentários aqui ou na comunidade do orkut: Fortran 90/95/2003 BR.
Até mais.

PARSER - avaliador de Expressões - f(x) = sin(x) + x**2 ... automaticamente.

2009-05-29T11:07:00.000-07:00

Um avaliador de expressões, como o próprio nome já diz, permite avaliar expressões diretamente, sem ser necessário criar uma função para efetuar tal avaliação. É possível, por exemplo, determinar o valor de uma função qualquer dada pelo usuário durante a execução de um programa (a função é armazenada em uma string), ou ler funções de um bloco de texto, interpretá-las e retornar o valor da função para determinados valores das variáveis da mesma.

Aqui trago a referência para um PARSER BRASILEIRO GRATUITO, que já utilizei em alguns trabalhos e que, segundo testes dos autores, apresenta desempenho melhor que outros PARSERs gratuitos existentes (um australiano e um alemão).

O PARSER foi desenvolvido por professores e alunos da Universidade Federal de Campina Grande e do ITA (Instituto Tecnológico da Aeronáutica), conforme pode ser visto no artigo
publicado no Science & Engineering Journal de 2005.

Mais detalhes sobre o PARSER e DOWNLOAD GRATUITO do mesmo podem ser encontrados em

http://br.geocities.com/pextensao/programetes/functionparser/brfunctionparser.html.

Download direto do código fonte AQUI.

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

2009-05-28T05:17:00.000-07:00

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

2009-05-27T07:59:00.000-07:00

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?

2009-05-21T05:49:00.000-07:00

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...

Why learn Fortran? - Original

2009-05-21T05:47:00.000-07:00

A versão original do texto de John Mahaffy - http://www.personal.psu.edu/jhm/f90/lectures/quickref.html

"Many of you have by now been told that Fortran is an obsolete language. I was told the same thing when I started in 1968. A major reason for this notion is that computer languages are generally developed and taught by Computer Scientists. Fortran is unquestionably not the best language for the types of applications found in Computer Science. The C language was developed for writing operating systems, compilers, and other related applications. As a result, many focused on these disciplines, see it and its relatives (C++) as the languages of choice. Many other languages have come and gone over the years, with varying followings.

Fortran (Formula Translation System) was developed by IBM specifically for performing scientific calculations. International language standards have been developed and expanded over the years to provide a uniform language syntax and set of supporting functions for all calculational needs in these fields. As a result, the body of scientific and engineering applications that have been developed over the last 30+ years is immense. If no new scientific programs were written in Fortran, the number of job opportunities supporting existing applications would still be quite large. However, with the release of the Fortran 90 language standards, Fortran continues to be the first choice for new scientific programs, and is the focus of efforts to develop computationally intensive applications for new generations of parallel and vector computers, through the use of an extention of Fortran 90 called High Performance Fortran (HPF)."

Até mais.