Calcul de pi

Commenter

Contenu du snippet

Ce petit programme calule Pi avec un grand nombre de décimales.
J'utilise une série simple qui converge assez rapidement (regarder le code de la classe calculpi)
L'implémentation du calcul sur beaucoup de décimales est minimaliste. J'ai juste fait ce qui servait à la série.
L'objectif de ce prog était de mesurer les perfs de Java sur des algo très itératif et de comparer avec le C. (Le prog C est à venir).

Source / Exemple : 


/* fichier calcpi.java


     
  •  Created on 22 janv. 2005

    •  
  •  @author cyberfastfred

    •  
  •  

    •  
  •  Calcul de pi avec une serie simple 

    •  
  •  objectif comparer les perf entre Java et C sur des algo

    •  
  •  tres itératifs

    •  
  • /

import java.util.Date;

public class calcpi {

	public static void main(String[] args) {
		int i;
		UDChar pi, frac;
		java.lang.String StrPI="PI="; 
		Date now = new Date();
		System.out.println(now);
		 
		pi = new UDChar(2);
		frac = new UDChar(2);
		for (i=1; i <3000; i++){
			frac.mulEntiere(i);
			frac.divEntiere(2*i +1);
			pi.add(frac);
		}
        now = new Date();
		System.out.println(now);
		System.out.println("PI="+ pi);
		System.out.println("frac="+ frac);	
	}
}
/**********************fichier UDChar.java**************************/
/**


     
  •  @author cyberfastfred

    •  
  •  Created on 23 janv. 2005

    •  
  •  implémentation basique orientée pour le calcul de pi à 100 décimale

    •  
  •  La série calculant pi n'ajoutant que des nombre fractionnaires de plus en plus petit

    •  
  •  Les grands nombres sont uniquement positifs

    •  
  • /

public class UDChar  {
	/*nombre de chiffres*/
	public static final int PRECISION = 1000;

	protected char [] chiffres = new char [PRECISION];
	/* 10 chiffres avant la virgule PRECISION-10 chiffres après */
	
	/*créé un grand décimal à partir d'un int


    	 
  •  

    • 	 
  • /   	

    public UDChar(int entier){
    	int i;
        /*


             
  •  Initiailisation de la partie entière

    •          
  • /

         for (i=9; i>=0; i--){
         	int chiffre;
         	chiffre = entier % 10;
         	chiffres[i] = intToChiffre(chiffre);

         	entier /=10;
         }
         /*mise à 0 des décimales*/
         for (i=10; i<PRECISION; i++) chiffres[i]='0';
    }
    
	/*


    	 
  •  Ajoute l'operande Ultradecmal

    • 	 
  • /

	public void add(UDChar operande) {
		int i, somme, retenue;
		retenue = 0;
		for(i = PRECISION - 1; i >= 0; i--){
			somme = chiffreToInt(chiffres[i])
			      + chiffreToInt(operande.chiffres[i])
				  + retenue;
			retenue = somme / 10;
			somme %= 10;
			chiffres[i] = intToChiffre(somme);
		}
	}

	/*


    	 
  •  Soustrait l'opérande UltraDecimal

    • 	 
  • /

	public void sub(UDChar operande) {
		int i, retrait, retenue;
		retenue = 0;
		for(i = PRECISION - 1; i >= 0; i--){
			retrait = 10 + chiffreToInt(chiffres[i])
			      - chiffreToInt(operande.chiffres[i])
				  - retenue;
			retenue = 1 - (retrait / 10);
			retrait %= 10;
			chiffres[i] = intToChiffre(retrait);
		}
		
	}

	/*


    	 
  •  multiplication d'un UD par un entier

    • 	 
  •  suffisant pour le calcul de séries simples

    • 	 
  • /

	public void mulEntiere(int operande){
		UDChar partiel, original;
		int i, chiffre, operandeSuiv;
		original = this.dupl();
		
		/* remise à zero de l'UD */
		for (i=0; i<PRECISION; i++) chiffres[i]='0';
		
		operandeSuiv = operande;
		for (i=0; i <10 ;i++){
			partiel = original.dupl();
			chiffre = operandeSuiv % 10;
			operandeSuiv /=10;
			partiel.mulUnit(chiffre);
			this.add(partiel);
			original.shiftLeft(1);
		}
	}

	/*


    	 
  •  multiplication d'un UD par un entier

    • 	 
  •  suffisant pour le calcul de séries simples

    • 	 
  • /

	public void divEntiere(int operande){
		int i, reste, result;
		reste = 0;
		result = 0;
		for (i = 0; i <PRECISION; i++){
			reste = reste * 10 + chiffreToInt(chiffres[i]);
			result = reste / operande;
			reste = reste % operande;
			chiffres[i] = intToChiffre(result);
		}
    	
	}

	/*


    	 
  •  Renvoie une chaine cotenant le nombre représenté 

    • 	 
  • /

	public String toString() {
		String str= new String("");
		int i;
		for(i=0; i<10; i++){
			str = str + chiffres[i];
		}
		str = str +",";
		for(i=10; i<PRECISION; i++){
			if (i%80==0)str=str+"\n";
			str = str + chiffres[i];
		}
		return str;
	}
	/*


    	 
  •  clone un UD

    • 	 
  • /

	private UDChar dupl(){
		UDChar ud = new UDChar(0);
		ud.add(this); /* pas optimal mais facile */
		return ud;
	}
	
	/*


    	 
  •  decalage à droite

    • 	 
  •  equivalent à multiplication par 10 puissance pas

    • 	 
  • /

	private void shiftRight(int pas){
		int i;
		if (pas <= 0) return;
		if (pas > PRECISION) pas = PRECISION;
		for (i = pas; i <PRECISION; i++){
			chiffres[i] = chiffres[i-pas];
		}
		for (i = 0; i < pas; i++){
			chiffres[i] = '0';
		}
	}
	
	/*


    	 
  •  decalage à gauche

    • 	 
  •  equivalent à multiplication par 10 puissance pas

    • 	 
  • /

	private void shiftLeft(int pas){
		int i;
		if (pas <= 0) return;
		if (pas > PRECISION) pas = PRECISION;
		for (i = 0; i < PRECISION-pas; i++){
			chiffres[i] = chiffres[i+pas];
		}
		for (i = PRECISION-pas; i <PRECISION; i++){
			chiffres[i] = '0';
		}
	}
	
	/*


    	 
  •  convertie un chiffre sous forme de char en entier

    • 	 
  • /

	private int chiffreToInt(char chiffre){
		switch(chiffre){
			case '0':
				return(0);
			case '1':
				return(1);
			case '2':
				return(2);
			case '3':
				return(3);
			case '4':
				return(4);
			case '5':
				return(5);
			case '6':
				return(6);
			case '7':
				return(7);
			case '8':
				return(8);
			case '9':
				return(9);
			default:
				return(0);
		}
	}
	
	/*


    	 
  •  Convertie un entier de 0 à 9 en char

    • 	 
  • /

	private char intToChiffre(int chiffre){
		switch(chiffre){
			case 0:
			  return('0');
			case 1:
				  return('1');
			case 2:
				  return('2');
			case 3:
				  return('3');
			case 4:
				  return('4');
			case 5:
				  return('5');
			case 6:
				  return('6');
			case 7:
				  return('7');
			case 8:
				  return('8');
			case 9:
				  return('9');
			default:
				return('0');
		}
	}
	
	/*


    	 
  •  multiplie par un chiffre de 0 à 9

    • 	 
  • /

	private void mulUnit(int operande){
		int chiffre, i, resultat, retenue;
		chiffre = operande%10;
		retenue = 0;
		for(i = PRECISION - 1; i >= 0; i--){
			resultat = chiffreToInt(chiffres[i])


    				  
  •  chiffre

				  + retenue;
			retenue = resultat / 10;
			resultat %= 10;
			chiffres[i] = intToChiffre(resultat);
		}
	}

}

Conclusion :


Pour le calcul sur plusieurs dizaine de décimales j'utilise un tableau de caractères.
Arbitrairement les 10 premiers sont avant la virgule et les suivants sont après.
Les UDChar représentent donc des nombres positifs < 10000000000.
Il n'y a aucun controle de dépassement.
Le code n'est absolument pas optimisé puisque je parcours l'intégralité les chiffres sans chercher à éliminer les 0.
Je n'utilise aucun outils spécifique java puisque je veux avoir une implémentation proche en C pour comparer les vitesses. (En plus ça m'arrange car je ne connais presque rien à Java).

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.