Salut tout le monde,
Je veux calculer un nombre transcendant de type pi, et j'ai envie de choisir le nombre de chiffre après la virgule, et le float pose problème car il est arrondie à 6 chiffres. Je veux pas un nombre fixe de chiffres après la virgule mais une possiblité de pouvoir le choisir, donc je pense qu'il faut en quelque sorte créer une variable ou recoder le float.
PS : je précise que je code sur C, et non C++

Merci d'avance.

bah tu peux utiliser les "double" ou les "long double" respectivement sur 8 et 10 octets (au lieu de 4 pour un float) mais dans tous les cas la précision sera fixée et ne pourra pas évoluer.

Si tu veux vraimment une précision variable et ce genre de choses, il faut te tourner vers de libs qui doivent implémenter ca (je n'en connais pas mais je suis certain que ca doit exister, fait un tour sur le net).

Sinon tu peux toujours coder ta propre lib, comme ca tu auras réellement quelque chose qui correspondra à tes besoin.
A coup de prog dynamique, tu pourras "réguler" ta précision à loisir.

BOn courage.

il y a des lib pour ca gere les "big numbers".

- GMP (GNU Multiple Precision Arithmetic Library)
http://www.swox.com/gmp/

devrait contenir ce qu'il te faut

Merci pour le lien, par contre comme je suis un débutant en C, j'ai un peu du mal à m'en servir... Déjà est ce qu'il marche sur un windows? car j'ai l'impression que GMP n'est compatible que sur linux. Et après, c'est quelle librairie à utiliser? Car il y en a plusieurs pour différentes fonctions mathématiques.

Merci

dans la section 2.4 de la documentation, il y a des informations sur comment l'utiliser sous windows.

Merci pour le lien godrik, en effet j'ai réussi à l'installer.

Par contre j'ai toujours un problème. En fait, je veux un logiciel qui calcule le nombre de champernowne
(0.12345678910111213141516171819202122232425....)

Mais avec le code que j'ai, j'ai 0.12345679012345679012345679012..., au lieu de continuer vers 10, 11 etc..., ça revient à 0 (en plus y'a le 8 qui disparait mystérieusement...

Voici le code que j'ai :

1. include <cstdlib>
2. include <iostream>
3. include <gmp.h>

using namespace std;

int main(int argc, char *argv[])
{
int n=1000; //approximation de l'affichage
int i=0;
int j=900; //décimales à calculer
mpf_t a; // pour declarer un grand flottant a
mpf_t b; //
mpf_t c; //
mpf_t d;//

mpf_init2 (a,1024); // pour allouer la memoire necessaire au flottant
mpf_init2 (b,1024); //
mpf_init2 (c,1024); //
mpf_init2 (d,1024); //

mpf_set_str (a, "0",10); // a = 0
mpf_set_str (d, "10",10); // d = 10

for (i=0;i<j;i++)
{
mpf_pow_ui (b,d,i); // b = 10^i
mpf_ui_div (c,i,b); // c = i/b
mpf_add (a,a,c); // a = a+c
}

gmp_printf ("%.*Ff with %d digits\n", n, a, n);

mpf_clear(a); // liberer l'espace allouer a a !
mpf_clear(b); // liberer l'espace allouer a a !
mpf_clear(c); // liberer l'espace allouer a a !

system("PAUSE");
return EXIT_SUCCESS;
}

bah oui...
for (i=0;i<j;i++)
{
mpf_pow_ui (b,d,i); // b = 10^i
mpf_ui_div (c,i,b); // c = i/b
mpf_add (a,a,c); // a = a+c
}

quand tu arrive a 10, il faut decaler de 2 decimale et plus d'une seule

gmp a certainement une fonction pour construire un flottant depuis uen chaîne de caractère. Donc le plus simple serait peut-être d'écrire le nombre à la précision que tu veux dans une chaîne et ensuite de la faire lire par gmp. En plus, ça serait certainement plus efficace.

dnob >>> gmp gére déjà les big numbers, il y a une utilité particulière d'utiliser des chaines?

godrik >>> je crois voir ce que tu me dis, mais par contre comment coder ça...