\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Représentation des réels}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en B
\begin{frame}[fragile]{Question 1 \textemdash{} Type des réels en Python}
    Quel est le type Python utilisé pour représenter les
nombres à virgule ?\medskip
    \begin{itemize}
        \item[A.] \texttt{number}
        \item[\alert<2>{B.}] \alert<2>{\texttt{float}}
        \item[C.] \texttt{int}
        \item[D.] \texttt{real}
    \end{itemize}
\end{frame}

% Q2 - Réponse en D
\begin{frame}[fragile]{Question 2 \textemdash{} Notation scientifique}
    L'écriture \textbf{scientifique} d'un nombre réel sépare un
réel en :\medskip
    \begin{itemize}
        \item[A.] Une fraction irréductible
        \item[B.] Une partie entière et une partie décimale
        \item[C.] Un signe et une valeur absolue
        \item[\alert<2>{D.}] \alert<2>{Une mantisse (entre $1$ et $10$) et un exposant entier de $10$}
    \end{itemize}
\end{frame}

% Q3 - Réponse en A
\begin{frame}[fragile]{Question 3 \textemdash{} Norme IEEE 754}
    Que définit la norme \textbf{IEEE $754$} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La représentation binaire des nombres à virgule flottante (signe, exposant, mantisse)}
        \item[B.] La connectique des câbles réseau
        \item[C.] Le format des adresses IP
        \item[D.] Le format des fichiers PDF
    \end{itemize}
\end{frame}

% Q4 - Réponse en A
\begin{frame}[fragile]{Question 4 \textemdash{} Approximation des réels}
    Pourquoi les réels stockés en machine sont-ils en général
des \textbf{approximations} plutôt que des valeurs exactes ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Parce qu'il y a une infinité de nombres réels mais une mémoire finie}
        \item[B.] Parce que les ordinateurs sont mal conçus
        \item[C.] Parce qu'il faut moins de mémoire
        \item[D.] Parce que les flottants sont plus rapides que les entiers
    \end{itemize}
\end{frame}

% Q5 - Réponse en D
\begin{frame}[fragile]{Question 5 \textemdash{} Calcul flottant en Python}
    Que renvoie l'expression Python \texttt{0.1 + 0.2} ?\medskip
    \begin{itemize}
        \item[A.] Une erreur Python
        \item[B.] Exactement $0{,}3$
        \item[C.] $0{,}29999\ldots$ (sans aucune erreur)
        \item[\alert<2>{D.}] \alert<2>{Une valeur très proche de $0{,}3$, mais avec une petite erreur d'arrondi (par exemple $0{,}30000000000000004$)}
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile]{Question 6 \textemdash{} Comparer deux flottants}
    Pour tester si deux flottants \texttt{a} et \texttt{b} sont « égaux »
en Python, la bonne pratique est :\medskip
    \begin{itemize}
        \item[A.] \texttt{a == b}
        \item[B.] \texttt{int(a) == int(b)}
        \item[\alert<2>{C.}] \alert<2>{\texttt{abs(a - b) < epsilon} avec \texttt{epsilon} petit (par exemple $10^{-9}$)}
        \item[D.] \texttt{a is b}
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} Virgule fixe}
    Quelle est la différence entre une représentation à
\textbf{virgule fixe} et une représentation à \textbf{virgule
flottante} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La virgule fixe a un nombre de chiffres fractionnaires constant ; la virgule flottante a une précision relative}
        \item[B.] La virgule fixe n'existe que sur les vieux ordinateurs
        \item[C.] Aucune différence en pratique
        \item[D.] La virgule fixe est plus précise pour les très grands nombres
    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Taille d'un float Python}
    En Python, sur combien de bits est stocké un \texttt{float} ?\medskip
    \begin{itemize}
        \item[A.] $128$ bits
        \item[\alert<2>{B.}] \alert<2>{$64$ bits}
        \item[C.] $8$ bits
        \item[D.] $32$ bits
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Valeurs spéciales IEEE 754}
    La norme IEEE $754$ définit quelques valeurs spéciales
