En tête general

© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.
Les activités partagées sur Capytale sont sous licence Creative Commons.

Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.



Addition binaire (corrigé)

Activité sur les booléens n°2

Important : Il est conseillé de réaliser cette activité après l'activité Portes logiques et booléens.



1. Somme de deux chiffres en binaire

En écriture binaire, on ne dispose que de deux chiffres pour l'écriture des nombres : 0 et 1.
Ces chiffres correspondent respectivement aux valeurs booléennes False et True.
La somme de deux chiffres en binaire donne un résultat à deux chiffres : Le chiffre des unités et le chiffre des "deuzaines".

Addition binaire de deux chiffres
e1e2s1s0
00
01
10
11

1.1. Recopier et compléter la table d'addition de deux chiffres binaires e1 et e2 ci-contre.
$\quad\;\;$(s0 et s1 sont respectivement le chiffre des unités et le chiffre des deuzaines du résultat)


1.2. a. Quelle est la porte logique qui permet d'obtenir s1 à partir de e1 et e2 ?
$\quad\;\;$b. Quelle est la porte logique qui permet d'obtenir s0 à partir de e1 et e2 ?
$\quad\;\;$c. Représenter un circuit combinatoire qui réalise l'addition de deux chiffres binaires.

1.3. Écrire une fonction Python add:

  • qui reçoit en entrée les signaux booléens e1 et e2 ;
  • qui renvoie les signaux booléens s1 et s0.
</strong>

In [ ]:
# Écrire ici la fonction add

def add(e1,e2):
    """
    fonction qui réalise la somme de deux chiffres en binaire
    """
    return e1 and e2,e1^e2 #s1,s0 dans cet ordre

1.4. La fonction Python Table_verite donnée ci-dessous renvoie la table de vérité d'un circuit combinatoire donné par une fonction Python.
$\quad\;\;$Exécuter les cellules suivantes pour vérifier que la fonction add permet de retrouver la table de vérité construite en 1.1.

In [ ]:
from itertools import product
from inspect import signature

def Table_verite(fonction_booleenne):
    """
    renvoie la table d'une fonction booléenne sous forme d'un dictionnaire
    À chaque tuple des valeurs booléennes en entrée est associé la(les) sortie(s) correspondante(s)
    """
    #récupération du nombre d'arguments de la fonction booleenne
    nbre_arguments = len (signature(fonction_booleenne).parameters) 
    
    #initialisation de la table
    Table={}
    
    #remplissage de la table : à chaque séquence de booléens possible...
    for liste_bool in product( *([[False,True] for j in range(nbre_arguments)] )):
        #...on fait correspondre le résultat de la fonction booléenne
        Table[liste_bool] = fonction_booleenne(*liste_bool)
    
    #renvoie la table
    return Table
In [ ]:
Table_verite(add)



2. Somme de deux nombres en binaire

Lorsqu’on pose une addition de deux nombres, on est amené à calculer la somme de trois chiffres :

  • le chiffre du 1er nombre ;
  • le chiffre du 2ème nombre ;
  • le chiffre de l’éventuelle retenue obtenue précédemment.

Ainsi, pour réaliser la somme de deux nombres, il est nécessaire de savoir sommer trois chiffres.

2.1. a. Effectuer à la main les additions binaires suivantes.

  • $10011+110$
  • $1111+1111$
  • $100101+10110$
$\quad\;\;$b. Activer la cellule ci-dessous pour obtenir un additionneur binaire. Utiliser cet additionneur pour vérifier les résultats de la question 2.1.a. </strong>

In [ ]:
#Sélectionner cette zone puis SHIFT+ENTREE
from IPython.display import HTML ; HTML("""<iframe scrolling="no" title="Additionneur binaire" src="https://www.geogebra.org/material/iframe/id/umzwxpdw/width/717/height/423/border/888888/sfsb/true/smb/false/stb/false/stbh/false/ai/false/asb/false/sri/false/rc/false/ld/false/sdz/false/ctl/false" width="717px" height="423px" style="border:0px;"> </iframe>""")
Somme binaire de trois chiffres
re1e2s1s0
000
001
010
011
100
101
110
111

2.2. Recopier et compléter la table d'addition de trois chiffres binaires e1, e2 et r ci-contre.
$\quad\;\;$(s0 et s1 sont respectivement le chiffre des unités et le chiffre des deuzaines du résultat)

