Neste tutorial trago um algoritmo simples, escrito em Fortran, que permite encontrar os números primos de 1 até um valor n, informado pelo usuário durante a execução do programa, para isso usando o algoritmo clássico conhecido como Crivo de Eratóstenes.

Números primos são números naturais maiores que 1 que têm apenas dois divisores: 1 e eles mesmos. Em outras palavras, são números que não podem ser divididos por nenhum outro número além de 1 e deles mesmos sem resultar em um resto.

Exemplos de números primos incluem 2, 3, 5, 7 e 11.

A propriedade fundamental dos números primos é que não podem ser formados multiplicando dois números inteiros diferentes entre si. A compreensão dos números primos é crucial em matemática, e sua identificação desempenha um papel fundamental em áreas como criptografia e teoria dos números.

O Crivo de Eratóstenes é um algoritmo antigo e eficiente para encontrar todos os números primos até um determinado limite. Ele funciona marcando os múltiplos de cada número primo encontrado, eliminando números compostos e deixando apenas os números primos. O algoritmo realiza iterações até que todos os números até o limite desejado sejam verificados.

Trata-se de uma maneira bastante eficaz de encontrar rapidamente todos os números primos dentro de um intervalo específico.

De acordo com a tradição, o Crivo de Eratóstenes foi criado pelo matemático grego Eratóstenes de Cirene por volta de 240 a.C., sendo assim uma das técnicas mais antigas conhecidas para encontrar números primos.

Busto de Eratóstenes

Neste tutorial vamos implementar este algoritmo usando a linguagem de programação Fortran.

Funcionamento do Crivo de Eratóstenes

O algoritmo do Crivo de Eratóstenes funciona da seguinte maneira:

1. Inicialização:
   Começamos criando uma lista de números a partir de 2 até o valor limite desejado pelo usuário.
   Marcamos todos esses números como não riscados, indicando que inicialmente consideramos todos como primos.
2. Seleção do Próximo Número:
   Começamos com o primeiro número não riscado, que é o 2.
   Este número é então marcado como primo, já que é o menor número não riscado (e 2 é o primeiro número primo).
3. Eliminação dos Múltiplos:
   Agora vamos riscar todos os múltiplos do número primo que acabamos de encontrar, até chegar no valor limite.
   No caso, riscamos todos os múltiplos de 2 (4, 6, 8, 10, 12, …).
4. Seleção do Próximo Número Não Riscado:
   Após riscar os múltiplos do número anterior, vamos nos mover para o próximo número não riscado na lista, que é o próximo número primo.
5. Repetição:
   Repetimos os passos 3 e 4 até que tenhamos marcado todos os números não riscados como primos ou não primos.

Ao final do processo, os números que permanecem não riscados são os números primos dentro do intervalo desejado. O Crivo de Eratóstenes é eficiente porque evita a verificação de múltiplos de números que já foram marcados como não primos, reduzindo significativamente o número de iterações necessárias.

Visualmente, o que o crivo de Eratóstenes equivale ao seguinte:

	0	1	2	3	4	5	6	7	8	9
0	1	2	3	4	5	6	7	8	9	10
1	11	12	13	14	15	16	17	18	19	20
2	21	22	23	24	25	26	27	28	29	30
3	31	32	33	34	35	36	37	38	39	40
4	41	42	43	44	45	46	47	48	49	50
5	51	52	53	54	55	56	57	58	59	60
6	61	62	63	64	65	66	67	68	69	70
7	71	72	73	74	75	76	77	78	79	80
8	81	82	83	84	85	86	87	88	89	90
9	91	92	93	94	95	96	97	98	99	100

Podemos ver que os números primos estão destacados (check verde), ao passo que os números múltiplos, que não são primos, são descartados (x vermelho).

Este algoritmo é bastante empregado em matemática computacional e é uma abordagem clássica para encontrar números primos.

Vejamos agora como implementar esse algoritmo usando uma linguagem de programação – no caso, o Fortran.

Código em Fortran

program CrivoDeEratostenes
implicit none

integer, parameter :: MAX_N = 1000000
integer :: n
logical :: e_primo(MAX_N)
integer :: i, j

! Inicializar o vetor de primos como verdadeiro
e_primo = .true.

