# 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
e1
e2
s1
s0
0
0
0
1
1
0
1
1
#
# 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.
#
#
# In[ ]:
# Écrire ici la fonction add
# 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.
#
# In[ ]:
#Sélectionner cette zone puis SHIFT+ENTREE
from IPython.display import HTML ; HTML("""""")
#
Somme binaire de trois chiffres
r
e1
e2
s1
s0
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
#
#
# 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
#
# In[ ]:
# Écrire ici la fonction add_r
# 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 ...
# In[ ]:
L[-2] # permet d'obtenir ...
# In[ ]:
L[-len(L)] # permet d'obtenir ...
# In[ ]:
L.insert(0,1) # permet ...
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
# 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])
# 
#
#
#