en plus des nombres réguliers. Lesquelles ?\medskip
    \begin{itemize}
        \item[A.] Aucune valeur spéciale
        \item[\alert<2>{B.}] \alert<2>{$+\infty$, $-\infty$, et NaN (« Not a Number »)}
        \item[C.] $\pi$, $e$, $\sqrt{2}$
        \item[D.] Vrai et Faux
    \end{itemize}
\end{frame}

% Q10 - Réponse en D
\begin{frame}[fragile]{Question 10 \textemdash{} Composantes d'un flottant IEEE 754}
    Quels sont les \textbf{trois champs} qui composent la
représentation IEEE $754$ d'un nombre flottant ?\medskip
    \begin{itemize}
        \item[A.] Partie entière, partie décimale, partie complexe
        \item[B.] Numérateur, dénominateur, exposant
        \item[C.] Octets supérieurs, médians, inférieurs
        \item[\alert<2>{D.}] \alert<2>{Bit de signe, exposant biaisé, mantisse (fraction)}
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile]{Question 11 \textemdash{} Erreur d'arrondi cumulative}
    Que peut-il se passer si on additionne plusieurs millions
de petits flottants entre eux ?\medskip
    \begin{itemize}
        \item[A.] Le résultat est exact, comme une somme d'entiers
        \item[B.] Le calcul devient infiniment lent
        \item[C.] Python lève une erreur de précision
        \item[\alert<2>{D.}] \alert<2>{Les erreurs d'arrondi peuvent s'accumuler et donner un résultat sensiblement différent du résultat mathématique exact}
    \end{itemize}
\end{frame}

% Q12 - Réponse en B
\begin{frame}[fragile]{Question 12 \textemdash{} Dépassement}
    Que renvoie en Python l'opération \texttt{1e308 * 10} (où
\texttt{1e308} désigne $10^{308}$) ?\medskip
    \begin{itemize}
        \item[A.] $10^{309}$
        \item[\alert<2>{B.}] \alert<2>{\texttt{inf}}
        \item[C.] Une erreur de Python
        \item[D.] $0$
    \end{itemize}
\end{frame}

% Q13 - Réponse en C
\begin{frame}[fragile]{Question 13 \textemdash{} Précision en double précision}
    Combien de chiffres décimaux significatifs un flottant
en \textbf{double précision} ($64$ bits) peut-il représenter
de manière fiable ?\medskip
    \begin{itemize}
        \item[A.] Une infinité
        \item[B.] Environ $50$
        \item[\alert<2>{C.}] \alert<2>{Environ $15$ à $17$}
        \item[D.] Environ $7$
    \end{itemize}
\end{frame}

% Q14 - Réponse en B
\begin{frame}[fragile]{Question 14 \textemdash{} math.isclose}
    En Python, la fonction \texttt{math.isclose(a, b)} :\medskip
    \begin{itemize}
        \item[A.] Convertit \texttt{a} et \texttt{b} en chaînes de caractères
        \item[\alert<2>{B.}] \alert<2>{Compare deux flottants en tolérant une petite différence relative et/ou absolue}
        \item[C.] Renvoie toujours \texttt{True}
        \item[D.] Lève une erreur si les nombres ne sont pas exactement égaux
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile]{Question 15 \textemdash{} Calcul financier}
    Pour un calcul financier (additionner des centimes),
quel choix est le plus prudent en Python ?\medskip
    \begin{itemize}
        \item[A.] Utiliser des \texttt{float}
        \item[B.] Utiliser des nombres complexes
        \item[\alert<2>{C.}] \alert<2>{Utiliser le module \texttt{decimal} ou des entiers représentant des centimes}
        \item[D.] Utiliser des chaînes de caractères
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} Conversion entier vers flottant}
    En Python, l'instruction \texttt{float(7)} renvoie :\medskip
    \begin{itemize}
        \item[A.] \texttt{7} (entier inchangé)
        \item[\alert<2>{B.}] \alert<2>{\texttt{7.0} (flottant)}
        \item[C.] Une erreur
        \item[D.] \texttt{'7'} (chaîne de caractères)
    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile]{Question 17 \textemdash{} Perte de signification}
    Pourquoi \texttt{(1e16 + 1) - 1e16} donne-t-il $0$ en Python
