Introdução
Neste laboratório, exploraremos como aproximar a constante matemática e utilizando sua expansão em série em C. A série para e é definida como a soma dos inversos dos fatoriais: e = 1 + 1/1! + 1/2! + 1/3! + ... Primeiro, criaremos um programa em C para calcular esta aproximação da série e, em seguida, o modificaremos para somar os termos até que um nível desejado de precisão seja alcançado. Isso nos permite controlar a precisão do nosso cálculo e obter uma aproximação mais precisa de e.
Utilizando e = ∑(1/n!)
Neste passo, exploraremos como aproximar a constante matemática e utilizando sua expansão em série em C. A série para e é definida como a soma dos inversos dos fatoriais: e = 1 + 1/1! + 1/2! + 1/3! + ...
Primeiro, vamos criar um programa em C para calcular esta aproximação da série. Abra um novo arquivo no diretório do projeto:
cd ~/project
nano e_approximation.c
Agora, insira o seguinte código C:
#include <stdio.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
double approximate_e(int terms) {
double e = 0;
for (int n = 0; n < terms; n++) {
e += 1.0 / factorial(n);
}
return e;
}
int main() {
int num_terms = 10;
double e_approximation = approximate_e(num_terms);
printf("Aproximação de e com %d termos: %f\n", num_terms, e_approximation);
return 0;
}
Vamos compilar e executar o programa:
gcc e_approximation.c -o e_approximation
./e_approximation
Exemplo de saída:
Aproximação de e com 10 termos: 2.718282
Somar Termos Até a Precisão Desejada
Neste passo, modificaremos nosso programa anterior para calcular a aproximação de e somando termos até atingir um nível desejado de precisão. Essa abordagem permite controlar a precisão do nosso cálculo.
Vamos atualizar o arquivo C anterior:
cd ~/project
nano e_approximation.c
Substitua o conteúdo anterior pelo código aprimorado a seguir:
#include <stdio.h>
#include <math.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
double approximate_e_with_accuracy(double desired_accuracy) {
double e = 0;
double term = 1;
int n = 0;
while (fabs(term) > desired_accuracy) {
e += term;
n++;
term = 1.0 / factorial(n);
}
return e;
}
int main() {
double accuracy = 1e-6; // Nível de precisão desejado
double e_approximation = approximate_e_with_accuracy(accuracy);
printf("Aproximação de e com precisão %e: %f\n", accuracy, e_approximation);
printf("Valor padrão de e do math.h: %f\n", M_E);
return 0;
}
Compile e execute o programa atualizado:
gcc e_approximation.c -o e_approximation -lm
./e_approximation
Exemplo de saída:
Aproximação de e com precisão 1.000000e-06: 2.718282
Valor padrão de e do math.h: 2.718282
Esta versão do programa continua adicionando termos à série até que o próximo termo seja menor que o limite de precisão especificado. A função fabs() garante que trabalhemos com o valor absoluto do termo.
Pontos importantes a notar:
- Usamos
1e-6como nosso nível de precisão desejado. - O programa determina dinamicamente quantos termos são necessários.
- Comparamos nossa aproximação com o valor padrão de e da biblioteca matemática.
Imprimir a Aproximação
Neste passo final, aprimoraremos nosso programa para imprimir a aproximação de e com diferentes níveis de precisão e fornecer uma saída mais detalhada.
Atualize o arquivo C mais uma vez:
cd ~/project
nano e_approximation.c
Substitua o conteúdo anterior pelo seguinte código abrangente:
#include <stdio.h>
#include <math.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
void print_e_approximations() {
double accuracies[] = {1e-1, 1e-3, 1e-6, 1e-9};
int num_accuracies = sizeof(accuracies) / sizeof(accuracies[0]);
printf("Aproximação de e com Diferentes Níveis de Precisão:\n");
printf("---------------------------------------------\n");
for (int i = 0; i < num_accuracies; i++) {
double e = 0;
double term = 1;
int n = 0;
int termos_usados = 0;
while (fabs(term) > accuracies[i]) {
e += term;
n++;
term = 1.0 / factorial(n);
termos_usados++;
}
printf("Precisão: %e\n", accuracies[i]);
printf("Aproximação: %.10f\n", e);
printf("Termos Usados: %d\n", termos_usados);
printf("Diferença em relação ao valor de e do math.h: %.10f\n\n", fabs(e - M_E));
}
}
int main() {
print_e_approximations();
return 0;
}
Compile e execute o programa:
gcc e_approximation.c -o e_approximation -lm
./e_approximation
Exemplo de saída:
Aproximação de e com Diferentes Níveis de Precisão:
---------------------------------------------
Precisão: 1.000000e-01
Aproximação: 2.7000000000
Termos Usados: 4
Diferença em relação ao valor de e do math.h: 0.0182818284
Precisão: 1.000000e-03
Aproximação: 2.7182500000
Termos Usados: 8
Diferença em relação ao valor de e do math.h: 0.0000318284
Precisão: 1.000000e-06
Aproximação: 2.7182818000
Termos Usados: 14
Diferença em relação ao valor de e do math.h: 0.0000000284
Precisão: 1.000000e-09
Aproximação: 2.7182818285
Termos Usados: 21
Diferença em relação ao valor de e do math.h: 0.0000000000
Melhorias-chave nesta versão:
- Imprime aproximações em vários níveis de precisão.
- Mostra o número de termos usados para cada aproximação.
- Calcula e exibe a diferença em relação ao valor padrão de e da biblioteca matemática.
Resumo
Neste laboratório, aprendemos como aproximar a constante matemática e utilizando sua expansão em série em C. Primeiro, implementamos uma função para calcular o fatorial de um número e, em seguida, a utilizamos para calcular a aproximação de e somando os termos da série até um número desejado de termos. Posteriormente, modificamos o programa para continuar somando os termos até que um nível desejado de precisão seja alcançado, permitindo que controlassemos a precisão do cálculo. O programa final exibe a aproximação de e com a precisão desejada.
