\documentclass[11pt]{amsart}

\usepackage[frenchb,english]{babel}
%\untypedspaces			% Pour mettre automatiquement les espaces
				% insécables devant les ',' ';' etc
\usepackage[latin1]{inputenc}	% Pour taper les accents en iso-latin1
                                % dans le source: é au lieu de \'e
\usepackage[T1]{fontenc}	% Pour la césure des mots accentués
				% Et pour utiliser << et >>
\usepackage{ae,aecompl}		% Use (almost) Type 1 fonts
\usepackage{verbatim}
\usepackage[top=2.5cm,bottom=2.5cm,left=3.5cm,right=3.5cm]{geometry}

%BEGIN LATEX
\catcode`\«=\active		% Pour que l'espacement autour des
\catcode`\»=\active             % « et » soit correct
\def«{\og\ignorespaces}
\def»{{\fg}}
%END LATEX

\newcommand{\command}[1]{{\selectlanguage{english}\texttt{#1}}}

\usepackage{graphicx}
\usepackage{hyperref}

\newcommand{\R}{\mathbb{R}}
\newtheorem{exercice}{Exercice}

\usepackage{ifthen}
\usepackage{color}
% Set this to true if you want the correction to be included
\newboolean{correction}
%\setboolean{correction}{true}

\newtheorem{correctionInternal}{Correction}
\newenvironment{code}{\endgraf\noindent\endgraf\verbatim}{\endverbatim}

\ifcorrection
\newenvironment{correction}{\endgraf\color{red}\verbatim}{\endverbatim}
\else
\newenvironment{correction}{\comment}{\endcomment}
\fi

\begin{document}

%Amphi:
%Démonstration:

\newpage
\section{TP: Prise en main (2H)}

L'objectif de ce TP est de reprendre des exercices précédemment faits
en TD, afin de découvrir ce qu'un système de calcul formel est
capable, ou pas, de faire.

\begin{exercice}[Arithmétique]\ 
  \begin{enumerate}
  \item Calculer $1+1$, $2*2$, $2^{30}$, $10!$, $5/9$.
    Que constate-t'on?
  \item Calculer $\sqrt 2$, puis $(\sqrt 2)^2$ (indication: consulter
    l'aide avec ?sqrt).  En calculer des approximations numériques
    (cf. ?float). Faire varier la précision en jouant avec
    \command{DIGITS := 200}. Puis réinitialiser à 10 chiffres de précision.
  \item Calculer $\sin(3.14)$, $\sin(\pi)$, $\sin(\pi/3)$ (cf. ?sin,
    ?PI). Que constate-t'on?
  \end{enumerate}
\end{exercice}

\begin{exercice}[Polynômes]\ 
  \begin{enumerate}
  \item Essayer la commande: \command{(f+g) ( x + y )}. Comparer avec
    \command{(f+g) * (x+y)}. Conclusion?
  \item Développer $(x+3)(x-2)$ (cf. ?\command{expand}), et stocker le
    résultat dans une variable $p$ (cf. ?:=).
    \begin{correction}
      p := expand((x+3)*(x-2));
    \end{correction}
  \item Refactoriser le résultat (cf. ?\command{factor}).
    \begin{correction}
      factor(p);
    \end{correction}
  \item Utiliser solve pour retrouver les racines de $p$.
  \item Factoriser $x^2-2$ et chercher ses racines.
    \begin{correction}
      factor(x^2-2);
      solve(x^2-2);
    \end{correction}
  \item Factoriser $p := x^7-3x^2+x+1$ et chercher ses racines.
    Interpréter.
    \begin{correction}
      p := x^7-3x^2+x+1;
      factor(p);
      solve(p);
    \end{correction}
  \item Évaluer $p$ en $x=0$, $x=2$, $x=\pi$, $x=y^2$ (cf. ?\command{|}).
  \item Tracer le graphe de la fonction $x\mapsto p(x)$ de $\R$ dans
    $\R$ (cf. ?\command{plot::Function2d}). En utilisant ce graphe et
    la fonctionnalité de zoom, donner le nombre de racines de $p$.
  \item Calculer numériquement les racines de $p$ (cf. ?\command{solve},
    ?\command{float}).
  \end{enumerate}
\end{exercice}

\begin{exercice}[Analyse]\ 
  \begin{enumerate}
  \item Calculer $\arccos(1)$, $\arccos(-1)$, $\arccos(\sqrt 2/2)$,
    $\arccos(-x)$.
  \item Calculer la dérivée de $\arccos$, puis en tracer le graphe
    (cf. ?\command{diff}, ?\command{plot::Function2d})
    \begin{correction}
      diff(arccos(x), x);
      plot(plot::Function2d(arccos(x), x=-1..1))
    \end{correction}

  \item Calculer la dérivée par rapport à $x$ des expressions suivantes:
    \begin{enumerate}
    \item $3\sin(x)+x^5 - 1/(1+x^2+3x^5)$
    \begin{correction}
      diff(3*\sin(x)+x^5 - 1/(1+x^2+3*x^5), x);
    \end{correction}
    \item $f(x) + g(x)$
    \item $f(x) g(x)$
    \item $f(x)/g(x)$
    \item $(f\circ g) (x)$ (cf. ?@)
    \end{enumerate}

  \item Calculer symboliquement puis numériquement les intégrales
    suivantes (cf. ?\command{int}):
    \begin{enumerate}
    \item $\int_{x=0}^{\pi/2} \frac{\cos(x)}{1+\sin(x)} dx$.
    \begin{correction}
            int(cos(x)/(1+sin(x)), x=0..PI/2);
      float(int(cos(x)/(1+sin(x)), x=0..PI/2))
    \end{correction}
    \item $\int_{x=0}^{1} \frac{dx}{e^{x^2} + 1}$.
    \end{enumerate}
    Que constate-t'on?

  \item Calculer les primitives des expressions suivantes, puis les
    redériver pour vérifier le résultat:
    \begin{enumerate}
    \item $x^2$.
    \begin{correction}
      int(x^2, x);
    \end{correction}
    \item $\frac{1}{4 e^x + e^{-x} + 4}$.
    \item $\frac{1}{e^{x^2} + 1}$.
    \end{enumerate}
    Que constate-t'on?
  \end{enumerate}
\end{exercice}

\begin{exercice}[Algèbre linéaire]
  Résoudre en fonction de $m$ le système d'équations:
  \begin{equation*}
    \left\{
      \begin{array}{rrrrl}
        -mx &-3y &-z &&= m\\
        &(m+1)y &+ (m+1)z &&=0\\
        &    3y &+ (m+1)z &&= 0\\
        &    6y &+     2z &+ mt &= m+1
      \end{array}
    \right.\,.
  \end{equation*}
  \begin{correction}
    solve([-m*x -    3*y -       z = m,
                 (m+1)*y + (m+1)*z = 0,
                     3*y + (m+1)*z = 0,
                     6*y + 2*z + m*t = m+1], [x, y, z, t])
  \end{correction}
\end{exercice}

% TODO: à rallonger:
% résolution à la mano avec matrices et Gauss-Jordan
% calcul du déterminant de la matrice
% plots en 3D (leur donner quelques surfaces à tracer)

% \newpage
% \section{TP Algèbre linéaire 1 (1H30)}

% Gauss à la semi-mano par multiplication matricielles

% Cf. poly d'exos

\newpage

\section{TP Algèbre linéaire 2 (1H30)}

L'objectif de ce TP est de voir quelques applications de la
\emph{diagonalisation} de matrices, en particulier pour l'étude des
suites récurrentes. Comme d'habitude, c'est à vous de déterminer, au
cas par cas, quels calculs il vaut mieux faire à la machine ou à la
main. Les exercices sont de difficulté croissante.

\begin{exercice}
  La première application concerne la modélisation de la dynamique des
  populations, telle qu'étudiée en écologie. Le cas d'école que nous
  allons considérer n'est pas nouveau, puisqu'il a été proposé en 1202
  par Leonardo Pisano comme problème récréatif dans un de ses
  ouvrages, le Liber Abaci.

  \begin{quotation}
    %«
    Possédant initialement un couple de lapins, combien de couples
    obtient-on en douze mois si chaque couple engendre tous les mois
    un nouveau couple à compter du second mois de son existence ?% »
  \end{quotation}
  
  Nous allons considérer un modèle très simple, dans lequel on notera
  $f_n$ le nombre nombre de paires de lapins en fin de $n$-ième mois,
  dans une population idéale telle que:
  \begin{itemize}
  \item le premier mois, il y a juste une paire de lapereaux,
  \item les lapereaux ne sont pubères qu'à partir du deuxième mois,
  \item chaque mois, toute paire susceptible de procréer engendre
    effectivement une nouvelle paire de lapereaux,
  \item les lapins ne meurent jamais.
  \end{itemize}

  \begin{enumerate}
  \item Donner la relation de récurrence satisfaite par la suite $f_n$.
  \item Donner le surnom de Leonardo Pisano.
  \item Nous souhaitons maintenant calculer $f_n$ pour $n$
    relativement grand. Pour cela, nous allons mettre le problème sous
    forme matricielle en notant pour $n>=2$,
    $F_n:=\left(\begin{smallmatrix}f_n\\f_{n-1}\end{smallmatrix}\right)$.
    \begin{enumerate}
    \item Donner $F_2$, et déterminer une matrice $M$ telle que
      $F_{n+1}=M F_n$ pour $n\geq 2$.
    \item À l'aide d'une boucle \command{for}, calculer $f_{1026}$ et
      $f_{65636}$.
    \item Calculer $F_{1026}=M^{1024} F_2$ et $F_{65638}=M^{65636} F_2$.
      À votre avis, comment s'y prend la machine? 
    \item Pouvez-vous l'égaler en utilisant \emph{uniquement} des
      produits de matrices?
    \item Évaluer le nombre d'opérations arithmétiques (+, * sur les
      coefficients des matrices) nécessaires pour calculer $M^{2^n}$.
    \item Utiliser la commande \command{time} pour comparer le temps de
      calcul de $M^{2^{20}}$ et de $float(M)^{2^{20}}$. Interpréter.
      \begin{correction}
        Le coût de l'arithmétique augmente très rapidement à cause de
        la taille des entiers manipulés.
      \end{correction}
    \item Calculer numériquement $f_{2^{20}}$, $f_{2^{23}}$,
      $f_{2^{24}}$. Interpréter.
      \begin{correction}
        Les nombres manipulés ne peuvent plus être stockés en flottant
        (exposant trop grand).
      \end{correction}
    \end{enumerate}
  \item Nous cherchons maintenant donner une formule exacte pour
    $f_n$.  Pour cela, on va \emph{diagonaliser} la matrice $M$.
    \begin{enumerate}
    \item Vérifier que $M^2-M-I_2=0$. Comparer avec le résultat de
      \command{linalg::minimalPolynomial(M,z)}.
    \item Soit $v$ un vecteur non nul et $\lambda$ un réel tels que
      $Mv=\lambda v$. Montrer que $\lambda^2-\lambda-1=0$. En déduire
      les deux valeurs $\lambda_1<\lambda_2$ de $\lambda$ possibles
      (cf.  \command{solve}; expérimenter avec \command{op} pour
      extraire les valeurs du résultat de \command{solve}).  Donner
      leurs valeurs numériques (cf. \command{float}).
      \begin{correction}
        resultat := solve(lambda^2-lambda-1);
        lambda1 := op(resultat, [1,1,2]);
        lambda2 := op(resultat, [2,1,2]);
      \end{correction}
    \item Chercher deux vecteurs non nuls $v_1$ et $v_2$ tels que
      $Mv_1=\lambda_1 v_1$ et $Mv_2=\lambda_2 v_2$. On pourra utiliser
      la commande \command{linalg::nullspace}, en remarquant que
      l'équation $Mv=\lambda v$ est équivalente à $(M-\lambda I_2) v =
      0$.
    \item $\lambda_1$ et $\lambda_2$ sont les \emph{valeurs propres} de
      $M$, et $v_1$ et $v_2$ des \emph{vecteurs propres} correspondants.
      comparer avec le résultat des commandes:
      \command{linalg::eigenvalues(M)} et
      \command{linalg::eigenvectors(M)}.
    \item Soit $B$ la base canonique de $\R^2$, et $B'$ la base $(v_1,
      v_2)$. Donner la matrice de passage $P$ de $B$ à $B'$. Vérifier
      que $P$ est inversible (cf. \command{linalg::det}), puis
      calculer la matrice de passage de $B'$ à $B$.
    \item Calculer au moyen des formules usuelles de changement de
      base la matrice $M'$ dans $B'$ de l'application qui a pour
      matrice $M$ dans la base $B$ (attention: le symbole ' dénote la
      dérivation; utiliser par exemple \texttt{M1} pour nommer $M'$).
      Essayer les commandes \command{expand}, \command{simplify},
      \command{radsimp} pour simplifier le résultat. Interpréter.
    \item Calculer $M'^n$. En déduire $M^n$, puis une formule close pour
      $f_n$.
    \item Utiliser cette formule pour calculer de manière exacte puis
      numériquement quelques valeurs de $f_n$ pour $n$ grand (voir
      \command{?radsimp}).
    \end{enumerate}
  \end{enumerate}
\end{exercice}

\begin{exercice}
  La deuxième application concerne le test automatique de programmes
  informatiques. À quelques simplifications près, le modèle que l'on
  va étudier est utilisé dans le monde industriel (voir
  \url{http://www.lri.fr/~gouraud/recherche.fr.html}), et les
  questions que l'on va rencontrer sont significatives des problèmes
  rencontrés dans le monde du test.
  
  Dans ce modèle, un programme est décrit par un graphe de contrôle.
  Par exemple, le programme suivant:
\begin{code}
decompositionBinaire :=
proc(nombre)
begin
    resultat := [];
    while nombre>0 do
        if nombre mod 2 = 1 then
             resultat := append(resultat,1);
             nombre := nombre-1
        else
             resultat := append(resultat,0)
        end_if;
        nombre := nombre div 2;
    end_while;
    resultat;
end_proc:
\end{code} %$
  sera décrit par le graphe suivant:
  
  \centerline{\includegraphics[height=7cm]{diagrammeFlot}}
  
  Une trace d'exécution est alors une suite de sommets consécutifs
  allant du sommet a au sommet h dans ce diagramme. Par exemple, en
  appliquant ce programme au nombre 5, on obtient la trace
  $(a,b,c,d,e,g,b,c,f,g,b,c,d,e,g,b,h)$. Vous pouvez le vérifier à la
  main, ou en utilisant la commande
  \command{debug(decompositionBinaire(5))}. La longueur d'une trace est
  le nombre de sommets parcourus, soit 17 dans l'exemple précédent.
  
  Le principe de cette méthode de test est d'étudier les traces
  d'exécutions possibles, et de déterminer si elles sont correctes.
  Ici, notre objectif est simplement de compter le nombre $h_k$ de
  traces d'exécutions de longueur $n$, afin de déterminer jusqu'à
  quelle longueur on peut envisager de faire du test exhaustif. En
  particulier, on ne se préoccupera pas ici des valeurs des variables
  du programme. Formellement, le problème est de compter les chemins
  dans un graphe orienté.
  \begin{enumerate}
  \item Lister toutes les traces d'exécutions de longueur inférieure à
    17.
  \item On considère le vecteur
    \begin{equation}
      V_n:=\begin{pmatrix}a_n\\b_n\\c_n\\d_n\\e_n\\f_n\\g_n\\h_n\end{pmatrix}
    \end{equation}
    où $c_n$ compte le nombre de traces d'exécutions du sommet $a$ au
    sommet $c$ de longueur $n$, et similairement pour $a_n,\dots,h_n$
    \begin{enumerate}
    \item Calculer les vecteurs $V_0, V_1, V_2, V_3, V_4$.
\begin{correction}
V_0
\end{correction}
\item Donner une formule de récurrence permettant d'exprimer $g_n$
      en fonction de $a_{n-1},\dots,h_{n-1}$. Exprimer de même les
      autres coordonnées de $V_n$.
    \item Déterminer une matrice $M$ telle que $V_n=MV_{n-1}$.
    \item Calculer le nombre de traces d'exécutions de longueur
      $1024$. Évaluer très grossièrement le temps nécessaire pour
      tester toutes ces traces, sur un ordinateur à 2GHz (on admettra
      que le traitement de chaque sommet prend environ 100 cycles
      d'horloge).
    \end{enumerate}
  \item Pour donner une formule approximative pour $h_n$, on va
    procéder comme dans l'exercice précédent en diagonalisant la
    matrice $M$.
    \begin{enumerate}
    \item Calculer les valeurs propres de $M$ à l'aide de la commande
      \command{linalg::eigenvalues(M)}. Interprétation?  Calculer le
      polynôme minimal de $M$ avec \command{linalg::minimalPolynomial}
    \item Pour simplifier, nous nous contenterons de faire un calcul
      numérique approché, en considérant la matrice de flottants
      \command{float(M)}.
    \item Calculer numériquement les vecteurs propres de $M$.
    \item En déduire une base $B'$ de $R^n$ dans laquelle $M$ est
      diagonale.
    \item Calculer les matrices de changement de base.
    \item Calculer la matrice $M'$ correspondant à $M$ dans cette
      nouvelle base.
    \item Calculer $M'^n$, puis $M^n$, puis $V_n$ puis $h_n$.
    \item Donner une approximation de $h_n$ sous la forme $a^n$.
    \item Jusqu'à quelle valeur de $n$ peut-on raisonnablement faire
      du test exhaustif?
    \end{enumerate}
  \end{enumerate}
\end{exercice}
\newpage

 - Analyse de données
   Plot de nuage de points

   Objectif: constater dans la pratique que les vecteurs propres de la
   matrice d'inertie d'un objet mécanique donnent ses axes principaux
   de rotation. À faire en 2D, puis en 3D, avec une centaine de
   points.

   Application à l'analyse de donnée: représenter un nuage de points
   par un patatoïde. => infos sur les corrélations.

   En principe, on se ramène à des variables réduites pour avoir une
   bonne métrique malgré les unités différentes.

   Exemple (pour lequel les unités sont homogènes; donc on peut
   prendre la métrique euclidienne). Voir TP d'Albane.


\newpage
\section{TP: Géométrie}

Le calcul matriciel est un outil fondamental en géométrie. En
particulier, il donne des notations compactes et puissantes pour le
graphisme 2D et 3D. Dans ce TP, nous allons explorer comment utiliser
les matrices pour implanter des transformations géométriques
naturelles comme les rotations, les symétries ou les projections.

Tout au long de ce TP, nous visualiserons l'effet des transformations
sur le polygone suivant, dont chaque sommet est décrit par un vecteur
de $\R^2$\footnote{Rappel: \command{matrix(1,2)} permet de construire
  le vecteur de $\R^2$ de coordonnées $(1, 2)$; pour comprendre la
  notation \$, essayer \command{f(x) \$ x in [a,b,c,d]}. }:
\begin{code}
points := [matrix(point)
           $ point in [[   0, 1755], [1980,  180], [2070, 1260], [3150,  720],
                       [2340, 3240], [4095, 1125], [3060, 3735], [4860, 1260],
                       [4050,  900], [4590,  900], [7650, 2070], [6300, 1890],
                       [5130, 1395], [3645, 4275], [3735, 4320], [5175, 1485],
                       [5445, 1620], [4950, 3105], [5355, 3285], [6795, 2250],
                       [7695, 2295], [4590, 4860], [4365, 4725], [4860, 3915],
                       [4590, 3780], [3915, 4455], [2790, 3780], [3060, 2880],
                       [2070, 3645], [1710, 2655], [2970, 990],  [1440, 2295],
                       [1845, 450], [1035, 2160]]];
\end{code}%$

Pour visualiser le polygône, utiliser:
\begin{code}
plot(plot::Polygon2d(points))
\end{code}
Si vous avez des talents de graphistes, merci de nous proposer
d'autres polygones esthétiques pour les TP de l'année prochaine!

\begin{exercice}
  Soit $M$ une matrice $M$ de dimension $2\times 2$, et $\phi$
  l'application linéaire de $\R^2$ dans $\R^2$ correspondante. Notre
  objectif est d'interpréter géométriquement la transformation $\phi$
  lorsque cela est possible.
  
  Considérons d'abord la matrice:
\begin{code}
    M := matrix ( [ [ 0,1],
                    [ 1,0] ]):
\end{code}
  Étant donné un vecteur $v$ de $\R^2$, l'image $\phi(v)$ de $v$ par
  $\phi$ peut être obtenue en calculant \command{M*v}. Calculer l'image
  des vecteurs de la base canonique de $\R^2$.

  Pour visualiser l'image du polygone par $\phi$, il suffit donc de faire:
\begin{code}
plot(plot::Polygon2d([ M*v $ v in points]))
\end{code}%$

  \begin{enumerate}
  \item Quelle est la transformation géométrique effectuée par $\phi$?
  \item Même question pour les matrices suivantes:
\begin{code}
    M := matrix ( [ [-1, 0],
                    [ 0,-1]])
\end{code}
\begin{code}
    M := matrix ( [ [ 4, 0],
                    [ 0, 1]])
\end{code}
\begin{code}
    M := matrix ( [ [ 1, 0],
                    [ 0, 1]])
\end{code}
\begin{code}
    M := matrix ( [ [ 1, 0],
                    [ 0,-1]])
\end{code}

  \item L'animation suivante permet de visualiser l'effet de la matrice
\begin{code}
    M := matrix ( [ [ 1, 0],
                    [ 0, 1/2^n]])
\end{code}
    lorsque $n$ tend vers l'infini.
\begin{code}
plot(plot::Polygon2d([ matrix([[1,0],[0,1/2^n]])*v $ v in points], n=1..10))
\end{code}%$
    Quelle est la transformation géométrique pour la matrice limite
\begin{code}
    M := matrix ( [ [ 1, 0],
                    [ 0, 0]])
\end{code}
  
  \item Chercher la matrice de l'application linéaire $\phi$ qui
    effectue une homothétie (zoom) de facteur 2, et plus généralement
    de facteur $lambda$. Vérifier le résultat en visualisant le
    polygone transformé.
  
  \item En vous inspirant de l'exemple précédent, construire une
    animation où le polygone grossit progressivement.
\begin{correction}
plot(plot::Polygon2d([matrix([[lambda,0],
                              [0, lambda]])*v
                      $ v in points],
                     lambda=1..100))
\end{correction}%$
  \item Chercher la matrice de l'application linéaire $\phi$ qui
    effectue une rotation d'un quart de tour dans le sens
    trigonométrique.
  
  \item Chercher la matrice de l'application linéaire $\phi$ qui
    effectue une rotation d'angle $\theta$ dans le sens
    trigonométrique (indication: chercher l'image par $\phi$ des
    vecteurs de la base canonique).
  
  \item Construisez une animation où le polygone tourne autour du
    point de coordonnées $(0,0)$.
\begin{correction}
r := 2*PI/360:
plot(plot::Polygon2d([matrix([[cos(theta*r),-sin(theta*r)],
                              [sin(theta*r), cos(theta*r)]])*v
                      $ v in points],
                     theta=0..359))
\end{correction}%$
  \item Même chose, en faisant grossir progressivement le polygone au
    fur et à mesure qu'il tourne.
\begin{correction}
r := 2*PI/360:
plot(plot::Polygon2d([matrix([[theta*cos(theta*r),-theta*sin(theta*r)],
                              [theta*sin(theta*r),theta*cos(theta*r)]])*v
                      $ v in points],
                     theta=1..5000))
\end{correction}%$
  \item Chercher la matrice de l'application linéaire $\phi$ qui
    envoie le vecteur $b_1:=\begin{smallmatrix}1\\1\end{smallmatrix}$
    sur $2b_1$, et $b_2:=\begin{smallmatrix}1\\-1\end{smallmatrix}$
    sur $\frac12 b_2$ (indication: donner la matrice de $\phi$ dans la
    base $(b_1,b_2)$, puis appliquer les formules de changement de
    base pour obtenir sa matrice $M$ dans la base canonique).
  \item 
  \end{enumerate}
\end{exercice}

\begin{exercice}[Transformations affines]
  Toutes les transformations que nous avons rencontrées pour l'instant
  sont \emph{linéaires}; en particulier le vecteur $0$ reste inchangé.
  \begin{enumerate}
  \item Quelle opération matricielle pourrait-on utiliser pour décaler
    le polygone de $1000$ points vers la gauche?
  \item Plus généralement pour effectuer une translation le long d'un
    vecteur de coordonnées $(x,y)$?
  \item Construire une animation où le polygone part vers la droite de
    plus en plus vite.
  \item Ce que nous venons de faire, c'est de nous placer dans une
    classe plus grande de transformations: les \emph{transformations
      affines}. Celles si sont de la forme $v \mapsto M v + u$, où $M$
    est une matrice $2\times 2$, et $u$ un vecteur de $\R^2$.
  \item Chercher la transformation affine correspondant à la rotation
    d'angle 45 degrés autour du centre du polygone.
  \item Construire une animation où le polygone tourne, grossit et se
    déplace simultanément.
  \end{enumerate}
\end{exercice}

\begin{exercice}[3D]
  Nous voulons maintenant animer le polygone en 3D. Afin de comprendre
  la mécanique interne, nous n'utiliserons pas les possibilités
  natives de $\command{MuPAD}$. Pour simplifier, nous nous contenterons
  ici de perspective cavalière.
  \begin{enumerate}
  \item Pour plonger le polygone dans $\R^3$, nous pouvons utiliser
    l'application linéaire de $\R^2$ dans $\R^3$ qui envoie les deux
    vecteurs de la base canonique de $\R^2$ sur les deux premiers
    vecteurs de $\R^3$. Donner la matrice de cette application
    linéaire.
  \item Réciproquement, pour visualiser un objet en 3D sur l'écran
    (qui n'a que deux dimensions), il faut faire une projection de
    $\R^3$ dans $\R^2$. Nous supposerons que l'observateur regarde
    depuis le haut, de sorte que la projection se fera sur le plan des
    $x$ et $y$.  Donner la matrice de cette application linéaire.
  \item Calculer le produit des deux matrices correspondant au
    plongement de $\R^2$ dans $\R^3$ suivi de la projection de $\R^3$
    dans $\R^2$.  Interprétation?
  \item Afficher le polygone après plongement puis projection.
  \item Donner la matrice de la rotation de $\R^3$ d'angle $\theta$
    autour de l'axe des $x$. Indication: faire un dessin, et chercher
    l'image des vecteurs de la base canonique. Afficher le polygone
    après plongement, rotation de 45 degrés puis projection. Animer le
    résultat pour $\theta$ variant de 0 à 359 degrés.
  \end{enumerate}
\end{exercice}

\begin{exercice}[Perspective cavalière]
  Probablement trop ambitieux.
\end{exercice}

\newpage
\section{TP: Polynômes 1 (1H30)}

L'objectif de ce TP est d'explorer plusieurs façons d'approximer une
fonction $f$ de $\R$ dans $\R$ par une fonction plus simple.

\begin{exercice}[Approximation par une fonction affine]
  Soit $f := x \mapsto \sin(x)$. Tracer son graphe avec
  \begin{code}
    f := sin:
    plot(plot::Function2d(f))
  \end{code}
  Notre objectif est de construire des fonctions simples qui
  approximent $f$ aux alentours d'un point $x_0$.
  
  \begin{enumerate}
  \item Chercher une constante $a_0$ telle que la fonction constante
    $g := a_0$ approxime au mieux $f$ aux environs de $0$. Tracer son
    graphe par dessus celui de $f$ avec
    \begin{code}
      plot(plot::Function2d(g(x)), plot::Function2d(g(x)))
    \end{code}
    Zoomer le graphique.
  \item Chercher une fonction affine $g := a_0 + a_1 x$ qui approxime
    au mieux $f$ aux environs de $x_0:=0$. La comparer graphiquement
    avec $f$.
  \item Chercher une fonction affine $g := a_0 + a_1 (x-x_0)$ qui
    approxime au mieux $f$ aux environs de $x_0 := \pi/4$ ($\pi$ se
    note \command{PI}).
  \item
    \begin{code}
      xmin := -2*PI:
      xmax := 2*PI:
      plot(plot::Function2d(sin(x), x=xmin..xmax),
           plot::Function2d(f(x0) + f'(x0)*(x-x0), x=xmin..xmax, x0=xmin..xmax),
           ViewingBoxYRange=-2..2)
   \end{code}
 \end{enumerate}
\end{exercice}

\begin{exercice}[Interpolation de Lagrange]
  
\end{exercice}


 - Approximation d'une fonction par un polynôme: interpolation / DL / Padé?
   Objectif: leur faire passer la notion de DL

\newpage
\section{TP: Polynômes 2 (1H30)}


\begin{exercice}
  Un vieux pirate est sur son lit de mort. Dans sa jeunesse il a
  enfoui un Fabuleux Trésor dans la lagune interminable de l'Ile de la
  Tortue, quelque part à l'est du Grand Cocotier. Il a réuni ses dix
  lieutenants préférés pour leur transmettre l'information secrète
  indispensable: la distance entre le Grand Cocotier et le Trésor.
  Connaissant bien ses lieutenants, et dans un étonnant dernier
  sursaut de justice, il ne voudrait pas qu'une conjuration de
  quelques uns d'entre eux assassines les autres pour empocher seuls
  le trésor. En tenant cependant compte de la mortalité habituelle du
  milieu, il souhaite donner une information secrète à chacun de ses
  lieutenants pour que sept survivants puissent toujours retrouver
  ensemble le trésor, mais pas moins.  Comment peut-il s'y prendre?

  \begin{enumerate}
  \item « The art of doing mathematics consists in finding that
    special case which contains all the germs of generality » -- David
    Hilbert
    
    Autrement dit, la première chose à faire pour attaquer ce genre de
    problème est de le généraliser pour des paramètres quelconques, et
    de commencer par essayer de comprendre ce qu'il se passe pour de
    petites valeurs des paramètres. Ici, les paramètres naturels sont
    le nombre $n$ de lieutenants, et le nombre $k$ de survivants. Que
    peut on dire pour $n\leq 1$? pour $k\leq 1$?
  \item Étudions maintenant le cas $n=k=2$. Soit $b$ la distance
    secrète. Le pirate choisit au hasard un coefficient $a$ qu'il
    garde secret, et considère la fonction $f(x) = ax+b$. Puis il
    choisit au hasard deux points d'évaluation $x_1:=-3$ et $x_2:=7$
    qu'il annonce publiquement. Enfin, il dit en secret au premier
    pirate que $f(x_1) = 5$ et au deuxième pirate que $f(x_2) = 7$.
    Les deux pirates se mettent ensemble; retrouver la valeur de $b$.
    Est-ce que le premier pirate aurait pu la retrouver tout seul?
  \item Généralisation pour $n=10$ et $k=7$: choisir une valeur
    secrète $b$. Tirer au hasard les coefficients d'un polynôme $f(x)
    = a_6 x^6 +\dots+a_1 x + b$ de degré $6$ et dont le terme constant
    est $b$. Tirer au hasard dix points d'évaluation $x_1,\dots,x_10$
    distincts et non nuls, et calculer $f(x_1),\dots,f(x_10)$. À
    l'aide de la commande \command{interpolate}, et en utilisant
    uniquement $x_1,\dots,x_7$ et $f(x_1),\dots,f(x_7)$ retrouver la
    valeur de $b$. Pour se mettre en condition réelle, donner à chaque
    étudiant du TP un couple $(x_i, f(x_i))$, et laissez les retrouver
    ensemble la valeur secrète.
  \end{enumerate}
\end{exercice}


%Codage Reed Solomon / crypto secret partagé

%\newpage
%\section{TP: Analyse 1 (1H30)}

% - Notion de limite: exemples de fonctions avec et sans limites,
%   exemples où la machine se plante, ...

%\newpage
%\section{TP: Analyse 2 (1H30)}

%Calcul numérique d'intégrale (TP préparé par Caroline?)


%A priori trop dur:
% - TD: traitement du signal: détection des périodes dans les marées
% - Phénomènes de résonance.
% - Manipulation de son

\end{document}
