Erreur d'arrondi avec les nb flottants

[djbad]

Bonjour à tous voila j'ai besoin d'aide
je dois résoudre ces exo mais en fait je ne comprends rien
En ce moment nous sommes sur les nb flottants
Voila le premier exo
il existe une plus grande valeur v représentée en virgule
flottante telle que x + v = x, à cause des erreurs d'arrondis
Écrire un programme pour déterminer cette valeur pour x = 1, x = 2, x = 4. Généraliser pour x = 2n.
Vérifier avec le programme

Pour le second
Écrire un programme qui calcule la fonction exponentielle
avec la formule de Taylor :
ex = 1 + x + x^2/2!+ x^3/3!+ x4^/4!+.... + x^n/n!
Constater l'erreur d'approximation produite.

Pour la premiere partie voila ce que j'ai compris
mais ca reste tres flou
on me demande à partir de combien de chiffres après la virgule la comparaison de deux nombres va provoquer une erreur d'arrondi
comment trouver cette valeur quand x = 1 ou x = 2
si on travaille sur 32 bit ou 64 bit ce n'est pas la même chose non ? Ca ne dépend aussi du langage ou de la machine utilisé ?
pour x = 1 ne serait pas 1^-23 ou pour x = 2^-23
j'ai l'impression de me noyé
Merci a ceux qui prendront le temps de me répondre
-----

[invite986312212]

oui ça dépend des machines, mais en pratique il y a des normes, notamment la norme IEEE 754, que les constructeurs respectent s'ils veulent vendre leurs microprocesseurs. Tu peux chercher sur wiki, la norme en question est bien décrite, mais comme il s'agit d'un exercice, je pense que tu dois supposer que tu ne sais rien de la machine ni du langage et écrire un programme qui découvre le nombre de bits et tous les paramètres du codage des flottants.

[djbad]

Merci oui nous etudions la norme IEEE 754
Signe x Mantisse x exposant
je pense avoir compris sa representation
Donc on cherche la valeur de v la plus petite de façon 1 + 0.0000000001 = 1 ou
2 + 0.00000000000000000000000002 = 2
si on travaille en 32 bit ou 64 bits ce n'est pas la meme chose
Ou je n'ai rien compris
j'ai essayé
V= 1, x = 1,
N = nb de bit = 0
Tant que x est different de x + v
alors faire v = 10^-n
n = n + 1
mais si x =2 c'est pareil j'ai l'impression de pataugé

[djbad]

je trouve toujours 16
x= 1 ou x = 2 ou x = 4
voila le code sur python

>>> x = 2.0
>>> v = 1.0
>>> while x + v != x :
... v = v/10.0;v

[A voir en vidéo sur Futura]

[invite986312212]

salut,

il me semble que je raisonnerais plutôt sur les puissances de 2. Et je testerais l'égalité non pas entre flottants mais bit par bit.

[NicoEnac]

Bonjour,

si on travaille en 32 bit ou 64 bits ce n'est pas la meme chose

Tu as parfaitement compris.

En 32 bits, la mantisse (qui est représentative de la précision) est sur 23 bits alors qu'en 64 bits, elle est sur 52.

Comme le souligne ambrosio, il serait plus judicieux de travailler avec les puissances de 2 car l'exposant est une puissance de 2 et la mantisse est la décomposition du nombre (en enlevant le signe et après translation d'exposant) en puissances négatives de 2.

[djbad]

Merci pour votre aide à tous les deux
Voial le code
pour x = 1

>>> x = 1.0
>>> v = 1.0
>>> while x + v != x :
... v = v/2.0;v

je trouve quelque chose comme 1.110223024625.....e-16

pour x = 2

>>> x = 2.0
>>> v = 1.0
>>> while x + v != x :
... v = v/2.0;v

je trouve quelque chose comme 2.22044604925.....e-16

pour x = 4

>>> x = 4.0
>>> v = 1.0
>>> while x + v != x :
... v = v/2.0;v

je trouve quelque chose comme 4.4408920985.....e-16

Est ce que ces valeurs sont correctes ?
Est ce que j'ai bien compris la marche a suivre ?
désolé si je parais insistant mais comme je débute c'est difficile pour moi
Mais merci quand même

[NicoEnac]

Re,

Tu as compris la méthode. Cependant, si tu cherches la plus grande valeur v telle que x+v=x, ce n'est pas cela.
x admet une décomposition comme suit : x = signe . 2^{exposant - décalage} . 1,mantisse
Ce qui limite la précision, c'est la mantisse. En effet, le signe ne nous donne qu'une indication de quel côté du zéro on se situe, l'exposant nous donne l'ordre de grandeur de la valeur mais la précision est donnée par la mantisse.

En 32 bits, la mantisse est sur 23 bits. On peut donc écrire : . Donc la plus petite valeur descriptible est 2^-23 (valeur binaire de 00000000000000000000001 pour la mantisse). Tu comprends ainsi que si tu ajoutes un nombre v strictement plus petit que 2^-23, cette valeur va passer à la trappe.
En 64 bits, le raisonnement est le même avec une mantisse sur 52 bits => une plus petite valeur descriptible de 2^-52.

Jusqu'ici je n'ai parlé que de mantisse, mais si on replace cela dans l'ordre de grandeur de x, on obtient une valeur v qui vaut : 2^{-longueur mantisse} . signe(x) . 2^{exposant - décalage}.

Ainsi, pour x = 1.0, ton algorithme a trouvé 1.110223024625.....e-16.
Si on applique mon raisonnement, on trouve v = 2,2204460492503e-16. Cela signifie que pour tout nombre v strictement plus petit que cette valeur, x + v = x.
Pour x = 2.0, v = 4,44089209850062e-16
Pour x = 4.0, v = 8,88178419700125e-16

Donc ton algorithme avait presque juste. Pour expliquer la différence de résultat, je dirais que ton algorithme ne permet pas de trouver la plus grande valeur v telle que x + v = x mais une valeur qui le vérifie.

J'aurais affiné l'algorithme : on sait que la valeur cherchée se trouve entre v et 2*v à la fin de ton algorithme. Donc j'aurais appliqué (bêtement je dois le dire car je n'ai pas d'idée transcendante) l'algo de dichotomie :

- x = valeur que tu souhaites
- v = x
- tant que x+v != x
on pose v=v/2
- on pose a = v et b = 2*v
- tant que b-a < 10^{précision souhaitée}
si x + (a+b)/2 != x, alors b = (a+b)/2
sinon a = (a+b)/2

[NicoEnac]

...si on replace cela dans l'ordre de grandeur de x, on obtient une valeur v qui vaut : 2^{-longueur mantisse} . signe(x) . 2^{exposant - décalage}.

2^{-(longueur mantisse + 1)} . signe(x) . 2^{exposant - décalage}.
Dans mon raisonnement, j'ai oublié le "+1". Et du coup, tes résultats sont justes. Désolé.
Ma proposition d'algo reste néanmoins valable pour des nombres qui ne s'écrivent pas aussi simplement que 1, 2 ou 4.

[djbad]

Merci pour ton aide
Maintenant il faut que je m'attaque au second exo
Écrire un programme qui calcule la fonction exponentielle
avec la formule de Taylor :
ex = 1 + x + x^2/2!+ x^3/3!+ x4^/4!+.... + x^n/n!
Constater l'erreur d'approximation produite.