2.3. a. Construire un circuit combinatoire qui permet d'obtenir s0 à partir de e1, e2 et r.
$\quad\;\;$b. Construire un circuit combinatoire qui permet d'obtenir s1 à partir de e1, e2 et r.
$\quad\quad$ (on pourra réaliser un autre schéma ou compléter le schéma précédent)

2.4. Écrire une fonction Python add_r:

  • qui reçoit en entrée les signaux booléens e1, e2 et r ;
  • qui renvoie les signaux booléens s1 et s0.

Effectuer ensuite un appel à la fonction Table_verite pour vérifier la cohérence avec la question 2.2 </strong>

In [ ]:
# Écrire ici la fonction add_r

def add_r(r,e1,e2):
    """
    fonction qui réalise la somme de trois chiffres en binaire
    """
    return ( e1 and e2 ) or ( r and e1 ^ e2 ) , r ^ ( e1 ^ e2 ) #s1,s0 dans cet ordre
    
    #return (not r and e1 and e2) or ((e1 or e2) and r) , (not r and (e1 ^ e2) ) or (not (e1 ^ e2) and r)  est une solution alternative
   
In [ ]:
# Exécuter cette cellule pour vérifier
Table_verite(add_r)

2.5. Pour la suite, un nombre binaire sera représenté par une liste contenant des 0 et des 1.
$\quad\;\;$Tester les syntaxes suivantes et compléter dans chaque cas le commentaire.

In [ ]:
L=[1,0,0,0,1,1,0] # représentation du nombre binaire 1000110 sous forme de liste
In [ ]:
L[-1]             # permet d'obtenir le dernier élément de la liste, càd le chiffre des unités
In [ ]:
L[-2]             # permet d'obtenir l'avant-dernier élément de la liste
In [ ]:
L[-len(L)]        # permet d'obtenir le premier élément de la liste
In [ ]:
L.insert(0,1)     # permet d'insérer la valeur 1 au début de la liste
L

2.6. Écrire une fonction Python add_bin :

  • qui reçoit en argument deux listes L1 et L2 de même longueur, correspondant à deux nombres binaires;
  • qui renvoie une liste correspondant à la somme de ces deux nombres.
Remarques :
  • on pourra utiliser la fonction add_r écrite précédemment;
  • pour s'assurer que les valeurs sont entières (0 ou 1) on pourra convertir les booléens calculés avec int.
In [ ]:
# Écrire ici la fonction add_bin

def add_bin(L1,L2):
    """
    Fonction qui réalise la somme de deux nombres binaires
    représentés par des listes de même longueur
    """
    r = 0  # retenue (nulle pour la première addition)
    L = [] # initialisation de la liste pour le résultat
    
    # on parcourt les chiffres du dernier au premier
    for k in range(-1,-len(L1)-1,-1):        
        # on additionne les 3 chiffres (et on crée la retenue)
        r,c = add_r( r,L1[k],L2[k] )
        # on insère le chiffre calculé
        L.insert(0,int(c)) 
    
    # insertion si nécessaire de la dernière retenue
    if r!=0: L.insert(0,int(r))    
    
    return L
    

2.7. Tester la fonction Python ci-dessous qui permet le calcul de deux nombres binaires quelconques (à l'aide de la fonction add_bin).

In [ ]:
# Exécuter cette cellule

def add_bin_final(L1,L2):
    """
    Fonction qui réalise la somme de deux nombres binaires
    représentés par des listes 
    """    
    # on ajoute des 0 "inutiles" pour que les listes soient de même longueur
    L2 = [0]*(len(L1)-len(L2)) + L2  # ajouts de chiffres 0 à L2 si nécessaire
    L1 = [0]*(len(L2)-len(L1)) + L1  # ajouts de chiffres 0 à L1 si nécessaire
    
    return add_bin(L1,L2)


add_bin_final([1,1,0,0],[1,1,0,0,1,1,1])

Claude_Shannon_George_Stibitz

Claude Shannon (1916-2001) et George Stibitz (1904-1995) ont initié le calcul binaire en électronique en 1937.

© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.
Les activités partagées sur Capytale sont sous licence Creative Commons.

This website does not host notebooks, it only renders notebooks available on other websites.

Delivered by Fastly, Rendered by OVHcloud

nbviewer GitHub repository.

nbviewer version: 90c61cc

nbconvert version: 5.6.1

Rendered (Mon, 18 Oct 2021 10:32:34 UTC)