\documentclass[10pt,landscape]{article}
\usepackage[width=240mm,height=173mm]{geometry}


% \documentclass[10pt,a4paper]{report}
% \usepackage[height=250mm,width=183mm]{geometry}



\usepackage{preambule}
\usepackage[upright]{fourier}

\usepackage{bbding}
 \usepackage{wasysym,marvosym,keystroke}
\definecolor{0.95white}{rgb}{0.95,0.95,0.95}

\graphicspath{{/home/moi/Photos/Tehessin/}{/home/moi/Figures/FigSTI/}{/home/moi/Figures/FigSeconde/}{/home/moi/Figures/figuresTS/}}

\entete{TD Maple n°2}{Programmation}{PCSI 2 - Lycée Clemenceau}%g,d,b

 \usepackage{index}
 \makeindex
 \renewindex{default}{idx}{ind}{Index des commandes vues aujourd'hui}

\newcommand{\indexkeywordsmaple }[1]{\index[default]{maple@\textbf{\large Commandes}!#1@\textcolor{red}{\texttt{#1}}|textbf}}

\newcommand{\indn }[1]{\index[default]{maple@{\large
      Notions }!#1@ #1}}

\newcommand{\indt }[1]{#1\index[default]{maple@{\large
      Touches }!#1@ #1}}


%%% Environnement des réponses du logiciel
\DefineVerbatimEnvironment{boxedverbatim}{Verbatim}{fontsize=\small,formatcom=\color{blue},fontshape=it,gobble=2,frame=single,framesep=4mm,label=\textit{\small \textcolor{black}{Réponse du logiciel}},xleftmargin=10pt,rulecolor=\color{black}}




\newcommand\Com[1]{%
\shorthandoff{;:}\textcolor{red}{{ \ttfamily #1}}\index[default]{maple@\textbf{\large Commandes}!#1@\textcolor{red}{\texttt{#1}}|textbf}}


%%% Com avec syntaxe
\newcommand\Comsi[2]{%
\shorthandoff{;:}\textcolor{red}{{ \ttfamily #1}}(\textcolor{red}{\texttt{#2}})\index[default]{maple@\textbf{\large Commandes}!#1@\textcolor{red}{\texttt{#1}}|textbf}}





%%%%%%  Commande personnelle ou bout de code

\renewcommand{\code}[1]{\textcolor{red}{\texttt{#1}}}





\newcommand{\MAPLE}{\lstset{numbers=none,language=Maple,xleftmargin=10pt,%
keywordstyle =\color{red}\usefont{OT1}{cmtt}{b}{n},basicstyle=\ttfamily\color{red},commentstyle=\normalfont\scriptsize\itshape,
    backgroundcolor=\color{0.95white},index=[2][keywords],indexstyle=[2]\indexkeywordsmaple,breaklines=true}
}

\begin{document}
\setlength{\parindent}{0pt}
\thispagestyle{empty}

\setcounter{NumLecon}{1}
         \TITREC{TD Maple }{Programmation }{0.95white}
        

\MAPLE

\begin{multicols}{2}



\SECTION{Avant de commencer}

Quelques rappels avant de travailler. Commencez chaque nouvel
exercice par un 

\begin{lstlisting}
restart;
\end{lstlisting}
 pour <<~désaffecter~>> toutes les
variables éventuellement utilisées dans un calcul précédent.

Si vous avez lancé un calcul qui a l'air de ne pas vouloir se
terminer, cliquez sur l'icône {\Large \Stopsign} qui n'est active que lorsqu'un
calcul est en cours.

Chacune de vos entrées débute après un $prompt$ \texttt{>}, se
termine par un \texttt{;}\footnote{si vous voulez que le résultat
soit affiché.} ou un \texttt{:}\footnote{si vous voulez que MAPLE
exécute sans afficher.} puis appuyez sur la touche
\Enter. Si vous voulez passer à la ligne sans valider la
ligne précédente, tapez \Shift + \Enter. Pour revenir
plus haut, utilisez la souris ou les flèches de déplacement.


\SECTION{Sept  manières de calculer 7 !}

\been



\item Bien sûr, on peut commencer par faire 

\begin{lstlisting}
7!;
\end{lstlisting}


mais le calcul de $7!$ n'est qu'un prétexte pour découvrir sur un
exemple simple la syntaxe de programmation MAPLE.

\item On pourrait alors taper 

\begin{lstlisting}
1*2*3*4*5*6*7;
\end{lstlisting} 

mais les choses
pourraient se compliquer au moment de calculer $3232!$

\item Nous allons donc utiliser une boucle $for$ avec indice
numérique : nous partons de 1, puis nous multiplions par 2, puis
nous multiplions le produit précédent par 3, etc. Cela donne


\begin{lstlisting}
p:=1: for k from 1 to 7 by 1 do p:=p*k od;
\end{lstlisting}

 Ce programme
n'est pas optimum. En fait, dans une boucle $for$, les
instructions $from$ et $by$ sont facultatives : elles valent par
défaut 1. Ici, on peut se contenter de 

\begin{lstlisting}
p:=1: for k to 7 do p:=p*k od;
\end{lstlisting} 



\begin{figure}[!h]
              \begin{DANGER}
              Que se passe-t-il si vous entrez~:

              \begin{lstlisting}
restart;
for k to 7 do p:=p*k od;
              \end{lstlisting}
               \end{DANGER}
               \end{figure}



Il reste un inconvénient : MAPLE affiche tous les
résultats intermédiaires. Rappelez-vous des rôles de \texttt{:} et
\texttt{;} puis écrivez un programme qui n'affichera que la valeur
finale.


\begin{figure}[!h]
  \begin{Idee}{incrément négatif}
    Que fait cette boule~:


\begin{lstlisting}
p:=1: for k from 7 to 1 by -1 do p:=p*k od;
\end{lstlisting}

    \end{Idee}
  \end{figure}



\item Nous aurions pu créer la liste des entiers de 1 à 7 puis
utiliser une boucle $for$ indexée cette fois par les éléments de
la liste. C'est plus compliqué, mais cela nous permet de découvrir
comment MAPLE traite les listes. Il faudra bien distinguer \bel
    \item les \textbf{ensembles} ($set$) qui sont des collections \textsl{non ordonnées} d'expressions
 toutes différentes séparées par des virgules et encadrées
 d'accolades.

\begin{lstlisting}
ens1:={2,4,1}; ens2:={2,5,8,5};
\end{lstlisting}

 On peut effectuer les opérations usuelles sur les ensembles

 \begin{lstlisting}
ens1 intersect ens2; ens1 union ens2; ens1 minus ens2;
\end{lstlisting}
 

l'ensemble vide se note \verb+{}+.



     \item les \textbf{suites} ($sequence$) qui sont des collections
     \textsl{ordonnées} d'expressions, différentes ou non,
     séparées par des virgules et encadrées ou non par des
     parenthèses.

\begin{lstlisting}
5,7,5,1,2,3;
\end{lstlisting}
     


On peut aussi utiliser les opérateurs \texttt{seq} et
     \texttt{\$} pour des suites définies par une formule explicite

 \begin{lstlisting}
seq(k^2,k=1..5);
p^2 $ p=1..5;
\end{lstlisting}



     \begin{lstlisting}
m $ 5;
seq(i^2,i=1..n);      // problème...
\end{lstlisting} 

  On peut changer un élément de la suite
     \begin{lstlisting}
j^2 $ j=1..n; 
subs(n=5,%); // remplacez % par " avec MAPLE V.4 
eval(%);
\end{lstlisting}

Les suites sont très pratiques à utiliser dans des boucles~:

\begin{lstlisting}
P:=NULL; // séquence vide
for k to 5 do P:=P,2^k od;
\end{lstlisting}

     \item les \textbf{listes} ($list$) qui sont des collections
     \textsl{ordonnées} d'expressions séparées par des virgules et
     encadrées par des crochets. La différence, c'est qu'une
     suite, en tant que juxtaposition d'expressions, est  en quelque sorte <<~en lecture seule~>>, alors
     qu'une liste est une expression en elle-même et pourra donc
     <<~subir~>> des opérations algébriques.

     Notez au passage quelques fonctions utiles
     \begin{lstlisting}
s1:=i $ i=-2..2; s2:=a,b,c,d,e;
L1:=[s1]; L2:=[s2];  // une liste est une suite entre crochets
nops(L2);     // nombre d'opérandes 
L2[3]; op(3,L2);          // extrait le 3ème opérande 
L2[3..5]; op(3..5,L2);
select (x->x>0,L1); remove(x->x<0,L1);
subs(b=32,L2); 
subsop(2=z,L1); subsop(5=NULL,L2);   // pour substituer ou supprimer un opérande 
map(cos,L2);
zip((x,y)->x+y,L1,L2);
\end{lstlisting}

\begin{figure}[!h]
  \begin{Idee}{concaténation}
    c'est une  opération extrèmement importante et  utile~:~il s'agit de
    faire de deux listes, une seule.

    \begin{lstlisting}
      L1:=[1,2,3,4];
      L2:=[a,b,c].
      L:=[op(L1),op(L2)];
    \end{lstlisting}
    \end{Idee}
  \end{figure}


% \item les \textbf{tableaux} ($array$) sont des objets plus complexes. Nous reviendrons plus tard dessus. Sachez seulement qu'une liste est un tableau d'une ligne

% \begin{lstlisting}
% T:=array(1..10);   // T est un tableau d'un ligne et de 10 colonnes
% T:=[k^2 $ k=1..10];   //  ... comme une liste
% T[3];
% \end{lstlisting}


     \el

\sm

Cela donne 
\begin{lstlisting}restart;
L:=[k $ k=1..7]: p:=1: for i to 7 do p:=p*L[i] od: 
p;
\end{lstlisting}


\item Nous pouvons utiliser une boucle $while$
\begin{lstlisting}restart;
p:=1: k:=1: while k<7 do k:=k+1: p:=p*k od:
p;
\end{lstlisting}

\item C'est bien beau, mais que ferons-nous quand il faudra
calculer 32! ou 3232! et tous les autres~? Il faudrait créer un
programme (on dira une \textbf{procédure}) qui donne $n!$ pour
tout entier naturel $n$. 
\begin{lstlisting}restart; // je ne vous le dirai plus //
fact:=proc(n)
local p,k;  // nous aurons besoin de variables locales i.e. internes à la procédure  
p:=1; 
for k to n do p:=p*k od; 
end:  // termine la procédure 

fact(32);
\end{lstlisting}

\item Le plus beau pour la fin : la \textbf{procédure récursive},
qui s'appelle elle-même 
\begin{lstlisting}
factr:=proc(n)
if n=0 then 1 // une boucle $if...then...else$ pour régler le cas de 0! 
else
n*factr(n-1) fi;  // symbolise la fin de la boucle 
end:

factr(32);
\end{lstlisting} 

En fait, ce mécanisme correspond à une suite
numérique qui s'écrirait mathématiquement $u_n=n\times u_{n-1}$.



\een


\SECTION{En guise d'échauffement...}


\exot{Partie entière} Déterminez une procédure \code{E:=proc(x)} qui, à un réel
positif $x$, associe sa partie entière.

\exot{Valeur absolue} Déterminez une procédure \code{ab:=proc(x)} qui, à un réel
$x$, associe sa valeur absolue.

\exot{Moyenne} Déterminez une procédure permettant de calculer la moyenne
des éléments d'une famille de nombres réels.

% \exot{Suite} Pour $n\in\bbn^*$, on considère $a_n=1+1/n$ et
% $b_n=a_n^{{a_n}^{.{^{.{^{.{^{a_n}}}}}}}}$, avec <<~$n$ fois
% $a_n$~>>.

% Par exemple, $b_2=(3/2)^{3/2}$.

% \been
% \item Déterminez une procédure qui calcule $b_n$ à partir de $n$.
% \item On admet que la suite $(b_n)$ est décroissante et converge
% vers 1. Déterminez une instruction qui permette de déterminer le
% plus petit entier $n$ tel que $b_n\ie 1,001$.\een




\exot{Somme} Vous savez peut-être que la suite $(S_n)_{n\in\bbn}$ de terme
général
$$S_n=\ds\sum_{k=0}^n\fr{1}{k!}$$
est croissante et converge vers $e$. Nous l'admettrons dans cet
exercice. \been
\item Déterminez une procédure \code{S=proc(n)} qui, à un entier
naturel $n$, associe $S_n$. N'oubliez pas les gages habituels :
vous n'utiliserez ni la fonction prédéfinie \code{sum}, ni les
procédures calulant $n!$ vues précédemment.
\item Déterminez une procédure \code{seuil:=proc(p)} qui, à un
entier naturel $p$, associe le plus petit entier naturel $n$ tel
que $|S_n-e|\ie10^{-p}$. Vous aurez besoin de savoir que $e$ se
dit \Comsi{exp}{1} en MAPLE. \een

\exot{\'Equation du second degré} Déterminez une procédure \code{sol:=proc(a,b,c)} qui, à une
équation $ax^2+bx+c=0$, associe son ensemble des solutions.

\exot{test sur une liste} Déterminez une procédure \code{test:=proc(L)}, \code{L}
étant une liste d'entiers, qui teste si ses éléments forment une
suite croissante.

\exot{Test d'appartenance} Créez une procédure pour tester l'appartenance d'un point dont on connaît
les coordonnées à une courbe donnée.


\exot{Retour sur l'oscillateur amorti}

Vous vous souvenez du problème de l'oscillateur amorti du TD précedent~:

\[x(t)==\E^{-0,1t}\left(\frac{2}{3}\sin(10t)+\frac{4}{5}\cos(10t)\right)\]

Nous avions  cherché les  trois premières valeurs  positives de  $t$ qui
annulaient la vitesse $v(t)$. Déterminez une procédure qui donne les $n$
premières valeurs positives de $t$ qui annulent la vitesse $v(t)$.

% Vous connaissez tous la formule du triangle de Pascal.
% Déterminez donc une procédure récursive \texttt{c:=proc(n,p)} qui
% calcule les coefficients du binôme. Testez avec \texttt{c(32,3)}
% et \texttt{c(3,32)}.



\SECTION{\twonotes \ Dessinons en programmant \dots \  \twonotes }



\exot{Spirale}

Comment dire à MAPLE de dessiner cette spirale ?




\begin{center}
\includegraphics{Nombres.2}
\end{center}


Pour ceux qui n'ont pas eu l'audace de choisir la spécialité maths l'année dernière, demandez à vos voisins ce qu'est une similitude.

Vous serez ensuite amenés à utiliser des complexes. Voici quelques clés utiles~:

\begin{lstlisting}
z:=2+3*I;
Re(z); 
Im(z);
Z_1:=z*exp(I*Pi/4);
Z_2:=Z_1*sqrt(13);
m:=[Re(z),Im(z)];
M_1:=[Re(Z_1),Im(Z_1)];
M_2:=[Re(Z_2),Im(Z_2)];
plot([m,M_1,M_2]);
\end{lstlisting}

Et voici un canevas\footnote{il y a bien d'autres moyens d'y arriver.} pour produire la figure~:

% 
 \begin{lstlisting}
z:=-I:P:=[Re(z),Im(z)]:

for i from 2 to 7 do
   z:=...?
   P:=...?
od:

plot([P]);
 \end{lstlisting}


Nous  nous sommes contentés  de tracer  6 côtés.  Il serait  pratique de
fabriquer une procédure \verb+escargot:=proc(n)+ pour fabriquer un polygone de n côtés.
% 











\SECTION{Les objets MAPLE - \'Etude des branches infinies}

Pour vous, $x$ est un réel, $n$ un entier, $[1,2]$ un intervalle, etc. Pour MAPLE, cela n'a rien d'évident : il faut parfois tout lui expliquer.

Pour illustrer notre propos, nous allons écrire un programme étudiant les branches infinies d'une fonction numérique. Un bref rappel de cours n'est peut-être pas inutile : schématisez-le sous forme d'un arbre.


%  \begin{center}
%  \includegraphics[width=\textwidth]{limfonc.18}
%  \end{center}

Il va falloir utiliser pas mal de boucles if qui correspondent à chaque embranchement de l'arbre. Il va d'abord falloir demander à MAPLE de calculer des limites. Il sait faire :

\begin{lstlisting}
limit(sin(x)/x,x=0); limit(1/sqrt(x),x=0);
limit(sin(x)/x,x=infinity); limit(sin(x),x=infinity);
\end{lstlisting}

Maintenant, il va falloir tester la réponse :$a$ est réel ou infini ? La limite existe ou n'existe pas ? Pour cela, commençons par explorer la fonction \texttt{whattype(expression)}

\begin{lstlisting}
whattype(32); whattype(1/2); 
whattype(x->2*x); whattype(limit(sin(x),x=0));
\end{lstlisting}

\begin{lstlisting}
whattype(limit(32*x,x=infinity)); whattype(limit(sin(x),x=infinity));
\end{lstlisting}

Ensuite, il existe une fonction qui teste si une expression est d'un type déterminé :\texttt{type(expression,domaine)}.

\begin{lstlisting}
type(32,integer); type(32.1,integer);
type(limit(sin(x),x=infinity),infinity);
\end{lstlisting}

Nous allons maintenant construire une procédure \texttt{branche:=proc(f)} Qui renvoie l'éventuelle branche infinie de la fonction $f$. Elle contiendra deux variables locales $a$ et $b$. Je vous livre le début

\begin{lstlisting}
branche:=proc(f)}
local a,b;
a:=limit(f(x)/x,x=infinity):
if type(a,..)=true then lprint(`pas d'asymptote`);
elif type(a,infinity)=true then lprint(`pas d'asymptote`);
\end{lstlisting}

\`A vous d'imaginer la suite...
Pour demander à MAPLE d'envoyer un message mélangeant du texte et un résultat de calcul, on peut utiliser la commande 
\begin{lstlisting}
printf(`asymptote d'equation y=%f x+%f`,a,b);
\end{lstlisting}
où l'objet flottant \texttt{f} (c'est à dire le réel \texttt{f}) va prendre les valeurs de $a$ et $b$.

%\Monster{$\sum_{k=0}^{n}\fr{\int_0^{\pi}\sqrt{x^2}}{\E^{\efr{\I\pi}{12}}}$}

% \pagebreak

% \printindex


\end{multicols}
\end{document}