au lieu de $1$ ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Parce que $1$ est négligeable face à $10^{16}$, la mantisse ne peut pas représenter cette différence avec sa précision limitée}
        \item[B.] Parce que Python ne sait pas additionner
        \item[C.] Parce que les nombres trop grands sont arrondis à zéro
        \item[D.] C'est un bug de Python
    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile]{Question 18 \textemdash{} Forme normalisée}
    En IEEE $754$, un flottant \textbf{normalisé} s'écrit dans la
forme :\medskip
    \begin{itemize}
        \item[A.] $0{,}m \times 2^e$ avec $m$ quelconque
        \item[\alert<2>{B.}] \alert<2>{$1{,}m \times 2^e$ avec un bit implicite à $1$ devant la mantisse}
        \item[C.] $m \times 10^e$ avec $m$ et $e$ entiers
        \item[D.] $m + e$ (somme)
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile]{Question 19 \textemdash{} Non-associativité de l'addition flottante}
    En arithmétique flottante, l'addition est-elle toujours
\textbf{associative} (c'est-à-dire $(a + b) + c = a + (b + c)$) ?\medskip
    \begin{itemize}
        \item[A.] Cela dépend du système d'exploitation
        \item[B.] Cela dépend du langage de programmation
        \item[\alert<2>{C.}] \alert<2>{Non, l'ordre des additions peut changer le résultat à cause des arrondis}
        \item[D.] Oui, comme pour les entiers
    \end{itemize}
\end{frame}

% Q20 - Réponse en D
\begin{frame}[fragile]{Question 20 \textemdash{} Décimal vs binaire}
    Pourquoi $0{,}5$ a une représentation binaire \textbf{exacte},
mais pas $0{,}1$ ?\medskip
    \begin{itemize}
        \item[A.] Parce que $0{,}5$ est plus grand que $0{,}1$
        \item[B.] Parce que $0{,}5$ est utilisé plus souvent
        \item[C.] Parce que $0{,}5$ a un seul chiffre, $0{,}1$ aussi
        \item[\alert<2>{D.}] \alert<2>{Parce que $0{,}5 = 1/2 = 2^{-1}$ est une puissance de $2$, alors que $0{,}1 = 1/10$ ne l'est pas et donne un développement périodique en binaire}
    \end{itemize}
\end{frame}

% Q21 - Réponse en A
\begin{frame}[fragile]{Question 21 \textemdash{} Exposant biaisé}
    Pourquoi l'exposant en IEEE $754$ est-il stocké avec un
\textbf{biais} (par exemple, $+1023$ pour la double précision) ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour simplifier la comparaison entre deux flottants en utilisant la comparaison entière standard}
        \item[B.] Pour respecter une convention historique sans intérêt technique
        \item[C.] Parce que les processeurs ne savent pas gérer les nombres négatifs
        \item[D.] Pour économiser de la mémoire
    \end{itemize}
\end{frame}

% Q22 - Réponse en D
\begin{frame}[fragile]{Question 22 \textemdash{} Nombres dénormalisés}
    Quand utilise-t-on des nombres \textbf{dénormalisés} en
IEEE $754$ ?\medskip
    \begin{itemize}
        \item[A.] Pour les très grands nombres
        \item[B.] Pour les valeurs spéciales comme NaN
        \item[C.] Pour les calculs en simple précision
        \item[\alert<2>{D.}] \alert<2>{Pour les nombres très proches de zéro, plus petits que le plus petit nombre normalisé représentable}
    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile]{Question 23 \textemdash{} Propagation des erreurs}
    Quel calcul est \textbf{numériquement instable} parmi les
suivants ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{$a - b$ quand $a$ et $b$ sont très proches (annulation catastrophique)}
        \item[B.] $a + b$ pour $a$ et $b$ de même signe
        \item[C.] $a \times b$ pour $a$ et $b$ proches de $1$
        \item[D.] $a / b$ quand $b$ est grand
    \end{itemize}
\end{frame}

% Q24 - Réponse en A
\begin{frame}[fragile]{Question 24 \textemdash{} decimal vs float}
    En Python, quelle est la principale différence entre les
modules \texttt{decimal} et le type \texttt{float} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{decimal} calcule en base $10$ avec une précision configurable, donc sans erreur d'arrondi pour les nombres décimaux humains}
        \item[B.] \texttt{decimal} utilise moins de mémoire
        \item[C.] \texttt{decimal} est plus rapide
        \item[D.] \texttt{decimal} ne fonctionne qu'avec des entiers
    \end{itemize}
\end{frame}

% Q25 - Réponse en C
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse sur les flottants}
    Parmi les énoncés suivants, lequel est \textbf{vrai} sur les
nombres flottants en machine ?\medskip
    \begin{itemize}
        \item[A.] La précision des flottants augmente avec la taille du nombre
        \item[B.] Les calculs flottants sont aussi précis que les calculs sur papier
        \item[\alert<2>{C.}] \alert<2>{Le test d'égalité \texttt{==} entre flottants est souvent piégeur, et il vaut mieux comparer avec une tolérance}
        \item[D.] Les flottants peuvent représenter exactement tous les nombres rationnels
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile]{Question 26 \textemdash{} Conversion décimal vers binaire avec virgule}
    Quelle est l'écriture binaire de $6{,}625$ ?\medskip
    \begin{itemize}
        \item[A.] $1010{,}11$
        \item[B.] $110{,}625$
        \item[C.] $110{,}11$
        \item[\alert<2>{D.}] \alert<2>{$110{,}101$}
    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile]{Question 27 \textemdash{} Décimal sans écriture binaire finie}
    Parmi les réels suivants (écrits en base $10$), lequel n'a
