Как я вычисляю PI в C#?

public double PI = 22.0 / 7.0;

Мне нравится эта статья , в которой объясняется, как вычислить π на основе разложения в ряд Тейлора для Арктангента.

Работа начинается с простого предположения, что

Атан (1) = π / 4 радиан

Атан (x) может быть итеративно оценен с помощью ряда Тейлора

атан (х) = х - х ^ 3/3 + х ^ 5/5 - х ^ 7/7 + х ^ 9/9 ...

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

@Thomas Kammeyer:

Примечание, что Atan (1.0) довольно часто hardcoded, таким образом, 4*Atan (1.0) не действительно 'алгоритм', если Вы вызываете функцию библиотеки Atan (довольно многие уже предложили действительно, продолжаются путем замены Atan(x) рядом (или бесконечное произведение) для него, затем оценивая его в x=1.

кроме того, существует очень немного случаев, где Вам было бы нужно пи в большей точности, чем несколько десятков битов (который может быть легко hardcoded!). Я работал над приложениями в математике, где, для вычисления некоторых (вполне сложный) математические объекты (которые были многочленом с целочисленными коэффициентами) я должен был сделать арифметику на вещественных и комплексных числах (включая вычислительное пи) с точностью до нескольких миллионов битов..., но это не является очень частым 'в реальной жизни':)

можно искать следующий пример код .

Что касается ...

... как это сделать с точки зрения обучения.

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

В любом случае, я думаю, что написание собственного Pi - это решенная проблема. Дмитрий уже показал константу «Math.PI». Атаковать еще одну проблему в том же пространстве! Пойдите для общих приближений Ньютона или чего-то другого.

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

(если Вы не пишете научному 'Pi' определенное программное обеспечение...)

    public static string PiNumberFinder(int digitNumber)
    {
        string piNumber = "3,";
        int dividedBy = 11080585;
        int divisor = 78256779;
        int result;

        for (int i = 0; i < digitNumber; i++)
        {
            if (dividedBy < divisor)
                dividedBy *= 10;

            result = dividedBy / divisor;

            string resultString = result.ToString();
            piNumber += resultString;

            dividedBy = dividedBy - divisor * result;
        }

        return piNumber;
    }

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

Базовая формула та же, что и выше, но этот подход усредняет частичные суммы для ускорения сходимости.

Определите двухпараметрическую функцию pie (h, w) так, чтобы:

pie(0,1) = 4/1
pie(0,2) = 4/1 - 4/3
pie(0,3) = 4/1 - 4/3 + 4/5
pie(0,4) = 4/1 - 4/3 + 4/5 - 4/7
... and so on

Итак, ваша первая возможность исследовать рекурсию - это кодирование этого «горизонтального» вычисления при увеличении параметра «width» (для «высоты» нуля).

Затем добавьте второе измерение с этой формулой:

pie(h, w) = (pie(h-1,w) + pie(h-1,w+1)) / 2

, которое используется, конечно, только для значений h больше нуля.

Хорошая особенность этого алгоритма состоит в том, что вы можете легко смоделировать его с помощью электронной таблицы, чтобы проверить код при изучении результатов, полученных с помощью постепенно увеличивающихся параметров. К тому времени, когда вы вычисляете pie (10,10), у вас будет приблизительное значение для pi, которое достаточно для большинства инженерных целей.

Вычислите как это:

x = 1 - 1/3 + 1/5 - 1/7 + 1/9  (... etc as far as possible.)
PI = x * 4

у Вас есть Pi!!!

Это - самый простой метод, о котором я знаю.

значение Pi медленно сходится к фактическому значению Pi (3.141592165......). Если Вы выполняете итерации больше раз, лучше.

Что такое PI? Окружность круга, разделенная на его диаметр.

В компьютерной графике вы можете нарисовать / нарисовать окружность с центром в 0,0 от начальной точки x, y, следующую точку x ', y' можно найти по простой формуле: x '= x + y / h: y '= y - x' / h

h обычно является степенью 2, так что деление может быть легко выполнено со сдвигом (или вычитанием из показателя степени в два раза). h также хочет быть радиусом r вашего круга. Легкой начальной точкой будет x = r, y = 0, а затем посчитать c количество шагов до x < = 0, чтобы построить четверть круга. PI 4 * c / r или PI 4 * c / h петля. Иногда рекурсивные алгоритмы поиска могут быть реализованы с использованием очереди, а не стека процесса, при поиске необходимо вернуться из тупика и выбрать другой путь - эти точки возврата могут быть помещены в очередь, а несколько процессов могут снять их с очереди и попробовать другие пути.

