\documentclass[utf8,crop,realfonts,rabat]{prepamath}
\usepackage{rabat}
\usepackage{xlop}
\graphicspath{{figures/}}
\title{Rabats pour le livre 1NSI}
\author{Stéphane Pasquet}
\definecolor{tabularcolorline}{cmyk}{0,0.2,0.5,0}
\newcommand{\base}[2]{\overline{\rm #1}^{\;#2}}
%%%%%%%%%%%%
\begin{document}

%% ==== VOLET 1

\begin{colonne}
\begin{cadre}{Conversions}
\novspace
\point{Du décimal au binaire}
\vspace*{-2em}
\[
\opidiv{25}{2} \quad \rightarrow \quad  
\opidiv{12}{2} \quad \rightarrow \quad  
\opidiv{6}{2} \quad \rightarrow \quad 
\opidiv{3}{2} \quad \rightarrow \quad 
\opidiv{1}{2}
\]
\Par
Ainsi, $\base{25}{10}=2^4 + 2^3 + 2^0 = \base{11001}{2}$.

\point{Du binaire au décimal}
\vspace*{-0.5em}
\renewcommand{\arraystretch}{1.2}

$\begin{array}{|>{\columncolor{tabularcolorline}}Zl|*7{c|}}
\hline
\text{Binaire} & 1 & 1 & 0 & 0 & 1 & 0 & 1 \\\hline
\text{Puissances de 2} & 2^6 & 2^5 & 2^4 & 2^3 & 2^2 & 2^1 & 2^0\\\hline
\text{Décimal} & \multicolumn{7}{c|}{2^6+2^5+2^2+2^0}\\\hline
\end{array}$

\Par
Ainsi, $\base{1100101}{2}=\base{101}{10}$.

\point{Du décimal à l'hexadécimal}
\vspace*{-1.5em}
\[
\renewcommand{\arraystretch}{1.2}
\begin{array}{ccccc}
\opidiv{1234}{16} & \quad \rightarrow \quad   &
\opidiv{77}{16} &\quad \rightarrow \quad  &
\opidiv{4}{16}\\
\downarrow & & \downarrow &  & \downarrow \\
2 &  & 13\rightarrow D &  & 4
\end{array}
\]

\Par
Ainsi, $\base{1234}{10}=\base{4D2}{16}$.

\point{De l'hexadécimal au binaire}
\vspace*{-.5em}

$\begin{array}{|>{\columncolor{tabularcolorline}}Zl|Zc|Zc|Zc|Zc|Zc|Zc|}
\hline
\text{Hexadécimal} & \text{A} & \text{B} & \text{C} & \text{D} & \text{E} & \text{F}\\\hline
\text{Pseudo-décimal} & 10 & 11 & 12 & 13 & 14 & 15\\\hline
\text{Binaire} & 1010 & 1011 & 1100 & 1101 & 1110 & 1111\\\hline
\end{array}$

\Par
Ainsi, $\base{BD}{16}=\base{10111101}{2}$.

\point{Du binaire à l'hexadécimal}
\vspace*{-.5em}

$\begin{array}{|>{\columncolor{tabularcolorline}}Zl|Zc|Zc|}
\hline
\text{Binaire} & 0100 & 1101\\\hline
\text{Pseudo-décimal} & 4 & 13\\\hline
\text{Hexadécimal} & 4 & \text{D}\\\hline
\end{array}$

\Par
Ainsi, $\base{01001101}{2}=\base{4D}{16}$.
\vspace*{-.5em}
\end{cadre}

\Par

\begin{cadre}{Algèbre de Boole}
\novspace\vspace*{-2.3em}
\begin{multicols}{2}
\point{Conjonction logique}
\vspace*{-0.5em}
\begin{tabular}{|>{\columncolor{tabularcolorline}}Zc|Zc|Zc|}
\rowcolor{tabularcolorline}\hline
ET & Faux & Vrai\\
\hline
Faux & Faux & Faux\\
\hline
Vrai & Faux & Vrai\\
\hline
\end{tabular}

\columnbreak

\point{Disjonction logique}
\vspace*{-0.5em}
\begin{tabular}{|>{\columncolor{tabularcolorline}}Zc|Zc|Zc|}
\rowcolor{tabularcolorline}\hline
OU & Faux & Vrai\\
\hline
Faux & Faux & Vrai\\
\hline
Vrai & Vrai & Vrai\\
\hline
\end{tabular}
\end{multicols}
\vspace*{-2.7em}
\end{cadre}
\end{colonne}

%%% ====== VOLET 6

\begin{colonne}
\begin{cadre}{Représentation binaire d'un entier}
\novspace
\point{Binaire pur}
\vspace*{-1.2em}
Codage dans lequel sont écrits les entiers \textit{naturels}.

Avec une mémoire de $n$ bits, tous les entiers de 0 à $2^n-1$ sont représentés.

\textit{Exemples :} $\begin{aligned}[t]
n=8\phantom{4} \to & \text{ les entiers de 0 à }2^8-1=255\text{ sont représentés}.\\[-4pt]
n=64 \to& \text{ les entiers de 0 à }2^{64}-1=\numprint{16777215}\text{ sont représentés}.
\end{aligned}$

\vspace*{-1.2em}
\point{Binaire signé}
\vspace*{-1.2em}
Codage dans lequel sont écrits les entiers \textit{relatifs}.

Avec une mémoire de $n$ bits, tous les entiers de $-(2^{n-1}-1)$ à $2^{n-1}-1$ sont\linebreak représentés.

Le bit de poids fort représente le signe (\og 0 \fg{}  pour \og $+$ \fg{} et \og 1 \fg{} pour \og $-$ \fg).

\Par

\textit{Exemple :} $\base{11011001}{2}=\base{-89}{10}$.

\vspace*{-1.2em}
\point{Complément à 2}
\vspace*{-1.2em}

Autre codage dans lequel sont écrits les entiers \textit{relatifs}.
\begin{itemize}
\item si $n>0$, on utilise le binaire signé ;\\[-1.5em]
\item si $n<0$, \\[-1.5em]
\begin{itemize}
\item[$\rightarrow$] on code $|n|$ en binaire signé,\\[-1.5em]
\item[$\rightarrow$] on prend le complément à 1 du binaire trouvé (c'est-à-dire que l'on remplace
\item[\hspace*{4mm}] tous les 0 par des 1, et tous les 1 par des 0),\\[-1.5em]
\item[$\rightarrow$] on additionne 1 au nombre binaire ainsi obtenu.
\end{itemize}
\end{itemize}

\Par

\textit{Exemple :} pour trouver le complément à 2 de $\base{-57}{10}$ avec une mémoire de 8 bits,
\begin{itemize}
\item[$\rightarrow$] on code le nombre sans son signe en binaire signé: $\base{00111001}{2}$;
\item[$\rightarrow$] on prend le complément à 1: $\base{11000110}{2}$;
\item[$\rightarrow$] on ajoute 1 au binaire obtenu: $\base{11000111}{2}$.
\end{itemize}
\vspace*{-1.7em}
\end{cadre}

\Par

\begin{cadre}{Représentation binaire d'un réel}
\novspace
\point{Nombres dyadiques}
\vspace*{-1.2em}
Ce sont les nombres de la forme $\dfrac{x}{2^n}$, où $x$ est un nombre relatif et $n$ un entier naturel.

\vspace*{-1.2em}
\point{Développement dyadique}
\vspace*{-1.2em}

Pour obtenir le développement dyadique de $\dfrac{x}{2^n}$, on prend le binaire correspondant à $x$ et on insère une virgule avant le $n$-ième bit en partant de la fin.

\Par

\textit{Exemple :} $\dfrac{13}{4}=\dfrac{13}{2^2}$ et $\base{13}{10}=\base{1101}{2}$ donc $\base{\dfrac{13}{4}}{10}=\base{11,01}{2}$.

\Par

Le développement dyadique de tout nombre décimal non dyadique est infini;\linebreak par exemple, $\base{0,1}{10}=\base{0,0001100110011\ldots}{2}$.

\vspace*{-1.2em}
\point{Représentation approximative d'un réel}
\vspace*{-1.2em}

Elle est obtenu à partir de l'écriture décimale du nombre.

\Par

\begin{minipage}{6cm}
\textit{Exemple :} $\dfrac{1}{3}\approx0,333\ldots$.
\begin{itemize}
\item $0,333\ldots\times2=\boxed{0},\underline{666\ldots}$
\item $0,666\ldots\times2=\boxed{1},\underline{333\ldots}$
\end{itemize}
\end{minipage}
\begin{minipage}{6cm}
Donc $\base{\dfrac{1}{3}}{10}=\base{0,010101\ldots}{2}$.
\end{minipage}
\vspace{-1.6em}
\end{cadre}
\end{colonne}

%%============ VOLET 2

\begin{colonne}[2]
\begin{cadre}{Python}
\begin{minipage}[t]{120mm}
\novspace
\point{Calculs de base}
\vspace*{-0.7em}
\begin{tabular}{|Zc|Zc|Zc|Zc|}
\rowcolor{tabularcolorline}\hline
\textbf{Calcul} & \textbf{Syntaxe} & \textbf{Exemple} & \textbf{Résultat}\\
\hline
Addition & \ttfamily + & \ttfamily 13+6 & \ttfamily 19\\
\hline
Soustraction & \ttfamily - & \ttfamily 13-6 & \ttfamily 7\\
\hline
Multiplication & \ttfamily * & \ttfamily 13*6 & \ttfamily 78\\
\hline
Division décimale & \ttfamily /  &\ttfamily 13/6 & \ttfamily 2.1666666666666665\\
\hline
Division entière & \ttfamily  // &  \ttfamily 13//6 &  \texttt{2} (partie entière de $\dfrac{13}{6}$)\\
\hline
Reste de la division euclidienne & \ttfamily \% & \ttfamily 13\%6 & \ttfamily 1\\
\hline
Puissances & \ttfamily ** & \ttfamily 2**5 & \ttfamily 32\\
\hline
Racine carrée & \ttfamily **0.5 & \ttfamily 9**0.5 & \ttfamily 3\\
\hline
\end{tabular}

\point{Boucles/instructions itératives et conditionnelles}
\vspace*{-0.7em}
\begin{tabular}{|Zc|Zc|Zc|}
\rowcolor{tabularcolorline}\hline
\textbf{Dénomination} & \textbf{Syntaxe}\\
\hline
Tant que $i = j$ & \ttfamily while i == j: \\
\hline
Tant que $i \leqslant j$ & \ttfamily while i <= j: \\
\hline
Tant que $i < j$ & \ttfamily while i < j: \\
\hline
Tant que $10 < i < 20$ & \ttfamily while i > 10 and i < 20: \\
\hline
Pour i allant de 0 à $n$ & \ttfamily for i in range(n+1):\\
\hline
Pour i allant de 1 à $n$ & \ttfamily for i in range(1,n+1):\\
\hline
Si i > j & \ttfamily if i > j:\\
\hline
\end{tabular}
\vspace*{-0.7em}
\point{Affectations et déclarations}
\vspace*{-0.7em}
\begin{tabular}{|Zc|>{\centering\arraybackslash}Z{m{55mm}}|}
\rowcolor{tabularcolorline}\hline
\textbf{Dénomination} & \textbf{Syntaxe}\\
\hline
Affecter la valeur 4 à la variable k & \ttfamily k = 4\\
\hline
Ajouter 7 à k & \ttfamily k += 7\\
\hline
Soustraire 7 à k & \ttfamily k -= 7\\
\hline
Multiplier k par 7 & \ttfamily k *= 7\\
\hline
Diviser k par 7 & \ttfamily k /= 7\\
\hline
Affectation de plusieurs variables & \ttfamily a,b,c = 3,4,5\\
\hline
Déclarer une chaîne de caractères & \ttfamily mot='Bonjour' / mot="Bonjour"\\
\hline
Déclarer un tableau vide & \ttfamily tableau = []\\
\hline
Déclarer un tableau rempli & \ttfamily tableau = [2,-3,5]\\
\hline
Déclarer un tableau rempli de \og 0 \fg{} & \ttfamily tableau = [0]*5\\
\hline
Déclarer un dictionnaire vide & \ttfamily dico = \{\}\\
\hline
Déclarer un dictionnaire rempli & \ttfamily dico = \{1:'Paul' , 2:'Jean'\}\\
\hline
Déclarer la matrice $\begin{pmatrix}1&2\\3&4\end{pmatrix}$ & 
m = [ [1,2] , [3,4] ]\\
\hline
Construire une matrice remplie de \og 0 \fg{}  & \ttfamily add = [[0] * 9\newline for i in range(9)]\\
\hline
\end{tabular}
\vspace*{-1.3em}
\end{minipage}
\begin{minipage}[t]{30mm}
~
\end{minipage}
\begin{minipage}[t]{16cm}
Par la suite, \texttt{L} désigne une liste et \texttt{dico} un dictionnaire.

\vspace*{-0.7em}
\point{Méthodes principales}
\vspace*{-0.7em}
\begin{tabular}{|>{\ttfamily}Zc|Z{m{55mm}}|Zc|Zc|}
\rowcolor{tabularcolorline}\hline
\textbf{Méthode} &\centering\arraybackslash \textbf{Dénomination} & \textbf{Syntaxe}\\
\hline
[:5] & Affiche les 5 premières entrées & L[:5]\\
\hline
append & Ajouter la valeur 5 à une liste. & \ttfamily L.append(5)\\
\hline
copy & Copie un dictionnaire. & \ttfamily dico2 = dico.copy()\\
\hline
count & Compte le nombre d'occurrences de 7 dans la liste. & \ttfamily L.count(7)\\
\hline
del & Supprime une entrée avec un index. & \ttfamily del L[1], del dico[clé]\\
\hline
extend & Ajouter les valeurs 5,6 à une liste. & \ttfamily L.extend((5,6))\\
\hline
get & Récupère la valeur d'une clé. & \ttfamily dico.get('clé')\\
\hline
insert & Insère la valeur 8 en 2\ieme position. & \ttfamily L.insert(1,8)\\
\hline
items & Affiche toutes les entrées d'un dictionnaire. & \ttfamily dico.items()\\
\hline
join & Transforme une liste en chaîne de caractères, où chaque entrée est séparée par le séparateur indiqué (dans notre exemple, une virgule). & \ttfamily chaine = ",".join(L)\\
\hline
len & Compte le nombre d'entrées dans une liste. & \ttfamily len(L)\\
\hline
remove & Supprime une entrée 8. & \ttfamily L.remove(8)\\
\hline
reverse & Inverse la liste. & \ttfamily L.reverse()\\
\hline
split & Transforme une chaîne de caractères \texttt{chaine} en liste où chaque entrée est définie par un séparateur (dans notre exemple, une virgule. & \ttfamily L = ",".split(chaine)\\
\hline
\end{tabular}

\point{Parcourir une liste, une chaîne de caractères ou un dictionnaire}
\vspace*{-0.7em}
\begin{tabular}{|Zl|Z{m{55mm}}|}
\rowcolor{tabularcolorline}\hline
\textbf{Syntaxe} & \centering\arraybackslash\textbf{Dénomination}  \\
\hline
\ttfamily for i in range(L): & i désigne l'item sur lequel on est. \\
\hline
\ttfamily for i in range(len(L)): & i désigne l'index sur lequel on est.\\
\hline
\ttfamily for cle,valeur in dico.items(): & Récupère la clé et la valeur de chaque entrée.\\
\hline
\end{tabular}

\vspace*{-0.7em}
\point{Fonction lambda}
\vspace*{-1em}
Syntaxe : \texttt{nom = lambda <variable> : expression}

\textit{Exemple :} \texttt{carre = lambda x: x**2}

\vspace*{-0.7em}
\point{Tri avec une fonction lambda}
\vspace*{-1em}

Syntaxe : \texttt{L.sort(key = lambda colonnes:colonnes[n])}

Tri suivant la colonne $n+1$ la liste \texttt{L}.
\end{minipage}
\end{cadre}
\end{colonne}

%===

\begin{colonne}
\begin{cadre}{Interaction client-serveur}
\begin{center}
\includegraphics[width=0.8\linewidth]{04-Client-serveur}
\end{center}

\vspace*{1em}

Dans un environnement client-serveur, 
\begin{itemize}
\item le \textit{client} est généralement l'ordinateur sur lequel on se connecte à Internet : c'est lui qui envoie les requêtes;
\item le \textit{serveur} est la machine sur laquelle est la page web : c'est elle qui répond aux requêtes.
\end{itemize}
\vspace*{-2em}
\end{cadre}

\Par\Par

\begin{cadre}{Architecture de Von Neumann}
\vspace*{-8mm}
\point{Unité Arithmétique Logique (UAL)}
\vspace*{-0.7em}

\begin{minipage}{6cm}
\includegraphics{05-UAL.eps}
\end{minipage}
\begin{minipage}{7.5cm}
\begin{itemize}
\item A et B sont les opérandes (les entrées);
\item R est le résultat;
\item F est une fonction binaire (l'opération à effectuer);
\item D est un drapeau indiquant un résultat secondaire de la fonction (signe, erreur, division par zéro, ...).
\end{itemize}
Opérations possibles :
\begin{itemize}
\item addition, soustraction, multiplication, division;
\item opérations logiques (ET, OU, NON);
\item opérations de comparaison ($>$, $<$ et $=$).
\end{itemize}
\end{minipage}

\vspace*{5mm}
\point{Mémoire}
\vspace*{-1em}
Sorte de tableau dans lequel seront stockés aussi bien les variables que les programmes. 

Chaque cellule de ce tableau possède une adresse X et la valeur de chaque cellule est noté M[X].


\point{Unité de commande}
\vspace*{-1em}
Elle donne les ordres à toutes les autres parties de l'ordinateur.

Elle est principalement composée de quatre registres :
\begin{itemize}
\item CO : le compteur ordinal, qui contient l'adresse de la prochaine instruction à exécuter;
\item RI : le registre d'instructions qui contient l'instruction en cours d'exécution;
\item AC : l'accumulateur chargé de stocker des opérandes intermédiaires;
\item CC : le code condition, utilisé pour les instructions de rupture conditionnelle (saut).
\end{itemize}
\vspace{-1.5em}
\end{cadre}
\end{colonne}

%===

\begin{colonne}
\begin{cadre}{Architecture réseau}
\vspace*{-6mm}
\point{Topologie en bus}
\begin{center}
\includegraphics{05-Topologie-en-bus}
\end{center}
\Par\Par
\begin{minipage}{0.45\linewidth}
\textit{Avantages :}
\begin{itemize}
\item facilité de mise en \oe uvre;
\item faible coût.\\~
\end{itemize}
\end{minipage}
\hfill
\begin{minipage}{0.45\linewidth}
\textit{Inconvénients :}
\begin{itemize}
\item réseau inutilisable en cas de rupture\\du bus;
\item signal jamais régénéré.
\end{itemize}
\end{minipage}

\vspace*{-3mm}
\point{Topologie en étoile}
\begin{center}
\includegraphics{05-Topologie-en-etoile}
\end{center}
\Par\Par
\begin{minipage}{0.45\linewidth}
\textit{Avantages :}
\begin{itemize}
\item précision d'envoi;
\item ajout facile de postes.\\~
\end{itemize} 
\end{minipage}
\hfill
\begin{minipage}{0.45\linewidth}
\textit{Inconvénients :}
\begin{itemize}
\item  dépend du n\oe ud central;
\item  coûteux (nécessite plusieurs\\câbles).
\end{itemize}
\end{minipage}

\vspace*{-2mm}
\point{Topologie en anneau}
\begin{center}
\includegraphics{05-Topologie-en-anneau}
\end{center}
\Par\Par\Par
\begin{minipage}{0.45\linewidth}
\textit{Avantages :}
\begin{itemize}
\item débit proche de 90\% de la bande\\passante,
\item signal régénéré par chaque station.\\~
\end{itemize}
\end{minipage}
\hfill
\begin{minipage}{0.45\linewidth}
\textit{Inconvénients :}
\begin{itemize}
\item réseau inutilisable si un poste\\ne fonctionne pas,
\item s'il y a trop de machines, le temps de transmission s'allonge.
\end{itemize}
\end{minipage}
\end{cadre}
\end{colonne}
\end{document}
