Comment convertir une fraction en binary?

1/10(decimal) = 0.0001100110011... (binary)

Comment je fais ça? Suis-je censé convertir en binary et ensuite diviser? Quelqu’un pourrait-il me montrer?

A l’université, je l’ai appris de cette façon:

  1. Multiplier par deux
  2. prendre décimal comme le chiffre
  3. prendre la fraction comme sharepoint départ pour la prochaine étape
  4. répétez jusqu’à ce que vous obteniez soit 0 ou un numéro périodique
  5. lire le numéro commençant par le haut – le premier résultat est le premier chiffre après la virgule

Exemple:

 0.1 * 2 = 0.2 -> 0 0.2 * 2 = 0.4 -> 0 0.4 * 2 = 0.8 -> 0 0.8 * 2 = 1.6 -> 1 0.6 * 2 = 1.2 -> 1 0.2 * 2 = 0.4 -> 0 0.4 * 2 = 0.8 -> 0 0.8 * 2 = 1.6 -> 1 0.6 * 2 = 1.2 -> 1 Result: 0.00011(0011) periodic. 
  1 1
 - (dec) = ---- (bin)
 10 1010


        0.000110011 ...
       -------------
 1010 |  1.0000000000
          1010
        ------
          01100
           1010
          -----
           0010000
              1010
             -----
              01100
               1010
              -----
               0010

Cela peut être quelque peu déroutant, mais les positions décimales en binary représenteraient des réciproques de puissances de deux (par exemple, 1/2, 1/4, 1/8, 1/16, pour la première, deuxième, troisième et quasortingème décimales, respectivement), tout comme en décimal, les décimales représentent les réciproques de puissances successives de dix.

Pour répondre à votre question, vous devez déterminer quels réciproques de pouvoirs de deux devraient être ajoutés pour totaliser 1/10. Par exemple:

1/16 + 1/32 = 0,09375, ce qui est assez proche de 1/10. L’ajout de 1/64 nous permet de dépasser, tout comme 1/128. Mais 1/256 nous rapproche encore. Alors:

0.00011001 binary = 0.09765625 décimal, ce qui est proche de ce que vous avez demandé.

Vous pouvez continuer à append de plus en plus de chiffres, donc la réponse serait 0.00011001 …

Voici comment penser la méthode.

Chaque fois que vous multipliez par 2, vous déplacez la représentation binary du nombre restant 1 place. Vous avez déplacé le chiffre le plus élevé après le point à la position 1s, donc retirez ce chiffre et il s’agit du premier chiffre (le plus élevé, donc le plus à gauche) de votre fraction. Faites cela encore et vous avez le chiffre suivant.

La conversion de la base d’un nombre entier en divisant et en prenant le rest comme chiffre suivant déplace le nombre vers la droite. C’est pourquoi vous obtenez les chiffres dans l’ordre inverse, le plus bas en premier.

Cela se généralise évidemment à n’importe quelle base, pas seulement 2, comme le fait remarquer GoofyBall .

Une autre chose à laquelle penser: si vous arrondissez à N chiffres, arrêtez-vous à N + 1 chiffres. Si le chiffre # N + 1 en est un, vous devez arrondir (puisque les chiffres en binary ne peuvent être que 0 ou 1, tronquer avec le chiffre suivant a 1 est aussi inexact que tronquer un 5 en décimal).

Il m’a fallu un moment pour comprendre la réponse de @Femaref (s), alors j’ai pensé que je pourrais élaborer.

Elboration

Vous voulez convertir un décimal 1/10 égal à 0.1 en binary. Commencez avec 0.1 comme entrée et suivez ces étapes:

  1. Multipliez l’entrée par 2 (colonne mult)
  2. Prenez décimal de la réponse (colonne de réponse) comme chiffre (colonne binary)
  3. Prenez la fraction (colonne de fraction) comme entrée pour l’étape suivante
  4. Répétez les étapes 1, 2 et 3 jusqu’à ce que vous atteigniez 0 ou un numéro périodique. Le début du numéro périodique dans ce cas est indiqué dans la dernière colonne afin que nous puissions nous arrêter là. Mais j’ai continué à montrer la répétition pour plus de clarté.
  5. La réponse est les nombres pris de la colonne binary commençant en haut.

Dans ce cas c’est:

 0.00011(0011) Note: numbers within parenthesis will keep repeating (periodic) 

 +-------+-------+--------+---------+----------+--------+----------------------+ | input | mult | answer | decimal | fraction | binary | | +-------+-------+--------+---------+----------+--------+----------------------+ | 0.1 | 2 | 0.2 | 0 | .2 | 0 | | | 0.2 | 2 | 0.4 | 0 | .4 | 0 | | | 0.4 | 2 | 0.8 | 0 | .8 | 0 | | | 0.8 | 2 | 1.6 | 1 | .6 | 1 | | | 0.6 | 2 | 1.2 | 1 | .2 | 1 | | | 0.2 | 2 | 0.4 | 0 | .4 | 0 | | | 0.4 | 2 | 0.8 | 0 | .8 | 0 | | | 0.8 | 2 | 1.6 | 1 | .6 | 1 | | | 0.6 | 2 | 1.2 | 1 | .2 | 1 | < Repeats after this | | 0.2 | 2 | 0.4 | 0 | .4 | 0 | | | 0.4 | 2 | 0.8 | 0 | .8 | 0 | | | 0.8 | 2 | 1.6 | 1 | .6 | 1 | | | 0.6 | 2 | 1.2 | 1 | .2 | 1 | | +-------+-------+--------+---------+----------+--------+----------------------+