! Solicitar ao usuário que insira o valor de 'n'
write(*,*) 'Digite um número inteiro positivo n:'
read(*,*) n

! Verificar se o valor de n está dentro dos limites permitidos para números primos
if (n <= 1 .or. n > MAX_N) then
    write(*,*) 'Valor de n fora dos limites permitidos.'
    stop
end if

! Algoritmo do Crivo de Eratóstenes
do i = 2, n
    if (e_primo(i)) then
        do j = 2*i, n, i
            e_primo(j) = .false.
        end do
    end if
end do

! Exibir os números primos encontrados
write(*,*) 'Números primos de 1 até', n, ':'
do i = 2, n
    if (e_primo(i)) then
        write(*,*) i
    end if
end do

end program CrivoDeEratostenes

Teste

Para testar, vamos pedir ao programa para retornar todos os números primos até o valor 500.000 (quinhentos mil!):

Resultado (truncado):

2
3
5
7
11
...
499943
499957
499969
499973
499979

Explicação do Código

E como exatamente funciona esse código? Vejamos uma explicação passo a passo:

1. Declaração de Variáveis – Começamos declarando algumas variáveis:

• MAX_N: Valor máximo permitido para n (limite superior para encontrar números primos).
• n: Número que será fornecido pelo usuário.
• e_primo: Um array lógico que indica se um número é primo (TRUE) ou não (FALSE).
• i e j: Índices para iteração.

2. Inicialização:

• e_primo = .TRUE.: Inicializa o vetor de primos como verdadeiro.

3. Entrada do Usuário:

• write(*,*) ‘Digite um número inteiro positivo n:’: Solicita ao usuário que insira um número inteiro positivo.
• read(*,*) n: Lê o valor inserido pelo usuário.

4. Verificação do Limite:
– if (n <= 1 .or. n > MAX_N) then: Verifica se o valor de n está dentro dos limites permitidos para números primos.
– write(*,*) ‘Valor de n fora dos limites permitidos.’: Exibe uma mensagem de erro se o valor de n estiver fora dos limites.
– stop: Encerra o programa.

5. Algoritmo do Crivo de Eratóstenes:
– A estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– A estrutura de repetição interna do j = 2*i, n, i marca todos os múltiplos de i como não primos, já que eles são divisíveis por i.

6. Saída dos Números Primos Encontrados:
– write(*,*) ‘Números primos de 1 até’, n, ‘:’: Exibe uma mensagem indicando que os números primos estão sendo mostrados.
– A segunda estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– write(*,*) i: Exibe o número primo.

Conclusão

Neste artigo vimos como empregar a técnica do Crivo de Eratóstenes para determinar números primos na linguagem de programação Fortran. Esse mesmo código pode ser adaptado para outras linguagens, como Python, C++, C# ou Rust, de acordo com sua necessidade.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Calcular números primos com Crivo de Eratóstenes em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Hoje vamos codificar um pequeno programa que permite calcular as raízes de uma equação quadrática polinomial (equação de segundo grau), usando a linguagem Fortran.

Relembrando: uma equação de 2º Grau tem o seguinte formato:

ax² + bx + c = 0

Nesta equação, o valor x é chamado de “incógnita”, e indica um valor desconhecido. Já as variáveis a, b e c são os coeficientes da equação.

Para resolver uma equação de segundo grau, precisamos determinar os valores reais da incógnita x que tornam a equação verdadeira. Esses valores são as raízes da equação.

Uma equação do segundo grau pode ter zero, uma ou no máximo duas raízes reais. No caso de não ter raízes reais, ela ainda possui raízes complexas – caso que nosso programa também será capaz de calcular.

Vamos ao código.

Código

PROGRAM EQ_SEG_GRAU
IMPLICIT NONE

! Declaração das variáveis
REAL :: a
REAL :: b
REAL :: c
REAL :: delta
REAL :: part_imag
REAL :: part_real
REAL :: x1
REAL :: x2

!Entrada do usuário: coeficientes da equação
WRITE (*,*) 'Programa que calcula as raízes de uma equação de segundo grau'
WRITE (*,*) 'Equação no formato a * x2 + b * x + c = 0'
WRITE (*,*) 'Digite os coeficientes A, B e C:'
READ (*,*) a, b, c

