Bonjour,
Je cherche à calculer la puissance 20ème d'un float donnèes voici le bout du code que j'ai utilisé:

   probléme:
dès que je prend d trés grand, le programme se plante,comment effectuer le meme calcul d'une manière rigoureuse d'un point de vu complexite
Merci pour toutes proposition

utilise au moins des double plutot que des float

debug en pas en pas.  
pour moi c'est pas powf qui plante ou déclenche une exception, c'est que tu sors de tes tableaux...

oui mais je dois manipuler des float, ca va diminuer un peux le temps de calcul mais je ne pense pas que cela réglera le problème

c'est quoi le message d'erreur ?
 
sinon y'a un delete qui manque...

mais ca fonctionne correctement pour des d petites de l'rdre 10,8..

et utilise boost::scoped_array<> si tu est autorisé à utiliser des bibliothèques externes.

pas  de message d'erreur ca plante uniquement, j'ai essayer ca sur un pc de faible mémoire virtuelle il me sort un message "mémoire faible" j'ai reportere ca su un autre pc plus grand ca fonctionne pour des d<20

ton d c'est deux chose: c'est ta puissance de pow, et en même temps la taille de tes tableaux.
 
ton bloc de float pointé par sqmax est toujours à 'd' en taille, mais tes 'vecteur' eux doivent avoir coord[] de constant. (au hasard à 2 ou 3)

tu peux me montrer comment bjone??

 
ça c'est lié a ta fuite mémoire dû au delete qui manque (boost::scoped_array<> ) est ton amis.

super fuite de mémoire au passage.

 
c'est quoi la définition de ta classe vecteur ?

et ton vilain #define d, c'est partout le même ?
 
ton coord[], il est initialisé comment ?
 
et ton virtual ~vecteur() il sert a quelque chose là ?
 
et tout ce petit monde ainsi que l'operator = et les constructeurs par recopie, c'est inutilement implémenté comment ?

#define d 20
 
 
dégage cette connerie.
class Vector {
static const size_t d = 20;
};

utilise std::vector

ok je vais te donner le fonction:

cette connerie et partout dans le code je m'en sert dans le main,mais c'est une bonne idée Taz

# vecteur::vecteur(float *a,int di)
# {
#     for(int i=0;i<di;i++)
#        coord[i]=a[i];
# }
 
dépassement si di > d. (c'est normalement pas la cause de ton pb)
 
vecteur::vecteur(const vecteur &p) & vecteur::operator=(const vecteur &vect) sont inutiles (surtout avec le void )
 
et ta fonction initiale:
 
float RealData::RealDistance(vecteur a,vecteur q);
ce sera mieux qu'elle soit en:
float RealData::RealDistance( const vecteur &a, const vecteur &q );
pour des raisons de clarté et de perfs

ben un #define c'est de la merde en soit. Et si en plus tu choisis un identifiant ridicule ...
 
char d = x;
 
perdu ...

l'idée est clair Taz, c vrai ,mais ca ne posera pas le problème de début n'est ce pas?

j'aurai pas besoin d'un delete non?? (destructeur)

ben si tu fais pas de new, fais pas de delete
 
vector<float> sqmax(variable);
 
for (size_t i = 0; i < variable; ++i)
   sqmax[i]

donc ce n'est pas du tout ca le probléme!!

ben si au contraire. t'as une fuite de mémoire. Commence par la corriger.

tu peux me dire comment??
ah, une remarque:je parie que les grandes puissanes ne sont pas pris en compte par les calculateurs, j'ai essayé n=pow(100,20), pas de valeurs, je crois c'est ca le problème, dés qu'on augmente la puissance on est perdu..  

100^20 = 10^40 hors les variables de type float ne peuvent aller que jusqu'a 3,4 x 10^38. Il y a un overflow la.
 
Utilise des double et tu pourras aller jusqu'a 10^308.

Merci pour l'info Angel64

palois(e) ?

Nan Nîmois

et 64 c'est ton QI ? ?

Nan c'est un nombre important pour moi (mais heureusement pas mon QI lol). Mais ce n'est pas le sujet du topic

De toute façon, d_imane, ton algo pour le calcul est mauvais, car non seulement avec des grandes puissances, tu risques à tout moment un overflow (ce qu'on voit au premier coup d'oeil), mais tu perds énormément en précision.
En principe, ce n'est pas comme ça qu'il faudrait faire ce calcul, mais je n'ai pas de réponse toute prête sur comment il faut le réaliser, car ça dépend essentiellement de ce que tu en fais après. En réalité, il y a de bonnes chances qu'un bon algo d'analyse numérique zappe complètement ce genre de calcul pour éviter les imprécisions ou instabilités.
 
Et enfin, si tu ne le retournes pas qq part, ton tableau ne sert strictement à rien.
Ceci fait la même chose, sans les bugs.
 

1.0d
powd
 
???

Bon ok, pour pow, j'ai pas vérifié s'il y a une version pour double, et pour 1.0, je corrige de suite. (J'ai pas codé sérieusement en C++ depuis un an, j'ai déjà oublié que c'est du double... )

l'idée est clair el muchacho merci

bonjour d_imane. Personne ne t'a expliqué pourquoi le static const est préférable au #define. Pour faire simple, le #define c'est une macro non débuggable (enfin en théorie) qui appartient au langage C. Là tu fais du C++, donc tu déclares ta constante en tant que membre global de ta classe et en plus la valeur est débuggable (que des avantages en somme).

youuuuuuuuuuupi slash33 est là!!
bonjour,
  ca veut dire quoi une valeur débuggable?

une valeur débuggable, çà veut dire que tu pourras y accéder une fois la compilation terminée genre en débugguant.
 
une macro n'existe plus (le preprocesseur applique le #define MACHIN truc en faisant un find & replace de MACHIN par truc dans le code source) avant que le processus de compilation proprement dit ne débute (linkage tout çà), par conséquent tu n'y as plus accés une fois le processus de codage terminé, c'est pour çà entre autre que les macros c'est "sale" dans la plupart des cas.