Приближение числа e с помощью ряда в C

Введение

В этом лабораторном практикуме мы рассмотрим, как приблизить математическую константу e, используя её разложение в ряд в языке C. Ряд для e определяется как сумма обратных величин факториалов: e = 1 + 1/1! + 1/2! + 1/3! + ... Сначала мы создадим программу на C для вычисления этого приближения ряда, а затем модифицируем её, чтобы суммировать члены до достижения желаемого уровня точности. Это позволит нам контролировать точность вычислений и получить более точное приближение значения e.

Использование e = ∑(1/n!)

В этом шаге мы рассмотрим, как приблизить математическую константу e, используя её разложение в ряд в языке C. Ряд для e определяется как сумма обратных величин факториалов: e = 1 + 1/1! + 1/2! + 1/3! + ...

Сначала создадим программу на C для вычисления этого приближения ряда. Откройте новый файл в каталоге проекта:

cd ~/project
nano e_approximation.c

Теперь введите следующий код на 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("Approximation of e with %d terms: %f\n", num_terms, e_approximation);
    return 0;
}

Теперь скомпилируем и запустим программу:

gcc e_approximation.c -o e_approximation
./e_approximation

Пример вывода:

Approximation of e with 10 terms: 2.718282

Суммирование членов до достижения заданной точности

В этом шаге мы модифицируем предыдущую программу для вычисления приближения числа e, суммируя члены ряда до достижения заданного уровня точности. Этот подход позволяет контролировать точность вычислений.

Обновим предыдущий файл C:

cd ~/project
nano e_approximation.c

Замените предыдущий код на следующий улучшенный код:

#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;  // Заданный уровень точности
    double e_approximation = approximate_e_with_accuracy(accuracy);

    printf("Approximation of e with accuracy %e: %f\n", accuracy, e_approximation);
    printf("Стандартное значение e из math.h: %f\n", M_E);

    return 0;
}

Скомпилируйте и запустите обновлённую программу:

gcc e_approximation.c -o e_approximation -lm
./e_approximation

Пример вывода:

Approximation of e with accuracy 1.000000e-06: 2.718282
Стандартное значение e из math.h: 2.718282

Эта версия программы продолжает добавлять члены ряда до тех пор, пока следующий член не станет меньше заданного порога точности. Функция fabs() гарантирует, что мы работаем со значением абсолютной величины члена.

Ключевые моменты:

• Мы используем 1e-6 в качестве заданного уровня точности.
• Программа динамически определяет, сколько членов необходимо.
• Мы сравниваем наше приближение со стандартным значением e из библиотеки math.

Вывод приближения

В этом заключительном шаге мы улучшим нашу программу, чтобы выводить приближение числа e с различными уровнями точности и предоставлять более подробный вывод.

Обновите файл C ещё раз:

cd ~/project
nano e_approximation.c

Замените предыдущий код на следующий расширенный код:

#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("Приближение e с различными уровнями точности:\n");
    printf("---------------------------------------------\n");

    for (int i = 0; i < num_accuracies; i++) {
        double e = 0;
        double term = 1;
        int n = 0;
        int terms_used = 0;

        while (fabs(term) > accuracies[i]) {
            e += term;
            n++;
            term = 1.0 / factorial(n);
            terms_used++;
        }

        printf("Точность: %e\n", accuracies[i]);
        printf("Приближение: %.10f\n", e);
        printf("Использованные члены: %d\n", terms_used);
        printf("Отклонение от значения e из math.h: %.10f\n\n", fabs(e - M_E));
    }
}

int main() {
    print_e_approximations();
    return 0;
}

Скомпилируйте и запустите программу:

gcc e_approximation.c -o e_approximation -lm
./e_approximation

Пример вывода:

Приближение e с различными уровнями точности:
---------------------------------------------
Точность: 1.000000e-01
Приближение: 2.7000000000
Использованные члены: 4
Отклонение от значения e из math.h: 0.0182818284

Точность: 1.000000e-03
Приближение: 2.7182500000
Использованные члены: 8
Отклонение от значения e из math.h: 0.0000318284

Точность: 1.000000e-06
Приближение: 2.7182818000
Использованные члены: 14
Отклонение от значения e из math.h: 0.0000000284

Точность: 1.000000e-09
Приближение: 2.7182818285
Использованные члены: 21
Отклонение от значения e из math.h: 0.0000000000

Основные улучшения в этой версии:

• Вывод приближений при различных уровнях точности.
• Отображение количества использованных членов для каждого приближения.
• Вычисление и отображение отклонения от стандартного значения e из библиотеки math.

Summary

In this lab, we learned how to approximate the mathematical constant e using its series expansion in C. We first implemented a function to calculate the factorial of a number, and then used it to compute the approximation of e by summing the terms of the series until a desired number of terms. We then modified the program to continue summing the terms until a desired level of accuracy is reached, allowing us to control the precision of the calculation. The final program outputs the approximation of e to the desired accuracy.