!Coeficientes:
WRITE (*,*) 'Os coeficientes fornecidos A, B e C são: ', a, b, c

!Calcular o delta (discriminante)
delta = b**2 - 4 * a * c

! Calcular as raízes
IF (delta > 0.) THEN ! Existem duas raízes reais
  x1 = (-b + sqrt(delta)) / (2. * a)
  x2 = (-b - sqrt(delta)) / (2. * a)
  WRITE(*,*) 'A equação possui duas raízes reais:'
  WRITE(*,*) 'x1 = ', x1
  WRITE(*,*) 'x2 = ', x2
ELSE IF (delta == 0.) THEN ! Há apenas uma raiz real, repetida
  x1 = (-b) / (2. *a)
  WRITE(*,*) 'A equação possui duas raízes reais idênticas:'
  WRITE(*,*) 'x1 = x2 = ', x1
ELSE ! A equação possui raízes complexas
  part_real = (-b) / (2. * a)
  part_imag = sqrt(abs(delta)) / (2. * a)
  WRITE(*,*) 'A equação possui raízes complexas:'
  WRITE(*,*) 'x1 = ', part_real, ' + ', part_imag, 'i'
  WRITE(*,*) 'x2 = ', part_real, ' - ', part_imag, 'i'
END IF

END PROGRAM EQ_SEG_GRAU

Teste

Vamos executar o programa, passando como valores dos coeficientes a, b e c respectivamente 2, 4 e 1 – ou seja, a equação 2x² + 4x +1 = 0

Programa que calcula as raízes de uma equação de segundo grau
Equação no formato a * x2 + b * x + c = 0
Digite os coeficientes A, B e C:
2
4
1
Os coeficientes fornecidos A, B e C são: 2.00000000 4.00000000 1.00000000 
A equação possui duas raízes reais:
x1 = -0.292893231 
x2 = -1.70710683

Funcionamento do Código

Inicialmente, são declaradas as variáveis que serão utilizadas no programa. São necessárias variáveis para os coeficientes da equação (a, b e c), o discriminante (delta), as partes real e imaginária das raízes complexas (part_real e part_imag) e para as próprias raízes (x1 e x2).

Na sequência, o programa inicia mostrando algumas mensagens para o usuário, explicando a finalidade do programa e solicitando que o usuário insira os coeficientes da equação (a, b e c). O comando READ é usado para receber esses valores do usuário e armazená-los nas variáveis correspondentes.

Logo após o programa ecoa na tela os coeficientes fornecidos pelo usuário, apenas para confirmar que os valores foram lidos corretamente.

Então são iniciados os cálculos necessários, sendo calculado primeiramente o discriminante (delta) usando a fórmula Δ = b² – 4ac, que é a parte crítica para determinar o tipo de raízes da equação.

Após calcular o valor do discriminante, o programa determina o tipo de raízes com base no valor de delta. Se delta for maior que zero, há duas raízes reais distintas, que são calculadas usando a fórmula quadrática. Se delta for igual a zero, há apenas uma raiz real (repetida). Caso contrário, existem raízes complexas, e suas partes real e imaginária são calculadas e exibidas.

Após calcular e exibir as raízes na tela, o programa é encerrado.

Resumindo, o programa solicita coeficientes ao usuário, calcula o discriminante (delta) e, com base em seu valor, determina o tipo de raízes da equação de segundo grau, exibindo-as no final.

Conclusão

Vimos neste tutorial como criar um programa simples em Fortran para calcular as raízes de uma equação quadrática. Nos próximos tutoriais vamos trabalhar com outros problemas matemáticos e lógicos, criando algoritmos esta linguagem.

Até.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Programa que calcula as raízes de uma equação de segundo grau em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vou mostrar de forma simples e rápida como instalar e executar via terminal o compilador GNU Fortran (GFortran) em um computador com o sistema operacional Linux, para várias distribuições.

O que é o GFortran

O GFortran (GNU Fortran) é uma implementação da linguagem de programação Fortran no GCC, GNU Compiler Collection, software livre e de código aberto mantido por uma grande comunidade de programadores, que possui compiladores para uma série de linguagens, como C, C++, Ada e outras (além do Fortran, claro).