\textbf{pas} une écriture finie en base $2$ ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{$0{,}1$}
        \item[B.] $0{,}75$
        \item[C.] $0{,}25$
        \item[D.] $0{,}5$
    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile]{Question 28 \textemdash{} Exposant biaisé en simple précision}
    Le réel $5{,}5$ s'écrit en notation scientifique binaire
$5{,}5 = 1{,}011_2 \times 2^{2}$. Quel est son exposant
\textbf{biaisé} sur huit bits, tel qu'il sera stocké en simple
précision (norme IEEE $754$) ?\medskip
    \begin{itemize}
        \item[A.] $2$
        \item[B.] $125$
        \item[C.] $130$
        \item[\alert<2>{D.}] \alert<2>{$129$}
    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Décoder un flottant simple précision}
    On considère le mot $32$ bits suivant, stocké en simple
précision (norme IEEE $754$) :

\begin{lstlisting}
0 | 10000001 | 01000000000000000000000
\end{lstlisting}

(signe sur $1$ bit, exposant sur $8$ bits, mantisse sur
$23$ bits). Quelle est la valeur décimale représentée ?\medskip
    \begin{itemize}
        \item[A.] $2{,}5$
        \item[B.] $5$
        \item[C.] $10$
        \item[D.] $-5$
    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Décoder un flottant simple précision}
    On considère le mot $32$ bits suivant, stocké en simple
précision (norme IEEE $754$) :

\begin{lstlisting}
0 | 10000001 | 01000000000000000000000
\end{lstlisting}

(signe sur $1$ bit, exposant sur $8$ bits, mantisse sur
$23$ bits). Quelle est la valeur décimale représentée ?\medskip
    \begin{itemize}
        \item[A.] $2{,}5$
        \item[\alert{B.}] \alert{$5$}
        \item[C.] $10$
        \item[D.] $-5$
    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
