Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2791 connectés 

 


Dernière réponse
Sujet : [C] Besoin d'aide (débutant)
fhr 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...) ?

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse


[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 

Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
fhr 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...) ?
gilou

la viper a écrit a écrit :

 
 
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 ???




 
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+,

fhr up again
fhr up
la viper

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 ???

fhr up
BifaceMcLeOD

El_gringo a écrit a écrit :

:eek2: 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...).

BifaceMcLeOD 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]

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

Citation :


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];  
}  

n0mad >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).
Gigathlon n0mad> T'es pas un peu bourrin là? :lol:  :pt1cable:  
 
C'est bien pour des petites fonctions, mais dans une grosse fonction, c'est dangereux... :ouch: Rebouclages intempestifs!
n0mad Une version pour les feignants du clavier  :-)
 
long facto(long n) {
 return (n ? facto(n-1)*n : 1);
}
gilou 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]

fhr 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.
BifaceMcLeOD

fhr a écrit a écrit :

Et il y aurait moyen de régler mon pb (pas plus de 170!) avec un "   enum  " ?




 :??: Quel rapport ??
 

Citation :


Je pense récupérer gcc (sous windows) aujourd'hui. Est ce qu'il va accepter les "   long double   " ?


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

fhr 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.
El_gringo :eek2: 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 !
BifaceMcLeOD 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"...
fhr tiens, salut aricoh, ça va ?
fhr c'est bien ce qui me semblait, alors comment je fais pour créer mon type de données ?
Aricoh Non FHR, le code que Verdoux a montré, c'est du Java, pas du C
fhr ok j'ai vu mais comment je fais pour utiliser le truc de Verdoux
 

Citation :


import java.lang.*;  
import java.math.*;  
 
public class test {  
public static BigInteger fact(BigInteger n) {  
  BigInteger r = BigInteger.ONE;  
  for(;!(n.equals(BigInteger.ONE));n = n.subtract(BigInteger.ONE)) r = r.multiply(n);  
  return r;  
}  
 
public static void main(String args[])  
{  
System.out.println(fact(new BigInteger(args[0])).toString());  
}  
};  


 
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

BifaceMcLeOD 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.
fhr merci mais je sais toujours pas comment aller plus haut que 170! .
 
Si quelqu'un a une idée...
BifaceMcLeOD

la viper a écrit a écrit :

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




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...

fhr quand je mets un truc du genre  
 
long double x;
 
mon compilateur l'accepte mais le prog merde après (résultats faux)
la viper tiens donc ... je croyais que le typage n'avait pas d'importance !?!?
Aricoh

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) !


Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)