В мире программирования вычисление числа Пи всегда было увлекательным занятием. Rust, будучи высокопроизводительным и безопасным языком, предоставляет множество методов для точного вычисления значения числа пи. В этой статье блога мы рассмотрим несколько подходов, сопровождаемых примерами кода, для вычисления значения числа Пи в Rust. Независимо от того, являетесь ли вы новичком или опытным разработчиком Rust, эта статья познакомит вас с различными методами и поможет понять основные концепции.

Метод 1: формула Лейбница
Формула Лейбница, также известная как ряд Грегори-Лейбница, представляет собой простой и понятный подход к оценке числа Пи. Он использует переменный ряд для аппроксимации значения числа “пи”.

fn calculate_pi_leibniz(terms: u64) -> f64 {
    let mut pi = 0.0;
    let mut sign = 1.0;
    for i in 0..terms {
        pi += sign / (2 * i as f64 + 1.0);
        sign *= -1.0;
    }
    pi * 4.0
}

Метод 2: моделирование Монте-Карло
Моделирование Монте-Карло — это вероятностный метод, который использует случайную выборку для оценки числа «пи». Создав большое количество случайных точек внутри квадрата и подсчитав точки, попадающие внутрь четверти круга, мы можем приблизительно определить значение числа пи.

use rand::Rng;
fn calculate_pi_monte_carlo(total_points: u64) -> f64 {
    let mut points_in_circle = 0;
    let mut rng = rand::thread_rng();
    for _ in 0..total_points {
        let x = rng.gen::<f64>() * 2.0 - 1.0;
        let y = rng.gen::<f64>() * 2.0 - 1.0;
        if x * x + y * y <= 1.0 {
            points_in_circle += 1;
        }
    }
    (points_in_circle as f64 / total_points as f64) * 4.0
}

Метод 3: Ряд Нилаканты
Ряд Нилаканты, бесконечный ряд, представляет собой еще один подход к аппроксимации значения числа Пи. Он предполагает сложение или вычитание дробей по определенному шаблону.

fn calculate_pi_nilakantha(terms: u64) -> f64 {
    let mut pi = 3.0;
    let mut sign = -1.0;
    let mut denominator = 2.0;
    for _ in 0..terms {
        pi += sign * (4.0 / (denominator * (denominator + 1.0) * (denominator + 2.0)));
        sign *= -1.0;
        denominator += 2.0;
    }
    pi
}

Метод 4: алгоритм Гаусса-Лежандра
Алгоритм Гаусса-Лежандра — это итерационный метод, который быстро сходится для вычисления значения числа Пи. Для уточнения аппроксимации используется ряд арифметических операций.

fn calculate_pi_gauss_legendre(terms: u64) -> f64 {
    let mut a = 1.0;
    let mut b = 1.0 / 2.0f64.sqrt();
    let mut t = 0.25;
    let mut p = 1.0;
    for _ in 0..terms {
        let a_next = (a + b) / 2.0;
        let b_next = (a * b).sqrt();
        let t_next = t - p * (a - a_next).powi(2);
        let p_next = 2.0 * p;
        a = a_next;
        b = b_next;
        t = t_next;
        p = p_next;
    }
    (a + b).powi(2) / (4.0 * t)
}

В этой статье мы рассмотрели различные методы расчета значения числа Пи в Rust. Мы рассмотрели формулу Лейбница, моделирование Монте-Карло, ряд Нилаканты и алгоритм Гаусса-Лежандра. Каждый метод обеспечивает свой подход и уровень точности. В зависимости от ваших требований вы можете выбрать наиболее подходящий метод для вашего применения. Характеристики производительности и безопасности Rust делают его отличным выбором для численных расчетов, таких как оценка числа Пи.

Не забудьте оптимизировать алгоритмы и при необходимости рассмотрите возможность использования библиотек Rust для повышения точности и эффективности. Наслаждайтесь экспериментами с этими методами и открывайте для себя красоту вычислений числа Пи в Rust!