R E P R E S E N TAT I O N

DES
NOMBRES
SEQUENCE 1
▶ 1 – R E P R E S E N TAT I O N D E S
NOMBRES EN MACHINE
 DEFINITIONS

Bit
Base
Numération
positionnelle Le bit est l’unité de mesure en
Une base est un entier positif
informatique désignant la
supérieur ou égal à 2 qui permet
La numération positionnelle est quantité élémentaire
de décomposer un nombre
une façon d’écrire un nombre où d’information. Un bit ne peut
entier dans une numération
la position de chaque chiffre est prendre que deux valeurs,
positionnelle.
importante. notées par convention 0 et 1,
appelés chiffres binaires.
 DEFINITIONS

Division Ex :
euclidienne

Octet La division euclidienne ou

division entière est une
Un octet est une unité de opération sur deux entiers
mesure de quantité de données. naturels, appelés dividende et
C’est un ensemble de 8 bits. diviseur, auxquels on associe
deux entiers appelés quotient et
reste.
▶ 2 – ECRITURE D’UN
ENTIER POSITIF DANS UNE
BASE
 C O U R S

Avec nos dix doigts, nous comptons et représentons naturellement les

nombres dans la base 10, appelée base décimale.

En informatique, les bases les plus utilisées sont les bases 2 et 16.
Quelle que soit la base utilisée, la position appelée rang est essentielle
dans l’écriture de la valeur.
 LA BASE BINAIRE
En représentation machine, les données sont stockées en base 2
appelée base binaire. L’écriture en base binaire est composée
uniquement des chiffres : 0 et 1.

En langage Python, on peut saisir un entier directement en écriture

binaire en écrivant sa représentation binaire précédée de [0b]

Exemple :
 LA BASE HEXADECIMALE
Les nombres sont représentés en machine en base binaire. La base 16,
appelée base hexadécimale, permet à l’humain de manipuler
facilement tout en facilitant leur conversion.

Pour écrire un entier positif dans la base hexadécimale, il faut pouvoir

écrire 10, 11, 12, 13, 14 et 15 avec un seul caractère. Comme les 10
chiffres de 0 à 9 ne suffisent plus, il faut utiliser les six premières lettres
de l’alphabet :
Base 10 10 11 12 13 14 15
Base 16 A B C D E F
 LA BASE HEXADECIMALE
La base hexadécimale est une des bases puissances de la base 2 ( = 16),
donc les conversions de la base 2 à la base 16 et inversement sont
facilitées.

En langage Python, on peut saisir un entier directement en écriture

hexadécimales en écrivant sa représentation précédée de 0x.

Exemple : >>> 0x5d

93
 CONVERSIONS EN PYTHON
La fonction Python native bin(x) convertit la variable x de type entier en
une chaîne de caractères binaires précédée de 0b.

Exemple : >>> bin(11)

0b1011
 CONVERSIONS EN PYTHON
Si l’on veut faire des calculs sur des valeurs exprimées sous forme de
caractères comme ‘0b1011’, il faut les convertir avec la fonction Python
int() qui prend pour arguments une chaîne de caractères et la base
utilisée.

Exemple : >>> int(‘0b1011’, 2) + 1

12
>>> int(‘0b1011’, 2)
11
 CONVERSIONS EN PYTHON
La fonction Python native hex(x) convertit la variable x de type entier
en une chaîne de caractères hexadécimaux précédée de 0x

Exemple : >>> hex(195)

‘0xc3’
>>> int(‘0xc3’, 16)
195
▶ 3 – E VA L U AT I O N D U
NOMBRE DE BITS
NECESSAIRES
 POUR UN ENTIER POSITIF
Sur n bits, on peut stocker 2n entiers positifs. Comme on doit coder
l’entier nul, le plus grand entier positif que l’on puisse représenter est 2n
– 1.

Pour évaluer le nombre de bits minimum nécessaires à l’écriture en

base 2 d’un entier positif, il faut trouver la plus petite puissance de 2 qui
soit strictement supérieure à l’entier à écrire.

Exemple : Comme 27 = 12810 et 28 = 25610, on a 27 20010 < 28, donc 8 bits

sont nécessaires pour écrire 20010 en base binaire.
POUR LA SOMME DE 2 NB ENTIERS
Sans connaître le résultat au préalable, le nombre de bits nécessaires
pour stocker la somme de deux entiers positifs stockés sur n bits est n
+ 1 bits.

Démonstration :
Sur n bits, le plus grand entier positif a pour valeur 2n – 1. La plus
grande somme possible de deux entiers sur n bits est le double de
2n – 1 donc 2 ⨯ (2n – 1) = 2 ⨯ 2n – 2 = 2n+1 – 2.
Or 2n+1 – 2 < 2n+1.
POUR LE PRODUIT DE 2 NB ENTIERS

Sans connaître le résultat au préalable, le nombre de bits nécessaires

pour représenter le produit de deux entiers positifs représentés sur n
bits est 2n bits.

