Mots-clés : nombre à virgule fixe, nombre à virgule flottante, $realtobits, $bitstoreal
Cette section présente principalement les fonctions de conversion entre nombres réels et entiers : $realtobits et $bitstoreal, et explique également comment une variable de type réel (identique au double float en langage C) est représentée à l'aide d'un code binaire sur plusieurs bits.
Représentation binaire des nombres décimaux
Représentation binaire des nombres décimaux
Lorsqu'un entier décimal est représenté en binaire, il est nécessaire d'effectuer l'opération de division des données par 2 et de prise du reste.
Lorsque la partie fractionnaire est représentée en binaire, c'est l'inverse : les données sont multipliées par 2, puis on vérifie si la partie entière est supérieure à 1.
Le processus d'obtention de la représentation binaire de la partie fractionnaire 0.3125 de 2.3125 est le suivant :
| Processus de calcul | Condition | Bit binaire |
|---|---|---|
| 0.3125 x 2 = 0.625 | < 1 | 0 |
| 0.625 x 2 = 1.25 | ≥ 1 | 1 |
| (1.25 - 1) x 2 = 0.5 | < 1 | 0 |
| 0.5 x 2 = 1 | ≥ 1 | 1 |
| Résultat : la fraction décimale est représentée par un nombre binaire sur 4 bits | stop | 0101 |
Par conséquent, la représentation binaire de 2.3125 est dec2bin(2.3125) = bin(10.0101). Ici, le point décimal ne sert qu'à distinguer la position de la partie fractionnaire, c'est-à-dire que la partie fractionnaire est représentée par un code binaire de 4 bits. En pratique, le marqueur de point décimal n'existe pas.
Lorsqu'on représente une fraction décimale en binaire, il existe également une méthode rapide. Si la partie fractionnaire est représentée par N bits, alors la valeur représentée par la représentation binaire d'un nombre décimal num est :
dec2bin(num) = bin(num x 2^N )
Par exemple, le processus de conversion du nombre décimal 2.3125 est le suivant :
2.3125 x 2 ^ 4 = 37 = bin(100101)
Avec une largeur de partie fractionnaire de 4, dec2bin(2.3125) = bin(10.0101).
Conversion de binaire en fractions décimales
Lors de la conversion d'un entier binaire en décimal, il est nécessaire d'effectuer une multiplication bit par bit en utilisant des exposants de base 2 et d'accumuler les résultats.
Lors de la conversion d'une fraction binaire en décimal, il est nécessaire d'effectuer une multiplication bit par bit en utilisant des exposants de base 1/2 et d'accumuler les résultats.
Par exemple, lorsque la largeur de la partie fractionnaire est de 4, la fraction décimale représentée par la partie fractionnaire de bin(11.1001) est :
bin2dec(1001) = 1 x 2^(-1) + 0 x 2^(-2) + 0 x 2^(-3) + 1 x 2^(-4) = 0. 5625
Alors la fraction binaire bin(11.1001) avec une largeur de partie fractionnaire de 4 représente la fraction décimale 3.5626.
La méthode rapide pour convertir en décimal une fraction binaire num ayant une partie fractionnaire de N bits est :
bin2dec(num) = num / 2^N
Par exemple, le processus de calcul de la fraction représentée par bin(11.1001) est :
bin(11.1001) = bin(111001) / (2^4) = 57/16 = 3.5625 。
En fait, le compilateur Verilog ne distingue pas si une variable multi-bit représente un entier ou une fraction ; les opérations ne sont effectuées qu'artificiellement au niveau fractionnaire.
Représentation des nombres à virgule flottante
Un nombre à virgule fixe est un nombre dont la position de la virgule décimale est fixe. Un entier est une sorte de nombre à virgule fixe car la virgule décimale se trouve toujours après le dernier chiffre.
Un nombre à virgule flottante est un nombre dont la position de la virgule décimale n'est pas fixe. Par exemple, 1.2 x 1.3 = 1.56 ; la position de la virgule décimale continue de flotter, d'où le nom de nombre à virgule flottante.
Bien sûr, la position de la virgule décimale d'un nombre fractionnaire peut aussi être fixe, ce qu'on appelle un nombre décimal à virgule fixe. Cependant, cette représentation réduit la précision de la fraction. Par exemple, si un seul chiffre après la virgule décimale est fixé pour représenter la fraction, alors 1.2 x 1.3 = 1.5, ce qui perd des données.
Représentation générale des nombres à virgule flottante décimaux :
dec(num) = (-1) ^ S x M x (10^E );
S est le bit de signe ; lorsqu'il vaut 1, il représente un nombre négatif, et lorsqu'il vaut 0, il représente un nombre positif.
E est la partie exposant du facteur d'échelle, exprimée sous forme d'entier, appelée code d'exposant. Le code d'exposant indique la position de la virgule décimale dans le mot de code, déterminant ainsi la plage du nombre à virgule flottante.
M est la partie fractionnaire, appelée mantisse. La largeur de la mantisse détermine la précision du nombre à virgule flottante.
Par exemple, le nombre 100.0344 peut être représenté comme :
1995.0907 = (-1) ^ 0 x 199.50907 x 10^1 (正数,尾数为199.50907, 阶码为1) = (-1) ^ 0 x 1.9950907 x 10^3 = (-1) ^ 0 x 0.19950907 x 10^ 4
De même, la représentation générale des nombres à virgule flottante binaires est :
dec(num) = (-1) ^ S x M x (2^E )
Par exemple :
dec(2.3125) (十进制) = bin(10.0101)
= bin(10.0101) x 2^0
= bin(1.00101) x 2^1 (正数,尾数为 1.00101,阶码为 1)
= bin(0.100101) x 2^2
D'après ce qui précède, différentes méthodes de représentation d'un même nombre à virgule flottante ont des mantisses et des exposants différents. Pour faciliter la portabilité, en 1985, l'IEEE (Institute of Electrical and Electronics Engineers) a proposé la norme IEEE-754 comme norme unifiée pour les formats de représentation des nombres à virgule flottante.
La norme IEEE-754 utilise logiquement un triplet {S, E, M} pour représenter un nombre à virgule flottante Num.
S représente le bit de signe ; 0 et 1 représentent respectivement les nombres positifs et négatifs.
E représente la partie exposant, appelée exposant biaisé. Pour éviter les exposants positifs et négatifs, l'exposant biaisé est obtenu en ajoutant un décalage fixe à l'exposant. Par conséquent, l'exposant peut être obtenu à partir de l'exposant biaisé : E - 2^(W-1) + 1. W est la largeur en bits de l'exposant biaisé. La base de l'exposant est 2.
M représente la mantisse. Le bit le plus élevé de la mantisse est toujours 1, mais le champ de mantisse ne stocke pas ce bit ; il ne stocke que la partie fractionnaire. Par conséquent, la valeur représentée par la mantisse est en réalité 1.M.
Il est spécifié que les nombres à virgule flottante en simple précision sont stockés sur 4 octets, et que les nombres à virgule flottante en double précision sont stockés sur 8 octets. Le schéma est le suivant.

