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.

Neste tutorial vou mostrar como criar um script relativamente simples em JavaScript que permite aos usuários gerarem uma lista com números primos, iniciando em 2 (que é o primeiro número primo) até um valor informado pelo usuário, que será o limite da lista gerada.

Um número é considerado primo se ele for maior que um e divisível (no caso, divisão inteira) apenas por si próprio e por 1. Por exemplo:

• O número 23 é um número primo, pois ele só é divisível por 23 (ele próprio) e por 1.
• Já o número 24 não é primo, pois além de ser divisível por si mesmo e por 1, ele também é divisível por outros números, como 2, 3, 4 e 6.

O número 1 não é considerado um número primo na matemática.

Script que gera números primos em JavaScript

O nosso script deverá realizar as seguintes tarefas:

1. Calcular e mostrar na tela os números primos de 2 até um valor fornecido pelo usuário, usando JavaScript
2. O numero fornecido pelo usuário será digitado em uma caixa de texto em uma página HTML
3. Os números gerados serão exibidos no corpo do documento, um por linha.
4. A geração dos valores se dará após o usuário clicar em um botão btnGeraPrimos.
5. O código JavaScript será declarado no cabeçalho da página HTML, para melhor organização do código, e invocado no botão.
6. Adicionar validação: se o usuário fornecer um número negativo, avisar que não é possível gerar a sequência de primos.
7. Mais validação: se o usuário informar um caractere que não seja um número, será avisado de que não é possível gerar a sequência de primos.

Também iremos estilizar o formulário e a saída gerada usando CSS, em um arquivo separado de folha de estilos, que chamaremos de estilos.css.

Vamos à codificação.

Códigos em HTML, CSS e JavaScript

1. Página HTML com JavaScript: arquivo index.html

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Gerador de Números Primos</title>
    <link rel="stylesheet" href="estilos.css">
    <script>
        // Função para verificar se um número é primo
        function ePrimo(num) {
            if (num < 2) return false;
            for (let i = 2; i <= Math.sqrt(num); i++) {
                if (num % i === 0) return false;
            }
            return true;
        }

        // Função para gerar e exibir os números primos
        function gerarPrimos() {
            // Limpa as mensagens e a saída anterior
            document.getElementById('mensagemErro').innerHTML = '';
            document.getElementById('saida').innerHTML = '';
            // Obter o valor inserido pelo usuário
            let valor = document.getElementById('inputNumero').value;
            // Verificar se o valor é um número válido
            if (isNaN(valor) || valor.trim() === '') {
                document.getElementById('mensagemErro').innerHTML = 'Por favor, insira um número válido.';
                return;
            }
            valor = parseInt(valor);

            // Validação de número negativo
            if (valor < 2) {
                document.getElementById('mensagemErro').innerHTML = 'Por favor, insira um número maior que 1 para gerar números primos.';
                return;
            }
            let primos = [];
            // Calcular os números primos
            for (let i = 2; i <= valor; i++) {
                if (ePrimo(i)) {
                    primos.push(i);
                }
            }

            // Exibir os números primos
            const saida = document.getElementById('saida');
            if (primos.length > 0) {
                primos.forEach(function(primo) {
                    saida.innerHTML += primo + '<br>';
                });
            } else {
                saida.innerHTML = 'Nenhum número primo encontrado.';
            }
        }
    </script>
</head>

<body>
<div class="container">
    <h1>Gerador de Primos</h1>
    <label for="inputNumero">Digite um número:</label>
    <input type="text" id="inputNumero" placeholder="Ex: 50">
    <div class="error" id="mensagemErro"></div>
    <button id="btnGeraPrimos" onclick="gerarPrimos()">Gerar Primos</button>
    <div class="output" id="saida"></div>
</div>
</body>
</html>

2. Folha de estilos externa: arquivo estilos.css

