Import TD_maple

TD_maple/Chiffrement/chiffrement.tex

@@ -0,0 +1,61 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Chiffrement et encodage}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+
+Ce TD est inspiré de l'épreuve 2008 d'informatique du concours de l'X en MP option SI.
+
+Le but de ce TD sera de crypter un message en utilisant deux types de codages ``simple'': Codage César et Codage Vigenère.
+\section{Chiffrer un message}
+Avant de crypter le message il faut le rendre manipulable par l'outil informatique. Un message \texttt{M} (une liste de lettres - on oubliera les espaces et les signes de ponctuations) doit donc être tranformé en une liste de nombres \texttt{L} ($a \leftrightarrow 1$, $b \leftrightarrow 2$..).
+
+Exemple sur \texttt{jaimelesmahts}:
+\begin{center}
+\begin{tabular}{c|ccccccccccccc}
+    liste \texttt{M} & j & a & i & m & e & l & e & s & m & a & t & h & s \\
+    \hline
+    liste \texttt{L} & 10 & 1 & 9 & 13 & 5 & 12 & 5 & 19 & 13 & 1 & 20 & 8 & 19      
+\end{tabular}
+\end{center}
+
+\begin{itemize}
+    \item Écrire une procédure \texttt{Chiffre} qui chiffre un message.
+    \item Écrire une procédure \texttt{Dechiffre} qui déchriffre un message.
+\end{itemize}
+
+\section{Codage de César}
+
+Le codage César consiste à décaler l'alphabet d'un nombre donnée \texttt{d}, la clé. Ainsi pour \texttt{d} $=1$, \texttt{jaimelesmaths} devient \texttt{kbjnfmftnbxgt}.
+
+\begin{itemize}
+    \item Écrire une procédure \texttt{CodeCesar} prenant en argument \texttt{M} le message et \texttt{d} la clé et renvoyant \texttt{M'} le message codé.
+    \item Écrire une procédure \texttt{DeCodeCesarCle} prenant en argument \texttt{M'} le message codé et \texttt{d} la clé et renvoyant \texttt{M'} le message.
+\end{itemize}
+
+
+\section{Casser le codage César}
+Pour casser le codage César, il faut découvrir \texttt{d}, la clé. On pourrai essayer tous les décalages possibles et voir lequel donne un texte cohérent mais ce serai pénible. Une autre solution consiste à calculer la fréquence d'apparition de chaque lettre. En effet, l'étude de la langue français indique que sur des textes suffisamment long, la lettre la plus courante est le \texttt{e}. Ainsi si notre message est suffisamment long, la lettre la plus fréquente correspondra à \texttt{e} et on pourra calculer le décalage.
+
+\begin{itemize}
+    \item Écrire une procédure \texttt{Frequence} qui prend en argument le message \texttt{M} et qui renvoie la lettre la plus fréquence.
+    \item Écrire une procédure \texttt{DecodeCesarAuto} qui prend en argument le message \texttt{M'} et qui renvoie le message décrypté \texttt{M}.
+\end{itemize}
+
+\section{Codage de Vigenère}
+Au XVIe siècle, Blaise de Vigenère a modernisé le codage César. Au lieu de décaler toutes les lettres du texte de la même manière, on les décale en fonction d'une clé. Prenons la clé \texttt{nimajneb}. Ainsi on codera la première lettre en utilisant le décalage qui envoie \texttt{a} sur \texttt{n} (c'est à dire de 13), la deuxième lettre du décalage qui envoie \texttt{a} sur \texttt{i} et ainsi de suite. Quand on arrive à la fin de la clé, on recommence par le début.
+
+\begin{itemize}
+    \item Écrire une procédure \texttt{Vigenère} qui prend en argument le message et la clé et qui renvoie le message crypté.
+    \item Écrire une procédure \texttt{DecVigene} qui décode un message crypté en connaissant la clé.
+\end{itemize}
+
+Pour casser le codage de Vigenère, vous pouvez regarder la fin de l'épreuve de l'X.
+
+\end{document}

TD_maple/Chiffrement/chiffrement2.tex

@@ -0,0 +1,49 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Chiffrement et encodage (suite)}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\section{ASCII}
+D'après Wikipedia, l'ASCII est une norme de codage de caractères en informatique ancienne. Elle fait une correspondance en des caractères et des nombres (entre 0 et 255) pour rendre leur manipulation plus aisé. Maple connait cette norme et pour contient deux commandes pour la manupuler: \texttt{Char} et \texttt{Ord} (pour les utiliser, il faut charger la bibliothèque \texttt{StringTools}). 
+\begin{itemize}
+    \item \texttt{Char} permet à partir d'un nombre (compris entre 0 et 255) de donner le caractère correspondant.
+    \item \texttt{Ord} fait l'opération inverse, c'est-à-dire transforme un caractère en son identifiant. 
+\end{itemize}
+Vous pouvez utiliser ces commandes pour vous faciliter la tache lors de vos conversions lors du chiffrement et du déchiffrement.
+
+\section{Codage affine}
+On propose ici une variante, un peu plus complexe, du codage de César. Le codage de César consistait à simplement décaler l'alphabet d'un certain nombre de rang. Cette opération peut se réécrire de la façon suivante $x+b$ où $x$ est le rang et $b$ est le décalage.
+
+Le codage affine consiste à faire l'opération suivante $ax+b$. Ainsi la clé n'est plus un unique nombre $b$ mais un couple $(a,b)$.
+\begin{itemize}
+    \item Écrire une procédure \texttt{CodeAffine} qui prend en argument un message \texttt{M} et la clé \texttt{C} et qui renvoie le message crypté.
+    \item (dure) Écrire une procédure \texttt{DecodeAffine} qui fait l'opération inverse.
+    \item (dure) Chercher une méthode pour casser ce codage.
+\end{itemize}
+
+
+\section{Annexes}
+\subsection{Transformer un texte en liste de caractères.}
+Pour manipuler directement de vrais texte ces deux procédures peuvent être utiles.
+\begin{itemize}
+    \item Écrire une procédure \texttt{textToList} qui prend un texte quelconque \texttt{Text} et qui renvoie ce même texte en forme de liste de caractères \texttt{ListCara}.
+    \item Écrire une procédure \texttt{listToText} qui fait l'opération inverse.
+\end{itemize}
+
+\subsection{Se passer un message entre ordinateur}
+Vous pouvez vous faire passer du texte à travers internet en utilisant \texttt{pastebin.com}. Essayez alors de décoder ou casser les textes encodés par vos camarades.
+
+
+\end{document}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/Chiffrement/notes

@@ -0,0 +1 @@
+http://sagenb.irem.univ-mrs.fr/home/pub/17/

TD_maple/DS1/99027.tex

@@ -0,0 +1,10 @@
+Soit $n$ un entier naturel non nul. On appelle somme des diviseurs propres de $n$ la somme des entiers naturels $k$ \textbf{différents de $n$} divisant $n$. Par exemple la somme des diviseurs propres de $12$ est $16$ ($1+2+3+4+6$).
+
+On dit qu'un entier $n$ est parfait si la somme de ses diviseurs propres est égale à lui-même. Par exemple $6$ est parfait.
+
+On dit  que deux entiers naturels  non nuls $a$ et  $b$ distincts sont des nombres amis (ou aimables ou  amicaux ou amiables) si la somme des diviseurs propres de $a$ est $b$ et que la somme des diviseurs propres de $b$ est $a$. Par exemple $220$ et $284$ sont amis.
+
+\begin{enumerate}
+\item Écrire une fonction calculant et affichant tous les nombres   parfaits compris entre $1$ et $10000$.
+\item  Écrire une fonction  calculant et  affichant toutes  les paires  nombres  amicaux  compris  entre  $1$  et $6000$.  On  essaiera  de n'afficher qu'une fois chaque paire (par exemple on affichera le couple $(220, 284)$ mais pas le couple $(284,220)$).
+\end{enumerate}

TD_maple/DS1/99028.tex

@@ -0,0 +1,9 @@
+Écrire une procédure maple médiane prenant en argument une liste $l$
+et retournant \textbf{une} médiane de la liste. On rappelle qu'une
+médiane d'une liste $l$ est tout nombre $x$ tel qu'au moins la moitié
+des éléments de $l$ soit supérieur ou égal à $x$ et au moins la moitié
+des éléments de la liste soit inférieur ou égal à $x$. Ainsi $10$,
+$14$, $20$, et $10,6$ sont des médianes de la liste
+\texttt{[10, 7, 42, 20]}.
+
+  

TD_maple/DS1/99029.tex

