Bonjour je fais des calculs matriciels avec des floats. Mais dans certains cas ou le resultat est 0 quand je le printf il me rajoute un - devant.
En gros si le resultat etait 0.000 il va m'ecrire -0.000 et rien a faire au niveau des conditions, le programme considere qu'il s'agit d'un 0. Y a t-il une solution parceque c'est quand meme assez moche

merci

https://www.jeuxvideo.com/forums/1-47-92594-1-0-1-0-aide-math-programmation.htm

Lit ça.

Au passage, tester l'égalité d'un flottant est une erreur. Un flottant a souvent une valeur approximative et certaines valeurs n'existent tout simplement pas (0.1, par exemple).

Bonjour

Moi je pense que se basé sur des affirmations sans fondement c'est de la bêtise, je vient de faire un petit programme avec une variable égale a 0.1f et j'ai demander de l'afficher sur une console, et sa affiche, magique, 0.100000.

Pour l'affichage de ton 0.0 a la place de -0.0 et bien teste ta valeur la valeur si c'est -0.0f tu attribut 0.0f et donc l'affichage se feras sans le -.

papy386 Non, j'ai balancé ça comme ça, sans jamais avoir fait de calcul numérique, sans jamais avoir été confronté à des ingénieurs qui pensaient que 0.1 valait 0.1 en représentation flottante. Et si tu refaisais ton test en additionnant plusieurs millions de fois 0.1, par curiosité ?

Oooooooh

Tiens, pour te faire gagner du temps, je t'ai écrit un petit fiddle : http://jsfiddle.net/CLVu7/

Et rappelle-moi de ne jamais te confier une fusée :D

Le truc c'est que tu confond la valeur d'un flottant et les calculs sur les flottants.

Et le rapport avec une fusée?

papy386 Hum, non, la valeur d'un flottant est par nature approximative, sauf pour un ensemble fini de valeurs (et 0.1 n'en fait pas partie). Pour les calculs, c'était juste pour faire ressortir l'approximation, l'imprécision des calculs sur les flottants est une conséquence de l'imprécision des flottants.

Pour compléter et te donner une introduction aux nombres flottants :
http://docs.python.org/3//3/tutorial/floatingpoint.html

Pour la fusée, c'est tout simplement que ce genre de méconnaissance des flottants amène toutes sortes de choses rigolotes vu les ordres de grandeurs en jeu, comme, se planter sur mars ou griller des spationautes à cause d'une ré-entrée dans l'atmosphère trop raide :D

Marrant ta page mais a aucun moment elle ne donne la vrai formule des flotants!!!

C'est a dire signe * mantisse * (2 ^ (exposant - décalage).

Pour les fusées c'est pas du float qu'on utilise (j'ai d’ailleurs fait des calculs de physique en gravité sur le système solaire, il faut genre 70bits rien que pour la masse du soleil,).

Appolo n'utilisait pas de float (sa existait pas), mais une sorte de virgule fixe (comme dans les moteurs de quake).

De nos jours c'est plutôt un double précision (genre 128 bits sur nos micro).

Si, elle explique parfaitement comment sont codés les flottants, elle donne même la référence de la norme IEEE qui régit leur représentation. l'exposant et le signe ne sont pour rien dans la problématique qui nous intéresse : l'impossibilité de coder exactement 0.1 et une infinité d'autres valeurs en flottant. De toute manière, même dans le cas d'un flottant respectant la norme, le problème reste le même :D
Je comprends que ça puisse te perturber et que tu ne maîtrises pas le sujet, mais tu devrais lire plus en détail les liens contenus dans cette page, tu comprendras pourquoi ton programme a affiché 0.100000 au lieu de 0.1 ;)
Ne t'inquiètes pas, même des ingénieurs font souvent la même erreur que toi :D

Pour les calculs en point fixe, oui, je connais, mais on parle des flottants, là :D

Double precision c'est 64 bit. 128 bit c'est quad precision. Les gens commencent a s'y interesser par ce que c'est plus simple de montrer la precision des nombres que d'ecrire du code stable numeriquement.

Je ne sais pas ce qu'ils utilisent dans les fusees, mais les gens de weather forecast et qui etudient les design de central nucleaire travaillent en double precision.

godrik Oui, c'est clair et net : éviter la propagation d'erreurs avec des nombres imprécis ('fin, tout dépend des ordres de grandeur et des calculs est une vraie plaie. Heureusement, comme tu le dis, les nombres flottants restent utilisables :p Par contre, il est important de connaître les limitations de cette représentation pour éviter de tomber dans les pièges classiques du calcul numérique. Ce thread montre en tous cas qu'on ne le rappelle jamais assez :D

j'en profite pour reposter les articles sur le float ieee de bruce dawnson qui n'est rien d'autre que le monsieur optimisation de chez valve:

https://www.jeuxvideo.com/forums/1-47-74224-1-0-1-0-jeu-de-programmation-devinette.htm#message_74254

elite_2009 Excellent, encore plus de ressources
Merci !

En vrai ces histoire de precision flottante sont une vraie calamite. Les gens de weather forecasting ont recement remarque que executer leur prediction sur differente machine ou plusieurs fois a la suite donne des predictions different. Faire du calcul numerique parallel et precis c'est vraiment difficile.
D'ailleurs la prochaine iteration du benchmark utilise pour le top500 imposera des contraint de precision numerique.

godrik Ils n'avaient qu'à pas utiliser des pentiums, ha, ha, ha. Plus sérieusement, les CPU utilisent de la prédiction pour ce genre de calculs sur flottants, non ? C'est une opération déterministe ?