---
jupytext:
  text_representation:
    extension: .md
    format_name: myst
    format_version: 0.13
    jupytext_version: 1.13.8
kernelspec:
  display_name: Python 3.9.7 64-bit
  name: python3
---

# Représentation binaire des nombres des entiers positifs

## Représentation d'un nombre

Un ordinateur ne manipule que des bits, c'est à dire des alternatives qu'on
peut représenter sous la forme 0 ou 1. Un bit est la plus petite quantité
d'information qui peut être transmise à un instant $t$ donné.

:::{prf:definition}
:label: uint-def-octet

Le regroupement de 8 bits s'appelle un octet.
:::

::::{margin}
:::{note}
En base 10, tout nombre $x$ peut s'écrire $x = d_0 10^0 + d_1 10^1 + … + d_n
10^n$, avec $d_0, … d_n$ des chiffres entre 0 et 9.
En base $b$, tout nombre $x$ peut s'écrire $x = c_0 b^0 + c_1 b^1 + … c_m
b^m$, avec $c_0, c_1, …, c_m$, $m$ symboles correspondant à des nombres
entre $0$ et $b-1$.
:::
::::
Tout nombre entier peut s'écrire en base 2, avec uniquement les symboles $0$
et $1$.

Pour obtenir la représentation binaire d'un nombre, on va écrire sa division entière par deux jusqu'à ce que le quotient soit nul.

::::{prf:example} Factorisation de Hörner d'un nombre en base 2
```
45 = 22×2 + 1
   = (11×2 + 0) + 1
   = ((5×2 + 1)×2 + 0) + 1
   = (((2×2 + 1)×2 +1)×2 + 0) + 1
   = ((((1×2 + 0)×2 + 1)×2 +1)×2 + 0) + 1
```
Le nombre 45 s'écrit `'0b101101'` en base 2.
::::

:::{warning}
La décomposition d'un nombre en base 2 donner les chiffres par ordre croissant de puissance (d'abord la plus petite puissance, jusqu'à la plus grande).
L'écriture usuelle des nombres se fait en commençant par la plus grande puissance et en finissant par la plus petite.

+ La première (du plus petit au plus grand) s'appelle le petit boutimse (ou little endianness)
+ La seconde (du plus grand au plus petit) s'appelle le grand boutimse (ou big endianness)

[Pour aller plus loin sur le sujet](https://fr.wikipedia.org/wiki/Boutisme)
:::


::::{margin}
:::{note}
un mot mémoire est l'unité de base manipulée par le microprocesseur.
:::
::::
Sur un ordinateur, la longueur des mots est conditionnée par la taille des
«mots mémoires» :
- 8 bits : de 0 à 255
- 16 bits : de 0 à 65535

:::{exercise}
:label: taille

Donner le plus grand entier représentable avec
1. 8 bits ;
1. 16 bits ;
1. 32 bits.
:::

:::{solution} taille

1. Les nombres sur 8 bits s'écrivent `'0b00000000'` pour le plus petit (0) à `'0b11111111'` soit $2^7 + 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 = 2^8 - 1$.
Ce qui se calcule :
```{code-block} python
2**8 - 1
```
Les nombres vont donc de 0 à 255 et il y en a bien 256.
2. $2^{16}$ nombres de 0 à $2^16 - 1$ soit $65535$
2. $2^{32}$ nombres de 0 à $2^32 - 1$ soit environ $4.29\times 10^9$.

:::



## Convention d'écriture en Python en base 2

:::{margin}
:class: note
La fonction `bin()` de Python permet de convertir un entier écrit en décimal
en écriture binaire
La fonction `int(⋅,2)` de Python permet de convertir un entier écrit en
binaire en entier écrit en décimal.
:::
```{code-cell} ipython
:tags: [margin]

int('0b11001010',2)
```

:::{prf:proposition}
:label: uint-ecriture

Les nombres binaires s'écrivent avec `0` et `1`, en préfixant par `0b`. Il se lisent dans le sens des puissances décroissantes rangées de la gauche vers la droite.
:::

::::{prf:example}
:label: uint-decomposition

```
0b11001010
  |||||||+- 0×1
  ||||||+-- 1×2
  |||||+--- 0×4
  ||||+---- 1×8
  |||+----- 0×16
  ||+------ 0×32
  |+------- 1×64
  +-------- 1×128
```
Le nombre ainsi représenté est $0×2^0 + 1×2^1 + 0×2^2 + 1×2^3 + 0×2^4 + 0×2^5 + 1×2^6 + 1×2^7 = 202$
::::

Dans la base 10, on dispose de 10 symboles différents, notés 0, 1, 2, …, 9, alors que dans la base 2, on dispose des 2 symboles distincts 0, 1. On peut généraliser à toute base entière $b ≥ 2$, comportant $b$ symboles distincts.