body {
    font-family: Arial, sans-serif;
    background-color: #f4f4f4;
    margin: 0;
    padding: 0;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
}
.container {
    background-color: white;
    padding: 20px;
    border-radius: 10px;
    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
    max-width: 400px;
    width: 100%;
}
h1 {
    text-align: center;
    color: #333;
}
label {
    font-size: 16px;
    margin-bottom: 10px;
    display: block;
}
input[type="text"] {
    width: 100%;
    padding: 10px;
    margin-bottom: 10px;
    border: 1px solid #ccc;
    border-radius: 5px;
    font-size: 16px;
}
.error {
    color: red;
    font-size: 14px;
    margin-bottom: 10px;
}
.success {
    color: green;
}
button {
    width: 100%;
    padding: 10px;
    background-color: #4CAF50;
    color: white;
    border: none;
    border-radius: 5px;
    font-size: 16px;
    cursor: pointer;
}
button:hover {
    background-color: #45a049;
}
.output {
    margin-top: 20px;
    background-color: #f9f9f9;
    padding: 10px;
    border-radius: 5px;
    height: 200px;
    overflow-y: auto;
    border: 1px solid #ccc;
}

Teste da aplicação

Vamos abrir a página e pedir para que sejam gerados os números primos até 33:

Caso o usuário tente gerar a sequência fornecendo um número negativo ou um caractere não-numérico, será exibida a mensagem de erro e a sequência de números primos não será gerada:

Foi fornecido o número -5 (negativo), por isso a mensagem de erro.

Funcionamento do Código

HTML: O formulário possui um campo de entrada (input) no qual o usuário digita um número, e um botão para invocar a função JavaScript que gera os números primos. Há uma área para exibir os erros de validação logo abaixo e uma área de saída para exibir os números primos.

CSS: A página está estilizada para ter uma aparência limpa e amigável, como é sempre recomendável. Centralizamos o formulário na página e os elementos como caixas de texto e botões têm um design agradável, com cor de fundo verde para o botão e texto de mensagem de erro em vermelho – mas você pode alterar isso à vontade, evidentemente.

A saída dos números primos será em uma área de rolagem (output), que facilita a visualização dos números, caso sejam gerados muitos.

JavaScript: O código JavaScript foi inserido no cabeçalho da página, e consiste em duas funções com tarefas específicas:

• ePrimo: Função que verifica se um número é primo. Ela percorre os divisores do número até sua raiz quadrada.
• gerarPrimos: Função principal que é chamada ao clicar no botão. Ela valida a entrada do usuário, calcula os números primos até o valor fornecido, e os exibe no corpo da página.

Também são realizadas validações: Se o valor fornecido não for um número, ou se for um número negativo, uma mensagem de erro é exibida.

Conclusão

Neste post mostrei um script simples para gerar uma listagem de números primos, que você pode – e deve – usar para estudar a linguagem e se aprofundar nas suas técnicas de programação.

Nos próximos artigos veremos scripts para resolver diversos outros problemas, sempre com esse foco: o aprendizado da linguagem JavaScript.

Até!

O post Como gerar números primos em JavaScript apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O arredondamento preciso de valores numéricos desempenha um papel muito importante em diversas aplicações científicas e de engenharia. No contexto da programação em Python, a biblioteca NumPy se destaca como uma ferramenta poderosa para manipulação eficiente de arrays e cálculos numéricos em geral.

Neste artigo, exploraremos algumas funções de arredondamento numérico disponíveis no NumPy, mostrando alguns exemplos de como empregar essas funções para realizar arredondamentos diversos, incluindo arredondamento de valores de ponto flutuante e para números inteiros.

Ao entender como usar essas funções, será possível otimizar nossos códigos e garantir resultados numericamente estáveis em uma variedade de cenários.

Vamos às funções de arredondamento de valores com NumPy, para Python.

Importar o NumPy

O primeiro passo para usar as funções que serão abordadas é importar a biblioteca NumPy no script que usará as funções de arredondamento (o módulo numpy deve estar instalado previamente; caso não esteja, realize a instalação do NumPy seguindo estas instruções):

import numpy as np

Após importar a biblioteca, vejamos as funções mais importantes para arredondamento de valores numéricos.

1. Função numpy.round

Ou seu alias numpy.around(): Arredonda o valor até uma precisão desejada

Sintaxe

numpy.round(valor,[num_casas_decimais])

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.round.html

Exemplo de uso

