1ereNSI/representation_base/chapitre_2/README.md

# Représentation des entiers relatifs

## Le Programme

<img src="assets/bo.png" alt="bo.png" style="zoom: 50%;" />

> Pour comprendre le fonctionnement du binaire, nous allons nous intéresser dans un premier temps à la représentation des entiers positifs en base 10. Quelle que soit la base utilisée, le fonctionnement est identique et les méthodes de conversion sont similaires.

## Pré-requis

### La valeur absolue d'un nombre

La valeur absolue d'un nombre réel est sa valeur numérique sans tenir compte de son signe. Elle est notée $`|n|`$.

- Si $`n > 0`$, alors $`|n| = n`$
- Si $`n < 0`$, alors $`|n| = `$ opposé de $`n`$

###  Les bits significatifs

### L'addition binaire

Les opérations ci dessous manipulent des nombres représentés en binaire, codés sur un (1) bit.

```math
\begin{align*}
0 + 0 &= 0 \\
1 + 0 &= 1 \\
0 + 1 &= 1 \\
1 + 1 &= 0 \rightarrow \textit{Mais on reporte la retenue sur le bit de poids supérieur}
\end{align*}
```

### La soustraction

Les opérations ci dessous manipulent des nombres représentés en binaire, codés sur quatre (4) bit.

```math
\begin{align*}
0110 - 0011 &= 0011 \\
1011 - 10 &= 1001 \\
10 - 101 &= ? \\
\end{align*}
```

**_À votre avis, que donne cette dernière opération ?_**



 Autre exemple : calculer 1000₂ − 0011₂ (soit 8 − 3 = 5)
$$
\begin{align*}
1000 - 0011 &= ? \\
\end{align*}
$$
On part du bit de droite (bit de poids faible, ou LSB) vers la gauche :
	•	Colonne 0 : 0 − 1 → impossible, on emprunte
on fait 0 + 2 − 1 = 1, et on place un emprunt pour la colonne suivante.
	•	Colonne 1 : on doit faire 0 − 1 − 1(emprunt) = 0 − 2 → on emprunte
0 + 2 − 2 = 0, emprunt pour la colonne suivante.
	•	Colonne 2 : 0 − 0 − 1(emprunt) = −1 → on emprunte
0 + 2 − 1 = 1, emprunt pour la colonne suivante.
	•	Colonne 3 : 1 − 0 − 1(emprunt) = 0 → pas d’emprunt.

Résultat : 0101₂ soit 5<sub>10</sub> 



## 1. La représentation binaire signée

La première méthode utilisée pour représenter des entiers négatifs est de réserver un bit qui déterminera le signe. 

Le bit de signe choisi est le bit de poids fort. Par convention, on définira :

- $`1`$ pour représenter un nombre négatif
- $`0`$ pour représenter un nombre positif

Avant de représenter un entier, il faut aussi définir le nombre de bits qui seront utilisés, souvent 4, 8, 16, 32 ou 64 bits.

Prenons un exemple avec l'entier $`5`$ sur 4 bits :

```math
\begin{align*}
5_{10} & = 0101_2 \\
-5_{10} & = 1101_{2}
\end{align*}
```

Cependant cette méthode possède un inconvénient majeur :

Les opérations "classiques" avec 2 nombres binaires ne fonctionnent plus ! 

Ensuite, on peut observer qu'il existe dorénavant deux manières de notation du nombre zéro (0) :

- $`0000\ 0000 = +0`$
- $`1000\ 0000 = -0`$

Cela pose problème, car en maths **0 est unique**.

Enfin, cela peut causer des **incohérences dans les calculs** : 
$$
(+1) + (−1)  ≠ 0
$$


Regardons cela : 
$$
  0001
+ 1001
= 
 1010
$$




Or 1010₂ correspond à −2 dans cette représentation, alors qu’en mathématiques, on devrait trouver **0**.

Résultat : les opérations arithmétiques classiques ne fonctionnent pas avec cette méthode, ce qui oblige à traiter des cas particuliers.

C’est une des raisons pour lesquelles on a inventé le **complément à 2**, qui supprime le double zéro et rend les additions correctes.



## 2. Le complément à 2

Le **complément à 2** est la méthode de représentation d'un entier négatif.

Cette méthode se décompose en quatre (4) étapes :

1. Représenter la valeur absolue de l'entier relatif sur $`p`$ bits
2. Inverser tous les bits (les 1 deviennent des 0 et vice versa)
3. Ajouter un (1) au nombre obtenu à l'étape précédente
4. Le résultat de cette dernière opération est donc la représentation sur $`p`$ bits de l'entier relatif.

**Travail à faire**

> Calculer l'entier -5 en appliquant le complément à 2 sur 8 bits.

Vérifions que la représentation par le complément à 2 satisfait la règle vue précédemment.

Dans l'opération ci-dessus, nous avons un 1 pour le 9ième bit, mais comme notre représentation se limite à 8 bits, il nous reste bien $`(00000000)_2`$.

> 1. Représenter sur 8 bits l'entier 4 puis représenter, toujours sur 8 bits, l'entier -5.
> 2. Additionner ces 2 nombres, vérifier que vous obtenez bien -1.

**Question pour vous**

- Quel est le plus petit entier négatif que l'on peut représenter sur huit (8) bits ?
- Et quel est le le plus grand ?



----------------

#### Mémo 

| **Binaire** | **Valeur non signée** | **Valeur signée (complément à 2)** |
| ----------- | --------------------- | ---------------------------------- |
| 0000        | 0                     | 0                                  |
| 0001        | 1                     | 1                                  |
| 0010        | 2                     | 2                                  |
| 0011        | 3                     | 3                                  |
| 0100        | 4                     | 4                                  |
| 0101        | 5                     | 5                                  |
| 0110        | 6                     | 6                                  |
| 0111        | 7                     | 7                                  |
| 1000        | 8                     | -8                                 |
| 1001        | 9                     | -7                                 |
| 1010        | 10                    | -6                                 |
| 1011        | 11                    | -5                                 |
| 1100        | 12                    | -4                                 |
| 1101        | 13                    | -3                                 |
| 1110        | 14                    | -2                                 |
| 1111        | 15                    | -1                                 |

### Remarque  :

Plus généralement, nous pouvons dire que pour une représentation sur $`n`$ bits, il sera possible de coder des valeurs comprises entre $`-2^{n-1}`$ et $`+2^{n-1} - 1`$ .

Sachant que dans le langage C, les entiers signés sont codés sur 32 bits, dont un (1) pour le signe, quelles sont les valeurs minimale et maximale des entiers que l'on peut représenter ?

- Ce qui est intéressant, c’est que quand on **dépasse la borne**, on “reboucle” :

  

  - 2147483647 + 1 = - 2147483648.
  - Ce phénomène s’appelle un **overflow (dépassement de capacité)**.
  - Et ça, c’est possible uniquement parce qu’on utilise le **complément à 2**, qui permet d’avoir des additions binaires cohérentes même quand on “déborde”.

En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeurs minimale et maximale des entiers ne dépendent que de la quantité de mémoire disponible sur votre machine.

Néanmoins, on dispose de la bibliothèque _numpy_ qui permet de forcer une représentation sur 8 bits, par exemple, à l'aide de la fonction *int8*

```python
import numpy as np

a = np.int8(120)
b = np.int8(10)

print(a + b)  # Résultat ?
```



--------

Auteurs  : Florian Mathieu - Philippe Boddaert

Licence CC BY NC

<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.