Fonctionnement d'un ordinateur/Les circuits de comparaison

Un livre de Wikilivres.
Aller à la navigation Aller à la recherche

Les comparateurs sont des circuits qui permettent de comparer deux nombres, à savoir s'ils sont égaux, si l'un est supérieur à l'autre, ou inférieur, ou différent, etc. Dans ce qui va suivre, nous allons voir quatre types de comparateurs. Le premier type de circuit vérifie si un nombre est nul ou différent de zéro. Le second vérifie si deux nombres sont égaux, tandis que le troisième vérifie s'ils sont différent. Enfin, le quatrième vérifie si un nombre est supérieur ou inférieur à un autre. Il faut signaler que nous avons déjà vu comment vérifier qu'un nombre est égal à une constante dans le chapitre sur les circuits combinatoires, aussi nous ne reviendrons pas dessus.

Le comparateur de 1 bit[modifier | modifier le wikicode]

Comparateur 1 bit.

Pour commencer, nous allons voir comment vérifier si deux bits sont égaux/différents, si le premier est inférieur au second ou supérieur. Le but est de créer un circuit qui prend en entrée deux opérandes A et B, et fournit en sortie quatre bits :

  • qui vaut 1 si l'opérande A est supérieure à B et 0 sinon ;
  • qui vaut 1 si l'opérande A est inférieure à B et 0 sinon ;
  • qui vaut 1 si l'opérande A est égale à B et 0 sinon ;
  • qui vaut 1 si l'opérande A est différente de B et 0 sinon.

Notons rapidement que les deux dernières entrées sont l'inverse l'une de l'autre, ce qui n'est pas le cas des deux premières. Nous allons d'abord voir comment calculer les deux premières sorties, à savoir et . La raison à cela est que les deux autres sorties peuvent se calculer à partir de celles-ci.

Peut-être avez-vous remarqué l'absence de sortie qui indique si ou . Mais ces deux sorties peuvent se calculer en combinant la sortie avec les sorties et .

Le comparateur de supériorité/infériorité stricte[modifier | modifier le wikicode]

En premier lieu, nous allons voir comment vérifier qu'un bit A est strictement supérieur ou inférieur à un bit B. Pour cela, le mieux est d'établir la table de vérité des deux comparaisons. La table de vérité est la suivante :

Entrée A Entrée B Sortie < Sortie >
0 0 0 0
0 1 1 0
1 0 0 1
1 1 0 0

On obtient les équations suivantes :

  • Sortie > :
  • Sortie < :

Le comparateur d'inégalité 1 bit[modifier | modifier le wikicode]

La seconde étape est de concevoir un petit circuit qui vérifie si deux bits sont différents, inégaux. Pour cela, on peut combiner les deux signaux précédents. En effet, on sait que si A et B sont différents, alors soit A>B, soit A<B. En conséquence, on a juste à combiner les deux signaux vus précédemment avec une porte OU.

Comparateur d'inégalité 1 bit.

Ce circuit devrait vous dire quelque chose. Pour ceux qui n'ont pas déjà remarqué, le mieux est d'établir la table de vérité du circuit, ce qui donne :

Entrée 1 Entrée 2 Sortie
0 0 0
0 1 1
1 0 1
1 1 0

On voit rapidement qu'il s'agit d'une porte XOR.

Le comparateur d'égalité 1 bit[modifier | modifier le wikicode]

Enfin, nous allons concevoir un petit circuit qui vérifie si deux bits sont égaux. La logique veut que l'égalité est l'inverse de l'inégalité, ce qui fait qu'il suffirait d'ajouter une porte NON en sortie du circuit. Le circuit précédent est alors facile à adapter : il suffit de remplacer la porte OU par une porte NOR. Et si le comparateur d'inégalité 1 bit était une porte XOR, on devine rapidement que le comparateur d'égalité 1 bit est quant à lui une porte NXOR. Ce qui se vérifie quand on regarde la table de vérité du comparateur :

A B A=B
0 0 1
0 1 0
1 0 0
1 1 1