# Criar um array de valores a serem arredondados:
valores = np.array([5.0, 6.98, 0.9863, 555, 10.099])
# Podemos usar também uma simples lista (descomentar para testar):
# valores = [5.0, 6.98, 0.9863, 555, 10.099] 
print('Array original:')
print(valores)

print('\nValores arredondados:')
print(np.round(valores, decimals = 2))
print(np.round(valores, decimals = 3))
print(np.around(valores)) # valores são exibidos no formato float64
print(np.around(valores).astype(int)) # converter valores para int antes da exibição (não mostra o ponto)

Resultado:

Array original:
[ 5. 6.98 0.9863 555. 10.099 ]

Valores arredondados:
[ 5. 6.98 0.99 555. 10.1 ]
[ 5. 6.98 0.986 555. 10.099]
[ 5. 7. 1. 555. 10.]
[ 5 7 1 555 10]

2. Função numpy.floor

Arredonda para o maior inteiro menor que o valor de entrada (“tipo” arredonda para baixo).

Retorna o menor inteiro i, tal que i <= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.floor.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.floor(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 6. 0. 55. 10. -1.]

3. Função numpy.ceil

Arredonda para o inteiro imediatamente maior que valor de entrada (“tipo” arredonda para cima). Essa função retorna o menor número inteiro i, tal que i >= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])  # mesmo array usado em np.floor
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.ceil(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 7. 1. 55. 11. -0.]

4. Função numpy.trunc

Truncar um valor numérico. Retorna o valor truncado da entrada, elemento a elemento.

O valor truncado do escalar x é o inteiro mais próximo i que está mais próximo de zero do que x. Resumindo, a parte fracionária do valor atribuido é descartada.

O que é truncar?

O verbo “truncar” se refere ao ato de cortar ou remover a parte fracionária de um número, mantendo apenas a parte inteira. A operação de truncamento geralmente é realizada em números de ponto flutuante, onde há uma parte inteira e uma parte decimal. Também é possível aplicar a operação de truncagem em strings, o que não é o caso aqui.

Por exemplo, se tivermos o número de ponto flutuante 7.75 e quisermos truncá-lo para um inteiro, o resultado será 7, pois a parte decimal (0.75) foi removida.

É importante observar que o truncamento difere do arredondamento, onde a parte decimal é arredondada para o inteiro mais próximo. No truncamento, a parte decimal é simplesmente removida, resultando sempre em um número menor ou igual ao número original.

Documentação de numpy.trunc: https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores truncados:')
print(np.trunc(valores))

Resultado:

Valores truncados:
[ 6. 0. 55. 10. -0.]

5. Função numpy.fix

Arredonda para o número inteiro mais próximo em direção a zero.

Arredonda um array de pontos flutuantes elemento a elemento para o número inteiro mais próximo de zero. Os valores arredondados são retornados como valores de ponto flutuante.

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.fix.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores Arredondados:')
print(np.fix(valores))

Resultado:

Valores Arredondados:
[ 6. 0. 55. 10. -0.]

Conclusão

As funções de arredondamento proporcionadas pela biblioteca NumPy conferem uma grande flexibilidade aos programadores Python ao lidar com operações numéricas. Seja em análises estatísticas, processamento de dados ou simulações complexas, o entendimento aprofundado dessas funções é fundamental para assegurar resultados confiáveis e consistentes.

Neste artigo, trabalhamos com as principais funções de arredondamento do NumPy, com exemplos de códigos simples para melhor entendimento de cada função. Ao incorporar esses conhecimentos em seus projetos, você estará mais preparado para resolver desafios numéricos e obter soluções eficientes e precisas ao criar aplicações com Python.

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 5 Funções de Arredondamento de Valores com NumPy em Python 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.

Fala pessoal! No artigo passado escrevemos um programa que permitia converter um número decimal em binário, usando C++. Agora vamos criar um pequeno programa que permite realizar o processo inverso – a conversão de um número binário, fornecido pelo usuário, em seu equivalente decimal, também usando a linguagem C++.

Vamos ao código.

Código – Converter binário em decimal com C++

#include<iostream>
#include<cmath>

using namespace std;