Format simple précision (32 bits) : le bit de signe S a une largeur de 1 bit ; l'exposant E a une largeur de 8 bits, avec un biais d'exposant de 127 (7'h7F) ; la mantisse M a une largeur de 23 bits, représentant la fraction, avec le point décimal placé au début du champ de mantisse.
Format double précision (64 bits) : le bit de signe S a une largeur de 1 bit ; l'exposant E a une largeur de 11 bits, avec un biais d'exposant de 1023 (10'h3FF) ; la mantisse M a une largeur de 52 bits, représentant la fraction, avec le point décimal placé au début du champ de mantisse.
La valeur réelle d'un nombre à virgule flottante N de 32 bits peut être exprimée par :
Num = (-1)^S × (1.M) × 2 ^(E-127)
La valeur réelle d'un nombre à virgule flottante N de 64 bits peut être exprimée par :
Num = (-1)^S × (1.M) × 2 ^(E-1023)
Par exemple, la fraction décimale représentée par le code binaire 64'h4002_8000_0000_0000 correspondant à un nombre à virgule flottante en double précision est :
Num = (-1)^0 x (1+ 8'h28/2**8) x 2^((12'h400 & 11'h7FF)-1023) = 2.3125
Le processus de calcul de mantisse ci-dessus omet une série de "0" de fin et ne prend que les 8 premiers bits significatifs.
Par exemple, le processus de représentation binaire du nombre à virgule flottante en double précision -13.14 est :
| 1 bit nécessaire pour le bit de signe | S = 1 |
|---|---|
| 4 bits nécessaires pour représenter l'entier | 13 = bin(1101) = bin(1.101) x 2^3 |
| 11 bits nécessaires pour représenter l'exposant | E = 3 + 1023 = 11'h402 |
| (52-3) bits nécessaires pour représenter la fraction | 0.14 * 2^(52-3) = 78812993478983.688 ≈ 78812993478984 = 49'h47ae147ae148 |
| 52 bits nécessaires pour la mantisse : intégrer les deux parties fractionnaires | M = (bin(101)<<49) + 49'h47ae147ae148 = 52'ha47ae147ae148 |
| Code binaire d'un nombre à virgule flottante | {S, E, M} = 32'hc02a_47ae_147a_e148 |
La variable de type real en Verilog est exactement la variable à virgule flottante en double précision d'une largeur de 64 bits selon la norme IEEE-754.
Fonctions de conversion
| Invocation de tâche système | Description de la tâche |
|---|---|
| int_val = $rtoi( real_val ) ; | Convertir le nombre réel real_val en entier int_val Par exemple, 3.14 -> 3 |
| real_val = $itor( int_val ) ; | Convertir l'entier int_vla en nombre réel real_val Par exemple, 3 -> 3.0 |
| vec_val = $realtobits( real_val ) ; | Convertir un nombre réel en vecteur de registre multi-bit Le registre stocke des données à virgule flottante en double précision conformément à la norme IEEE-754 |
| real_val = $bitstoreal( vec_val ) ; | Convertir un vecteur de registre multi-bit en nombre réel |
Le processus de génération ou de conversion des variables de type réel doit être conforme à la norme IEEE Std 754-1985 [B1].
Utilisez $realtobits et $bitstoreal pour convertir les données :
Exemple
reg [63:0] num_bits ;
initial begin
num_bits = 64'h4002_8000_0000_0000 ;
$display("-14.13 -> hex : %h", $realtobits(-13.14));
$display("64'h4002_8000_0000_0000 -> réel : %f", $bitstoreal(num_bits));
end
Le journal de simulation est le suivant, et l'on peut voir que la conversion est correcte.

Utilisez $itor et $rtoi pour effectuer une conversion de format sur les données :
Exemple
initial begin
$display();
$display("Réel vers entier : %h", $rtoi(13.14));
$display("Afficher l'entier en flottant : %f", 1001);
$display("Entier vers réel : %f", $itor(1001));
end
D'après le journal de simulation suivant, lorsque $rtoi convertit le nombre réel (13.14) en entier (4'hd), il ne fait que tronquer la partie entière. Lorsque $itor convertit l'entier (1001) en nombre réel (1001.000000), il semble qu'il n'y ait aucun changement.

En fait, la fonction de $rtoi et $itor est de changer le mode de stockage de la variable.
Par exemple, lorsque 14 est stocké comme variable entière, il est représenté par 32'h1110, et s'il est stocké comme variable de type réel, il est représenté par 64h402c_0000_0000_0000.
Téléchargement du code source de ce chapitre
Téléchargement