L'ordinateur, language et représentation des nombre
Cet article explique comment convertir un nombre en base 2, comment l'ordinateur traite les nombres négatifs, à virgule etc.
Base 10
On peut représenter un nombre tel que 456 comme étant:
4 centaines
5 dizaines
6 unités
avec une base 10 on peux créer ce tableau dont on peut utiliser chaque case 9 fois (le nombre de la base -1) pour définir le nombre donné.
| puissance 10 | \(10^2\) | \(10^1\) | \(10^0\) |
|---|---|---|---|
| 100 | 10 | 1 | |
| nombre de fois | 4 | 5 | 6 |
Base 2
| puissance 2 | \(2^8\) | \(2^7\) | \(2^6\) | \(2^5\) | \(2^4\) | \(2^3\) | \(2^2\) | \(2^1\) | \(2^0\) |
|---|---|---|---|---|---|---|---|---|---|
| 256 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | |
| nombre de fois | 1 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 |
111001000 est la représentation binaire de 456.
bit, byte
Ces termes à l'écriture et la prononciation proche peuvent préter à confusion.
un bit c'est soit 0 soit 1, c'est la plus petite unité d'information dans un ordinateurs. Il peut valoir ""soit 1 soit 0"".
un byte où octet en français c'est un ensemble de 8 bits. C’est l’unité de base utilisée pour mesurer la quantité de données.
un byte c'est 256 valeurs possibles.
un word = 32 bits = 4 bytes.
un half-word = 16 bits = 2 bytes.
nombres positifs et négatifs. - signé / non signé
afin de représenter les nombres négatifs on a pris la moitié d'un byte, soit 128 bits.
Les 128 premières valeurs sont réservés pour les nombres positifs, de la 129ème à la 256ème, pour les nombres négatifs.
Le premier bit est le bit de signature, 1 = négatif. 0 = positif. nos 7 bits restants permettent de représenter 128 nombres.
On parle de nombre signé si ils comprennent les négatifs, non signé si il comprennent que les positifs.
Uint8 = non signé, 256 valeurs exprimants les nombres de 0 à 256
int8 = signé, 256 valeurs allant de -128 à 127
Uint8_t = un int de 8 bit, c'est garanti
int = un int au nombre de bit variable
règle de calcule des nombres négatifs: si le 1er sign est 1, on a affaire à un nombre négatif. on va inverser les 7 bits suivants. on détermine le nombre et on rajoute - devant:
👉 10110001
👉 01001110 -> 78
👉 -78
floating numbers
ce sont les nombres à virgule flottante. le terme flottant fait référence au fait que la virgule n'occupe pas forcément la même place. Sa position dépend de l'exposant. voyons ça en détail:
Les ordinateurs utilisent le standard IEEE 754 pour stocker (se "représenter") les nombres flottants. il s'agit de 4 bytes, soit 32 bits.
👉 le 1er bit est le bit de signature. 0= positif. 1 = négatif.
👉 les 8 prochains bits sont réservés pour l'Exposant. ils déterminent la position de la virgule. l'échelle de l'exposant va de 0 à 255 mais comme on souhaite aussi inclure les nombres négatifs on l'a décallée pour qu'elle aille de -127 à 128. il suffit de lire sa valeur sans ce soucier de cette coupe et de soustraire 127 pour savoir quel nombre est représenté. Si je lit 137, on a en fait 10.
👉 le 23 derniers bits sont nommés mantisse et chaque bit représente une fraction de 1 sur 2 puissance X (x = position du bit dans la mantisse - 1). Ainsi le 1er bit de la mantisse représente 1/2^0 = 1, le 4ème bit 1/2^3 = 0.125.
cela nous permet de représenter un nombre entre 1 et 2
voici comment ce lit cette valeur de 32 bit:
signe----exposant------mantisse
0-----------01011001-----10110110111000101001100111011001
Ce qui est un peu embêtant c'est qu'en tant qu'human quand on représente le nombre sous forme factoriel on place l'exposant à droite et la mantisse à gauche alors que dans le code binaire la mantisse et à droite et l'exposant à gauche:
Cette théorie contient quelques erreurs afin de ne pas trop compliquer le tout. en fait les bits réservés à l'exposant vont de -126 à 127 car les extrémités sont réservés pour des cas spécial et le premier bit de la mantisse qui vaut 1 est implicite. on ne le compte pas, de cette manière le 1er bit vaut 0.5. La mantisse représente un nombre entre 1 et presque 2, sans jamais atteindre 2.
Dans notre exemple on a:
- pour le signe
89 pour l'exposant, attention il faut soustraire 127. (on dit qu'on a un biais de 127) donc -38 La mantisse est normalisé, il y a un 1 implicite devant le tout, donc on a 1.10110110111000101001100 qui vaut 1.710093
🎥 Vidéo explicative : Comprendre les nombres flottants en IEEE 754 (YouTube)
4 types de languages
-
Langage compilé vers du code machine
Le code est compilé directement en instructions machine, prêtes à être exécutées par le CPU.
+ ultra rapide
- peu transportable C, C++, Rust, Go -
language interprété
Le code source est lu ligne par ligne et exécuté directement par un interpréteur sans compilation
+ facile à tester et modifier rapidement
- moins rapide, car 1 instruction génère 1 instruction, une loop va générer beaucoup d'instruction
Python, JavaScript, Ruby, PHP -
Langage compilé vers du bytecode
Le code est compilé en bytecode, un format intermédiaire qui sera ensuite interprété ou exécuté par une machine virtuelle.
+ portabilité d'un système à un autre
- besoin d'une machine virtuelle Java, C#, Python, Lua -
Langage transpileur
le code est transformé vers un autre language de programmation.