@@ -0,0 +1,13 @@
+Pour tout $a\in\R$, on note $f_{a} :
+\fct{[1,+\infty[}{\R}{x}{x^{4}+7 x^{3}+2 x^{2}+x-\frac{7}{x} - a }$.
+
+Pour tout $a\in\R$,
+on note $n_{a}$ le plus petit entier naturel non nul $n$ vérifiant
+$f_{a}(n)\geq 0$.
+\begin{enumerate}
+\item Écrire une application \texttt{cherche} qui, prend en argument un réel
+$a$ et retourne le plus petit entier naturel $n$ vérifiant
+$f_{a}(n)\geq 0$.
+\item Que vaut \texttt{cherche(42)}~?
+\item Que vaut \texttt{cherche(42\^42)}~?
+\end{enumerate}

TD_maple/DS1/99030.tex

@@ -0,0 +1,13 @@
+On définit la suite $u$ comme suit par $u_{0}=1$ et pour tout
+$n\in\N$, $u_{n+1}=\sin u_{n}$. On peut montrer que cette suite $u$ tend
+vers $0$.
+\begin{enumerate}
+\item Écrire une procédure \texttt{valeuru} prenant en argument un
+  entier naturel $n$ et retournant la valeur de $u_{n}$ (on calculera
+  avec des valeurs numériques approchées, on rappelle que
+  \texttt{evalf} calcule des valeurs approchées).
+\item Écrire une procédure \texttt{cherche\_rang} prenant en
+  argument un réel strictement positif $\epsilon$ et retournant le
+  plus petit entier $n$ vérifiant $u_{n}\leq \epsilon$.
+\item Que vaut \texttt{cherche\_rang(0.007)}~?
+\end{enumerate}

TD_maple/DS1/99031.tex

@@ -0,0 +1,23 @@
+On définit la suite $(u_n)_n$, la suite de Syracuse, de la manière suivante (avec $N \in \N$ fixé):
+\begin{eqnarray*}
+    u_0 & = & N //
+    u_{n+1} & = & \franc{u_n}{2} \mbox{ si $u_n$ est pair}//
+    &   & 3u_n + 1 \mbox{ Si $u_n$ est impaire}
+\end{eqnarray*}
+La conjecture affirme que pour tout $N > 0$, il existe un $n$ tel que $u_n = 1$. Nous allons écrire quelques algorithmes pour nous rendre compte du caractère chaotique de cette suite.
+\begin{itemize}
+    \item Écrire une procédure \texttt{syra} qui prend pour argument \texttt{N} et \texttt{n} et qui renvoie la valeur de $u_n$ avec $u_0 = N$.
+    \item Écrire une procédure \texttt{tempsDeVol} qui prend pour argument \texttt{N} et qui renvoie le premier $n$ tel que $u_n = 1$.
+    \item Tracer le résultat de cette fonction pour $N$ variant de 1 à 20. \note{Vérifier que ça ne prenne pas trop de temps!} 
+    \item Écrire une procédure \texttt{tempsDeVolAltitude} qui prend pour argument \texttt{N} et qui renvoie le premier $n$ tel que $u_n < u_0$.
+    \item Écrire une procédure \texttt{tempsVolAltitudeBis} qui prend pour argument \texttt{N} et qui renvoie le nombre de fois que $u_n$ est strictement plus grand que $u_0$ avant d'atteindre pour la première fois 1.
+    \item Écrire une procédire \texttt{AltitudeMax} qui prend pour argument \texttt{N} et qui renvoie la valeur maximale de $(u_n)$.
+
+\end{itemize}
+\note{On peut aussi faire cet exercice avec Syracuse compressée (on divise par 2 le cas impaire)}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/DS1/99032.tex

@@ -0,0 +1,10 @@
+Le but de cet exercice va être de convertir un temps en $ms$ en temps ``habituel'' $(h, m, s, m)$.
+\begin{itemize}
+    \item Écrire une procédure \texttt{FromMS} qui transforme un temps en $ms$ en un temps ``habituel''.
+    \item Écrire la procédure inverse \texttt{ToMS}, qui transforme un temps $(h, m, s, ms)$ en $ms$.
+\end{itemize}
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/DS1/99033.tex

@@ -0,0 +1,19 @@
+On cherche les nombres entiers, $a,b,c \in \N$ qui vérifient la relation de pythagore
+\begin{eqnarray*}
+    a^2 + b^2 &=& c^2 
+\end{eqnarray*}
+\begin{itemize}
+    \item Écrire une procédure \texttt{pythagore} qui prend comme argument \texttt{c} et qui renvoie $0$ si $c^2$ n'est pas somme de 2 carrés ou la liste des couples $(a,b)$ (avec $a<b$) tel que $a^2 + b^2 = c^2$.
+    \item Écire une procédure \texttt{fermat} qui fait la même chose en remplaçant 2 par 3.
+    \item Tester \texttt{pythagore} et \texttt{fermat} pour tout les $c$ variant de 1 à 50. Faire une conjecture sur les entiers tel que
+        \begin{eqnarray*}
+            a^3 + b^3 = c^3
+        \end{eqnarray*}
+\end{itemize}
+
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/DS1/99034.tex

@@ -0,0 +1,32 @@
+Si les biologistes savaient faire des mesures, on le saurait. En attendant, leurs mesures présentent une grande imprecision. Pour dégager des profils exploitables, ils peuvent tricher en lissant les courbes.
+Aidons les!
+
+Voici les relevés de la fréquence cardiaque d'un rat en attente d'un choc éléctrique.
+\begin{verbatim}
+    L = [ 101.04 104.4 123 128.58 153.5 147.94 168.92 176.7 181.25
+      182.84 166 166.95 165.87 171.69 145.32 136.96 130.18 133.3
+      99.3 81.98]
+\end{verbatim}
+\begin{itemize}
+    \item Tracez la courbe
+\end{itemize}
+
+Une technique de lissage consiste à considerer que chaque point est la moyenne de trois points consécutifs : lui-même, le précédent et le suivant.
+
+\begin{itemize}
+    \item Proposez une solution pour les points extremaux.
+    \item Écrire une procédure \texttt{lissage} qui prend en argument une liste et qui renvoie la courbe correspondante lissée.
+    \item L'appliquer au relevé de la fréquence cardiaque du rat.
+    \item On se propose d'augmenter le fenêtre de lissage. Pour cela la moyenne sera faite des deux précedents, de lui-même et des deux suivants. Écrire la procédure \texttt{lissageBis} correspondante.
+\end{itemize}
+
+
+
+
+
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/DS1/DSmaple.tex

@@ -0,0 +1,27 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+
+% Title Page
+\title{DS d'informatique}
+\author{}
+\date{}
+
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\begin{Exo}(Lissage de courbe)\\
+\input{99034}
+\end{Exo}
+
+
+
+\end{document}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/DS1/correction.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+#-*- coding:utf8-*-
+
+# ------------------------------
+# Imports
+# ------------------------------ 
+from math import sqrt, sin
+
+# ------------------------------
+# Fonctions
+# ------------------------------ 
+
+# --------------------------
+# Exo 1
+#
+
+def divProp(n):
+    """ divProp
+    
+    Renvoie les diviseurs propres de n
+    
+    """
+    divP = []
+    for i in range(int(n/2)):
+        if not (n%(i+1)):
+            divP += [(i+1)]
+    return divP
+
+def divPropBis(n):
+    """ divProp
+    
+    Renvoie les diviseurs propres de n
+    a
+    
+    """
+    divP = []
+    for i in range(int(sqrt(n))):
+        if not (n%(i+1)):
+            divP += [(i+1), (int(n/(i+1)))]
+    return divP
+
+def SumDivProp(n):
+    """ SumDivProp
+    
+    Retourne la somme des diviseurs propres
+    
+    """
+    return sum(divProp(n))
+
+def nbrParfait(n):
+    """ nbrParfait
+    
+    Retourne les nombres parfaits inferieur à n
+    
+    """
+    nbrParf = []
+    for i in range(n):
+        if SumDivProp((i+1)) == (i+1):
+            nbrParf += [(i+1)]
+    return nbrParf
+
+def nbrAmis(n):
+    """ nbrAmis
+    
+    Retourne les nombres amis inferieurs à n
+    
+    """
+    L = set() 
+    for i in range(n):
+        I = SumDivProp((i+1))
+        if ((i+1) == SumDivProp(I)):
+            L = L.union({(max((i+1),I), min((i+1),I))}) 
+    return L
+
+
+# --------------------------
+# Exo 2
+#
+
+def calf(x, a):
+    """ calf
+    
+    Return value of f at x
+    
+    """
+    val = x**4 + 7*x**3 + 2*x**2 + x - 7/x - a
+    return val
+
+def cherche0(a, pas, start = 1):
+    """ cherche0
+    
+    Cherche le n tel que la fonction x^4 + 7x^3 + 2x^2 + x - 7 - 1/x - a passe de negatif à positif
+    
+    @param a: le parametre
+    @param pas: la puissance de 10 pour les pas
+    @param start: à partir d'ou commencer la recherche
+
+    """
+    # print("New")
+    # print("Pas: ", pas)
+
+    step = calf(start, a)
+    i = 0
+    while step < 0:
+        i += 1
+        step = calf((start + 10**pas * i), a)
+    # print(step)
+    # print(calf((start + 10**pas * (i-1)), a))
+    # print('i: ', str(i))
+
+
+    if pas == 0:
+        return i
+    else:
+        return 10**pas * (i-1) + cherche0(a, (pas-1), start + 10**pas * (i-1))
+
+
+# --------------------------
+# Exo 3
+#
+
+def evalu(n):
+    """ evalu
+    
+    Fonction récurcive qui calcul u_n définie par u_n = sin (u_n{n-1}) et u_0 = 1
+    
+    """
+    if n == 0:
+        return 1
+    else:
+        return sin(evalu(n-1))
+
+def cherche_rang(e):
+    """ cherche_rang
+    
+    Determine le n minimal pour que u_n < e
+    
+    """
+    u = 1
+    i = 0
+    while (u > e):  
+        u = sin(u)
+        i += 1
+
+    return i
+    
+
+
+# ------------------------------
+# Bloc principal
+# ------------------------------
+
+if __name__ == '__main__':
+    #n = 21236789
+    #print(divProp(100))
+    #print(divPropBis(n))
+    #print(SumDivProp(30))
+    #print(nbrParfait(10000))
+    #print(nbrAmis(6000))
+
+    #print(cherche0(42, 1, 1))
+    print(cherche0(42**42, 17, 1))
+    a = 42**42
+    # n = cherche0(a, 17, 1)
+    # print(n)
+    # print(calf(n-1,a))
+    # print(calf(n,a))
+    # for i in range(10):
+    #     print(n+i)
+    #     print(calf(n+i,a))
+
+    n = 110692335104026962
+    print(n)
+    print(calf(n-5,a))
+    print(calf(n-1,a))
+    print(calf(n,a))
+    print(calf(n+1,a))
+
+    #print(evalu(1))
+    #print(cherche_rang(0.007))
+
+# ------------------------------
+# Fin du programme
+# ------------------------------
+
+# -----------------------------
+# Reglages pour 'vim'
+# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
+# cursor: 16 del 
+

TD_maple/DS1/notes.csv

@@ -0,0 +1,48 @@
+Nom,                    Exo1,   Exo2,   Exo3,   Exo4,   Exo5
+Pan Shnegxiong,         5   ,   0   ,   0   ,   0   ,   0   
+Harvatopoulos Andreas,  1   ,   0   ,   0   ,   1   ,   0
+Azzarone Alexandre,     2   ,   0   ,   0   ,   0   ,   0
+Cattelle Thomas,        7   ,   0   ,   7   ,   3   ,   0
+Douma Nejmenddine,      8   ,   8   ,   7   ,   8   ,   0
+Bennaiem Mohammed,      7   ,   0   ,   0   ,   8   ,   0
+Mandica Nicalas,        3   ,   0   ,   0   ,   8   ,   0
+Rageot Simon,           2   ,   0   ,   5   ,   10  ,   0
+Quercia Bruno,          10  ,   7   ,   7   ,   8   ,   0
+Vaudaine Remi,          5   ,   0   ,   0   ,   1   ,   0
+Mathias Hugo,           5   ,   0   ,   7   ,   7   ,   0
+Verrier Sacha,          3   ,   0   ,   0   ,   7   ,   0
+Baraillon Joris,        1   ,   0   ,   7   ,   7   ,   0
+Joseph Elio,            8   ,   10  ,   7   ,   6   ,   0
+Besiers Faustin,        3   ,   0   ,   0   ,   0   ,   0
+Perrin Paul,            0   ,   0   ,   0   ,   7   ,   0
+Scozzari Adrien,        8   ,   10  ,   7   ,   10  ,   0
+Bebon Ludovic,          5   ,   10  ,   7   ,   9   ,   0
+Boyadjian Antoine,      8   ,   7   ,   5   ,   0   ,   0
+Gross Aurore,           4   ,   0   ,   6   ,   1   ,   0
+Lecomte Alice,          8   ,   0   ,   0   ,   0   ,   0
+Rouland Honore,         6   ,   0   ,   6   ,   9   ,   0
+Blondot Victor,         0   ,   0   ,   7   ,   7   ,   0
+Belcadi Amine,          2   ,   0   ,   0   ,   1   ,   0
+Cocchi Elian,           7   ,   4   ,   7   ,   10  ,   0
+Michon Lucie,           2   ,   10  ,   7   ,   7   ,   0
+Vaile Nicalas,          2   ,   0   ,   4   ,   7   ,   0
+Marin Julie,            4   ,   0   ,   6   ,   0   ,   0
+Berat Juline,           2   ,   0   ,   0   ,   0   ,   0
+Cremy Julien,           4   ,   0   ,   0   ,   6   ,   0
+Commune Laurent,        6   ,   0   ,   7   ,   2   ,   0
+Mottal Gabin,           1   ,   5   ,   5   ,   2   ,   0
+Matray Pierre,          1   ,   0   ,   7   ,   1   ,   0
+Walter Clement,         4   ,   0   ,   7   ,   7   ,   0
+Berne Aurore,           1   ,   0   ,   0   ,   2   ,   0
+Sebbagh Simon,          3   ,   5   ,   7   ,   8   ,   0
+Leonet Cindy,           6   ,   0   ,   0   ,   2   ,   0
+Vernot Rochey Charlie,  0   ,   0   ,   7   ,   5   ,   0
+Meyet Tiphaine,         0   ,   0   ,   6   ,   5   ,   0
+Groleaz Lucas,          1   ,   0   ,   7   ,   10  ,   0
+Neveu Remy,             0   ,   0   ,   5   ,   2   ,   0
+Roiron Coline,          2   ,   0   ,   7   ,   4   ,   0
+Bayon Sebastien,        6   ,   10  ,   10  ,   2   ,   2
+Cindy Planys,           ?   ,   ?   ,   ?   ,   ?   ,   ?
+
+
+

TD_maple/DS1/test.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+#-*- coding:utf8-*-
+
+# ------------------------------
+# Imports
+# ------------------------------ 
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ------------------------------
+# Classes
+# ------------------------------ 
+
+# ------------------------------
+# Fonctions
+# ------------------------------ 
+
+def lissage(L):
+    """ lissage
+    """
+    D = [0 for l in L]
+    D[0] = L[0]
+    for i in range(len(L) - 2):
+        D[i+1] = sum(L[i:i+3])/3
+    D[-1] = L[-1]
+    return D
+        
+
+# ------------------------------
+# Bloc principal
+# ------------------------------
+
+if __name__ == '__main__':
+
+    X = np.linspace(0,1, 20)
+    A = -320 * X * (X-1) + 25*np.random.random(20)
+    L = [float(int(A[i]*100))/100 for i in range(len(A))] + np.array([80]*20)
+
+    print L
+
+    # L = [  83.68,  103.54,  119.28,  124.75,  136.37,  142.3, 158.33,  157.94,  162.86,  168.11,  162.01,  167.05,  164,149.95,  149.03,  142.29,  124.51,  111.61, 98.7,  87.23]
+    D = lissage(L)
+    plt.plot(X,L)
+    plt.plot(X,D)
+    plt.show()
+
+
+
+# ------------------------------
+# Fin du programme
+# ------------------------------
+
+# -----------------------------
+# Reglages pour 'vim'
+# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
+# cursor: 16 del 
+

TD_maple/Feu_foret/feu_foret.tex

@@ -0,0 +1,73 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Automates cellulaires: feu de forêt}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\section{Description de l'automate}
+Nous allons programmer un automate cellulaire qui simule la propagation d'un feu de forêt. La forêt sera représentée par une grille avec dans les cases rien, des arbres, du feu ou des cendres. La propagation du feu de forêt se fera de la manière suivante:
+\begin{itemize}
+		\item Une case avec rien reste comme elle est.
+		\item Une case avec un arbre devient en feu si une case adjacente est en feu.
+		\item Une case en feu devient une case cendre.
+		\item Une case cendre devient une case vide.
+\end{itemize}
+On construira la forêt initiale aléatoirement. Avec, pour chaque case, une probabilité $p$ d'être un arbre et une probabilité $1-p$ d'être vide.
+
+Le but de ce TD est de programmer cet automate et d'avoir une animation affichant la propagation du feu de forêt.
+
+\section{Programmation de l'automate}
+Les étapes proposées dans la suite sont données à titre indicatif. Vous n'êtes pas obligé de les faire dans l'ordre ni même de les suivre si vous avez de meilleurs idées. 
+
+\subsection{Moteur du jeu}
+\begin{itemize}
+		\item \textbf{Stockage des données:} Comment va-t-on stocker l'état de la forêt?
+		\item \textbf{Trame principale:} Écrire le programme principal \texttt{feuForet} prenant en argument \texttt{p} la probabilité d'être une case arbre initialement et affichant l'animation du feu de forêt. Ce programme devra juste décrire la trame et fera appel à d'autres fonctions que nous écrirons ensuite.
+\end{itemize}
+
+\subsection{Forêt initiale}
+\begin{itemize}
+		\item \textbf{Forêt initiale:}  Écrire un programme \texttt{foretIni} prenant en argument \texttt{p} et créant la forêt initiale.
+		\item \textbf{Mettre le feu:} Écrire un programme \texttt{FeuIni} mettant le feu à une case.
+\end{itemize}
+
+\subsection{Propagation du feu}
+\begin{itemize}
+		\item Écrire un programme \texttt{propaFeu} prenant en argument \texttt{feu} l'état de la forêt et renvoyant l'état de la forêt à l'étape suivante.
+\end{itemize}
+
+\subsection{Affichage et animation}
+\begin{itemize}
+		\item \textbf{Afficher une cellule:} Écrire une procédure \texttt{dessCel} prenant en argument la position de la cellule \texttt{l}, \texttt{c}, la taille de la forêt \texttt{n} (on pourra supposer que la forêt est carré) et la couleur de la cellule et renvoyant cette cellule.
+
+				On rappel que pour dessiner un polygone, on utilise \texttt{polygon} (il faut avoir chargé les bibliothèques \texttt{plots}, \texttt{geometry} et \texttt{plottools}).
+
+		\item \textbf{Dessiner un forêt:} Écrire une procédure \texttt{dessForet} prenant en argument l'état de la forêt et renvoyant l'image représentant la forêt.
+
+				On rappel que pour mettre plusieurs éléments sur une même image, on les stocks dans un ensemble puis on utilise \texttt{display} (on pourra utiliser les options suivantes pour avoir un meilleur rendu \texttt{scaling=constrained,axes=none}).
+
+		\item \textbf{Animer le feu:} Écrire une procédure \texttt{anime} prenant en argument la liste des états de la forêts et renvoyant l'animation du feu de forêt.
+\end{itemize}
+
+\section{Modifier l'automate}
+Voici quelques idées pour modifier votre automate.
+\begin{itemize}
+		\item Rendre la forêt ``périodique''. C'est à dire que les cases de droites sont adjacentes à celles de gauches et que celle d'en haut sont adjacentes à celle du bas. 
+		\item Faire en sorte que le feu puisse se propager non seulement sur les cases adjacentes mais aussi sur celles aux angles.
+		\item Modifier les règles de l'automate pour simuler le jeu de la vie.
+				
+				Le jeu de la vie est un automate cellulaire avec deux états: mort ou vivant. Voici les règles de son évolution:
+				\begin{itemize}
+
+						\item  Une cellule morte possédant exactement trois voisines vivantes devient vivante (elle naît).
+						\item Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.
+				\end{itemize}
+\end{itemize}
+
+
+\end{document}

TD_maple/Feu_foret/feu_foret2.tex

@@ -0,0 +1,36 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+\usepackage{url}
+
+\title{Automates cellulaires: feu de forêt (suite)}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\section{Triche graphique}
+Une fois que vous avez réussi à faire tourner votre algorithme et qu'il marche, vous pouvez aller récupérer trois fonctions graphiques à l'adresse suivante \url{http://paste2.org/KEnOC4Jh}. Elles vous permettront d'animer la propagation de votre feu de forêt. 
+
+Il reste tout de même à adapter ces trois fonctions à votre code.
+\begin{itemize}
+		\item \texttt{dessin}: Il faut compléter cette fonction pour l'adapter à vos correspondances chiffre-arbre
+		\item \texttt{afficher}: Adaptez la ligne définissant \texttt{n} au cas où vous utilisez un Array ou une forêt non carré.
+\end{itemize}
+
+\section{Aller plus loin}
+Voici quelques propositions pour faire évoluer votre code.
+
+\paragraph{Modifier votre code}
+\begin{itemize}
+		\item Mettre une condition pour arrêter ``correctement'' la simulation.
+		\item Faire en sorte que le feu puisse se propager de façon périodique.
+		\item Modifier le mode le propagation du feu.
+		\item Faire preuve d'imagination et faire quelque chose de jolie.
+\end{itemize}
+
+\paragraph{Changer de moteur de jeu}
+Essayer de modifier votre code pour qu'il simule le \textbf{jeu de la vie} au lieu de propager le feu.
+
+\end{document}

TD_maple/Oscillateur_EDO/oscill.tex

@@ -0,0 +1,86 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+
+\title{Oscillateurs}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+Ce TD utilise des résultats présents dans le poly sur les oscillateurs. Nous ne nous intéresserons pas à la mise en place des équations. Nous porterons notre attention sur l'analyse de ces équations grâce à Maple. Voyez ce TD comme un façon de visualiser les solutions des équations que vous manipulez.
+
+
+Nous aurons besoin des deux bibliothèques suivantes: \texttt{plots} et \texttt{DEtools}. Et nous utiliserons essentiellement les deux commandes suivantes:
+\begin{itemize}
+    \item \texttt{dsolve} résout formellement les équations
+    \item \texttt{DEplot(eqn, vars, ranges, [CIs], linecolor = [colors], scene = [-,-], stepsize = 0.1)} (attention aux majuscules) trace directement les trajectoires (avec \texttt{scene = [t,x]}) ou les portraits de phase (avec \texttt{scene = [x,v]}).
+\end{itemize}
+
+\section{Oscillateur simple}
+Intéressons nous à l'équation représentant une masse reliée à un ressort
+\begin{eqnarray*}
+    x'' + \omega_0^2 x = 0  &\mbox{ où }&   \omega_0 = \sqrt{\frac{k}{m}} \\
+    x(0) = a, x'(0)=0&&
+\end{eqnarray*}
+Jusqu'à la fin de ce TD, nous supposerons que $\omega_0 = 2\pi$.
+
+\begin{itemize}
+    \item Résolvez et tracez les solutions de cette équation avec les conditions initiales $a = $ 1 et 2.5 (dans la suite du TD, on reprendra ces conditions initiales).
+    \item Transformez l'équation du second degré en un système de deux équations du premier degré en posant $v(t) = x'(t)$ la vitesse de la masse. Le système devra avoir la forme suivante avec $a, b, c, d$ des constantes.
+        \begin{eqnarray*}
+            \left\{ \begin{array}{c}
+                x' = ax + bv \\
+                v' = cx + dv
+            \end{array} \right.
+        \end{eqnarray*}
+    \item Tracez le portrait de phase des trajectoires $x(t),v(t)$ avec les mêmes conditions initiales.
+    \item Une conjecture sur la nature de ces trajectoires? Pourquoi tournent elles dans le sens des aiguilles d'une montre? Quelle est la signification des flèches (\texttt{arrow = none} pour les désactiver)?
+\end{itemize}
+
+\section{Oscillateur amorti}
+On ajoute un frottement fluide au système. L'équation devient alors
+\begin{eqnarray*}
+    x'' + 2h x' + \omega_0^2 x = 0  \\
+    x(0) = a, x'(0)=0
+\end{eqnarray*}
+On rappelle que le comportement de ce système dépend du signe de $\Delta = h^2 - \omega_0^2$. Effectuez les questions suivantes pour les 3 cas possibles (en adaptant les valeurs de $h$ par exemple) et adaptez les paramètres pour faire apparaitre les différents comportements.
+
+\begin{itemize}
+    \item Déterminez les solutions exactes.
+    \item Essayez les fonctions \texttt{simplify} et \texttt{factor} sur les solutions.
+    \item Tracez les.
+    \item Tracez le portrait de phase (il faut avoir mis l'équation sous forme de système comme dans la première partie)
+\end{itemize}
+
+
+\section{Régime forcé}
+On ajoute des oscillations forcées au système. L'équation devient
+\begin{eqnarray*}
+    x'' + 2h x' + \omega_0^2 x = f \sin(\omega t)  \\
+    x(0) = a, x'(0)=0
+\end{eqnarray*}
+
+\begin{itemize}
+    \item Mettre en évidence la transition de phase.
+\end{itemize}
+
+\section{Système non linéaire (Van Der Pol)}
+Pour finir intéressons nous à l'équation suivante (que l'on retrouve dans des oscillateurs en électricité)
+\begin{eqnarray*}
+    x'' - \e (1-x^2)x' + \omega_0^2 x = 0
+\end{eqnarray*}
+\begin{itemize}
+    \item Essayez de résoudre cette équation avec Maple.
+\end{itemize}
+
+Distinguons 3 comportements différents suivant les valeurs de $\e$.
+
+\begin{itemize}
+    \item Tracez les portraits de phase pour les valeurs de $\e$ suivante: -0.1, 0.5, 10.
+    \item Que remarquez vous?
+\end{itemize}
+
+\end{document}

TD_maple/Polynomes/poly.tex

@@ -0,0 +1,155 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+\usepackage{multirow}
+\usepackage{tabularx}
+
+\title{Polynômes}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\section{Polynômes}
+\subsection{Les polynômes dans Maple}
+
+\begin{verbatim}
+	> p := x^5 + 4x^3 - 12x + 2; # Définition d'un polynôme
+
+	> type(p, polynom) # Tester si p est bien un polynome
+
+	> q := x^n - 1; type(q, polynom);
+	# Attention les exposants doivent être des nombres entiers
+
+	> q := 3x^2 + 1;
+
+	> q+p; q*p; # Les opérations sur les polynômes marchent.
+
+	> subs(x=1,p); # Évaluer p en 1
+
+	> f := unapply(p,x); # Transformer p en une fonction
+
+	> degree(p); # Degré du polynôme
+
+	> ldegree(p); # Valuation du polynôme
+
+	> coeffs(p,x); # Avoir tous les coefficients de p
+
+	> coeff(p,x,2); # Coefficient devant le terme x^2
+
+	> lcoeff(p,x); # Coefficient dominant de p
+
+	> rem(p,q,x); # Reste de la division euclidienne de p par q
+
+	> quo(p,q,x); # Quotient de la division euclidienne de p par q
+\end{verbatim}
+
+\subsection{Manipulation des polynômes}
+
+\begin{verbatim}
+	> expand(q*p); # Développer une forme factorisée
+
+	> factor(x^2 - 1); # Factorise un polynôme.
+
+	> factor(x^2 + 1); factor(x^2 + 1, I); # Il faut préciser dans quel corps on veut factoriser.
+
+	> factor(x^2 - 2); factor(x^2 - 2, sqrt(2)); # Même remarque
+
+	> factor(x^2+x+1); factor(x^2+x+1,[I,sqrt(3)]); # Encore un autre exemple
+\end{verbatim}
+\texttt{factor} factorise par défaut dans le corps de base du polynôme (celui dans lequel sont ses coefficients). Le plus souvent ce corps est $\Q$. Pour lui dire de factoriser dans un corps plus grand, il faut lui préciser les éléments à ajouter au corps (on appelle cette ``méthode'' \textbf{extension de corps}). Il n'est pas toujours facile de connaitre les éléments à ajouter pour cela, on peut utiliser \texttt{RootOf}.
+\begin{verbatim}
+	> allvalues(RootOf(x^2 - 2)); # Racines de x^2 - 2
+
+\end{verbatim}
+On peut aussi directement se placer sur le corps $\R$ et avoir une factorisation complète mais nous n'aurons plus d'expression exacte.
+\begin{verbatim}
+	> factor(x^2 - 2.0); # Factorisation complète mais approchée
+
+\end{verbatim}
+
+Pour extraire les polynômes dans une forme Factorisée, on utilisera \texttt{convert}.
+\begin{verbatim}
+	> p = x^2 - 1; 
+
+	> convert(factor(p), list); # Sous forme de liste (l'ordre des facteurs est maintenu)
+
+	> convert(factor(p), set); # Sous forme d'ensemble (ordre non maintenu et par de doublons)
+
+\end{verbatim}
+
+
+\begin{Exo}
+		On considère le polynôme suivant $P = X^4 + X^3 + aX^2 + \sqrt{2} X + b$.
+		\begin{enumerate}
+				\item Déterminer $a$ et $b$ tels que $1+i$ soit une racine de $P$.
+				\item Trouver tous les zéros de $P$.
+				\item Factoriser $P$ dans $\R[X]$ puis dans $\C[X]$.
+		\end{enumerate}
+\end{Exo}
+
+\begin{Exo}
+		Déterminer les polynômes $P \in \R_3[X]$ tels que $P(-1) = -18$ et dont le reste de la division euclidienne par $X-1$, $X-2$ ou $X-3$ soit égale à 6
+\end{Exo}
+
+
+\begin{Exo}
+		On s'intéresse aux polynômes de la forme $X^n - 1$.
+		\begin{enumerate}
+				\item Écrire une procédure \texttt{P} qui prend en argument \texttt{n} qui renvoie le polynôme $X^n - 1$.
+				\item Factoriser dans $\Q$ les 10 premiers polynômes de cette forme. Que peut-on conjecturer sur les coefficients des facteurs? (Les facteurs sont les polynômes \textbf{cyclotomiques}).
+				\item En espérant que vous ayez fait la bonne conjecture, nous allons essayer de la vérifier plus systématiquement. Écrire un procédure qui prend en argument \texttt{n} et qui renvoie l'ensemble (sans doublons) des coefficients des facteurs de $X^n - 1$.
+				\item Tester votre conjecture pour $n$ allant jusqu'à 150. Que pouvez vous conclure?
+		\end{enumerate}
+\end{Exo}
+
+\begin{Exo}
+		On s'intéresse maintenant aux polynômes de Tchebichev. On rappelle que se sont les polynômes $T_n$ tels que $\cos(nt) = T_n(\cos(t))$.
+		\begin{enumerate}
+				\item Écrire une procédure qui prend en argument \texttt{n} et qui renvoie le polynôme de Tchebichev $T_n$. (\texttt{expand} marche aussi avec les fonctions trigonométriques).
+				\item Vérifier sur des petites valeurs de $n$ et $m$ que l'on a bien les propriétés suivantes:
+						\begin{eqnarray*}
+								T_n(1) &=& 1 \\
+								T_n(T_m(X)) &=& T_{nm}(X) \\
+								T_n(-x) &=& (-1)^n T_n(x) \\
+								\forall n \in N \quad \forall k \leq n && T_n\left( \cos\left( \frac{(2k-1)\pi}{2n} \right) \right) = 0
+						\end{eqnarray*}
+				\item Tracer les courbes des 5 premiers polynômes de Tchebichev sur un même graphique.
+		\end{enumerate}
+\end{Exo}
+
+
+\section{Fractions rationnelles}
+
+\subsection{Les fractions rationnelles}
+
+\begin{verbatim}
+	> f := (x^2 - 3) / (x + 1); # définir une fraction rationnelle
+
+	> type(f, ratpoly); # les fractions rationnelles sont appelées ratpoly dans Maple
+
+	> numer(f); denom(f); # Numérateur et dénominateur de f
+
+	> f + 1; factor(f+1); normal(f+1); # Opération sur les fractions rationnelles et simplifications
+
+\end{verbatim}
+
+\section{Décomposition en éléments simples}
+
+\begin{verbatim}
+	> h := (x(x+2)) / (x+1);
+
+	> convert(h, parfrac, x); # Décomposition en éléments simples
+
+	> F:=1/(x^3+1): convert(F,parfrac,x,sqrt(3)); # Même soucis qu'avec les polynômes, il faut préciser le corps
+
+	> convert(F,parfrac,x,{sqrt(3),I});
+
+\end{verbatim}
+
+\begin{Exo}
+		Décomposer en éléments simples la fraction rationnelle suivante $F = \frac{1}{X^4 + 1}$ sur $\R$ puis sur $\C$.
+\end{Exo}
+
+\end{document}

TD_maple/TD1/TD1.tex

@@ -0,0 +1,158 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+% Title Page
+\title{TD1: Premiers pas avec Maple}
+\author{}
+
+
+\begin{document}
+\maketitle
+
+Pensez à sauvegarder régulièrement votre travail! \textbf{Ctrl + S} ou \textbf{File $>$ Save as}
+\newline
+
+\begin{Exo}(La ligne de commande - l'invite) \\
+    Tapez les calculs suivants (Ne tapez pas le \texttt{>})
+    \begin{verbatim}
+        > 2+3;
+        > 10^10;
+        > cos(Pi);
+        > 2*n + 5*n - 4;
+    \end{verbatim}
+    \begin{itemize}
+        \item Quel est l'utilité du \texttt{;} à la fin de chaque ligne?
+        \item Que se passe-t-il si on met plusieurs calculs sur la même ligne? 
+    \end{itemize}
+    Essayez
+    \begin{verbatim}
+        > 2+3
+        > 4-5; 2^4-1;
+    \end{verbatim}
+    Entrez ces commandes et essayez de deviner le résultat.
+    \begin{verbatim}
+        > 12/6; 3/-10; 1/6 + 1/3; (n^2 + n)/(n+1); 
+        > sqrt(9); sqrt(3); sqrt(-1);
+        > 2 + sqrt(3); 1/(1+sqrt(3));
+    \end{verbatim}
+    Vous remarquez que Maple ne donne jamais de valeur approchée. Pour y remédier nous avons deux solutions.
+
+    La première est de dire à Maple de conciderer les nombres comme des nombres flottants (à virgules) en ajoutant un point \texttt{12.} et \texttt{3.}.
+    \begin{verbatim}
+        > 12./6; sqrt(3.);
+    \end{verbatim}
+    La deuxième (qu'on utilise plus souvent) conciste à utiliser \texttt{evalf} (\texttt{eval} pour évaluer et \texttt{f} pour flottant).
+    \begin{verbatim}
+        > evalf(12/6); evalf(2 + sqrt(3));
+    \end{verbatim}
+    Voilà maintenant, nous savons utiliser Maple comme une calculette.
+\end{Exo}
+
+\begin{Exo}(Un peu d'aide?)\\
+    Vous allez être amené à rencontrer des fonctions dont vous ne connaissez pas l'utilités ou à oublier le fonctionnement de certaines. Pour cela Maple dispose d'une aide locale.\\
+    Si vous connaissez le nom de la fonction vous pouvez taper:
+    \begin{verbatim}
+        >?nom_de_la_fonction
+    \end{verbatim}
+    \begin{itemize}
+        \item Que calcul \texttt{ilcm}?
+        \item Quelle est la fonction de \texttt{plot}? Exécutez les 3 premiers exemples.
+    \end{itemize}
+
+    Si vous ne connaissez pas le nom de la fonction, une aide interactive est proposée dans le menu \textbf{Help}.
+    \begin{itemize}
+        \item Quel est la fonction qui donne la valeur absolue d'un nombre?
+        \item Comment fait-on des graphiques en 3D?
+    \end{itemize}
+
+    Savoir utiliser l'aide est une chose important. N'hésitez pas à en user et en abuser.
+\end{Exo}
+
+\begin{Exo}(Sauvegarde basique du résultat)\\
+    Tapez les calculs suivants
+    \begin{verbatim}
+        > 3 + 4;
+        > % * 3;
+        > % - 4;
+        > 2 + sqrt(3);
+        > evalf(%);
+        > acrtan(2);
+        > evalf(%);
+    \end{verbatim}
+    \begin{itemize}
+        \item À quoi sert \texttt{\%}?
+        \item Que ce passe-t-il avec \texttt{\%\%}?
+    \end{itemize}
+    Dans la pratique, on évitera d'utiliser \texttt{\%\%}. Cela rend la relecture plus compliqué et mène à des bugs difficiles à détecter. Dans l'exercice suivant on vera un bon moyen de s'en passer.
+\end{Exo}
+
+\begin{Exo}(Enregistrer des valeurs : les variables)\\
+    Entrez ces commandes et essayez de deviner le résultat.
+    \begin{verbatim}
+        > a := 3;
+        > a;
+        > 2 + a;
+        > 2 + A;
+        > a * a;
+        > b := 2^10;
+        > a + b;
+        > c = a + 3;
+        > c;
+        > c:= a+3;
+        > c;
+        > a;
+        > a := a + 1;
+        > a;
+    \end{verbatim}
+    \begin{itemize}
+        \item À quoi sert \texttt{:=}? Et \texttt{=}?
+        \item Maple est-il sensible aux majuscules dans le nom des variables?
+    \end{itemize}
+    Donner un ``bon'' nom aux varibles est important. Cela rend le code plus lisible pour vous quand vous le relirez ou pour les autres qui le lirons. On serai alors tenter de le faire de cette manière:
+    \begin{verbatim}
+        > super variable := 4;
+    \end{verbatim}
+    Mais Maple ne tolère pas les espaces dans les noms. Il existe des conventions pour nommer les variables (qui dependent en général du language) comme celles qui suivent.
+    \begin{verbatim}
+        > super_variable := 4;
+        > superVariable := 4
+    \end{verbatim}
+
+    Attention, definir des variables est retroactif.
+    \begin{verbatim}
+        > a := 2*n + 3;
+        > a;
+        > n := 4;
+        > a;
+    \end{verbatim}
+
+    Pour reinitialiser toutes les variables, on utilise \texttt{restart}.
+    \begin{verbatim}
+        > a := 3; b := 5; c:= a^2 + cos(b);
+        > restart;
+        > a; b; c; 
+    \end{verbatim}
+    À chaque début d'exercice, on utilisera \texttt{restart} pour éviter que les variables précédement afféctées créent des problèmes.
+\end{Exo}
+
+
+\begin{Exo}(Puissance de Maple: Le calcul formel)\\
+    En vous aidant de l'aide, enregistrez ces sommes (\textit{sum} en anglais) dans des variables et évaluez les avec \texttt{value}.
+    \begin{eqnarray*}
+        \sum_{i=1}^{n} i^2 ;\quad \sum_{i=0}^{\infty} \frac{(-1)^i}{i-1} ;\quad \sum_{k=0}^{\infty} \frac{x^k}{k!}
+    \end{eqnarray*}
+
+    Evaluez le produit (\textit{product} en anglais) suivant
+    \begin{eqnarray*}
+        \prod_{i = 1}^{n} i
+    \end{eqnarray*}
+    Que signifie la réponse de Maple? Tracez la fonction associé à la réponse.
+\end{Exo}
+
+\end{document}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/TD2/TD2.tex

@@ -0,0 +1,204 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+% Title Page
+\title{TD2:  Les boucles}
+\author{}
+
+
+\begin{document}
+
+\maketitle
+
+
+Pensez à
+\begin{itemize}
+    \item Sauvegarder régulièrement votre travail! \textbf{Ctrl + S} ou \textbf{File $>$ Save as}.
+    \item Faire un \texttt{restart;} au début de chaque exercice.
+\end{itemize}
+
+\section{Boucles} 
+\label{sec:Boucles}
+
+
+\indent
+\begin{Exo}(Introduction aux boucles)\\
+    Tapez les lignes suivantes (pour passer à la ligne sans déclencher son interprétation, au lieu d'utiliser \textbf{Entrée}, utilisez \textbf{Maj + Entrée})
+    \begin{verbatim}
+        > for i from 1 to 4 do # Maj+Entrée
+            pipo; # Maj+Entrée
+            od; # Entrée
+    \end{verbatim}
+    \begin{itemize}
+        \item Commentez.
+    \end{itemize}
+    Tapez maintenant le code suivant.
+    \begin{verbatim}
+        > for i form 1 to 5 do
+            i^2;
+            od;
+    \end{verbatim}
+    \begin{itemize}
+        \item Commentez.
+        \item Que ce passe-t-il si on remplace \texttt{od;} par \texttt{od:}?
+    \end{itemize}
+    Enfin essayez le code suivant.
+    \begin{verbatim}
+        > x := 1;
+        > for i from 1 to 5 do
+            x := x*2;
+            od;
+        > x;
+    \end{verbatim}
+    \begin{itemize}
+        \item Commentez.
+        \item Que ce passe-t-il si on remplace \texttt{od;} par \texttt{od:}?
+        \item Évaluez \texttt{i}. Que remarquez vous?
+    \end{itemize}
+\end{Exo}
+
+\begin{Exo}(Calcul de sommes et de produit)\\
+    En utilisant les boucles calculez la somme suivante
+    \begin{eqnarray*}
+        \sum_{k = 0}^{10} 2^k
+    \end{eqnarray*}
+    En utilisant les boucles, calculez \texttt{10!}.
+\end{Exo}
+
+\begin{Exo} (Suites récurrentes d'ordre 1)\\
+    On se donne la suite $(u_n)_{n \in \N}$ définit par
+    \begin{eqnarray*}
+        u_{n+1} & = & 2u_n + 1 \quad \forall n \in \N \\
+        u_0 & = & 0
+    \end{eqnarray*}
+    Calculer $u_{100}$.
+    
+    On se donne la suite $(v_n)_{n \in \N}$ définit par
+    \begin{eqnarray*}
+        v_{n+1} & = & \frac{v_n}{2} + \frac{1}{v_n} \quad \forall n \in \N \\
+        v_0 & = & 1
+    \end{eqnarray*}
+    Calculer $v_{100}$.
+\end{Exo}
+
+\begin{Exo}(Suites récurrentes d'ordre 2)\\
+    On se donne la suite $(v_n)_{n \in \N}$ définit par
+    \begin{eqnarray*}
+        v_{n+2} & = & v_{n+1} + v_n \quad \forall n \in \N \\  
+        v_0 & = & 1 \\
+        v_1 & = & 1
+    \end{eqnarray*}
+    Calculer $v_{100}$.
+
+    \begin{hint}
+        Vous pouvez vous ramener à un récurrence d'ordre 1 en considérant $(v_n,u_n)$ avec $u_n = v_{n+1}$.
+    \end{hint}
+
+\end{Exo}
+
+
+\section{Séquences et listes} 
+\label{sec:Sequences et listes}
+
+\indent
+\begin{Exo}(Séquences)
+    Tapez les commandes suivantes.
+    \begin{verbatim}
+        > S := a,b,c,d,e;
+        > S[1]; S[3];
+        > S[10];
+        > S[1..3];
+        > T := S[1..3], x, S[4..5];
+        > T;
+    \end{verbatim}
+    On dit que \texttt{S} et \texttt{T} sont des \textit{séquences}.
+    \begin{itemize}
+        \item Comment accède-t-on à une valeur particulière d'une séquence? Que se passe-t-il si l'on fait \texttt{S[1] := z}?
+        \item Que signifie \texttt{S[1..3]}?
+        \item  Quelle transformation a-t-on fait à \texttt{S} pour obtenir \texttt{T}?
+    \end{itemize}
+\end{Exo}
+
+
+\begin{Exo}(Puissances de 2)\\
+    En utilisant les boucles, construisez une séquence contenant les puissance de 2 jusqu'à 35.
+    \begin{eqnarray*}
+        1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024\cdots
+    \end{eqnarray*}
+    Donnez les puissances de 2 de 25 à 30.
+    
+    Maple dispose d'une fonction qui permet de faire la même chose plus rapidement: \texttt{seq}. Refaite l'exercice en utilisant \texttt{seq}.
+
+    Donner la séquence, pour $n$ variant de 5 à 10 de 
+    \begin{eqnarray*}
+        u_n = \frac{x^n}{n!}
+    \end{eqnarray*}
+\end{Exo}
+
+\begin{Exo}(Retour aux suites)\\
+    On se donne la suite $(u_n)_{n \in \N}$ définit par
+    \begin{eqnarray*}
+        u_{n+1} & = & 2u_n + 1 \quad \forall n \in \N \\
+        u_0 & = & 0
+    \end{eqnarray*}
+    Donnez la séquence des 10 premières valeurs de la suite.
+    
+\end{Exo}
+
+\begin{Exo}(Séquence de séquence: utilisation de listes)\\
+    Dans cet exercice on voudrai faire une séquence de séquences. C'est à dire qu'on voudrai avoir accès à une séquence quand on appel \texttt{S[1]}. 
+    Essayez.
+    \begin{verbatim}
+        > A := a,b,c,d,e;
+        > Z := z,y,x,w,v;
+        # On voudrai construire S tel que S[1] = A et S[2] = Z.
+        # La première idée serai
+        > S := A,Z;
+        # La deuxième serai
+        > S[1] := A;
+        > S[2] := Z;
+    \end{verbatim}
+    \begin{itemize}
+        \item Est-ce que la première idée marche? Que ce passe-t-il?
+        \item Est-ce que la deuxième idée marche? Que ce passe-t-il?
+        \item Une autre idée?
+    \end{itemize}
+
+    L'astuce est de mettre la séquence entre crochets. Essayez.
+    \begin{verbatim}
+        > A := [A];
+        > Z := [Z];
+        > S := A, Z;
+    \end{verbatim}
+    \begin{itemize}
+        \item Est-ce que ça marche?
+        \item Essayez à partir de \texttt{S} d'atteindre la première valeur de \texttt{A}. Et la troisième valeur de Z?
+    \end{itemize}
+    
+\end{Exo}
+
+\begin{Exo}(Produit de matrices)\\
+    On se donne de matrices $A$ et $B$ telles que
+    \begin{eqnarray*}
+        A = \begin{pmatrix}
+            1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9
+        \end{pmatrix};
+        \quad
+        B = \begin{pmatrix}
+            a & b & c \\ d & e & f \\ g & h & i
+        \end{pmatrix}
+    \end{eqnarray*}
+    \begin{itemize}
+        \item Comment stocker ces matrices dans Maple?
+        \item Écrivez une boucle(double!) pour faire le produit de $A$ par $B$.
+    \end{itemize}
+    
+\end{Exo}
+
+\end{document}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/TD_Euler/TDmaple-euler.tex

@@ -0,0 +1,112 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Méthode d'Euler}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+Le but de ce TD est de chercher puis d'approximer les solutions sur $[a,b]$ de
+\begin{eqnarray*}
+    y'(t) &= & f(t,y(t))  \quad \forall t \in [a,b]\\
+    y(a) & = & z_0
+\end{eqnarray*}
+
+
+\section{Solution Exacte (Calcul formel)}
+
+Maple arrive parfois à résoudre formellement ce type d'équation. 
+
+
+\begin{itemize}
+    \item Résoudre l'équation différentielle et tracer la courbe de la solution.
+        \begin{eqnarray*}
+            y' + y &=& e^{-t} \cos(10t) \quad \forall t \in [0,2] \\
+            y(0) &=& 0
+        \end{eqnarray*}
+    \item Écrire une procédure qui prend pour entrée $f$ et $z_0$ (la valeur en $a$ de la solution) et qui renvoie la fonction solution. 
+\end{itemize}
+
+
+\paragraph{Commandes utiles:}
+\begin{itemize}
+    \item Pour résoudre l’équation différentielle, utiliser \texttt{dsolve}. 
+    \item \texttt{dsolve} ne renvoie pas exactement une fonction. Pour obtenir une fonction solution, utiliser \texttt{subs}.
+\end{itemize}
+
+\section{Schéma d'Euler (Analyse numérique)}
+
+\paragraph{Rappel:}(Méthode d'Euler):\\
+On pose $t_i = a + i * \frac{b-a}{n}$. 
+
+On prend comme valeur approchée de la solution $y(t_i)$ la valeur $z_i$ définie par récurrence par : $$z_{i+1}=z_i+\frac{b-a}{n}*f(t_i,z_i)$$
+Une représentation approchée de la solution est la ligne brisée passant par les points $(t_i,z_i)$.
+
+\begin{itemize}
+    \item Écrire une procédure qui prend en entrée :
+    \begin{itemize}
+        \item $f$
+        \item $n$ le nombre de subdivision de l'intervalle
+        \item $a,b$ les extrémités de l'intervalle
+        \item $z_0$ la valeur en $a$ de la solution recherchée.
+    \end{itemize}
+    et qui renvoie la séquence $(t_i, z_i)_{i \in \{0..n\}}$ calculée par la méthode d'Euler.
+
+    \item Tester la procédure sur l'équation différentielle avec $n = 10$ et tracer le résultat
+        \begin{eqnarray*}
+            y' + y &=& e^{-t} \cos(10t) \quad \forall t \in [0,2] \\
+            y(0) &=& 0
+        \end{eqnarray*}
+
+    \item Écrire une procédure qui prend en entrée :
+    \begin{itemize}
+        \item $f$
+        \item $n$ le nombre de subdivision de l'intervalle
+        \item $a,b$ les extrémités de l'intervalle
+        \item $z_0$ la valeur en $a$ de la solution recherchée.
+    \end{itemize}
+    et qui renvoie le graphe de la solution approchée et celui de la solution exacte sur un même graphe.
+
+    \item Tester la procédure sur l'équation différentielle avec différents $n$
+        \begin{eqnarray*}
+            y' + y &=& e^{-t} \cos(10t) \quad \forall t \in [0,2] \\
+            y(0) &=& 0
+        \end{eqnarray*}
+\end{itemize}
+
+\paragraph{Commandes utiles:}
+\begin{itemize}
+    \item En Maple, $t_i$ se note \texttt{t[i]}.
+    \item Pour créer la liste des points $(t_i,z_i)$, utiliser \texttt{seq}. Si la liste est trop grande, Maple vous demandera d'utiliser \texttt{array}.
+    \item Pour tracer plusieurs courbes sur un même graphe, donner un nom à chaque courbe puis utiliser \texttt{display}.
+\end{itemize}
+
+\section{Évaluation de l'erreur}
+
+Nous allons maintenant nous intéresser à l'erreur commise par la méthode d'Euler. On calcule l'erreur suivante
+\begin{eqnarray*}
+    E_n = \max_{i \in \{0..n\}} |y(t_i) - z_i|
+\end{eqnarray*}
+Où $y(t)$ est la solution exacte et $z_i$ la valeur en $t_i$ de la solution approchée.
+
+\begin{itemize}
+    \item Écrire une procédure qui prend en entrée :
+    \begin{itemize}
+        \item $y$ la solution exacte
+        \item $(t_i, z_i)_{i\in \{0..n\}}$ la solution approchée
+    \end{itemize}
+    et qui renvoie l'erreur
+    \item On restreint à l'équation $y'(t) = y(t)$ que l'on sait résoudre. Écrire une procédure qui prend en entrée :
+    \begin{itemize}
+        \item $a,b$ les extrémités de l'intervalle
+        \item $z_0$ la valeur en $a$ de la solution recherchée.
+        \item $(n_k)$ la liste des valeurs de $n$ à tester
+    \end{itemize}
+    et qui renvoie $(n_k, E_{n_k})$ les erreurs correspondant aux différentes  valeurs de $n$.
+    \item Tester la procédure avec $[a,b] = [0,10]$, $z_0 = 1$ et $(n_k) = \{10, 20, .., 100\}$
+\end{itemize}
+
+\end{document}

TD_maple/TD_revision/TDmaple_revision.tex

@@ -0,0 +1,129 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\usepackage{eurosym}
+\usepackage{url}
+
+% Title Page
+\title{Révision}
+\author{}
+\date{}
+
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+
+\section{Conseils}
+\begin{itemize}
+    \item Pensez à Sauvegarder!
+    \item Commencez par écrire le squelette de ce que vous voulez faire. Complétez ensuite.\\
+        \textbf{Exemple} Pour une procédure
+        \begin{verbatim}
+            > MaProc := proc(LesArguments)
+
+            return(ValeurARetourner);
+            end;
+        \end{verbatim}
+        Pour les boucles
+        \begin{verbatim}
+            for i from 1 to n do
+
+            od;
+        \end{verbatim}
+    \item Sauvegardez!
+    \item Si vous n'avez pas d'idées pour écrire une procédure, commencez par traiter à la main un cas particulier puis essayez de généraliser.
+    \item Sauvegardez!
+    \item Donnez des noms de variables compréhensibles et parlant.
+    \item Sauvegardez!
+\end{itemize}
+
+\section{Examen 2011/2012}
+\begin{Exo}(Jour et date)\\
+Écrire une procédure \texttt{date} prenant en argument un entier $j$
+compris entre $1$ et $365$ et retournant pour résultat un couple
+$(n,m)$ représentant le numéro du mois (les mois sont numérotés de $1$
+à $12$ par ordre chronologique en commençant en janvier) et la date
+dans le mois correspondant au $j$e jour de l'année. Ainsi
+\texttt{date(1)} retourne la valeur $(1,1)$ (premier janvier),
+\texttt{date(365)} retourne la valeur $(31,12)$ (31 décembre). 
+
+Note~: On se placera uniquement dans le cas d'une année non
+bissextile.
+\end{Exo}
+
+\begin{Exo}(Algorithme de Babylone)
+\begin{align*}
+ p_0 & = 1\\
+ q_0 & = 1\\
+ \forall n\in\N\ p_{n+1} &= p_n^2 + 2 q_n^2\\
+ \forall n\in\N\ q_{n+1} &= 2 p_n q_n
+\end{align*}
+
+On remarquera que $p$ et $q$ sont à valeurs entières.
+
+\begin{itemize}
+    \item Écrire des procédures maple $p$ et $q$ prenant chacune un entier
+      $n$ en paramètre et retournant respectivement $p_{n}$ et
+      $q_{n}$. Calculez $p_{10}$ et $q_{10}$.
+    \item Quelle conjecture peut-on émettre sur la convergence de
+      la suite des $\dfrac{p_{n}}{q_{n}}$ pour $n\in\N$~?
+    \end{itemize}
+    NB~: Pour mémoire $p_{3}=577$, $q_{3}=408$.
+\end{Exo}
+
+\begin{Exo}(Minimum)\\
+        Écrire une procédure \texttt{mini} prenant en argument une liste
+    (non-vide) de nombres et rendant en résultat le plus petit de ces
+    nombres. On s'interdit évidemment tout usage des procédures Maple
+    \texttt{max} et \texttt{min}.
+\end{Exo}
+
+\begin{Exo}(Étude d'une suite)\\
+    \begin{align*}
+      u_{0}&= 2,8\\
+      \forall n\in\N\quad u_{n+1}&= u_{n} -1 + \ln u_{n}
+    \end{align*}
+    On admettra que cette suite est strictement croissante et non bornée.
+
+    \begin{itemize}
+        \item Écrire une procédure \texttt{valeuru} prenant en paramètre un entier naturel $n$ et retournant la valeur de $u_{n}$.
+        \item Écrire une procédure \texttt{depasse} prenant en argument un flottant $x$ et retournant le plus petit entier $n$ vérifiant $u_{n} \geq x$.
+        \item Que vaut \verb+depasse(100)+~?
+        \item Que vaut \verb+depasse(100000)+~?
+    \end{itemize}
+    
+\end{Exo}
+
+\section{Exercices}
+\begin{Exo}(Compter Shadoks)\\
+    Les \textbf{Shadoks} ne connaissent que 4 mots différents:
+    \begin{eqnarray*}
+        \mbox{ GA, BU, ZO, MEU} 
+    \end{eqnarray*}
+
+    \begin{itemize}
+        \item Trouvez leur une façon de compter utilisant leurs 4 mots.
+        \item Écrire un programme \texttt{ShadokToHuman} qui convertit un nombre Shadok en nombre ``humain'' (en base 10).
+        \item Écrire un programme \texttt{HumanToShadok} qui fait l'opération inverse.
+    \end{itemize}
+
+    \paragraph{Indication:} \url{http://www.youtube.com/watch?v=nm0cw6b1PMA}
+\end{Exo}
+
+
+\begin{Exo}(Dénombrement)\\
+    Écrire une procédure \texttt{DenSomme} qui prend en argument \texttt{n} et qui renvoie les couples $(i,j) \in \N^2$ tel que $i+2j = n$.
+
+    De combien de façon peut on payer 10\euro{ } avec uniquement des pièces de 1 et 2 euros?
+\end{Exo}
+
+
+\end{document}
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:
+

TD_maple/algLineaire/algLin.tex

@@ -0,0 +1,209 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+\usepackage{multirow}
+\usepackage{tabularx}
+
+\title{Algèbre linéaire}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+\section*{LinearAlgebra}
+
+Ce TD est consacré à l'utilisation de Maple pour faire de l'algèbre linéaire. Pour cela, il faudra charger au début de la feuille de calcul la bibliothèque \texttt{LinearAlgebra}.
+
+\paragraph{Remarque:} Il existe aussi la bibliothèque \texttt{Linalg} mais elle est considérée comme obsolète. Nous utiliserons uniquement la bibliothèque \texttt{LinearAlgebra}.
+
+
+
+\section{Les vecteurs: \texttt{Vector}}
+\begin{verbatim}
+>Vector([1,2,3]) #  Un vecteur colonne de dimension 3 
+
+>Vector[row]([1,2,3]) # Un vecteur ligne de dimension 3 
+
+>V1 + V2 # Addition des vecteur V1 et V2 s'ils ont les même dimensions
+
+>3*V	# Multiplication par un scalaire du vecteur V
+
+>V1.V2 # Produit scalaire de V1 par V2
+
+>Dimension(V)} # Dimension du vecteur V
+
+>Basis([V1, V2, V3]) # Renvoie un base de $Vect(V1, V2, V3)
+
+\end{verbatim}
+\begin{Exo}
+		Soit $A = \left(%
+		\begin{array}[h]{cccc}
+				1 & -3 & 3 & -2 \\
+				1 & 1 & 1 & 2 \\
+				2 & 4 & 1 & 6 \\
+				1 & 1 & 1 & 2 
+		\end{array}%
+		\right)$
+		Déterminer le rang de $A$ ainsi qu'une base de son image.
+
+\end{Exo}
+
+\section{Les matrices: \texttt{Matrix}}
+
+\subsection{Création de matrices}
+\begin{verbatim}
+		> Matrix([[ 1, 2, 3],[4, 5, 6],[7, 8, 9]]); # Matrice à partir de la liste des lignes
+
+		> convert(C, Matrix); # Matrice à partir de la liste des colonnes
+
+		> Matrix(3, 2, [1, 2, 3, 4, 5]); # Matrice à partir des dimension de la liste des coéficients
+
+		> Matrix(2, 5, 0); # À partir des dimensions et d'une seul valeur
+
+		> f := (i,j) -> |i-j|; # Un fonction avec deux arguments
+
+		> Matrix(3, 4, f); # À partir des dimensions et d'une fonction à deux arguments
+
+		> A := Matrix(3, 3); #  Matrice avec que des 0
+
+		> A[1, 2] := 2; # Modification d'un seul élément de la matrice
+
+		> A[2..3,2..3] := Matrix(2,2,5); Modification d'un bloc
+
+		> IdentityMatrix(n) 				# Matrice identité de taille n
+
+		> DiagonalMatrix([1, 2, 3, 4, 5]) 	# Matrice diagonale
+\end{verbatim}
+
+
+
+\subsection{Opération sur les matrices}
+\begin{verbatim}
+		> A:=Matrix([[0,1,2],[1,1,1]]): B:=Matrix([[5,4,0],[2,5,-1]]): # on crée des matrices pour les exemples
+		C:=Matrix([[1,-1,2],[1,0,1],[1,1,2]]): V:= Vector([1,20,1]):
+
+		> Dimension(A) 		# Dimension de la matrice
+
+		> A + B 			# Addition de matrices
+
+		> A.B; A.C; A.C		# Multiplication de matrices
+
+		> Transpose(A) 		# Transposition
+
+		> C^2 				# Puissance de matrices
+
+		> C^(-1) 			# Inverser une matrice
+
+		> Trace(C) 			# Trace de la matrice
+
+		> Determinant(C) 	# Déterminant
+
+\end{verbatim}
+
+\begin{Exo}
+		Créer les matrices suivantes, dire si elles sont inversibles, calculer l'inverse quand c'est possible et calculer la puissance n-ième. Comme les matrices suivantes dépendent de $n$, vous pouvez faire une procédure qui prend en argument $n$ et qui renvoie la matrice voulu.
+		\begin{enumerate}
+				\item $\left( \dfrac{ji}{i+j} \right)_{1 \leq i,j \leq n}$
+				\item $\left( pgcd(i,j) \right)_{1 \leq i,j \leq n}$
+				\item $\left( \left( i+j \right)^k \right)_{1\leq j,i \leq n}$.
+				\item $\forall i,j \leq n$ $a_{ij} = \left\{%
+								\begin{array}[h]{c}
+										i-j \mbox{ si } i \leq j \\
+										0 \mbox{ sinon}
+								\end{array}	\right.$. (On pourra utilise \texttt{piecewise}.)
+		\end{enumerate}
+\end{Exo}
+
+\begin{Exo}
+		Fabriquez la matrice de Hilbert $\left( \dfrac{1}{i+j+1} \right)_{i,j \leq n}$ et calculer son déterminant suivant les valeurs de $n$. Vérifier que pour ces valeurs, le determinant est égal à 
+		\begin{eqnarray*}
+				\prod^{n}_{k=1} \frac{(k!)^2}{(2k+1)(2k)!^2}
+		\end{eqnarray*}
+\end{Exo}
+
+\subsection{Système linéaire}
+
+\begin{verbatim}
+		> solve({x+y+z=0,2*x+3*y+z=1,x+y-z=2}); # résout le système d'équations
+
+		> A:=Matrix([[1,1,1],[2,3,1],[1,1,-1]]):b:=Vector([0,1,2]):
+
+		> LinearSolve(A,b); # Résout le système associé.
+
+		> A:=Matrix([[1,1,1],[2,3,1],[1,1,-1]]): b:=Matrix([[0,1,1],[0,0,0],[2,1,1]]):
+
+		> LinearSolve(A,b); # Marche aussi avec les équations matricielles
+
+\end{verbatim}
+
+\begin{Exo}
+		Résoudre le système d'équation de deux manières différentes
+		\begin{eqnarray*}
+				\left\{%
+						\begin{array}[h]{ccc}
+								x + 2y + 3z &=& 1 \\
+								-2x + 4y + z &=& 2 \\
+								x + 18y + 17z &=& 9
+						\end{array}\right.
+		\end{eqnarray*}
+\end{Exo}
+
+\begin{Exo}
+		Soit $A = \left(%
+		\begin{array}[h]{cccc}
+				1 & 0 & 1 & 0 \\
+				0 & 1 & 0 & 1 \\
+				-2 & 4 & 4 & -2 \\
+				1 & 1 & 1 & 1
+		\end{array} \right)$
+		\begin{enumerate}
+				\item Trouver les matrices $B \in \M_4(\R)$ telles que $AB = 0$.
+				\item Trouver les matrices $B \in \M_4(\R)$ telles que $ABA = A$
+		\end{enumerate}
+\end{Exo}
+
+\begin{Exo}
+		Trouve les matrices qui commutent avec 
+		\begin{eqnarray*}
+				A = \left(%
+				\begin{array}[h]{ccc}
+						2 & 1 & 1 \\
+						1 & 2 & 1 \\
+						0 & 0 & 3
+				\end{array}\right)
+		\end{eqnarray*}
+\end{Exo}
+
+\subsection{Noyau, image, rang}
+
+\begin{verbatim}
+	> Rank(A) 			# Donne le rang de A
+
+	> ColumnSpace(A) 	# Calcule une base de l'image de A
+
+	> NullSpace(A) 		# Calcule une base du noyau de A
+
+\end{verbatim}
+
+\begin{Exo}
+		Refaire l'exercice 1
+\end{Exo}
+
+\begin{Exo}
+		Pour tout $n \in \N*$, on définit $A_n$ de manière suivante
+		\begin{eqnarray*}
+				(A_n)_{ij} = (i+j)^3
+		\end{eqnarray*}
+		\begin{enumerate}
+				\item Écrire une procédure prenant $n$ en argument et renvoyant la matrice $A_n$.
+				\item Conjecturer la valeur du rang de $A_n$ en fonction de $n$.
+		\end{enumerate}
+\end{Exo}
+
+
+
+
+
+
+\end{document}

TD_maple/fractal/fractal.tex

@@ -0,0 +1,44 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Fractales}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+
+\section{Tapis de Sierpinski}
+Cette partie se fera en parallèle avec le poly de Gullaume Connan, Chapitre 5.
+Le but de cette partie va être de créer un programme qui va dessiner un tapis de Sierpinski à l'étape \texttt{n}.
+
+Dans cette partie, nous aurons besoin des librairies suivantes \texttt{plots}, \texttt{plottools} et certainement \texttt{ArrayTools} chargez les.
+
+\begin{itemize}
+    \item Familiarisez vous avec \texttt{rectangle} pour dessiner des rectangles. Dessinez en plusieurs à la fois. Qu'a-t-on besoin pour tracer un rectangle?
+    \item Faites les questions du 1.2. À quoi correspondent les 8 transformations?
+    \item Écrire une procédure \texttt{huitTransfo} qui prend en argument un \texttt{array} et qui renvoie un \texttt{array} avec l'image des points par chacune des transformations.
+    \item Écrire une procédure \texttt{tapis} qui renvoie les informations nécessaire pour tracer la n-ième itération du tapis de Sierpinski.
+    \item Écrire une procédure \texttt{plotTapis} qui dessine la n-ième itération du tapis de Sierpinski.
+    \item Répondre aux questions du 1.3.
+\end{itemize}
+
+\section{Flocon de Koch}
+Voici la description du Flocon de Koch donnée par Wikipedia:
+\begin{quote}
+    
+On peut la créer à partir d'un segment de droite, en modifiant récursivement chaque segment de droite de la façon suivante :
+
+\begin{itemize}
+    \item On divise le segment de droite en trois segments de longueurs égales,
+    \item On construit un triangle équilatéral ayant pour base le segment médian de la première étape,
+    \item On supprime le segment de droite qui était la base du triangle de la deuxième étape.
+\end{itemize}
+\end{quote}
+
+En vous inspirant de ce qui a été fait avec le tapis de Sierpinski, écrire un programme qui dessine la n-ième itération du flocon de Koch. 
+
+
+\end{document}

TD_maple/fractal/fractal_suite.tex

@@ -0,0 +1,60 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Fractales (suite)}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+
+Ce td se fera en parallèle avec le poly de Guillaume Connan, Chapitre 5.
+
+\section{Végétation récursive}
+\subsection{Végétation}
+Comme dans le poly de G.Connan, on propose de construire des arbres récursivement.
+\begin{itemize}
+    \item Reprendre la procédure proposée dans le poly. Analysez la et commentez la (et corrigez la!)
+    \item Expérimentez les autres arbres.
+\end{itemize}
+
+
+\subsection{Flocon de Koch}
+Voici la description du Flocon de Koch donnée par Wikipedia:
+\begin{quote}
+    
+On peut la créer à partir d'un segment de droite, en modifiant récursivement chaque segment de droite de la façon suivante :
+
+\begin{itemize}
+    \item On divise le segment de droite en trois segments de longueurs égales,
+    \item On construit un triangle équilatéral ayant pour base le segment médian de la première étape,
+    \item On supprime le segment de droite qui était la base du triangle de la deuxième étape.
+\end{itemize}
+\end{quote}
+
+En vous inspirant de ce qui a été fait avec le tapis de Sierpinski et la végétation, écrire un programme qui dessine la n-ième itération du flocon de Koch. 
+
+\section{Julia et Mandelbrot}
+On s'intéresse à la suite suivante
+\begin{eqnarray*}
+    z_0 \in \C, c \in \C\\
+    z_{n+1} = z_n^2 + c
+\end{eqnarray*}
+En particulier à la limite de $(z_n)_n$ pour différent point de départ $z_0$. Deux approches sont possibles:
+\begin{itemize}
+    \item On fixe $c\in \C$ et on fait varier $z_0 \in \C$. La limite entre les $(z_n)_n$ qui convergent et celles qui ne convergent pas s'appelle \textbf{l'ensemble de Julia}. 
+    \item On fixe $z_0 = 0$ et on fait varier $c \in \C$. La limite entre les $(z_n)_n$ qui convergent et celles qui ne convergent pas s'appelle \textbf{l'ensemble de Mandelbrot}. 
+\end{itemize}
+
+\paragraph{Remarque:} On peut démontrer (non demandé) que Si $\exists p \in \N$ tel que $|z_p| \geq \max(2,|c|)$ alors $(z_n)_n$ diverge. 
+
+\begin{itemize}
+    \item Réécrire le code proposé par G.Connan (Chap 5 section 3) en commentant (et corrigeant!) le code. Puis tester différentes valeurs de $c$.
+    \item Proposer un façon similaire de dessiner l'ensemble de Mandelbrot.
+\end{itemize}
+
+
+
+
+\end{document}

TD_maple/notes

@@ -0,0 +1,39 @@
+######## Notes et idées sur les TDs de Maple
+##
+#
+
+# Outils indispensables
+
+
+# Idées d'exos
+
+    - Differentes formes d'integrations et approximation de fonctions
+        -> Monte Carlo
+        -> Trapèze
+        -> Simpson
+
+    - Automates cellulaires
+        -> Jeu de la vie
+        -> Feu de forêt
+
+    - Outils d'algèbres généraux
+        -> arithmétique (is_prime, pgcd, ppcm, Bezout...)
+        -> algèbre linéaire (déterminants, produit de matrices, inversion, pivot de Gauss...)
+        -> théorie des groupes - sans le nommer (expo rapide, RSA...)
+
+    - Étude de fonctions
+        -> limites, tableaux de variations
+        -> graphs
+        -> intro aux limites de fonctions?
+
+    - Fractal
+        -> lesquel?
+
+    - Calcul formel
+
+    - Algorithmie
+        -> trie
+
+
+
+# Idées de questions

TD_maple/style.sty

@@ -0,0 +1,62 @@
+\NeedsTeXFormat{LaTeX2e}
+ 
+%% \ProvidesPackage{Extention_Stage}
+%\ProvidesPackage{/media/documents/Cours/Latex/Utile/style/Extention_Stage}
+% extensions
+
+\RequirePackage[utf8]{inputenc}
+\RequirePackage[english]{babel}
+\RequirePackage{amssymb}
+\RequirePackage{amsmath}
+\RequirePackage{amsfonts}
+\RequirePackage{subfig}
+\RequirePackage[pdftex]{graphicx}
+\RequirePackage{color}
+\RequirePackage{fancyhdr}
+\RequirePackage{geometry}
+\geometry{left=15mm,right=15mm, top=15mm, bottom=15mm}
+
+
+
+\newcommand{\N}{\mathbb{N}}
+\newcommand{\Z}{\mathbb{Z}}
+\newcommand{\Q}{\mathbb{Q}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\C}{\mathbb{C}}
+\newcommand{\M}{\mathcal{M}}
+
+
+\newcommand{\e}{\varepsilon}
+\newcommand{\ii}[1]{[\![#1]\!]}
+\newcommand{\iifo}[1]{[\![#1[\![}
+\newcommand{\iiof}[1]{]\!]#1]\!]}
+
+
+
+% New environement Exercise
+\newcounter{exo}
+\setcounter{exo}{1}
+\newenvironment{Exo}{%
+    \medskip
+    \indent \textbf{Exercice \theexo:}
+}{%
+    \addtocounter{exo}{1}       
+}
+
+\newenvironment{hint}{%
+    Indication:
+    \begin{itshape}
+}{%
+\end{itshape}
+}
+
+\newcommand{\note}[1]{\textcolor{red}{note(#1)}}
+
+% Les en-têtes
+\pagestyle{fancy}
+
+\setlength{\headheight}{15.2pt}
+\setlength{\headsep}{5pt}
+
+\fancyhead[L]{MPSI - Maple}
+\fancyhead[R]{2012/2013}

TD_maple/test_primalité/test_primalité.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+#-*- coding:utf8-*-
+
+# ------------------------------
+# Imports
+# ------------------------------ 
+
+# ------------------------------
+# Classes
+# ------------------------------ 
+
+# ------------------------------
+# Fonctions
+# ------------------------------ 
+
+def estPremier(n):
+    """ estPremier
+    
+    Test si le nombre est un nombre premier
+    
+    """
+    if n == 2:
+        return True
+    elif n <= 1:
+        return False
+    elif n % 2:
+        return False
+
+    i = 3
+    print("ici")
+    while (i*i<=n) & (n%i != 0):
+        i = i+2
+        print("la " + str(i))
+
+    if n%i ==0 :
+        return False
+    else:
+        return True
+
+
+
+# ------------------------------
+# Bloc principal
+# ------------------------------
+
+if __name__ == '__main__':
+    for i in range(30):
+        print("{i}, {prems}".format(i = i, prems = estPremier(i)))
+
+
+# ------------------------------
+# Fin du programme
+# ------------------------------
+
+# -----------------------------
+# Reglages pour 'vim'
+# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
+# cursor: 16 del 
+

TD_maple/test_primalité/test_primalité.tex

@@ -0,0 +1,109 @@
+\documentclass[10pt,a4paper]{article}
+\usepackage{/media/documents/Cours/Prof/TD_maple/2012_2013/style}
+
+\title{Tests de primalité}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\thispagestyle{fancy}
+Le but de cet exercice est de comprendre comment tester la primalité
+d'un entier. Avant de s'attaquer au problème, on lira attentivement la
+page d'aide «mod (modulo)» de Maple» et on s'attachera à comprendre ce
+que fait l'expression \verb|i &^ n mod m| qui y est décrite.
+
+\begin{enumerate}
+\item Étudier le programme suivant et comprendre ce qu'il est censé
+  faire et pourquoi il est incorrect. Le corriger.
+\begin{verbatim}
+  estpremier := proc(n)
+    local i;
+    if n=2 then return true; fi;
+    if n<=1 then return false; fi;
+    if irem(n,2) = 0 then return false; fi;
+    i := 3;
+    while i*i < n and irem(n,i) <> 0 do
+      # ici n n'est pas divisible par i ni par aucun nombre impair
+      # inférieur à i, ni par deux.
+      # on essaie le suivant
+      i := i + 2;
+    od;
+    if i*i < n then return false; else return true; fi;
+  end;
+\end{verbatim}
+\item Essayez de trouver un entier premier $n$ aussi grand que
+  possible de façon à ce que Maple mette moins de 10s à tester sa
+  primalité avec le programme corrigé.
+\item Le but est de trouver une méthode plus efficace pour tester la
+  primalité d'un entier. On s'intéressera ici au test de Fermat.
+  Soit $n$ un entier. On sait que si $n$ est premier, alors pour tout
+  entier $a\in ]0,n[$, on a $a^{n-1} \equiv 1 [n]$.
+  Donc par contraposée, si $a^{n-1}\not\equiv 1 [n]$, alors $n$ n'est
+  pas premier. On dit alors que $a$ est un témoin de non-primalité du
+  test de Fermat pour $n$. Si $a^{n-1}\equiv 1 [n]$ mais que $n$ n'est
+  pas premier, on dit que $n$ est un pseudo-premier de Fermat de base
+  $a$.
+
+  Y a t-il des entiers compris entre 1 et 1000 qui soient des
+  pseudo-premiers de Fermat de base $2$ (on les appelle aussi nombres
+  de Poulet)~? Lesquels ?
+
+  Y a t-il des entiers $n$ compris entre 1 et 1000 qui soient des
+  pseudo-premiers de Fermat de base $a$ pour tout $a$~? Pour presque
+  tous~?
+\item Le logiciel de chiffrement PGP utilise des tests de Fermat (avec
+  les bases 2,  3, 5 et 7) pour  trouver un nombre premier.\footnote{Le
+    risque  de  choisir  accidentellement  un nombre  non-premier  est
+    apparemment  très faible pour  les plages  de nombres  testées par
+    PGP.}  Essayez d'avoir une idée  de la taille du plus grand nombre
+  que vous puissiez trouver avec ce test de façon à ce que Maple mette
+  moins de 10s à tester la primalité d'un entier. Jusqu'à combien
+  pouvez-vous aller ?
+\item On propose maintenant un autre test, appelé test de
+  Miller-Rabin.
+  Il fonctionne de la façon suivante. Pour tester si un entier $n$ est
+  premier, on commence par écrire $n-1$ sous la forme $2^{s} \times
+  m$, où $m$ est impair.
+  Soit $a\in \ii{1,n-1}$.
+  Le test repose sur le résultat suivant~: si $n$ est
+  premier, alors ou bien $a^{m}\equiv 1[n]$, ou bien il existe
+  $d\in\ii{0,s-1}$ vérifiant $a^{2^d.m}\equiv -1[n]$. On peut démontrer ce
+  résultat en utilisant le petit théorème de Fermat, le fait que si
+  $n$ est premier $\Z/n\Z$ est un corps et le fait que dans tout
+  anneau intègre, l'équation $x^{2} = 1$ a
+  au plus deux solutions%
+  \footnote{Dans certains anneaux intègres, il n'y en a qu'une,
+    par exemple dans $\Z/2\Z$, où $-1=1$.}
+  ($1$ et $-1$).
+
+  On dira que $a$ est un menteur fort s'il vérifie les conditions
+  ci-dessus et que $n$ n'est pas premier.
+  
+  On peut montrer qu'au plus un quart des valeurs de $\ii{1,n-1}$ sont
+  des menteurs forts.\footnote{Voir sur Wikipédia en anglais l'article
+    \textit{Miller–Rabin primality test} et notamment  Schoof, René, \textit{Four primality testing algorithms},
+  Algorithmic Number Theory: Lattices, Number Fields,
+  Curves and Cryptography, Cambridge University Press,
+  ISBN 0521808545, \url{http://tinyurl.com/schoof-miller-rabin}.}
+  Le  test de  Miller-Rabin s'effectue  donc en  pratique de  la façon
+  suivante~: prendre  une valeur $a$  au hasard comprise entre  $1$ et
+  $n-1$ et effectuer le test avec cette base $a$. Si $a$ respecte
+  les conditions données ci-dessus, $n$ est probablement premier, dans
+  ce cas, on recommence avec un nouveau $a$ pris au hasard. Si au bout
+  de $40$ essais, on n'a pas trouvé de $a$ violant les conditions
+  données plus haut, on considérera que le nombre donné était premier.
+
+  Pour effectuer le test aussi vite que possible, on calcule
+  $a^{m}$ dans $\Z/n\Z$ et on effectue ensuite des mises au carré
+  successives pour calculer $a^{2 m}$, $a^{4 m}$,\ldots{},$a^{2^{s-1}
+    m}$. De plus, on n'est pas obligé de calculer toutes ces valeurs~:
+  on s'arrête dès le début si $a^{m}\equiv 1[n]$, on s'arrête
+  également dès qu'on trouve la valeur $-1$, et enfin on peut aussi
+  s'arrêter si l'on trouve la valeur $1$ (pourquoi ?).
+
+  Mettre en œuvre ce test pour vérifier si les grands nombres que vous
+  avez trouvés avec le test de Fermat sont bien premiers.
+\end{enumerate}
+
+\end{document}