int main() {
  int num, resto, base = 2, soma = 0, i = 0;

  // Solicita ao usuário que digite o número binário a ser convertido
  cout << "CONVERSÃO DE BINÁRIO PARA DECIMAL \n"; 
  cout << "Digite o número em binário e pressione ENTER: ";
  cin >> num;

  // Laço onde é realizada a conversão do número binário em decimal
  while (num > 0) {
    resto = num % 10; // Calcula o dígito binário menos significativo
    soma = soma + (resto * pow(base, i)); // Converte e acumula o dígito binário em decimal
    num = num / 10; // Remove o dígito binário processado
    i += 1; // Incrementa o expoente da base (2)
  }

  // Exibe o número decimal resultante
  cout << "\nNúmero convertido para decimal: " << soma;
  return 0;
}

Resultado

CONVERSÃO DE BINÁRIO PARA DECIMAL 
Digite o número em binário e pressione ENTER: 1001111
Número convertido para decimal: 79

Funcionamento do Código

O programa inicia incluindo as bibliotecas iostream e cmath para permitir entrada/saída de dados e realizar cálculos matemáticos, respectivamente. Também usa using namespace std para evitar a necessidade de usar std:: antes de funções como cin e cout.

O programa então declara algumas variáveis, incluindo num para armazenar o número binário inserido pelo usuário, resto para armazenar o dígito binário atualmente sendo processado, base, que é 2 (pois estamos convertendo de binário para decimal), soma para acumular o valor decimal resultante e i para controlar o expoente da base.

Na sequência é solicitado que o usuário insira o número binário que deseja converter.

O programa entra então em um laço while que continuará até que o número binário (num) seja maior que zero.

Dentro esse laço, ele calcula o dígito binário menos significativo usando a operação num % 10. Isso resulta em 0 ou 1, que é o dígito binário atual.

O dígito binário é convertido em decimal e adicionado à variável soma usando a fórmula soma = soma + (resto * pow(base, i)). Aqui, resto é o dígito binário, base é 2 (base binária) e i é o expoente que começa em 0 e aumenta a cada iteração.

Logo após o número binário (num) é dividido por 10 (num = num / 10) para remover o dígito binário que foi processado.

Então, o expoente da base (i) é incrementado em 1 (i += 1) para lidar com o próximo dígito binário.

Após a conclusão do laço de repetição, o programa exibe o número decimal resultante.

Finalmente, o programa retorna 0, indicando que a execução foi bem-sucedida.

É isso aí! Nos próximos tutoriais veremos outros tipos de conversões de bases numéricas usando a linguagem C++, como a conversão de hexadecimal em decimal e binário e vice-versa.

Até!

O post Programa que converte um número de binário para decimal em C++ 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.

Exercício: Escreva um programa em Python que retorne uma lista de números primos compreendidos em um intervalo fornecido pelo usuário (incluindo os extremos). Use funções para tal.

Por exemplo, ao executar o script se o usuário solicitar a lista de primos entre 7 e 50, o programa deve retornar um resultado como segue:

Entre com o menor valor: 
7
Entre com o maior valor: 
50
Os números primos no intervalo de 7 a 50 são:
7 11 13 17 19 23 29 31 37 41 43 47 

Vejamos o código que permite gerar números primos em Python.

Código

# Como gerar números primos em um intervalo numérico
# Função para verificar os números primos
def primo(n):
    if n < 2:
        return False
    for i in range(2, int(n/2)+1):
        if n % i == 0:
            return False
    return True

if __name__=='__main__':
    # Usuário escolhe o intervalo
    inf = int(input('Entre com o menor valor: '))
    sup = int(input('Entre com o maior valor: '))

    print('Os primos no intervalo de {} a {} são:'.format(inf, sup))

    for i in range(inf, sup + 1):
        if primo(i):
            print(i, end=' ')

Funcionamento do script

Vou dividir a explicação em duas partes: a função primo e o bloco principal do programa.

Função primo(n)

A função primo(n) é definida para verificar se um número n é primo ou não. Ela funciona da seguinte maneira:

1. Verifica se um valor n passado como parâmetro é menor que 2. Se for, retorna False, pois números menores que 2 não são primos.
2. Se n não for menor do que 2, a função inicia um loop que percorre os valores de i de 2 até n/2 + 1 (metade +1 do valor informado).
3. Para cada valor de i, verifica se n é divisível por i (ou seja, se n % i == 0). Se essa condição for verdadeira, significa que n não é primo, pois possui um divisor além de 1 e ele mesmo. Portanto, a função retorna False.
4. Caso nenhum valor de i resulte em uma divisão exata de n, a função retorna True, indicando que n é um número primo.

Bloco if __name__==’__main__’:

No bloco principal, o programa realiza as seguintes ações:

1. Solicita que o usuário insira o valor mínimo (inf) e o valor máximo (sup) do intervalo a gerar.
2. Exibe uma mensagem informando que os números primos no intervalo de inf a sup serão exibidos na sequência.
3. Usando um laço for, percorre todos os valores de i no intervalo de inf a sup + 1.
4. Para cada valor de i, chama a função primo(i) para verificar se i é um número primo.
5. Se i for primo (ou seja, se a função primo(i) retornar True), o valor de i é impresso na mesma linha, seguido de um espaço. Isso ocorre para todos os números primos encontrados no intervalo.

Portanto, o programa vai iterar por todos os números no intervalo especificado pelo usuário, verificar se cada número é primo usando a função primo(n), e imprimir os números primos encontrados.

Veja que essa implementação é funcional, porém não é a mais eficiente em termos de tempo de execução para encontrar números primos, especialmente para intervalos maiores, pois realiza uma divisão para cada número no intervalo.

Existem algoritmos mais eficientes para geração de números primos, como o Crivo de Eratóstenes .

O post Como gerar números primos em Python em um intervalo especificado apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O que é a sequência de Fibonacci

Como saber se um número pertence à série de Fibonacci?

“Um número é Fibonacci se e apenas se uma ou ambas as expressões 5*n² + 4 ou 5*n² – 4 retornarem um quadrado perfeito.”

Algoritmo em Português Estruturado

programa
{
inclua biblioteca Matematica --> m
inclua biblioteca Tipos --> t

real num
inteiro raiz

  funcao inicio()
  {
  escreva("Descobrir se número é Fibonacci\n")
  escreva("Entre com um número: ")
  leia(num)

  se (eFibonacci(num)) {
      escreva(num + " pertence à série de Fibonacci.")
  }
  senao {
      escreva(num + " não pertence à série de Fibonacci.")
  }
}

  // Função para determinar se número é quadrado perfeito
  funcao logico quadradoPerfeito(real x) {
      raiz = t.real_para_inteiro(m.raiz(x, 2.0))
      retorne raiz * raiz == x
  }

  // Função para verificar se número pertence à série de Fibonacci
  funcao logico eFibonacci(real n){
      // n é Fibonacci se o resultado de 5*n² + 4 ou 5*n² - 4 (ou ambos) for quadrado perfeito.
      retorne quadradoPerfeito(5*n*n + 4) ou quadradoPerfeito(5*n*n - 4)
  }
}

Descobrir se número é Fibonacci
Entre com um número: 17711
17711.0 pertence à série de Fibonacci.

Descobrir se número é Fibonacci
Entre com um número: 12290
12290.0 não pertence à série de Fibonacci.

Algoritmo em Python

import math

# Função que verifica se n é um quadrado perfeito.
def quadradoPerfeito(x):
    raiz = int(math.sqrt(x))
    return raiz*raiz == x
  
# Verifica se número n pertence à série de Fibonacci
# n é Fibonacci se o resultado de 5*n*n + 4 ou 5*n*n - 4 ou ambos
# forem quadrados perfeitos.
def eFibonacci(n):
    return quadradoPerfeito(5*n*n + 4) or quadradoPerfeito(5*n*n - 4)

if __name__=='__main__':
    print("Verificar se número é Fibonacci")
    n = int(input('Digite um número qualquer, positivo: '))

    if(eFibonacci(n)):
        print(f"{n} pertence à série de Fibonacci.")
    else:
        print(f"{n} não pertence à série de Fibonacci.")

O post Algoritmo para verificar se um número pertence à série de Fibonacci apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.