Как я могу вычислить значение PI с помощью С#?
Я думал, что это будет через рекурсивную функцию, если да, то как бы она выглядела и есть математические уравнения для ее поддержки?
Я не слишком суетлив к производительности, в основном, как это сделать с учебной точки зрения.
Если вы хотите рекурсию:
PI = 2 * (1 + 1/3 * (1 + 2/5 * (1 + 3/7 * (...))))
Это станет, после некоторой перезаписи:
PI = 2 * F(1);
с F (i):
double F (int i) {
return 1 + i / (2.0 * i + 1) * F(i + 1);
}
Исаак Ньютон (вы, возможно, слышали о нем раньше;)) придумал этот трюк. Обратите внимание, что я оставил конечное условие, чтобы оно было простым. В реальной жизни вы нуждаетесь в этом.
Как насчет использования:
double pi = Math.PI;
Если вам нужна более высокая точность, вам потребуется использовать алгоритмическую систему и десятичный тип.
Есть несколько действительно, действительно старых трюков, которых я удивляюсь, чтобы не видеть здесь.
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 as: +3,14159265358979323846 что, вероятно, хорошо, насколько это возможно.
Урок, который вы получаете от оценки PI, состоит в том, что есть много способов сделать это, никто никогда не будет совершенным, и вы должны отсортировать их по назначению.
355/113 - старая китайская оценка, и я считаю, что она предваряет 22/7 на многие годы. Меня научил профессор физики, когда я был несовершеннолетним.
Если вы внимательно изучите это действительно хорошее руководство:
Вы найдете на этой милой реализации (с незначительными изменениями с моей стороны):
static decimal ParallelPartitionerPi(int steps)
{
decimal sum = 0.0;
decimal step = 1.0 / (decimal)steps;
object obj = new object();
Parallel.ForEach(
Partitioner.Create(0, steps),
() => 0.0,
(range, state, partial) =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
decimal x = (i - 0.5) * step;
partial += 4.0 / (1.0 + x * x);
}
return partial;
},
partial => { lock (obj) sum += partial; });
return step * sum;
}
Хороший обзор различных алгоритмов:
Я не уверен в сложности, заявленной для алгоритма Гаусса-Лежандра-Саламина в первой ссылке (я бы сказал O (N log ^ 2 (N) log (log (N)))).
Я рекомендую вам попробовать, однако, конвергенция очень быстро.
Кроме того, я не совсем уверен, зачем пытаться преобразовать довольно простой процедурный алгоритм в рекурсивный?
Обратите внимание: если вы заинтересованы в производительности, то работа с ограниченной точностью (как правило, требующая "double", "float",... output) на самом деле не имеет смысла, поскольку очевидный ответ в таком случае просто для того, чтобы жестко определить значение.
Вот статья о вычислении PI в С#:
Что такое 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
Рекурсия на любую большую глубину, как правило, непрактична для коммерческой программы, но хвостовая рекурсия позволяет рекурсивно выражать алгоритм, а реализована как цикл. Рекурсивные алгоритмы поиска иногда могут быть реализованы с использованием очереди, а не стека процессов, поиск должен отступать от мертвой точки и идти другим путем - эти точки возврата могут быть помещены в очередь, а несколько процессов могут отключать точки и пытаться другие пути.
Рассчитайте так:
x = 1 - 1/3 + 1/5 - 1/7 + 1/9 (... etc as far as possible.)
PI = x * 4
У тебя есть Pi!!!
Это самый простой метод, о котором я знаю.
Значение PI медленно сходится к фактическому значению Pi (3.141592165......). Если вы повторяете больше раз, тем лучше.
Здесь хороший подход (от главная запись в Википедии на стр.); он сходится намного быстрее, чем простая формула, рассмотренная выше, и вполне поддается рекурсивному решению, если вы намерены продолжить рекурсию в качестве учебного упражнения. (Предполагая, что вы после обучения, я не даю никакого реального кода.)
Основная формула такая же, как и выше, но этот подход усредняет частичные суммы для ускорения сходимости.
Определите функцию двух параметров, 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
Итак, ваша первая возможность исследовать рекурсию - это кодировать "горизонтальное" вычисление по мере увеличения параметра "ширина" (для "высоты" ).
Затем добавьте второе измерение с помощью этой формулы:
pie(h, w) = (pie(h-1,w) + pie(h-1,w+1)) / 2
который используется, конечно, только для значений h больше нуля.
Хорошая вещь об этом алгоритме заключается в том, что вы можете легко объединить его с электронной таблицей, чтобы проверить свой код, когда вы исследуете результаты, полученные по более высоким параметрам. Когда вы вычислите пирог (10,10), вы получите приблизительное значение для pi, которое будет достаточно хорошим для большинства инженерных целей.
Enumerable.Range(0, 100000000).Aggregate(0d, (tot, next) => tot += Math.Pow(-1d, next)/(2*next + 1)*4)
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();
}
}
}
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;
}
В любом сценарии производства я заставил бы вас искать значение, до нужного числа десятичных точек и хранить его как "const", где ваши классы могут добраться до него.
(если вы не пишете научное специальное программное обеспечение Pi...)
Что касается...
... как это сделать с учебной точки зрения.
Вы пытаетесь научиться программировать научные методы? или для производства программного обеспечения для производства? Я надеюсь, что сообщество увидит это как правильный вопрос, а не нитпик.
В любом случае, я думаю, что написать свой собственный Pi - это проблема. Дмитрий уже показал константу "Math.PI". Атакуйте еще одну проблему в одном пространстве! Пойдите для общих аппроксимаций Ньютона или чего-то гладкого.
@Томас Каммайер:
Обратите внимание, что Atan (1.0) довольно часто жестко закодирован, поэтому 4 * Atan (1.0) на самом деле не является "алгоритмом", если вы вызываете библиотечную функцию Atan (довольно многие из них уже начали предлагать замену Atan ( х) на ряд (или бесконечное произведение) для него, затем оценивая его при х = 1.
Кроме того, очень мало случаев, когда вам понадобится pi с большей точностью, чем несколько десятков бит (который может быть легко жестко запрограммирован!). Я работал над приложениями в математике, где для вычисления некоторых (довольно сложных) математических объектов (которые были полиномиальны с целыми коэффициентами) мне приходилось делать арифметику на реальные и сложные числа (включая вычисление pi) с точностью до несколько миллионов бит... но это не очень часто "в реальной жизни":)
Вы можете посмотреть следующий пример code.
Следующая ссылка показывает, как вычислить константу pi на основании ее определения как интеграла, который можно записать как предел суммирования, это очень интересно: https://sites.google.com/site/rcorcs/posts/calculatingthepiconstant Файл "Pi как интеграл" объясняет этот метод, используемый в этом сообщении.
Мне нравится этот документ, в котором объясняется, как рассчитать π на основе расширения серии Тейлора для Arctangent.
Работа начинается с простого предположения, что
Atan (1) = π/4 радиан
Atan (x) можно итеративно оценить с помощью ряда Тейлора
atan (x) = x - x ^ 3/3 + x ^ 5/5 - x ^ 7/7 + x ^ 9/9...
В документе указывается, почему это не особенно эффективно и продолжает делать ряд логических уточнений в технике. Они также предоставляют примерную программу, которая вычисляет π до нескольких тысяч цифр, в комплекте с исходным кодом, включая требуемые математические процедуры с бесконечной точностью.
Во-первых, обратите внимание, что С# может использовать поле Math.PI платформы .NET:
https://msdn.microsoft.com/en-us/library/system.math.pi(v=vs.110).aspx
Приятная особенность здесь заключается в том, что она представляет собой полный предел точности, который вы можете использовать или сравнивать с вычисленными результатами. Вкладки этого URL имеют похожие константы для С++, F # и Visual Basic.
Чтобы рассчитать больше мест, вы можете написать свой собственный код с расширенной точностью. Быстрый, быстрый и простой в программировании код:
Pi = 4 * [4 * arctan (1/5) - arctan (1/239)]
Эта формула и многие другие, в том числе некоторые, которые сходятся с удивительно быстрыми темпами, такими как 50 цифр на член, находятся во Вулграме:
public double PI = 22.0 / 7.0;