Voilà, j´ai écrit un petit bout de code pour calculer pi²/6, afin après de retrouver la valeur ( approchée, les décimales étant infinies) de pi.

1. include < iostream.h>

void main()
{
double x;
double y;
double n;

for(n = 0; n < = 20; n++)
{
x = 1/(2^n);
y = x + 1/(2^(n+1));
n = n + 1;
}

cout < < y;

return 0;
}

Mais comment dire que pour 2^n je veux dire 2 puissance n ? Il me semble qu´il faut utiliser les bits de décalage ou un truc dans le genre mais je ne sais plus quoi.

Note de la formule :

infini
__E_____1/2^n = pi²/6
n = 0

Dans math.h il y´a une fonction pow

POW(3) Manuel du programmeur Linux POW(3)

NOM
pow, powf, powl - Fonction puissance

SYNOPSIS
#define _GNU_SOURCE
#include < math.h>

double pow ( double x, double y);

float powf ( float x, float y);

long double powl ( long double x, long double y);

DESCRIPTION
La fonction pow() renvoie la valeur de x élevé à la puissance y.

ERREURS
EDOM L´argument x est négatif, et y n´est pas entier. Le résultat
serait un nombre complexe.

NOTES
Pour utiliser les fonctions de la bibliothèque mathématique, il ne faut
pas oublier d´ajouter l´argument -lm sur la ligne de commande de cc(1)
ou ld(1), lors de l´édition des liens.

CONFORMITÉ
SVID 3, POSIX, BSD 4.3, ISO 9899 Les variantes float et long double
sont des demandes C99.

VOIR AUSSI
sqrt(3), cbrt(3)

TRADUCTION
Christophe Blaess, 1996-2003.

Merci

1. include < iostream.h>
2. include < math.h>
3. define _GNU_SOURCE

void main()
{
int n;
double x;
double Array[150];

for(n = 0; n < = 150; n++)
{
x = 1/(pow(2, n));
Array[n] = x;
}

double b;
double c;

for(int a = 0; a < = 20; a++)
{
b = Array[n] + Array[n+1];
c = c + b;
a = a + 1;
}

cout < < c < < " \n\n";

c = c * 6;
c = sqrt(c);

cout < < c;

for(;;){}
}

Comme résulat il me sort 3.43... e-153 pas logique ça

pas trop non

Je crois avoir trouvé, j´ai mis Array[n] dans le deuxième for au lieu de Array[a].

Quel abruti -_-

Ouais...
Mais il trouve 3.4641, serait-ce du au fait que je n´ai mis " que" double ? Parce que si je mets long double pour x, Array, b et c il plante :/

OUAIS !
Il me met 3.14166 ! ! C´est qui le plus fort ?

Bon ça va je suis content, je viens de terminer mon premier programme qui touche aux maths

félicitation, les math c´est trop fort en C.

juste, je trouve que ton premier prog était plus propre que celui ou tu stocke les puissance dans un tableau ( ça ne te fait pas gagner de temps, donc ça ne sert à rien sauf à utiliser de la mémoire et à rendre le prog un peu moins compréhensible).

et pour tes puissance, utilise plutot _scalb(1,x) pour calculer 2 à la puissance x ( logiquement c´est un peu plus rapide car optimisé pour les puissances de 2).

voila, bonne chance pour la suite.

moi jvoudrais bien savoir quelle est l´opération pour trouver pi?

Merci dnob
Je vais essayer avec ce que tu m´as dit, voir si je trouve plus exact.

Pour trouver, il n´y a pas d´opération " exacte", les décimales étant infinies ( du moins on le suppose, Pi étant surement un nombre univers).

Et la formule c´est :

infini
___E____ 1 / 2^n
n = 0

Avec cette formule tu trouvez pi² / 6, tu multiplies donc par 6, puis tu le mets sous une sqrt et tu as pi ( ou une approximation).

P.S: Puis-je trouver un nombre avec plus de 5 décimales

dnob, le compilo me sort :

implicit declaration of ´int scalb(...)´

J´ai essayé avec _scalb, et il me dit pareil

( il me fait la même pour _asm)

C´est parce que j´ai DEV C++ peut-être ?

on ne suppose pas que Pi ait une infinité de décimal, on sait que Pi a une infinité de décimal.

en faisant tourner ta boucle plus loin, tu devrais pouvoir atteindre 8 ou 9 décimal ( je ne conait pas la précision du type double). Mais il y a 2 problème qui se pose.

d´une part cette suite n´est pas excellente, il en existe de bien meilleur qui converge bcp plus vite ( c´est a dire qui vont plus vite vers un résultat plus précis) et donc avec cette algorithme, tu en aurais pour des jours rien que pour avoir quelques milliers de décimal ( peut être un peu plus quand même mais bon).

l´autre problème est que les type de donnée de base sont quand même limité en précision et donc si tu veux vraiment une bonne précision, il te faut soit utiliser un langage mathématique qui supporte plus de précision ( mapple, ou autre) mais qui sont assez lent, soit utilisez une bibliothèque de calcul en précision infinie.

l´une des meilleur ( en attendant que je finisse la mienne bien sur) est probablement celle disponible ici : http://www.mpfr.org/ qui s´appuie sur le projet GNU ( gage de qualité s´il en est).

Il faut que j´extracte tous les fichiers du . rar de mpfi dans mon projet ou dans le include de mon compilo ?

Et j´ai agrandi ma boucle jusqu´à 512, 1024 puis 2048, ça ne change rien

oki merci chaos clad

mince...

avant il était distribué avec les fichiers de projets pour vc6 qui se compilait très bien.

bon, le plan de rechange, c´est de DL GMP depuis cette page : http://www.cs.nyu.edu/exact/core/gmp/
où tu peut le trouver déjà compiler ( ce quin´est pas le cas di site officiel : http://www.swox.com/gmp/#DOC mais sur lequel tu peut trouver la doc du logiciel).

donc, il te faut soit Visual Studio, soit cygwin ( avec ou sans mingw) ( désolé si t´utilise dev c++).

tu téléacharge sur le premier site les fichiers " static GMP library and header file for Visual C++" ( ou autre selon ton compilo) c´est plus simple que de prendre les dynamic.

ensuite tu mets dans le dossier include de ton compilo le . h du zip et dans le dossier lib les . lib du zip.

puis tu link ton projet à la lib et tu include le . h et voila, il ne te reste plsu qu´a lire l´aide.

Mais il ne s´agit pas exactement du même logiciel que le MPFR, entre autre, i est un peu moins bon pour les nombre à virgule flottantes, mais ça va quand même ( ça va même très bien).

Merci pour l´info, mais malheureusement j´utilise DEVCPP

en fait, c´est pas grave, il suffit que tu dl les fichier pour mingw, c´est le compilo de dev cpp je croit.