Desenvolva um código em Fortran que seja capaz de realizar
a soma do número 1 por 100.000 vezes, usando precisão simples.

Passo 1

O enunciado pede um programa em Fortran que realize a soma do número \,1 por \,100{,}000 vezes usando precisão simples.
Informações dadas e o que é solicitado:
  • Somar a quantidade \,1 repetidamente.
  • O número de repetições é \,100{,}000.
  • Deve ser usada precisão simples (single precision) para as variáveis reais.
  • Entregar o código em Fortran que faça isso (deve poder ser compilado e executado).

Passo 2

Estratégia/algoritmo simples (em palavras, sem código ainda):
  • Declarar uma variável \,sum em precisão simples para acumular a soma.
  • Declarar uma variável \,one em precisão simples contendo o valor \,1.
  • Declarar um contador inteiro \,i e um inteiro \,n com \,n=100{,}000.
  • Inicializar \,sum=0.
  • Fazer um laço que execute de \,i=1 até \,i=n e em cada iteração executar \,sum = sum + one.
  • Ao final, imprimir \,sum.
Este é o método mais direto e robusto para o pedido. Não exige estruturas complexas e é o que normalmente se pede numa prova básica de programação numérica.

Passo 3

Conceitos importantes sobre precisão simples (explicação didática e curta):
  • Computadores representam números reais em ponto flutuante seguindo um padrão (normalmente IEEE-754). Um número em ponto flutuante tem sinal, expoente e mantissa (às vezes chamada de fração).
  • Na precisão simples típica (IEEE-754 single), a mantissa tem \,24 bits de precisão (incluindo o bit implícito). Isso significa que todos os inteiros até \,2^{24} = 16{,}777{,}216 são representados exatamente (sem arredondamento).
  • A “máquina epsilon” para single é aproximadamente \,\varepsilon_{mach}\approx 2^{-23}\approx 1,19\times10^{-7}. Esse valor dá uma ideia do menor incremento relativo distinguível perto de \,1.
  • Consequência prática para este exercício: somar \,1 repetidamente \,100{,}000 vezes em precisão simples deve resultar exatamente em \,100{,}000, pois \,100{,}000 < 2^{24} e os inteiros intermediários permanecem exatos. Portanto, o método direto não perde exatidão aqui.

Passo 4

Boas práticas e escolhas em Fortran que vou usar (explicando por que):
  • Evitar o uso de REAL*4 ou REAL(KIND=4) escrito literalmente pode ser menos portátil. Uma opção mais portátil é usar selected_real_kind(p=6), que pede uma precisão decimal mínima (aproximadamente 6 dígitos decimais, apropriada para single). Vou declarar um parâmetro sp com selected_real_kind(p=6) e usar REAL(kind=sp).
  • Sempre usar implicit none para evitar erros de nomes de variáveis.
  • Inicializar explicitamente sum com 0.0 em escala do tipo single usando real(0.0, kind=sp) ou literal com especificação de kind.
  • Usar um laço do simples.
  • Imprimir o resultado com um formato legível.

Passo 5

Explicação linha a linha do que o código fará (sem mostrar o código aqui):
  • Programa começa e força declaração explícita (implicit none).
  • Define sp = selected_real_kind(p=6) para representar o “kind” de precisão simples.
  • Declara integer :: i, n e real(kind=sp) :: one, sum.
  • Atribui n = 100000, one = real(1.0, kind=sp) e sum = real(0.0, kind=sp).
  • Executa do i = 1, n com sum = sum + one.
  • Fecha o laço e imprime n e sum (por exemplo com formato F12.6 para ver casas decimais).
  • Encerra o programa.

Passo 6

Como compilar e executar (exemplo com gfortran):
  • Salve o código em um arquivo, por exemplo sum_one.f90.
  • Compile com: gfortran -std=f2008 -O2 -o sum_one sum_one.f90
  • Execute com: ./sum_one
    Saída esperada: o programa imprimirá o valor de \,sum, que deverá ser \,100{,}000 (ou 100000.000000 dependendo do formato de impressão), porque, como explicado, inteiros até \,2^{24} cabem exatamente em single.

Passo 7

Observações finais e variações:
  • Se o número de somas \,n fosse muito maior que \,2^{24}, a soma por adição sequencial em single poderia começar a perder unidades (ou seja, sum + 1 pode não aumentar quando sum ficou grande o suficiente). Nesse caso, soluções como usar precisão dupla ou algoritmos de soma compensada (p.ex. Kahan) seriam recomendadas.
  • Para este exercício específico ( \,n=100{,}000 ), a solução direta é suficiente e exata em single precision.
  • Se for exigido explicitamente usar uma notação literal com kind, pode-se optar por one = 1.0_sp — isso requer que sp seja um parâmetro conhecido no momento da escrita do literal.

Resposta

program sum_one_single
  implicit none
  integer, parameter :: sp = selected_real_kind(p=6)
  integer :: i, n
  real(kind=sp) :: one, sum

  n = 100000
  one = real(1.0, kind=sp)
  sum = real(0.0, kind=sp)

  do i = 1, n
     sum = sum + one
  end do

  write(*,'(A,I0)') 'n = ', n
  write(*,'(A,F12.6)') 'sum (single precision) = ', sum

end program sum_one_single

Exercícios relacionados