L'interprétation de ce circuit est assez simple. Par définition, deux nombres sont égaux si les deux conditions et sont fausses. C’est pour cela que le circuit calcule d'abord les deux signaux et , puis qu'il les combine avec une porte NOR.

Le circuit complet[modifier | modifier le wikicode]

Fort de ces résultats, nous pouvons fabriquer un comparateur de 1 bit. Celui-ci prend deux bits en entrée, et fournit trois bits en sortie : un pour l'égalité, un autre pour la supériorité et un autre pour l'infériorité. Voici le circuit au complet (sans le bit de différence). On pourrait rajouter le bit de différence assez simplement, en ajoutant une porte OU en sortie des signaux et , mais nous le ferons pas pour ne pas surcharger inutilement les schémas.

Comparateur de magnitude 1 bit.
Comparateur de magnitude 1 bit, alternatif.

Il est aussi possible de reformuler le schéma précédent pour supprimer une redondance invisible dans le circuit, au niveau de la porte NXOR qui calcule le bit d'égalité. A la place, il est possible de prendre les signaux et et de les combiner avec une porte NOR. Ou encore mieux : on utilise une porte OU et une porte NON, la sortie de la porte OU donnant directement le bit d'inégalité, celle de la porte NON donnant le bit d'égalité. Cela économise quelques transistors, mais rallonge un petit peu le circuit.

Comparateur 1 bit complet

Le comparateur avec une constante[modifier | modifier le wikicode]

Voyons maintenant un comparateur qui vérifie si le nombre d'entrée est égal à une certaine constante (2, 3, 5, 8, ou tout autre nombre) qui dépend du circuit et renvoie un 1 seulement si c’est le cas. Ainsi, on peut créer un circuit qui mettra sa sortie à 1 uniquement si on envoie le nombre 5 sur ses entrées. Ou comme autre exemple, créer un circuit qui met sa sortie à 1 uniquement quand l'entrée correspondent au nombre 126. Et ainsi de suite : tout nombre peut servir de constante à vérifier. Il possède donc plusieurs entrées, sur lesquelles on place les bits du nombre à comparer. Sa sortie est un simple bit, qui vaut 1 si le nombre en entrée est égal à la constante et 0 sinon.

Introduction : le comparateur avec zéro[modifier | modifier le wikicode]

Le premier circuit que nous allons aborder vérifie si un nombre est nul. Il fonctionne sur un principe simple : un nombre est nul si tous ses bits valent 0.

La solution la plus simple pour créer ce circuit est d'utiliser une porte NOR à plusieurs entrées. Par définition, la sortie d'une NOR vaut zéro si un seul bit de l'entrée est à 1 et 0 sinon, ce qui répond au cahier des charges.

Porte NOR utilisée comme comparateur avec zéro.

Il existe une autre possibilité strictement équivalente, mais qu'il est utile de comprendre pour la suite de ce chapitre. L'idée est d'inverser l'entrée avant de faire la comparaison. Les bits inversés valent tous 1 si l'entrée est nulle, alors qu'une entrée non-nulle donnera au moins un bit à 1. Cette fois-ci, le circuit ne se résume plus à une seule porte logique, mais à deux couches de portes logiques. La première inverse tous les bits, et un autre qui vérifient s'ils valent tous un. Le premier circuit est naturellement composé de portes NON, une par bit. Elle est suivie par une porte ET à plusieurs entrées qui vérifie si tous les bits sont à 1.

Circuit compare si l'opérande d'entrée est nulle.

Notons qu'en peut passer du premier circuit au second, et du second circuit au premier, en utilisant les lois de de Morgan.

Le comparateur avec une constante : cas général[modifier | modifier le wikicode]

Les circuits qui vont suivre sont une amélioration du circuit de comparaison avec zéro. Ou plutôt, les circuits de comparaison avec zéro précédents ne sont que des cas particuliers des circuits qui vont suivre. Dans ce qui va suivre, nous allons voir les comparateurs avec une constante, et nous allons voir qu'il y en a deux types, qui ressemblent aux deux types de comparateurs avec zéro. Le premier type est basé sur une porte NOR, à laquelle on ajoute des portes NON. Le second est basé sur une porte ET précédée de portes NON. Le second type ressemble beaucoup au comparateur avec zéro, ce qui fait que nous allons le voir en priorité. Tout comparateur avec une constante est systématiquement composé de deux couches de portes logiques

