Comment calculer pi à N, le nombre de places en C# à l'aide de boucles

Comment pourrais-je aller sur le calcul de PI en C# pour un certain nombre de décimales?

Je veux être en mesure de passer un nombre dans une méthode et de revenir PI calculé à un nombre de décimales.

public decimal CalculatePi(int places)
{
    //magic
    return pi;
}

Console.WriteLine(CalculatePi(5)); //Would print 3.14159

Console.WriteLine(CalculatePi(10)); //Would print 3.1415926535

etc...

Je ne se soucient pas de la vitesse du programme. J'ai juste envie d'être aussi simple et facile à comprendre car il peut être. Merci d'avance pour l'aide.

Simple à comprendre en termes de programmation, ou en termes de mathématiques?
en.wikipedia.org/wiki/...
Jetez un oeil ici: dotnetperls.com/pi Il y a des exemples de méthodes de calcul de pi à 20 places, toutefois, certaines limitations sont abordés tels que le manque de précision
de la programmation.

OriginalL'auteur Chev | 2012-07-26

  1. 11

    Tout d'abord, en supposant que vous voulez un certain nombre quelconque de chiffres de pi, et nous ne voulons pas être confiné avec la précision d'un des divers nombres à virgule flottante là-bas, nous permet de définir une fonction de Pi comme une chaîne de caractères plutôt que de tout type de nombre.

    L'un des plus cool des algorithmes j'ai trouvé lors de la recherche de cette technique est la Stanley Rabinowitz et Stan Wagon - Algorithme. Il ne nécessite pas de calcul en virgule flottante, et est surtout une méthode itérative. Il nécessite de la mémoire pour stocker des entiers tableaux dans les calculs intermédiaires.

    Sans prendre le temps de rationaliser ou de nettoyer le code ici est une implémentation de l'algorithme (notez le résultat n'a pas d'ajouter le point décimal).

    Assurez-vous de citer l'algorithme et ce site si vous avez l'intention d'utiliser ce code pour rien d'autre que l'utilisation personnelle.

    De Code C#

    public static string CalculatePi(int digits)
{   
digits++;
uint[] x = new uint[digits*10/3+2];
uint[] r = new uint[digits*10/3+2];
uint[] pi = new uint[digits];
for (int j = 0; j < x.Length; j++)
x[j] = 20;
for (int i = 0; i < digits; i++)
{
uint carry = 0;
for (int j = 0; j < x.Length; j++)
{
uint num = (uint)(x.Length - j - 1);
uint dem = num * 2 + 1;
x[j] += carry;
uint q = x[j] / dem;
r[j] = x[j] % dem;
carry = q * num;
}
pi[i] = (x[x.Length-1] / 10);
r[x.Length - 1] = x[x.Length - 1] % 10; ;
for (int j = 0; j < x.Length; j++)
x[j] = r[j] * 10;
}
var result = "";
uint c = 0;
for(int i = pi.Length - 1; i >=0; i--)
{
pi[i] += c;
c = pi[i] / 10;
result = (pi[i] % 10).ToString() + result;
}
return result;
}

    Mise à jour

    J'ai enfin réussi à réparer le "porter erreur qui survient après 35 chiffres. Page 6 du document lié, en fait, expressément parle de ce qui se passe ici. J'ai testé la version finale du bon de 1000 chiffres.

    Je n'ai pas regardé pendant un moment, et j'ai quitté un travail sur elle après une autre réponse a été acceptée. Je vais le revoir dans le courant de cette semaine pour voir si je ne trouve pas où ça se passe mal.
    après 4 ans, vous avez finalement m'a motivé à le résoudre
    environ 3 ans, vous avez demandé s'il y avait des mises à jour sur elle... j'ai enfin résolu
    génial, j'ai testet avec 100 chiffres - semble de travail +1

    OriginalL'auteur nicholas

  2. 7
    Math.Round(Math.PI, places)

    Si vous avez besoin de plus de précision, vous aurez de la difficulté à utiliser le type de données double car il prend en charge un certain max. précision (qui est fourni par les Mathématiques.PI).

    Oui, vous avez fait de répondre à la question, mais non, ce n'était pas ce que la question asker voulu ;-).
    Cela ne me permet d'aller à 15 places.
    Virgule a toujours 4 chiffres après la virgule? D'où vous est venue cette idée?
    Ensuite, vous devez définir le nom de domaine de votre problème. Cette méthode fonctionne pour les deux exemples que vous donnez (5 et 10 jours.p.) Qu'est-ce que vous nombre maximum de décimales?
    Oui, je sais ce que la décimale est pour, mais votre commentaire est encore non-sens. Si je fais ceci: decimal myPi = (decimal)Math.Round(Math.PI, 10); - je obtenir 3.1415926536. En d'autres termes, 10 décimales dans un type decimal. Aller de l'avant et de vérifier le site web MSDN (msdn.microsoft.com/en-us/library/system.decimal.aspx)

    OriginalL'auteur usr

  3. 6

    Après beaucoup de recherches j'ai trouvé ce petit extrait:

    public static class BigMath
{
//digits = number of digits to calculate;
//iterations = accuracy (higher the number the more accurate it will be and the longer it will take.)
public static BigInteger GetPi(int digits, int iterations)
{
return 16 * ArcTan1OverX(5, digits).ElementAt(iterations)
- 4 * ArcTan1OverX(239, digits).ElementAt(iterations);
}
//arctan(x) = x - x^3/3 + x^5/5 - x^7/7 + x^9/9 - ...
public static IEnumerable<BigInteger> ArcTan1OverX(int x, int digits)
{
var mag = BigInteger.Pow(10, digits);
var sum = BigInteger.Zero;
bool sign = true;
for (int i = 1; true; i += 2)
{
var cur = mag / (BigInteger.Pow(x, i) * i);
if (sign)
{
sum += cur;
}
else
{
sum -= cur;
}
yield return sum;
sign = !sign;
}
}
}

    Il se porte comme un charme jusqu'à présent. Vous avez juste à ajouter le Système.Numériques de la bibliothèque de la part du GAC pour résoudre le BigInteger type.

    Ce sera plus rapide si vous n'utilisez pas IEnumerable et ElementAt, mais il suffit de fournir ArcTan1OverX le nombre d'itérations à effectuer.
    comment beaucoup plus rapide?

    OriginalL'auteur Chev

  4. 5

    Même algorithme que nicolas, mais les utilise de rendement pour l'évaluation différée

        static public IEnumerable<uint> Pi()
{
uint[] x = new uint[short.MaxValue];
uint[] r = new uint[short.MaxValue];
for (int j = 0; j < short.MaxValue; j++)
x[j] = 20;
for (int i = 0; i < short.MaxValue; i++)
{
uint carry = 0;
for (int j = 0; j < x.Length; j++)
{
uint num = (uint)(x.Length - j - 1);
uint dem = num * 2 + 1;
x[j] += carry;
uint q = x[j] / dem;
r[j] = x[j] % dem;
carry = q * num;
}
yield return (x[x.Length - 1] / 10);
r[x.Length - 1] = x[x.Length - 1] % 10; ;
for (int j = 0; j < x.Length; j++)
{
x[j] = r[j] * 10;
}                    
}
}

    J'ai utilisé court.MaxValue comme limite supérieure pour le nombre d'endroits, mais c'est parce que ma machine est faible sur la mémoire virtuelle. Une meilleure machine doit être en mesure d'accueillir jusqu'à int.MaxValue.

    La fonction peut être appelée de la sorte:

     class Program
{
static void Main(string[] args)
{
foreach (uint digit in Calculator.Pi().Take(100))
{
Console.WriteLine(digit);
}
Console.Read();
}
}
    Bien fait. Merci! Que j'aime ce yield 😀
    Résultat non valide. C'est un 4 au lieu de 5, lors de la 35e chiffres - regardez-nicolas de mise à jour

    OriginalL'auteur Jason Bowers

  5. 4

    Si vous êtes satisfait avec le nombre de chiffres fournis par le natif de la bibliothèque math, alors c'est très simple; il suffit de ronde pour le nombre désiré de chiffres. Si vous avez besoin de plus des chiffres (des dizaines ou des centaines ou des milliers), vous avez besoin d'un algorithme qui crache les chiffres un à un. Jeremy Gibbons donne un algorithme qui je mettre en œuvre deux fois à mon blog, où vous trouverez le code sur le Schéma, C, Python, Haskell, Perl-et-Vient (mais pas de C#, désolé).

    OriginalL'auteur user448810

  6. 2

    La façon la plus simple est de stocker un grand nombre de chiffres de pi dans une Chaîne de caractères constante. Alors à chaque fois que vous avez besoin n de chiffres de précision, il vous suffit de prendre une sous-chaîne de 0 à n+2.

    OriginalL'auteur tskuzzy