Reprise du message précédent :

Dion a écrit a écrit : Aricoh: C  un débutant(comme moi), donc je lui conseille un livre pour débutant. Et pour la vanne vaseuse, je croyais que j'allais échapper à ce genre de truc lourd sur prog et bah

 
Oups, oui, j'ai un humour de merde je sais
 
le r'frais pu, promis juré craché ... ptttttou !!!!
 
Concernant la limite de 170 en factorielle indiquée par FHR, c'est sous Linux et en utilisant un double que ça se produit.
Je vous raconte pas sous Windows (ME), ça affiche plein de zéros dès qu'on demande la factorielle de 40 (même moins) !

tiens donc ... je croyais que le typage n'avait pas d'importance !?!?

quand je mets un truc du genre  
 
long double x;
 
mon compilateur l'accepte mais le prog merde après (résultats faux)

Non, c'est parce que la représentation en virgule flottante n'est que très rarement exacte dans un ordinateur. Ce qui fait que dans plein de calculs, les erreurs d'arrondis peuvent rendre le résultat complètement faux. Un seul exemple :
 
double a = 1.0;
 
a = a + 1.0e+40;
a = a - 1.0e+40;
 
Si tu affiches a, il vaudra alors zéro et non un...

merci mais je sais toujours pas comment aller plus haut que 170! .
 
Si quelqu'un a une idée...

Je t'ai déjà répondu ("Posté le 17-04-2001 à 01:34:46" ). Il faut que tu changes de type de données. Si ton compilateur supporte un type flottant allant plus loin que 10^308, utilises-le. Sinon, il te faut écrire ton propre type de données numérique qui aille aussi loin que tu en as besoin.

ok j'ai vu mais comment je fais pour utiliser le truc de Verdoux
 

 
Il faut l'intégrer au prog ? Est ce qu'il faut avoir des trucs java spéciaux pour que ça marche ?
 
merci d'avance

Non FHR, le code que Verdoux a montré, c'est du Java, pas du C

c'est bien ce qui me semblait, alors comment je fais pour créer mon type de données ?

tiens, salut aricoh, ça va ?

Eh bien, c'est assez compliqué pour un débutant. En fait, c'est un excellent exercice de programmation, mais il te faut connaître la plupart des ressources offertes par les langages de programmation et l'algorithmique : les pointeurs, la gestion mémoire en particulier.
Rien à voir avec un simple calcul de factorielle...
 
Tu veux avoir une idée ? Recherche le sujet "bistromatique" sur ce même forum "Programmation"...

Ouah, j'aurai jammais cru qu'on pourrais se prendre la tête autant que ça sur un simple programme de calcul des factoriels en C... c fou cette habitude qu'on les informaticiens de rendre compliqués de trucs pourtant simples !

Et il y aurait moyen de régler mon pb (pas plus de 170!) avec un "   enum  " ?
 
Je pense récupérer gcc (sous windows) aujourd'hui. Est ce qu'il va accepter les "   long double   " ?
 
Merci d'avance.

  Quel rapport ??
 

J'en sais rien. Mais en faisant un petit programme de quelques lignes, tu devrais rapidement le savoir...

j'arrive pas à utiliser gcc (je connais les commandes qu'il veut, apprement ce sont pas les mêmes que sous Linux.
 
BifaceMcLeOD > enum permet de définir les valeurs que peut prendre la variable, non ? Donc je pensais qu'on peut pouvais peut-être se débrouiller pour que ma variable puisse prendre des valeurs >1E308 en remplissant le enum d'une certaine façon. Excuse-moi si ce que je dis est bête mais je suis un débutant et je suis là pour progresser.

D'apres Numerical Recipes in C:
 
#include <math.h>
float gammln(float xx)
/* Returns the value ln[gamma(xx)] for xx>0 */
{
/* Internal arithmetic will be done in double precision, a nicety that you can omit if five-figure accuracy is good enough.*/
double x,y,tmp,ser;
static double cof[6]={76.18009172947146,-86.50532032941677,
24.01409824083091,-1.231739572450155,
0.1208650973866179e-2,-0.5395239384953e-5};
int j;
y=x=xx;
tmp=x+5.5;
tmp -= (x+0.5)*log(tmp);
ser=1.000000000190015;
for (j=0;j<=5;j++) ser += cof[j]/++y;
return -tmp+log(2.5066282746310005*ser/x);
}
 