Le comparateur avec une constante de type NON-ET[modifier | modifier le wikicode]

Le comparateur avec une constante de type NON-ET est conçu avec une couche de portes NON et une porte ET à plusieurs entrées. Créer un tel circuit se fait en trois étapes. En premier lieu, il faut convertir la constante à vérifier en binaire : dans ce qui suit, nous nommerons cette constante k. En second lieu, il faut créer la couche de portes NON. Pour cela, rien de plus simple : on place des portes NON pour les entrées de la constante k qui sont à 0, et on ne met rien pour les bits à 1. Par la suite, on place une porte ET à plusieurs entrées à la suite de la couche de portes NON.

Exemples de comparateurs (la constante est indiquée au-dessus du circuit).

Pour comprendre pourquoi on procède ainsi, il faut simplement regarder ce que l'on trouve en sortie de la couche de portes NON :

  • si on envoie la constante, tous les bits à 0 seront inversés alors que les autres resteront à 1 : on se retrouve avec un nombre dont tous les bits sont à 1 ;
  • si on envoie un autre nombre, soit certains 0 du nombre en entrée ne seront pas inversés, ou alors des bits à 1 le seront : il y aura au moins un bit à 0 en sortie de la couche de portes NON.

Ainsi, on sait que le nombre envoyé en entrée est égal à la constante k si et seulement si tous les bits sont à 1 en sortie de la couche de portes NON. Dit autrement, la sortie du circuit doit être à 1 si et seulement si tous les bits en sortie des portes NON sont à 1 : il ne reste plus qu'à trouver un circuit qui prenne ces bits en entrée et ne mette sa sortie à 1 que si tous les bits d'entrée sont à 1. Il existe une porte logique qui fonctionne ainsi : il s'agit de la porte ET à plusieurs entrées.

Fonctionnement d'un comparateur avec une constante.

Le comparateur avec une constante de type NON-NOR[modifier | modifier le wikicode]

Le second type de comparateur avec une constante est fabriqué avec une porte NOR précédée de portes NON. Il se fabrique comme le comparateur précédent, sauf que cette fois-ci, il faut mettre une porte NON pour chaque bit à 1 de l'opérande, et non chaque bit à zéro. En clair, la couche de portes NON est l'exact inverse de celle du circuit précédent. Le tout est suivi par une porte NOR.

Exemples de comparateurs de type NON-NOR.

Pour comprendre pourquoi on procède ainsi, il faut simplement regarder ce que l'on trouve en sortie de la couche de portes NON :

  • si on envoie la constante, tous les bits à 0 seront inversés alors que les autres resteront à 1 : on se retrouve avec un zéro en sortie ;
  • si on envoie un autre nombre, soit certains 1 du nombre en entrée ne seront pas inversés, ou alors des bits à 0 le seront : il y aura au moins un bit à 1 en sortie de la couche de portes NON.

La porte NOR, quant à elle est un comparateur avec zéro, comme on l'a vu plus haut. Pour résumer, la première couche de portes NON transforme l'opérande et que la porte NOR vérifie si l'opérande transformée vaut zéro. La transformation de l'opérande est telle que son résultat est nul seulement si l’opérande est égale à la constante testée.

Fonctionnement des comparateurs de type NON-NOR.

Il est possible de simplifier le circuit en utilisant la loi de de Morgan, afin de supprimer la double négation implicite de certains bits de l'opérande. Après tout, l'inversion de la porte NOR fait doublon avec la couche de portes NON sur certains bits de l'opérande. En faisant cela, on se retrouve avec le comparateur précédent, de type NON-ET.

Le comparateur d'égalité et de différence pour entiers[modifier | modifier le wikicode]