Instalação do GFortran

Antes de realizar a instalação do compilador em si, vamos primeiramente verificar se já não temos o GFortran instalado na distribuição Linux. Para isso, execute o comando a seguir no terminal:

which gfortran

Se nada for retornado no terminal, significa que o compilador não está presente no sistema. Teremos de instalá-lo.

Antes de prosseguir com a instalação, devemos atualizar a lista de pacotes dos repositórios:

sudo apt update

Após atualizar as listas de pacotes, vamos proceder à instalação propriamente dita do compilador GFortran. Se sua distribuição Linux for Debian ou baseada nele (Ubuntu, Mint, etc.), basta executar o comando a seguir :

sudo apt install gfortran

Caso sua distro seja baseada em pacotes RPM, como Red Hat Enterprise Linux, CentOS, ou Fedora, entre outros, execute:

sudo dnf install gcc-gfortran

Para versões mais antigas desses sistemas use:

sudo yum install gcc-gfortran

E se você estiver usando a distribuição Arch Linux ou derivada, use o gerenciador pacman:

sudo pacman -S gcc-fortran

Após o término da instalação, verifique se tudo correu bem consultando a versão instalada com a opção –version do comando gfortran, como segue:

gfortran --version

Saída:

GFortran instalado no Linux Ubuntu

No meu caso, foi instalada a versão 11.4 do GFortran em um sistema Ubuntu Linux 22.04.

Caso não seja informada a versão, algo saiu errado. Tente executar novamente os passos anteriores.

Teste do gfortran

Se tudo correu bem, vamos escrever um programa simples para testar nosso compilador. Para isso, abra um editor de texto de sua escolha e crie um arquivo de nome “teste.f90” (o importante aqui é a extensão).

Por exemplo, vou usar o nano para isso:

nano teste.f90

No arquivo aberto digite o seguinte código:

program teste
  write(*,*) 'Teste de instalação do Fortran'
end program teste

Salve o arquivo e saia do editor.

Vamos compilar o programa no terminal. Para isso, execute o comando a seguir no diretório onde o arquivo foi salvo:

gfortran -o teste teste.f90

Liste o conteúdo da pasta para ver o programa gerado:

ls -l

Saída:

Note no meu exemplo o arquivo de nome “teste”, marcado em verde no meu terminal, que é o executável gerado pela compilação do programa com o comando gfortran. Note que ele já possui as permissões de execução configuradas, e desta forma pode ser diretamente executado.

A opção -o teste é usada para criar um executável de nome teste (ou do nome que você quiser); se essa opção não for usada, o programa será compilado normalmente, porém o arquivo gerado terá o nome padrão a.out.

Para conhecer mais opções do compilador gfortran, execute o comando gfortran –help no terminal.

Para finalizar, vamos então rodar o programa:

./teste

Resultado:

 Teste de instalação do Fortran

É isso aí! Compilador GFortran instalado com sucesso no Linux. Nos próximos artigos vamos configurar editores de texto mais elaborados para codificar com mais facilidade e também vamos estudar a sintaxe da linguagem Fortran – e também mostrarei como instalar o GFortran no Windows, entre outras tarefas.

Até!

O post Como instalar o compilador GFortran no Linux para Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos criar um pequeno programa em Fortran para exibir os elementos de uma progressão geométrica, com base em parâmetros fornecidos pelo usuário em tempo de execução.

O que é uma Progressão Geométrica?

Progressão geométrica (PG) é uma sequência numérica em que cada termo, a partir do segundo, é obtido multiplicando o termo anterior por uma constante chamada de “razão”.

Matematicamente, uma progressão geométrica pode ser representada da seguinte forma:

a, ar, ar², ar³, …

Onde:

• a é o primeiro termo da progressão.
• r é a razão da progressão, que é um número constante.
• ar é o segundo termo da progressão.
• ar² é o terceiro termo da progressão.

E assim por diante.

Em uma progressão geométrica, a razão r determina como os termos subsequentes são calculados a partir do termo anterior. Se r for maior que 1, a progressão será crescente, e se r estiver entre -1 e 1 (exclusivamente), a progressão será decrescente.