Вот статья о Вычислении PI в C#:

http://www.boyet.com/Articles/PiCalculator.html

Хороший обзор различных алгоритмов:

• Вычислительное пи ;
• Gauss-Legendre-Salamin .

я не уверен в сложности, требуемой алгоритм Gauss-Legendre-Salamin в первой ссылке (я сказал бы O (N log^2 (N) журнал (журнал (N)))).

я действительно поощряю Вас пробовать его, тем не менее, сходимость действительно быстро.

кроме того, я не действительно уверен в почему, пытаясь преобразовать довольно простой процедурный алгоритм в рекурсивный?

Примечание, которое, если Вы интересуетесь производительностью, затем работающей в ограниченной точности (обычно, требуя 'двойного', 'плавания'... вывод) действительно не имеет смысла как очевидный ответ в таком случае, является только к hardcode значением.

Существуют несколько действительно, действительно старые приемы, которые я удивлен не видеть здесь.

atan (1) == PI/4, таким образом, старая история, когда защищенная функция арктангенса присутствует, 4*atan (1).

очень милый А, оценка фиксированного отношения, которая заставляет старый Западный 22/7 быть похожим на грязь, является 355/113, который хорош к нескольким десятичным разрядам (по крайней мере три или четыре, я думаю). В некоторых случаях это даже достаточно хорошо для целочисленной арифметики: умножьтесь на 355, тогда делятся на 113.

355/113 также легко запомнить (для некоторых людей так или иначе): считайте один, один, три, три, пять, пять и помните именование цифр в знаменателе и числителе (если Вы забываете, какой триплет идет на вершину, мысль микросекунды обычно собирается выяснить его).

Указание, которое 22/7 дает Вам: 3.14285714, который является неправильным в тысячных частях.

355/113 дает Вам 3.14159292, который не является неправильным до этих десяти миллионных частей.

Acc. к/usr/include/math.h на моем поле, M_PI является #define'd как: 3.14159265358979323846, который, вероятно, хорош, насколько это идет.

урок Вы добираетесь от оценки, что PI - то, что существует много способов сделать его, ни один никогда не будет прекрасен, и необходимо уладить их надлежащим использованием.

355/113 является старой китайской оценкой, и я полагаю, что он предшествует 22/7 на многие годы. Этому преподавал меня преподаватель физики, когда я был старшекурсником.

Как насчет использования:

double pi = Math.PI;

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

using System;

namespace Strings
{
    class Program
    {
        static void Main(string[] args)
        {

/*          decimal pie = 1; 
            decimal e = -1;
*/
            var stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start(); //added this nice stopwatch start routine 

  //leibniz formula in C# - code written completely by Todd Mandell 2014
/*
            for (decimal f = (e += 2); f < 1000001; f++)
            {
                 e += 2;
                 pie -= 1 / e;
                 e += 2;
                 pie += 1 / e;
                 Console.WriteLine(pie * 4);
            }

                 decimal finalDisplayString = (pie * 4);
                 Console.WriteLine("pie = {0}", finalDisplayString);
                 Console.WriteLine("Accuracy resulting from approximately {0} steps", e/4); 
*/

// Nilakantha formula - code written completely by Todd Mandell 2014
// π = 3 + 4/(2*3*4) - 4/(4*5*6) + 4/(6*7*8) - 4/(8*9*10) + 4/(10*11*12) - (4/(12*13*14) etc

            decimal pie = 0;
            decimal a = 2;
            decimal b = 3;
            decimal c = 4;
            decimal e = 1;

            for (decimal f = (e += 1); f < 100000; f++) 
            // Increase f where "f < 100000" to increase number of steps
            {

                pie += 4 / (a * b * c);

                a += 2;
                b += 2;
                c += 2;

                pie -= 4 / (a * b * c);

                a += 2;
                b += 2;
                c += 2;

                e += 1;
            }

            decimal finalDisplayString = (pie + 3);
            Console.WriteLine("pie = {0}", finalDisplayString);
            Console.WriteLine("Accuracy resulting from {0} steps", e); 

            stopwatch.Stop();
            TimeSpan ts = stopwatch.Elapsed;
            Console.WriteLine("Calc Time {0}", ts); 

            Console.ReadLine();

         }
     }
 }