Les circuits qui vérifient si deux nombres sont égaux ou différents sont plus simples que les autres comparateurs. Ceux-ci sont juste composés de deux couches de portes logiques, contrairement aux autres. La vérification de supériorité ou d'infériorité est nettement plus complexe et leur fonctionnement est quelque peu différent. C'est la raison pour laquelle nous allons voir ces deux types de comparateurs ensemble.

Les deux sont cependant basés sur le même modèle et ont une structure similaire. Ils sont composés d'une couche de comparateurs de 1 bits, suivi par une porte logique à plusieurs entrées. La couche de comparateur 1 bits vérifie si les bits de même poids des deux opérandes sont différents ou identiques. La porte logique combine les résultats de ces comparaisons individuelles et en déduit le bit de sortie.

Le comparateur d'égalité[modifier | modifier le wikicode]

Voyons d'abord le circuit qui vérifie si deux nombres sont égaux. Pour cela, il faut prendre les bits de même poids (ceux à la même position dans le nombre, sur la même colonne) et vérifier qu'ils sont égaux. Si tous les bits de même poids sont égaux, alors les deux nombres sont égaux. Par contre, si deux bits de même poids sont différents, quelque soit la colonne, alors les deux nombres sont différents. En clair, la moindre différence entraine l'inégalité.

On devine que ce circuit est composé de deux couches de portes logiques : une première couche vérifie l'égalité des paires de bits, le second combine les résultats de la couche précédente. Vérifier l'égalité de deux bits se fait avec une porte NXOR, ce qui fait que la première couche est composée de portes NXOR. Reste à combiner les résultats des différentes portes NXOR pour fournit le bit de sortie. La logique dit que la sortie vaut 1 si tous les bits de sortie des NXOR valent 1. La seconde couche est donc, par définition, une porte ET à plusieurs entrées.

Comparateur d'égalité.

Le comparateur de différence[modifier | modifier le wikicode]

Le circuit qui vérifie si deux nombres sont différents peut être construit à partir du circuit précédent. Par définition, deux nombres sont différents s'ils ne sont pas égaux et réciproquement. On pourrait donc ajouter une simple porte NON à la suite d'un circuit d'égalité, ou mieux : changer la porte ET finale par une porte NAND. Mais il existe une autre solution, complétement équivalente, qui permet d'économiser l'utilisation de cette porte NON.

L'idée est de simplifier le circuit précédent de manière, ce qui permet d'éliminer des négations redondantes (la porte NON en sortie du circuit, mais aussi les négations implicites des portes NXOR). Pour cela, on applique la loi de de Morgan, qui veut que . La porte NAND en sortie du circuit est donc remplacée par un OU, et les entrées de ce OU sont précédés par une couche de portes NON. On peut alors fusionner les portes NON avec les portes NXOR, ce qui donne naturellement des portes XOR. Le circuit obtenu est donc une adaptation du circuit précédent, où les portes NXOR sont remplacées par des XOR et où la porte ET est remplacée par une porte OU à plusieurs entrées.

Une autre manière de concevoir ce circuit est de raisonner comme suit. Deux nombres sont différents si au moins un de leur bit diffère : il doit y avoir au moins un bit qui est différent de celui à la même place dans l'autre nombre. Pour cela, on utilise une couche de comparateurs d'inégalité de un bit, dont le but est de vérifier si les bits de même poids sont identiques ou différents. Ensuite, les résultats sont combinés entre eux. Sachant qu'un seul bit différent met le signal de sortie à 1, on devine que la combinaison se fait avec une porte OU à plusieurs entrées.

Les comparateurs pour entiers non-signés[modifier | modifier le wikicode]

Comparateur 4 Bits.

Dans ce qui va suivre, nous allons créer un circuit qui est capable de vérifier l'égalité, la supériorité ou l'infériorité de deux nombres. Celui-ci prend deux nombres en entrée, et fournit trois bits : un pour l'égalité des deux nombres, un autre pour préciser que le premier est supérieur au second, et un autre pour préciser que le premier est inférieur au second. Il existe deux méthodes pour créer des comparateurs : une basée sur une soustraction, l'autre sur des comparaisons bit par bit.

