Conversion bits

Bonjour,

157 (10) représenté sur 16 bits

0000000010011101(2) = 157 (10)

Le complément à 1 :
(inversion des bits)
1111111101100010

Le complément à 2 : -> Complément à 1 + 1

1111111101100010
0000000000000001
------------
1111111101100011

Lupin

Bonsoir,

Lupin tu m'as rafraichi un peu la mémoire mais mes (lointains) souvenirs m'amène une petite interrogation...
Le complément à 2 ce n'est pas pour représenter les nombres négatifs uniquement ?
Sans doute c'est sous-entendu dans la question remarque, sinon plus trop d'interet
eric

Salut,

C'est loin aussi pour moi, mais enfin si l'on considère que dans la plupart des cas, la logique
négative réduit de moitié au minimum le nombre de portes pour une équation donnée (algèbre de bool),
on comprend facilement que la représentation négative d'un nombre est vital.

Et quelque soit la représentation utilisé, la machine elle ne comprends que le binaire !

Oui de mémoire je crois que le complément à 2 ne sert qu'a représenter les nombres négatifs.
Remarque, ma mémoire n'est pas infaible !

@+
Lupin

La logique négative... lointain souvenir aussi.
En tout cas merci de ta réponse
eric

Merci pour cette aide précieuse mais j'ai encore deux trois doutes alors je me permets de vous poser ses questions pour avoir des confirmations

la représentation en base 2 de 2^16 - 1 sur 32 bits est tels bien ça

2^16 = 1000 0000 0000 0000 0000 0000 0000 0000
1 = 0000 0000 0000 0000 0000 0000 0000 0001

et donc complément à 1 cela donne 1111 1111 1111 1111 1111 1111 1111 1110
donc à 2 1111 1111 1111 1111 1111 1111 1111 1111
et en aditionnant on arrive à ( avec 1 en retenu ) 0111 1111 1111 1111 1111 1111 1111 1111

Est ce que cela est bon ?
merci d'avance

bonjour

" la représentation en base 2 de 2^16 - 1 sur 32 bits est tels bien ça

2^16 = 1000 0000 0000 0000 0000 0000 0000 0000"

Non cela c'est -2^31

2^16 - 1 c'est (sur 32 bits) 0000 0000 0000 0000 1111 1111 1111 1111

Manu

Bonjour,

32 bits, donc de 2^16 correspond au 17è bit.

2^16-2^15-2^14-2^13-2^12-2^11-2^10-2^9-2^8-2^7-2^6-2^5-2^4-2^3-2^2-2^1-2^0
..1...-..0...-..0...-..0...-..0...-..0...-..0...-..0..-.0..-.0..-.0..-..0..-..0..-.0..-.0..-..0..-..0..

10000000000000000

représenté sur 32 bits

00000000000000010000000000000000

complément à 1

11111111111111101111111111111111

complément à 2

+
00000000000000000000000000000001
=
11111111111111110000000000000000

Lupin

re :

ah oui, je n'ai pas fait attention au [ -1 ], Manu a raison !

2^16 = 0000 0000 0000 0001 0000 0000 0000 0000

2^16 - 1 = 0000 0000 0000 0000 1111 1111 1111 1111

C 1 -> .....1111 1111 1111 1111 0000 0000 0000 0000

C 2 -> .....1111 1111 1111 1111 0000 0000 0000 0001

Lupin

Okiche merci pour vos info j'ai compris pour le 2^16 mais je ne comprends pas pour le -1 ? Pourquoi faire le complement à 1 puis à 2 de 2^16; je ne vois pas quand le -1 intervient ?

Est-ce que vous pouvez m'aider aussi a resoudre ceci convertir le nombre 9E[16 en petit en bas ] en base 10 ?

Merci pour votre aide je suis vraiment pas douée avec le binaire ...

Bonjour,

L'énoncé que vous avez présenté est :

" ... la représentation en base 2 de 2^16 - 1 sur 32 bits est tels bien ça ... "

j'en comprends que :

2^16
-
1
=
représentation du résultat en base 2 sur 32 bits
------
les puissances de base commencent à n^0 = 1

32 positions, le 32ième bit étant 2^31, donc le
premier selon notre mode de lecture (de gauche à droite)
0000 0000 0000 0001 0000 0000 0000 0000

2^16 = 65536
d'ou
65536 - 1 = 65535
65535(10) = 0000 0000 0000 0000 1111 1111 1111 1111(2)
------

L'intérêt du complément à 1 et à 2 est relativement simple !
Ce n'est pas un hazard si nous choissisons de représenter des
mots binaire par regroupement binaire de 4 bits, nous travaillons
avec des octets qui renferme 8 bits !!!

0000 0000 0000 0000 1111 1111 1111 1111
00000000 00000000 11111111 11111111

Circuit-Logique-101 (Collège de Sherbrooke/Québec/Canada)
Un mathématicien à démontré qu'il était aiser de passer du binaire
à l'hexadécimal par simple regroupement binaire de 4 bits.

