Tentando calcular Pi para o número N de decimais com C #

Question

Nota: Eu já li este tema , mas Eu não entendo isso e não fornece uma solução que eu poderia usar. Eu sou terrível com problemas numéricos.

O que é um simples maneira de gerar Pi para o número de casas decimais um usuário quer? Isto não é para lição de casa, apenas tentando concluir alguns dos projetos listados aqui:

Fazer a ligação

Answer 1

Um algoritmo clássico para calcular dígitos do pi é o algoritmo de Gauss-Legendre. Embora não seja tão rápido como alguns dos algoritmos mais modernos, tem a vantagem de ser compreensível.

Let

a_0 = 1
b_0 = 1/Sqrt(2)
t_0 = 1/4
p_0 = 1

Em seguida

a_(n+1) = (a_n + b_n) / 2
b_(n+1) = Sqrt(a_n * b_n)
t_(n+1) = t_n - p_n * (a_n - a_(n+1))^2
p_(n+1) = 2 * p_n

Em seguida

pi =. (a_n + b_n)^2 / (4 * t_n)

Aqui (meio =. "aproximadamente igual") Este algoritmo exposições convergência quadrática (o número de corretas duplos casas decimais, com cada iteração).

Eu vou deixar para você traduzir isso para C #, incluindo a descoberta de uma biblioteca bignum.

Answer 2

O tópico seu falar calcular o valor de PI usando a série de Taylor. Usando a função de "duplo F (int i)", escreveu sobre o assunto vai dar-lhe o valor de PI depois de "i" termos.

Esta forma de calcular PI é uma espécie de lento, eu sugiro que você olhar para o PI rápido algoritmo .

Você também pode encontrar uma implementação aqui que obter o PI calcular ao n º dígito.

Boa sorte!

Answer 3

Se você tomar um olhar mais atento a este realmente bom guia:

Padrões para Programação Paralela : compreensão e aplicação de padrões paralelo com o .NET Framework 4

Você vai encontrar na página 70 esta implementação bonito (com pequenas alterações do meu lado):

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;
}