float factrl(int n)
/* Returns the value n! as a floating-point number.*/
{
 float gammln(float xx);
 void nrerror(char error_text[]);
 static int ntop=4;
 static float a[33]={1.0,1.0,2.0,6.0,24.0};  
 /* Fill in table only as required.*/
 int j;
 if (n < 0)  
         nrerror("Negative factorial in routine factrl" );
 if (n > 32)  
         return exp(gammln(n+1.0));
/* Larger value than size of table is required. Actually, this big a value is going to overflow on many computers, but no harm in trying.*/
  while (ntop<n)  
     {  
/* Fill in table up to desired value.*/
       j=ntop++;
       a[ntop]=a[j]*ntop;
     }
return a[n];
}
 
A+,

[edit]--Message édité par gilou--[/edit]

Une version pour les feignants du clavier  :-)
 
long facto(long n) {
 return (n ? facto(n-1)*n : 1);
}

n0mad> T'es pas un peu bourrin là?    
 
C'est bien pour des petites fonctions, mais dans une grosse fonction, c'est dangereux... Rebouclages intempestifs!

>Gigathlon :  oui, je suis bourrin ;-) Non blague à part, je ne  programme pas comme ça. (je suis suffisamment en train de me prendre la tête avec le PERL pour éviter de programmer moi même en "code à écriture seule" comme on dit).
 
Par contre, c'est vrai que j'ai un peu tendance à abuser de l'operateur ternaire (faut pas, il parait).

euh c'est quoi le machin qu'a donné Gilou ?
 

up

C'est une fonction rapide pour obtenir une bonne estimation de la valeur de factorielle n, pour n grand.
Le calcul se base sur la famille des fonctions gamma (mais à connaissance, on ne voit ces fonctions-là qu'au niveau 2ème cycle universitaire...)
 
Plus de précisions (au cas où) : si n est inférieur ou égal à 32, on revient à la méthode de calcul classique. Enfin, pour un "calcul" plus rapide, les valeurs de factorielle n sont calculées une fois pour toutes et stockées dans un tableau local statique pour qu'une deuxième demande de calcul de factorielle soit immédiate.

[edit]--Message édité par BifaceMcLeOD--[/edit]

El_gringo a écrit a écrit : Ouah, j'aurai jammais cru qu'on pourrais se prendre la tête autant que ça sur un simple programme de calcul des factoriels en C... c fou cette habitude qu'on les informaticiens de rendre compliqués de trucs pourtant simples !

Comment ça, rendre compliqué des trucs simples ?    
C'est fhr qui est exigeant ! (si tu veux une image : il veut faire un vol stratosphérique avec un avion de ligne alors que chacun sait qu'un avion de ligne ne peut aller qu'à une dizaine de kilomètres d'altitude...).

up

BifaceMcLeOD a écrit a écrit :   Comment ça, rendre compliqué des trucs simples ?     C'est fhr qui est exigeant ! (si tu veux une image : il veut faire un vol stratosphérique avec un avion de ligne alors que chacun sait qu'un avion de ligne ne peut aller qu'à une dizaine de kilomètres d'altitude...).

 
moi je dirais plutot .. il veux faire un vol stratospherique alors à altitude normale suffit amplement !
 
il savoir poser ses limites ... c'est une question de tps donc d'argent dans le monde informatique .. un dvpeur c'est min 2000F / jour
 
alors oui tu peux surement optimiser la chose en asm aussi mais est ce que ca vaut le cout ???

up

up again

 
Ce que mon intervention soulignait, c'est que des que tu as besoin de qque chose d'assez standard, il y a des generations de programmeurs C qui sont passe avant toi et on pondu une solution efficace. Et negliger cela, quel gachis.
A+,

Bon j'ai trouvé un compilateur Borland qui gère les long double. Je peux donc aller jusqu'à 1752! . Merci à tous pour votre aide et toutes vos remarques.
 
ps : là, je fais un prog qui lit directement une expression entière (genre 10!, 2^10, 12*5, etc), s'il y en a que ça interesse...  
D'ailleurs, y a t il une instruction du style atof, atoi, pour convertir en long double (et oui, toujours ces cons de long double...) ?