A série infinita
converge para um valor
quando
tende a infinito. Escreva um programa em precisão simples para calcular
para
, calculando a soma de
a 10.000 . A seguir, repita os cálculos, mas na ordem inversa isto é, de
até 1 usando incrementos de -1 . Em cada caso, calcule o erro relativo percentual verdadeiro. Explique os resultados.
Passo 1
O que o enunciado pede e o que é dado:
- Pede-se calcular a soma finita
com usando aritmética em precisão simples (float, 32 bits), de duas maneiras: - somando em ordem direta:
; - somando em ordem inversa:
.
- somando em ordem direta:
- Em cada caso, pede-se calcular o erro relativo percentual verdadeiro, tomando como valor “verdadeiro” o limite
- Informação útil (valor verdadeiro):
Passo 2
Breve aula sobre ponto-flutuante (precisão simples) e por que a ordem importa
- Representação: em precisão simples (IEEE 754, 32 bits) um número é aproximado por
com bits de fração. Isso dá aproximadamente bits de precisão efetiva (incluindo o 1 implícito), ou cerca de dígitos decimais significativos. - Machine epsilon (definição prática): o menor número
tal que em float é - Consequência para soma de termos positivos: ao somar um termo muito pequeno
a um acumulador , se for menor que algo da ordem de , então será arredondado para (o incremento é perdido). Em outras palavras, acrescentos menores que cerca de meia-ulp serão descartados pelo arredondamento. - Para a série
isso significa que quando o acumulador já estiver da ordem de , termos com serão efetivamente ignorados. Vamos estimar para qual isso sucede no Passo 5. - Intuição sobre ordem: somar termos pequenos primeiro (da menor para a maior) permite que esses pequenos termos acumulem entre si antes do acumulador crescer, preservando a contribuição total. Somar do maior para o menor faz com que muitos termos muito pequenos sejam adicionados a um acumulador grande e, por isso, se percam por arredondamento.
Passo 3
Como implementar em precisão simples (exemplo em C)
- Pseudocódigo / código em C (usar tipo float, constantes com sufixo f):
#include <stdio.h>
#include <math.h>
int main(void) {
const int N = 10000;
float sum_forward = 0.0f;
for (int i = 1; i <= N; ++i) {
float t = 1.0f / ( (float)i * (float)i * (float)i * (float)i );
sum_forward += t;
}
float sum_reverse = 0.0f;
for (int i = N; i >= 1; --i) {
float t = 1.0f / ( (float)i * (float)i * (float)i * (float)i );
sum_reverse += t;
}
float S_true = (float)( (M_PI*M_PI*M_PI*M_PI) / 90.0 ); /* cuidado: M_PI em double; aqui estamos convertendo para float */
/* Melhor: calcular S_true em double e depois fazer (float) para comparar em float. */
printf("sum_forward = %.8f\n", sum_forward);
printf("sum_reverse = %.8f\n", sum_reverse);
printf("S_true (double->float) = %.8f\n", S_true);
return 0;
}
- Observações práticas:
- Forçar cálculos em float: use literais com sufixo
fe convertaiexplicitamente parafloatantes de elevar. - Quando se imprime, usar formato que mostra dígitos suficientes (por exemplo
%.8f) para visualizar a precisão de float. - Comparar cada soma com
convertido para float: isso dá o “erro verdadeiro” relativo na escala da precisão simples.
- Forçar cálculos em float: use literais com sufixo
Passo 4
Estimativa teórica do comportamento (por que um deles é muito melhor)
- Vamos encontrar
tal que . Tomando tem-se - Interpretação: quando o acumulador estiver por volta de
, termos com são menores que e correm o risco de ser perdidos ao somá-los a . - Consequência prática:
- Somando em ordem direta (do maior termo para o menor:
até ), o acumulador atinge rapidamente (já depois de poucas dezenas de termos) e quase todos os termos com passarão a ser negligenciados quando adicionados — o efeito é que a soma fica praticamente igual à soma parcial até . - Somando em ordem inversa (dos menores para os maiores:
até ), os termos pequenos se acumulam entre si inicialmente, crescendo o acumulador gradualmente; muitos desses termos não serão perdidos porque o acumulador, enquanto pequeno, representa bem incrementos comparáveis a eles. Depois, quando o acumulador atingir valores maiores, grande parte da contribuição dos termos pequenos já foi incorporada.
- Somando em ordem direta (do maior termo para o menor:
Passo 5
Estimativa numérica do erro causado por “perda” dos termos pequenos (ordem direta)
- Podemos estimar a contribuição total dos termos com
usando uma aproximação integral: - Tomando
(valor onde um termo individual fica da ordem de ), a sobra (o “tail” perdido na soma direta) é aproximadamente (usando ). Se usar diretamente, temos - Esse é um valor do mesmo da ordem de
. Comparado ao valor verdadeiro , a fração relativa perdida é da ordem de , ou seja, . - Conclusão: a soma direta pode perder cerca de
em valor absoluto, o que corresponde a um erro relativo da ordem de , isto é, cerca de .
Passo 6
Resultados numéricos esperados em precisão simples e cálculo do erro relativo percentual verdadeiro
- Valor verdadeiro:
- Estimativas (comportamento típico de float quando se soma com as duas ordens):
- Soma em ordem direta (
a ) tende a perder a contribuição do “caldo” de termos pequenos. Uma estimativa razoável para a soma em float é Diferença absoluta aproximada: Erro relativo verdadeiro: Em porcentagem: - Soma em ordem inversa (
a ) preserva muito melhor a contribuição dos termos pequenos. O resultado em float costuma ficar praticamente arredondado corretamente ao valor representável mais próximo: Diferença absoluta aproximada: Erro relativo verdadeiro: Em porcentagem:
- Soma em ordem direta (
- Interpretação numérica: a soma em ordem inversa é cerca de duas ordens de magnitude mais precisa (em termos relativos) do que a soma em ordem direta no contexto da precisão simples.
Passo 7
Explicação final e conselho prático para a prova
- Por que a ordem inversa é melhor: somar os termos menores primeiro evita que eles sejam somados a um acumulador grande (onde seriam arredondados a zero). Assim, a ordem inversa permite que as pequenas contribuições “cresçam” e sejam representadas com mais precisão antes que o acumulador atinja valores maiores.
- Regra prática que dá para usar na prova: quando somar uma série (ou somar muitos números) em ponto flutuante, some do menor para o maior (ou use algoritmos de soma compensada, como Kahan) para reduzir erro de arredondamento.
- No enunciado pediam especificamente precisão simples; se puder usar precisão dupla (double) o problema praticamente desaparece porque o limite onde termos são perdidos fica muito maior (ε é muito menor).