La toute première utilise un soustracteur, qui soustrait les deux nombres et vérifie leur signe. Si la soustraction A - B donne un résultat nul, les deux nombres A et B sont égaux. Si le résultat est positif, alors on sait que A > B. De même, un résultat négatif indique que A < B. Ainsi, le bit de sortie A > B est simplement égal au bit de signe du résultat, tandis que le bit de sortie est égal à son inverse. Pour savoir si le résultat de la soustraction est nul, un simple comparateur avec zéro suffit. Cette méthode, qui utilise un soustracteur et un comparateur avec zéro est relativement simple et économe en circuits, ce qui fait qu'elle est utilisée dans la majorité des processeurs actuels.

Mais il est possible de créer des circuits dédiés aux comparaisons. Ceux-ci sont créés à partie de comparateurs de 1 bits, qui sont assemblés pour obtenir un comparateur de nombres de N bits. Nous allons les aborder dans ce qui suit. La première étape est d'utiliser un comparateur de 1 bit pour chaque colonne à comparer : chaque comparateur compare les bits de même poids de deux nombres. Reste à combiner leurs résultats. Par exemple, le bit final d'égalité peut être obtenu simplement : il suffit de faire un ET logique entre tous les bits d'égalité fournis par les comparateurs de 1 bit. Simple logique : deux nombres sont égaux si tous leurs bits sont égaux. En cela, cette portion du circuit ne diffère aucunement du comparateur d'égalité vu plus haut. Mais pour le bit de supériorité et d'infériorité, c'est autre chose.

Les comparateurs sériels[modifier | modifier le wikicode]

La manière la plus simple est de faire la comparaison bit par bit avec un circuit séquentiel, sur le même modèle que l'additionneur série. Pour cela, on doit utiliser trois registres à décalage : un pour le résultat, et un pour chaque opérande. Outre les registres à décalage, on trouve un comparateur 1 bit amélioré qui fait la comparaison bit par bit, colonne par colonne. Le tout est de savoir comment combiner les résultats de la colonne précédente avec les résultats de la colonne en court de traitement, chose que le comparateur 1 bit précédent ne sait pas faire. Pour cela, nous allons devoir créer un circuit, nommé le comparateur complet.

Comparateur sériel.

Dans ce qui va suivre, la comparaison va s'effectuer en partant du bit de poids faible et se fera de gauche à droite, chose qui a son importance pour ce qui va suivre. Quelque soit le sens de parcours, on sait comment calculer le bit d'égalité : celui-ci est égal à un ET entre le bit d'égalité fournit en entrée, et le résultat de la comparaison A = B. Pour les bits de supériorité et d'infériorité, les choses changent : la colonne en cours de traitement supplante l'autre colonne. Dit autrement, les bits de poids fort donnent le résultat de la comparaison. Pour déterminer comment calculer ces bits, le mieux est encore d'établir la table de vérité du circuit pour ces deux bits. Nous allons postuler que les bits A > B et A < B ne peuvent être à 1 en même temps : il s'agit de supériorité et d'infériorité stricte. Voici la table de vérité :

Entrée > Entrée < A > B A < B Sortie > Sortie <
0 0 0 0 0 0
0 0 0 1 0 1
0 0 1 0 1 0
0 0 1 1 X X
0 1 0 0 0 1
0 1 0 1 0 1
0 1 1 0 1 0
0 1 1 1 X X
1 0 0 0 1 0
1 0 0 1 0 1
1 0 1 0 1 0
1 0 1 1 X X
1 1 0 0 X X
1 1 0 1 X X
1 1 1 0 X X
1 1 1 1 X X

Les équations logiques obtenues sont donc les suivantes :

  • Sortie (=) :
  • Sortie (>) :
  • Sortie (<) :

Les comparateurs série[modifier | modifier le wikicode]