Se r for igual a 1, todos os termos serão iguais, formando uma sequência constante.

Onde usamos Progressão Geométrica?

As progressões geométricas são usadas em várias áreas da matemática e das ciências em geral para modelar crescimento exponencial, decaimento e fenômenos relacionados à multiplicação ou divisão por uma constante fixa em cada etapa.

São frequentemente aplicadas em finanças, física, biologia, engenharia e muitos outros campos.

Vejamos como implementar um programa em linguagem Fortran que nos permite calcular e exibir os termos de uma progressão geométrica, com base nos valores de termo inicial e razão informados pelo usuário.

Código

PROGRAM ProgressaoGeometrica

  IMPLICIT NONE

  INTEGER :: n
  REAL(8) :: a, r
  INTEGER :: i

  WRITE (*,*) 'Programa para calcular e mostrar uma Progressão Geométrica'
  WRITE (*,*) 'Digite o primeiro termo (a):'
  READ(*, *) a
  WRITE (*,*) 'Digite a razão (r):'
  READ(*, *) r
  WRITE (*,*) 'Digite o número de termos (n):'
  READ(*, *) n

  IF (n <= 0) THEN
    WRITE (*,*) 'O número de termos deve ser maior que zero.'
    STOP
  END IF

  WRITE (*,*) 'Os', n, 'primeiros termos da Progressão Geométrica são:'

  DO i = 1, n
    WRITE (*,*) 'Termo ', i, ': ', a
    a = a * r ! Calcula o próximo termo
  END DO

END PROGRAM ProgressaoGeometrica

Teste

Programa para calcular e mostrar uma Progressão Geométrica
Digite o primeiro termo (a):
5
Digite a razão (r):
2
Digite o número de termos (n):
10

Os 10 primeiros termos da Progressão Geométrica são:
Termo 1 : 5.0000000000000000 
Termo 2 : 10.000000000000000 
Termo 3 : 20.000000000000000 
Termo 4 : 40.000000000000000 
Termo 5 : 80.000000000000000 
Termo 6 : 160.00000000000000 
Termo 7 : 320.00000000000000 
Termo 8 : 640.00000000000000 
Termo 9 : 1280.0000000000000 
Termo 10 : 2560.0000000000000 

Funcionamento do programa Fortran para calcular e mostrar uma progressão geométrica

IMPLICIT NONE: Essa instrução força a declaração explícita de todas as variáveis, que é uma boa prática para evitar erros de tipo.

Logo a seguir temos a declaração das variáveis usadas no programa:

• INTEGER :: n: Essa variável inteira será usada para armazenar o número de termos da progressão geométrica.
• REAL(8) :: a, r: a é o primeiro termo da progressão e r é a razão. Ambos são números reais com precisão dupla (REAL(8)).
• INTEGER :: i: Essa variável será usada como um contador em um loop.

Configuramos então algumas mensagens de  introdução

WRITE (*,*) ‘Programa para calcular e mostrar uma Progressão Geométrica’: Isso exibe uma mensagem informativa para o usuário no console.
WRITE (*,*) ‘Digite o primeiro termo (a):’, WRITE (*,*) ‘Digite a razão (r):’, WRITE (*,*) ‘Digite o número de termos (n):’: Essas mensagens solicitam ao usuário que insira o valor do primeiro termo (a), a razão (r) e o número de termos (n) da progressão geométrica.

Lógica principal do programa:

IF (n <= 0) THEN: Esta estrutura condicional verifica se o número de termos (n) é menor ou igual a zero.
WRITE (*,*) ‘O número de termos deve ser maior que zero.’: Se o número de termos for menor ou igual a zero, o programa exibe uma mensagem de erro.
STOP: A instrução STOP encerra a execução do programa.

Mensagem de exibição dos termos da progressão

WRITE (*,*) ‘Os’, n, ‘primeiros termos da Progressão Geométrica são:’: Esta linha de código exibe uma mensagem indicando que os termos da progressão geométrica serão exibidos a seguir.

Laço de repetição para o cálculo e exibição dos valores:

