Le Calcul De Pi Programme Java

Je vais prendre mon premier langage de programmation Java de la classe et c'est mon premier projet de la classe. Je suis tellement confus sur la façon de l'aborder. Toute aide ou correction sera appréciée.

Vous pouvez calculer approximativement la valeur de la constante PI en utilisant les séries suivantes:

PI = 4 ( 1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + ... + ( (-1)^(i+1) )/ (2i - 1) )

Invite à l'utilisateur la valeur de i (en d'autres mots, combien de termes de cette série à utiliser)
calcul de PI. Par exemple, si l'utilisateur entre 10000, somme les 10 000 premiers éléments de la série et ensuite afficher le résultat.

En plus d'afficher le résultat final (final de l'approximation de PI), je veux que vous pour afficher le long de la façon dont votre intermédiaire calcule à chaque puissance de 10. Donc, 10, 100, 1000, 10000, et ainsi de suite, l'affichage à l'écran de l'approximation de PI au numéro de résumé des éléments.

C'est ce que j'ai fait jusqu'à présent ..

import java.util.Scanner;
        public class CalculatePI {

            public static void main(String[] args) {
                //Create a Scanner object
                Scanner input = new Scanner (System.in);

                //Prompt the user to enter input
                System.out.println("Enter number of terms");
                double i = input.nextDouble(); //value of i user entered
                    double sum = 0;
                for(i=0; i<10000; i++){
                           if(i%2 == 0) //if the remainder of `i/2` is 0
                           sum += -1 / ( 2 * i - 1);
                        else
                           sum += 1 / (2 * i - 1);
    }

                        System.out.println(sum);


    }
}
Woudl la récursivité de l'aide ici?
Le point essentiel de cette est de le mettre infinie formule de sommation dans le code
for(int i = 0; i < input; i++) { summation += Math.pow(-1, i + 1) / (2 * i - 1) }
ce sont de drôles de conventions de nommage que vous ahve il
À l'exception de la tentative de retour à un double à la fin d'une méthode qui est déclarée comme void ..., votre code a l'air assez bon pour un débutant.

OriginalL'auteur sean | 2014-02-10

  1. 8

    Première chose que je vois est à vous de tenter de renvoyer une valeur à partir de votre void main méthode.

    ne pas return pi; de votre méthode principale. L'imprimer.

    System.out.println(pi);

    Deuxièmement, quand les gens écrire un for boucle, ils sont généralement une itération sur i, ce qui est probablement le même i que votre professeur visées dans la formule

    for(double i=0; i<SomeNumber; i++)
{
    sum += ((-1)^(i+1)) / (2 * i - 1) );
}

    maintenant, ça ne fonctionnera pas correctement comme il est, vous avez encore à gérer la ^, java n'utilise pas de manière native. heureusement pour vous, -1^(i+1) est une alternance de nombre, de sorte que vous pouvez simplement utiliser un if déclaration

    for(double i=0; i<SomeNumber; i++)
{
    if(i%2 == 0) //if the remainder of `i/2` is 0
        sum += -1 / ( 2 * i - 1);
    else
        sum += 1 / (2 * i - 1);
}
    Effectivement ^ est valide (natif) de l'opérateur en java (et beaucoup de style C les langues en général). Mais ce n'est pas applicable à virgule flottante types, puisqu'il signifie bit à bit ou exclusif.

    OriginalL'auteur Sam I am

  2. 2

    parfois la réponse est une simple ligne de code. Aussi, vous réaffectez i à 0 donc Im en supposant que vous utilisez la saisie de l'utilisateur dans le mauvais sens. 

    for(int counter=1;counter<input;counter++){
    sum += Math.pow(-1,counter + 1)/((2*counter) - 1);
}

    pour une entrée qui peut être n'importe quelle variable, codé en dur ou définie par l'utilisateur (telles que 1000, 10000, 100000). Cela devrait fonctionner

    OriginalL'auteur Man I Am

  3. 1

    Comprendre la formule: Réfléchir sur la nature de la formule avant de tenter de les résoudre par le code. Je dis cela parce que si vous l'avez fait, vous ne devriez pas essayer d'alterner entre le positif et le négatif avec le code suivant:

    if(i%2 == 0)
    sum += -1 / ( 2 * i - 1); 
else
    sum += 1 / (2 * i - 1);

    La série alterne entre des nombres positifs et négatifs parce que le numérateur,

    -1 ^ (i + 1).

    Lorsque l'exposant est pair, le numérateur est positif. Lorsque l'exposant est impair, le numérateur est négatif. Ce qui signifie qu'il n'y pas besoin d'alterner entre les nombres positifs et négatifs dans votre code car la formule intrinsèquement le fait. Aussi, on doit calculer la somme dans la parenthèse 1er et ensuite multiplier par 4 à la fin.

    Formule dans le code: D'écrire la formule dans le code, vous devez être conscient que vous aurez besoin de faire des Mathématiques.pow(base, exposant) méthode à un nombre à une puissance. Par exemple, 2 ^ 3 est les Mathématiques.pow(2, 3). Avec cette méthode à l'esprit la formule comme ceci:

    PI = 4 * (1 - 1/3 + 1/5 + ... + Math.pow(-1, i + 1) / (2 * i - 1));

    Calcul de PI: Vous pouvez utiliser une boucle for pour calculer PI en utilisant une boucle for comme ceci:

    for (int i = 10000; i > 0; i--) {
      PI += Math.pow(-1, i + 1) / (2 * i - 1); //Calculate series in parenthesis
      if (i == 1) { //When at last number in series, multiply by 4
        PI *= 4;    
        System.out.println(PI); //Print result
      }  
}

    J'ai choisi de faire mon pour le début de la boucle de 10000 et à la fin quand j'ai = 1. La raison fondamentale en est que, en Java, en raison de l'arrondissement des nombres à virgule flottante, vous obtiendrez des résultats plus précis, si vous ajoutez les petits numéros de 1ère et de travailler votre chemin à un plus grand nombre. Je suis donc le calcul de la série de droite à gauche au lieu de gauche à droite. Puis-je laisser le programme pour calculer les valeurs dans la parenthèse et qu'au dernier numéro de la série t-il multiplier par 4 et imprimer le résultat.

    Remarque: vous pouvez remplacer 10000 avec la saisie de l'utilisateur comme suit:

    java.util.Scanner input = new java.util.Scanner(System.in); //You can import instead
System.out.println("Enter number of loops: ");
int loops = input.nextInt();

for (int i = loops; i > 0; i--) {
...

    OriginalL'auteur Edmond Weiss

  4. 0

    //Voici la formule pour comment je ferais PI approximations en utilisant Babylonien de la méthode.

    int count = 10;
int m = 1;
int n = 0;
double pi = 0.0;
final double SQRT_12 = Math.sqrt(12);
while (count > n)
{
    pi += SQRT_12 * (Math.pow(-1, n)/(m * Math.pow(3, n)));
    System.out.println(pi);
    m += 2;
    n++;
}

    OriginalL'auteur William Hanson