Démonstration :
Sur n bits, le plus grand entier positif a pour valeur 2n – 1. Le plus grand
produit possible de deux entiers sur n bits est le carré de 2n – 1.
(2n – 1) ⨯ (2n – 1) = (2n – 1)²
= (2n)² - 2 ⨯ 2n ⨯ 1 + 1² = 22n - 2n+1 + 1.
Or 22n - 2n+1 + 1 < 22n.
▶ 4 – ADDITION BINAIRE
 DE DEUX ENTIERS POSITIFS

Pour additionner deux entiers positifs en base binaire, l’algorithme de

calcul est le même qu’en base décimale, selon la table d’addition ci-contre.

Ex : 11 Somme binaire
0011
+ 0110
1001
et 1 de retenue
 D E D E U X E N T I E R S R E L AT I F S

Pour effectuer l’addition de deux entiers relatifs (positifs ou négatifs),

dits aussi signés, avec le même algorithme que pour les entiers positifs,
il faut utiliser la représentation en complément à (ou complément à 2)
où n est un nombre de bits fixé à l’avance.

En effet, le nombre de bits utilisés pour cette représentation doit

toujours être précisé. Par convention, le bit le plus à gauche vaut 1 pour
les entiers négatifs et 0 pour les entiers positifs, ce qui permet de
reconnaitre immédiatement le signe d’un entier relatif.
 METHODE DE COMPLÉMENT À 2

Pour représenter un nombre positif, on utilise sa représentation en

binaire, précédée d’autant de 0 que nécessaire pour avoir n bits au
total.

Pour représenter un nombre négatif - m :

1. Coder en binaire le nombre m comme précédemment;
2. Inverser tous ses bits (ce qu’on appelle prendre le « complément à
1 »);
3. Additionner 1 au nombre binaire obtenu sans oublier les retenues
éventuelles.
 D E D E U X E N T I E R S R E L AT I F S

Exemple : Nombre 3810 en binaire 0010 0110

1
Complément à 1 1101 1001
Addition de 1 + 0000 0001
Complément à 1101 1010 (-3810)

Pour évaluer le nombre de bits nécessaires pour représenter un

nombre en complément à 2, il faut prévoir un bit supplémentaire pour
le bit de signe par rapport à la représentation en base binaire.
Ainsi, en complément à 2, on peut représenter sur n bits les valeurs
entières de à .
 METHODE RAPIDE

Pour transformer un nombre en son complément à 2 sans poser de

calcul, il suffit de garder tous les bits depuis la droite jusqu’au premier 1
compris, puis d’inverser tous ceux qui sont à gauche du premier 1.

Exemple : Pour le nombre 38 en binaire : 0010 0110,

- on garde la partie à droite : 0010 0110 ;
- on inverse la partie de gauche après le premier un : 1101 1010.
L’écriture de en complément à est : 1101 1010.
▶ 5 – R E P R E S E N TAT I O N
A P P R O X I M AT I V E D E S
NOMBRES REELS
R E P R E S E N TAT I O N A P P R O X I M AT I V E
DES NB REELS
En informatique, les nombres non entiers sont souvent représentés en
nombre à virgule flottante, encore appelés nombres flottants.

Compte tenu du nombre limité de bits en mémoire, tous les nombres

réels ne sont pas exactement représentables en binaire. Ainsi, certains
nombres réels ont-ils un représentation binaire infinie.

Exemple : La représentation de en base binaire est , etc.

R E P R E S E N TAT I O N A P P R O X I M AT I V E
DES NB REELS
 LE TEST D’EGALITE SUR LES NB
F L O T TA N T S
Il faut éviter de tester l’égalité sur deux nombres flottants.

Exemple : En Python et dans la plupart des langages de programmation,

0,1 + 0,2 n’est pas exactement égal à 0,3.
>>> 0.1 + 0.2 == 0.3
False
 LE TEST D’EGALITE SUR LES NB
F L O T TA N T S
Certaines versions du module Python [math] et le module [numpy]
contiennent la fonction [isclose()] qui permet de pallier le problème de
la représentation approximative d’un nombre flottant.

Exemple : >>> from math import *

>>> isclose(7.00000000001, 7)
True

L’instruction [isclose(7.00000000001, 7)] renvoie [True]. L’importation

du module Python [math] ou [numpy] est indispensable.
 LE TEST D’EGALITE SUR LES NB
F L O T TA N T S
Une autre possibilité consiste à modifier le test [a == b] en calculant la
valeur absolue de la différence entre [a] et [b] avec la précision
souhaitée (ici ), ce qui donne [abs(a-b) <= 10**-9].

Exemple : L’instruction [abs(a-5) <= 10**-8] permet de tester si la

variable [a] de type [float] a une valeur proche de 5 avec une précision
de .
 LE TEST D’EGALITE SUR LES NB
F L O T TA N T S
L’affichage d’un nombre flottant peut prêter à confusion à cause de sa
représentation potentiellement approximative, et donc non exacte.

La fonction native [round()] permet de calculer des arrondis en

précisant en arguments la valeur à arrondir et le nombre de décimales
souhaité.

Exemple : L’instruction [round(1.23562, 3)] renvoie [1.236].

C E Q U ’ I L FA U T S AV O I R ( FA I R E )