DO i = 1, n: Inicia um laço DO que vai de 1 até n. Isso permitirá que o programa calcule e exiba os primeiros n termos da progressão geométrica.
WRITE (*,*) ‘Termo ‘, i, ‘: ‘, a: Dentro do laço, o programa exibe o número do termo (contado pelo índice i) e o valor do termo atual (a) no console.
a = a * r: O valor do termo atual (a) é multiplicado pela razão (r) para calcular o próximo termo da progressão geométrica.

Finalização do Programa:

O programa atinge o final do laço após calcular e exibir os n termos da progressão, e então é encerrado com a instrução END PROGRAM.

Conclusão

Neste artigo apresentamos uma sugestão de programa em linguagem Fortran que solicita ao usuário o primeiro termo (a) de uma progressão geométrica, a razão (r) e o número de termos (n) desejados. Em seguida, ele verifica se o número de termos é válido, e se for, calcula e exibe os primeiros n termos da progressão geométrica.

Cada termo é calculado multiplicando o termo anterior pela razão r. O programa usa um laço de repetição DO para repetir essa operação e a exibição até que todos os termos sejam processados.

É isso aí! Veja também: Como calcular Fatorial com Fortran.

O post Programa que gera Progressão Geométrica em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos criar um pequeno programa que permite calcular o fatorial de um número usando a linguagem Fortran.

O programa irá solicitar ao usuário que entre com um número inteiro, calculará o fatorial desse número usando um loop DO e, em seguida, exibirá o resultado. O fatorial será então calculado multiplicando o número pelo número anterior, repetidamente, até que o loop termine.

Código do programa a seguir.

Código: Fatorial em Fortran

PROGRAM fatorial
  IMPLICIT NONE
  INTEGER::n,i,fat=1
  PRINT *, 'Programa que calcula o fatorial de um número'
  PRINT *, 'Digite um número para calcular seu fatorial:'
  READ(*,*) n
  DO i=1,n
    fat=fat*i
  END DO
  WRITE(*, '(A, I0)') 'O fatorial é ', fat
END PROGRAM

Testando

Programa que calcula o fatorial de um número
Digite um número para calcular seu fatorial:
7
O fatorial é 5040

Funcionamento

Vejamos o funcionamento do código linha a linha:

• PROGRAM fatorial: Definimos um programa Fortran de nome “fatorial”.
• IMPLICIT NONE: Esta linha declara que todas as variáveis devem ser explicitamente definidas com seus tipos de dados. Essa é uma boa prática para evitar erros de tipo.
• INTEGER::n,i,fat=1: Aqui, são declaradas três variáveis:
  • n: número inteiro para o qual calcularemos o fatorial.
  • i: variável de controle que será usada em um loop.
  • fat: variável que armazenará o resultado do fatorial, inicializada com 1.
• PRINT *, ‘Programa que calcula o fatorial de um número’: Mensagem informativa para o usuário, indicando a finalidade do programa.
• PRINT *, ‘Digite um número para calcular seu fatorial’: Mensagem que solicita ao usuário que insira o número para o qual deseja calcular o fatorial.
• READ(*,*) n: Esta linha lê o valor inserido pelo usuário e o armazena na variável n.
• DO i=1,n: Inicia um loop DO que irá executar as instruções dentro dele repetidamente. O loop começa com o valor da variável i igual a 1 e continua até chegar em n.
• fat=fat*i: Dentro do loop, o valor atual de fat (que começa em 1) é multiplicado por i e o resultado é armazenado em fat. Isso efetivamente calcula o fatorial.
• END DO: Encerra o laço DO.
  • Após a conclusão do loop, o programa exibe a mensagem “O fatorial é” seguida pelo valor calculado em fat, que é o fatorial do número inserido pelo usuário. Para tal usamos a instrução WRITE:
• WRITE(*, ‘(A, I0)’): instrução WRITE que formata a saída. Ela diz para escrever para a saída padrão (*) uma string de texto (‘A’) seguida de um inteiro (‘I0’).
  • ‘O fatorial é ‘: Esta é a string de texto que será impressa.
  • fat: E este é o valor do fatorial calculado, que será impresso como um valor inteiro.
• END PROGRAM: Finaliza o programa FORTRAN.

É isso aí! No próximo artigo veremos como escrever um programa em Fortran que permite gerar uma sequência de Fibonacci. Até!

O post Programa que calcula o fatorial de um número em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.