Il est possible de dérouler le circuit précédent, de la même manière que l'on peut dérouler un additionneur série pour obtenir un additionneur à propagation de retenue. Le circuit est alors composé de comparateur complets placés en série, la sortie des uns étant envoyée sur l'entrée d'un autre. Le circuit comparateur obtenu est alors très similaire à l'additionneur à propagation de retenue, à une différence près : ce ne sont pas des retenues qui sont propagées d'un comparateur complet à l'autre, mais des bit de supériorité, d'infériorité et d'égalité. Pour cela, on doit ajouter une troisième entrée, qui permet de combiner le résultat d'un autre comparateur.

Interface d'un comparateur parallèle.

A noter que ce genre de circuit peut être généralisé, à savoir que certains comparateurs complets sont conçus pour comparer plusieurs bits à la fois, et non seulement 2 : il suffit simplement d'écrire leur table de vérité et en déduire le circuit correspondant. Ces comparateurs possèdent évidemment une entrée sur laquelle envoyer les bits >, < et = des colonnes précédentes. Par exemple, supposons que nous voulons créer un comparateur pour nombres de 7/8 bits avec comparateurs de 4 bits. Pour cela, on doit comparer les bits par groupes de 4 et combiner les résultats de comparaison entre eux.

Interface d'un comparateur parallèle avec "retenues".

Les comparateurs parallèles[modifier | modifier le wikicode]

Une autre solution est de faire les comparaisons en parallèle et de combiner les bits de résultats des différents comparateurs avec un dernier comparateur. On obtient alors un comparateur parallèle. Cela permet ainsi de créer des comparateurs capables de comparer des nombres de 4, 8, 16 bits entre eux.

Comparateur entier parallèle.

Il est possible de combiner des comparateurs parallèles de plusieurs bits entre eux, en les plaçant en série. Pour cela, on peut envoyer les résultats sur les entrées normales, en faisant passer ces bits de résultats pour les bits des nombres à comparer. Une entrée pour chaque nombre est ainsi remplacée par les bits de supériorité ou d'infériorité fournit par le comparateur précédent.

Comparateur entier série.

Les comparateurs pour nombres signés[modifier | modifier le wikicode]

Comparer deux nombres signés n'est pas la même chose que comparer deux nombres non-signés. Autant la comparaison d'égalité et de différence est strictement identique, autant les comparaisons de supériorité et d'égalité ne le sont pas. Les comparateurs pour nombres signés sont naturellement différents des comparateurs vus précédemment. On verra plus tard qu'il en est de même avec les comparateurs pour nombres flottants. Il fut aussi faire attention : la comparaison ne s'effectue pas de la même manière selon que les nombres à comparer sont codés en signe-magnitude, en complément à deux, ou dans une autre représentation. Dans ce qui va suivre, nous allons aborder la comparaison en signe-magnitude et en complément à deux, mais pas les autres représentations.

Le comparateur signe-magnitude[modifier | modifier le wikicode]

Un comparateur en signe-magnitude n'est pas trop différent d'un comparateur normal. Effectuer une comparaison entre deux nombres en signe-magnitude demande de comparer les valeurs absolues, ainsi que comparer les signes. Une fois cela fait, il faut combiner les résultats de ces deux comparaisons en un seul résultat.

Comparateur en signe-magnitude

Comment comparer les signes ?[modifier | modifier le wikicode]

Comparer les signes est relativement simple : le circuit n'ayant que deux bits à comparer, celui-ci est naturellement simple à concevoir. On pourrait penser que l'on peut réutiliser le comparateur 1 bit vu précédemment dans ce chapitre, mais cela ne marcherait pas ! En effet, un nombre positif a un bit de signe nul alors qu'un nombre négatif a un bit de signe égal à 1 : les résultats sont inversés. Un bon moyen de s'en rendre compte est d'écrire la table de vérité de ce circuit, selon les signes des nombres à comparer. Nous allons supposer que ces deux nombres sont appelés A et B.

Bit de signe de A Bit de signe de B Sortie = Sortie < Sortie >
0 (+) 0 (+) 1 0 0
1 (-) 0 (+) 0 0 1
0 (+) 1 (-) 0 1 0
1 (-) 1 (-) 1 0 0

On obtient les équations suivantes :

  • Sortie = :
  • Sortie < :
  • Sortie > :

