Décimal/Binaire et erreur

[invitef3f3826f]

Bonjour tout le monde,
J'ai un petit problème de conversion décimal/binaire à résoudre mais je ne sais pas par quel bout le prendre.
Mon problème est le suivant :

Convertir 0,2 (base 10) en binaire avec un nombre de digits suffisamment important pour avoir une erreur relative vraie inférieur à 0,005.

Pour convertir 0,2 en binaire, pas de soucis. Mon problème se situe sur l'erreur relative.
J'ai une formule qui pourrait m'être utile mais je ne sais pas comment l'exploiter :

E_s = (0,5 x 10^2-n)% avec n le nombre de digits nécessaires pour avoir un résultat correct.

Sachant que E_s> E_a avec E_a une erreur relative d'approximation si je ne me trompe pas.

En vous remerciant d'avance pour votre coup de pouce.
-----

[invited1c1a33e]

Bonjour, il y a une confusion entre le binaire et le décimal dans votre question.
http://fr.wikipedia.org/wiki/Binary_coded_decimal

Voulez-vous parler d'entiers et de nombres à virgule flottante ?

Sinon vous pouvez coder 0,2 en binaire en posant (par exemple) que 00000001 = 0,1, erreur = 0 (et 2 <=> 00000010)
http://fr.wikipedia.org/wiki/Virgule_fixe

En virgule flottante vous avez effectivement une marge d'erreur. Je vous laisse regarder :

http://fr.wikipedia.org/wiki/Virgule_flottante

La marge d'erreur sera la valeur absolue de (le nombre - sa représentation en virgule flottante) / le nombre

[invitef3f3826f]

Merci pour ta réponse mais cela ne m'aide pas plus. J'ai déjà lu tout ça mais je ne sais pas comment coder "précisément" 0,2 en binaire.
Dois-je passer en floating-point?

La question précisément est la suivante :"Rewrite the number 0.2 in binary form with sufficient number of digits so that the true relative error is less than 0.005." (Désolé pour l'anglais j'étudie au Canada en ce moment)
Je n'ai pas plus d'information.

Merci encore

[Jack]

les maths ne sont pas ma tasse de thé, mais je me dis que si l'erreur relative qu'on appellera e doit être inférieure à 0,005, on peut écrire:
(e/0.2) < 0.005, soit e < 0.001
L'erreur maxi en représentation binaire correspond donc au bit n le moins significatif, donc 2^-n

On peut écrire que 2^-n < 0.001
On fait le log des 2 membres:
log(2^-n)< log(0.001) => -n.log(2) < -3.log(10) => -n < -3/log(2) => n > 9,97 environ

Comme n est entier, on prendra n = 10

Il faudra donc 10 bits après la virgule.

A+

[A voir en vidéo sur Futura]

[invitef3f3826f]

Merci pour ta réponse,
J'étais plutôt parti comme suite:

dx/x = 0,005 l'erreur relative [erreur /valeur vraie] = [0,001/0,2] = 0,005
Eps = 2^1-n

0,005 < 2^1-n
En passant par le log je trouve n=8,64 soit n=9

A+

[Jack]

Eps = 2^1-n

Que signifie Eps? Epsilon? Mais à quoi cela correspond-il?

On est bien d'accord que l'erreur absolue est égale à 0.001? Et qu'elle correspond à la valeur du bit le moins significatif?

2^-9 = 0,001953125 et comme 0,001953125 > 0.001, il faut bien 10 bits.
2^-10 = 0,0009765625 < .001

Ou alors je n'ai pas bien compris le problème.

[polo974]

en fait, si on fait un arrondi correct, 9 bits suffisent...

[Jack]

C'est quoi une arrondi correct? Un exemple?

A+

[polo974]

1,1 tronqué => 1 erreur ,1
1,9 tronqué => 1 erreur ,9 arghh, le max d'erreur est donc tout juste inférieure à 1

1,1 arrondi => 1 erreur ,1
1,9 arrondi => 2 erreur ,1
1,4 arrondi => 1 erreur ,4
1,5 arrondi => 2 erreur ,5 bof, l'erreur max est ici de ,5

on a donc divisé l'erreur par 2 en faisant un arrondi au lieu d'une troncature.

l'arrondi correspond pour un nombre positif à ajouter 0,5 (en base 10) puis de tronquer.

maintenant, si on arrondi mal les nombre négatif (un bug, quoi ! ! !), on risque d'avoir des surprises,
donc bien voir comment sont codés les négatifs (complément à 2 (comme dans les int) ou valeur plus signe (comme dans la mantisse des float (sans entrer trop dans le détail du poids fort toujours à un donc non stocké et cas spécifique du 0)).

d'où le "correct" juste pour signaler que ce n'est pas aussi trivial (mais je laisse les autres cogiter un peu )...

[invited1c1a33e]

La question précisément est la suivante :"Rewrite the number 0.2 in binary form with sufficient number of digits so that the true relative error is less than 0.005."

Je pose 1 = 0.2 et donc j'ai ma réponse avec une erreur relative nulle. Quand on n'a qu'un seul nombre à coder et pas de système imposé on fait ce qu'on veut. Ou alors manque-t-il une partie de l'énoncé ?

[invite8486e7c5]

Il faut savoir comment coder le nombre. Je m'explique, si tu veux coder un nombre flottant, il faut savoir comment tu le codes. Il faut le coder avec le minimum de bits et les nombres binaires sont toujours considéré comme des entiers, dans N ou Z. Supposons que le premier bit (bit de poid fort) correspond à la valeur 2^(-1) (soit 0,5) et tous les bits suivants (du poid fort au poid faible) seront considérés comme tel.

Dans ton cas, un nombre de 10 bits est requis (et non 9), Jack a raison (voir son calcul), on peut aussi intituivement voir:
Bit 01 - 0,5 (MSB)
Bit 02 - 0,25
Bit 03 - 0,125
Bit 04 - 0,0625
Bit 05 - 0,03125
Bit 06 - 0,015625
Bit 07 - 0,0078125
Bit 08 - 0,00390625
Bit 09 - 0,001953125
Bit 10 - 0,0009765625 (LSB)
...

Soit nous avons un nombre de 10 bits pour avoir la résolution de +/- 1 LSB (0,001). Mais on doit prendre en considération que ce nombre tiens compte du LSB soit Flottant = Entier*2^(-10). Ainsi le nombre binaire 10 0100 0000 ne correspond à 576 mais à 576*2^(-10) = 0,5625.
Les valeurs binaires sont donc pour 0,2 de: 00 1100 1100 (0.19921875) ou 00 1100 1101 (0.2001953125). Dans les 2 cas, la valeur est juste si on prend en compte la précision mais la deuxième est plus précise, on prendra cette valeur.

Juste pour info:

Sur les ordinateurs à base de micro-processeur x86 (les PC), les nombres flottants sont des entiers, dans N, accompagné par un bit indiquant la pleine résolution du nombre, la valeur de leur exposant de 2, qui est aussi un entier dans N, et d'un bit de signe. Ces nombres flottants peuvent aussi bien être un entier qu'un nombre avec des décimales, cela dépend de la valeur de l'exposant et du domaine d'application.

On peut considéré que pour tous 2^(10*n) où n est un entier, dans Z, la valeur est proche de 10^(3*m) où m est un entier, dans Z. Attention, c'est juste une approximation pour aller plus vite.
1TB -> 40bits
1GB -> 30bits
1MB -> 20bits
1kB -> 10bits
1B -> 1
1mB -> 10bits (dans ton cas)
1µB -> 20bits
1nB -> 30bits
1pB -> 40bits