Il faut vraiment avoir codé en assembleur pour comprendre
que lorsqu'il y a debordement du registre, les compléments 1 & 2
permettent de retenir le bit du registre d'état du débordement.
1111 1111 1111 1111 0000 0000 0000 0001
.............................................................^
si tu prends une lecture indirect sur 16 bits,
tu récupère ainsi le bit de débordement avant
qu'il ne surviennent.

0000(2) = 0(16) = 0(10)
0001(2) = 1(16) = 1(10)
0010(2) = 2(16) = 2(10)
0011(2) = 3(16) = 3(10)
0100(2) = 4(16) = 4(10)
0101(2) = 5(16) = 5(10)
0110(2) = 6(16) = 6(10)
0111(2) = 7(16) = 7(10)
1000(2) = 8(16) = 8(10)
1001(2) = 9(16) = 9(10)
1010(2) = A(16) = 10(10)
1011(2) = B(16) = 11(10)
1100(2) = C(16) = 12(10)
1101(2) = D(16) = 13(10)
1110(2) = E(16) = 14(10)
1111(2) = F(16) = 15(10)

9E(16) = ( 9(10) * 16^1 ) + ( 14(10) * 16^0 )

Lupin

Et pourquoi on peut pas faire 2^16 = 0000 0000 0000 0001 0000 0000 0000 0000
1 = 0000 0000 0000 0000 0000 0000 0000 0001
complément a 1 = 1111 1111 1111 1111 1111 1111 1111 1110
completment a 2 = 1111 1111 1111 1111 1111 1111 1111 1111

et pour finir faire 0000 0000 0000 0001 0000 0000 0000 0000
- 1111 1111 1111 1111 1111 1111 1111 1111
----------------------------------------------------------
0000 0000 0000 0000 1111 1111 1111 1111

ah bah si c'est la même chose donc ma méthode est valide ^^ Merchi

Par contre je ne comprends pas la conversion de 9E(16)

et pouver vous m'éclaircir aussi sur cette question que se passe t il quand un processeur effectue un calcul dont le résultat dépasse ses capacités ? s'il vous plait. merci d'avance (il plante ou il rame ? )

re :

c'est dans votre énoncé !

" ... la représentation en base 2 de 2^16 - 1 sur 32 bits est tels bien ça ... "

il est spécifié : [ 2^16 - 1 sur 32 bits ] et non [ 2^16 sur 32 bits ].

"... la conversion de 9E(16) ... "
Revoir votre formation sur les bases : http://membre.oricom.ca/lupin/images/lesbases.gif

"... que se passe t il quand un processeur effectue un calcul dont le résultat dépasse ses capacités ..."

ça je ne pourrais dire, ça dépend de l'erreur. J'ai vu les deux, le processeur planté, ou encore prit
dans une boucle sans fin.

Lupin

bonsoir,

petit complément: en cas de dépassement de capacité un des bit d'erreur du processeur (overflow error) se positionne et permet de gerer (si le programme l'a prévu) cette erreur.

eric

Bonjour,

voilà, je suis d'accord.

La conversion

Voyons les choses plus globalement, le processeur est synchronisé sur un crystal pour connaître
le point de départ ( start bit ), ensuite il envoie une série de bits, prenons par exemple la série
suivante (une trame de bits) : 0000000000000000000100011110

par regroupement binaire, on obtient :

0000 0000 0000 0000 0000 1001 1110

exprimons maintenant chaque groupe en base 10

...0......0......0......0......0......9.....14

exprimons maintenant chaque groupe en base 16 ( utiliser la table fournit en message 10 )

...0......0......0......0......0......9......E

16^6-16^5-16^4-16^3-16^2-16^1-16^0

alors :

E(16) * 16^0 = 14 (10)
9(16) * 16^1 = 144(10)

9E(16) = [ 14(10) + 144(10) ] = 158(10)

Lupin

re :

Le bit de débordement !

Le registre est constitué d'un nombre fixe
de bits, posons exemple un registre à 8 bits
pour faire simple.

RRHINZVC

Réservé
Réservé
Halt
Irq
Négatif
Zéro
oVerflow
Carrybit

Or il suffit de vérifier ces états pour rendre
compte du bit de débordement, en assembleur
l'erreur n'est pas permise, il faut toujours
contrôlé le programme.

Le complément à 1 et à 2 sont des exemples
mathématiques appliqués par des circuits
logiques.

Quelque soit le nombre de bits qui forment
le registre, celui-ci prend ses informations
sur chaque instructions du programme et
réflête l'état du systême en tout temps.
Le complément à 1 & à 2, sont codés
dans l'architecture par des opérations
d'algèbre de Bool (mathématicien), et
c'est opérations réflêtent certains bits
du registre d'états. Le processeur procure
ainsi des instructions valide de branchement,
ex.: bra, beq, bne, bcc, etc ...
( branche toujours, branche si égale, branche si non égale, branche si carry clear ...)

Lupin