On peut remarquer que si l bit d'égalité est identique au comparateur 1 bit vu plus haut, les bits de supériorité et l'infériorité sont inversés, échangés. On peut donc réutiliser le comparateur à 1 bit, mais en intervertissant les deux sorties de supériorité et d'infériorité.

Comment combiner les résultats ?[modifier | modifier le wikicode]

Une fois qu'on a le résultat de la comparaison des signes, on doit combiner ce résultat avec le résultat de la comparaison des valeurs absolues. Pour cela, on doit rajouter un circuit à la suite des deux comparateurs. On pourrait penser qu'il suffit d'établir la table de vérité de ce comparateur, mais il faut faire attention au cas où les deux opérandes sont nulles : dans ce cas, peut importe les signes, les deux opérandes sont égales. Pour le moment, mettons ce fait de coté et établissons la table de vérité du circuit. Dans tous les cas, la comparaison des bits de signe prend le pas sur la comparaison des valeurs absolues. Par exemple, 2 est supérieur à -255, bien que ce ne soit pas le cas pour les valeurs absolues. Ce fait n'est que l'expression du fait qu'un nombre positif est systématiquement supérieur à un négatif, de même qu'un négatif est systématiquement inférieur à un positif. Ce n'est que quand les deux bits de signes sont égaux que la comparaison des valeurs absolue est à prendre en compte. Cela devrait donner les équations suivantes. On note les résultats de la comparaison des bits de signe comme suit : , alors que les résultats de la comparaison des valeurs absolues sont notés : .

  • pour le résultat d'égalité ;
  • pour l’infériorité ;
  • pour la supériorité.

Néanmoins, il faut prendre en compte le cas où les deux opérandes sont nulles, ce qui complique un petit peu les équations Pour cela, il fat rajouter une sortie au comparateur de valeurs absolues, qui indique si les deux nombres valent tous deux zéro. Notons cette sortie . Les équations deviennent :

  • pour l'égalité ;
  • pour l’infériorité ;
  • pour la supériorité.

Les comparateurs en complément à un et en complément à deux[modifier | modifier le wikicode]

La comparaison en complément à un est relativement simple, si ce n'est un détail : il faut calculer les valeurs absolues avant de les comparer. Rien de plus simple pour cela : il suffit de regarder le bit de signe et d'inverser les bits du nombre s'il vaut 1 (nombre négatif). On peut remarquer que cette technique consiste à traduire les nombres vers une représentation signe-magnitude avant de les comparer avec le comparateur vu plus haut. Reste à calculer les valeurs absolues suivant la représentation.

En complément à 1, il faut inverser tous les bits si le bit de signe est de 1 et ne rien faire sinon. On a vu dans les premiers chapitres du cours comment réaliser un inverseur commandable avec des portes XOR, aussi je ne reviendrais pas dessus. Ici, on peut juste réutiliser cet inverseur, et le commander avec le bit de signe de l'opérande.

Circuit de comparaison entière en complément à 1.

La comparaison en complément à deux est plus compliquée, compte tenu des spécificités de cet encodage. On pourrait parfaitement utiliser la méthode précédente : comparer les signes et les valeurs absolues, avant de combiner les résultats. Le seul problème est qu'il faut rajouter un circuit pour le calcul de la valeur absolue. Ce circuit est composé naturellement d'une couche de porte NON (un inverseur), ainsi que d'un circuit pour incrémenter le tout, le tout combiné à un MUX. Le problème est la conception du circuit incrémenteur, qui sera vue dans le prochain chapitre.

Circuit de comparaison en complément à 1 et à 2

Une autre solution consiste à soustraire les deux nombres et à regarder le bit de signe du résultat. S'il est négatif, la première opérande est inférieure. Si ce signe est positif, soit la première opérande est supérieure à l'autre, soit les deux opérandes sont égales. Le seul moyen pour départager les deux situations est de vérifier si le résultat obtenu est nul ou non. Mais cette méthode demande de concevoir un circuit de soustraction, chose que nous apprendrons à faire dans le chapitre suivant.

Circuit de comparaison entière en complément à 2.