% \thispagestyle{empty}
% \input{/home/moi/Lycee/makdevoir}
% 
% \thispagestyle{empty} \setlength{\parindent}{0pt}
% 
% 
% 
% \begin{document}
% 
% \setlength{\parindent}{0pt}
% 
% 
% 
% \textsl{Lycée Clemenceau - PCSI 2\hfill Année scolaire 2005 -
% 2006}
% 
% \bigskip
% 
% \begin{center}
% 
% \Large{\textbf{COLLES MAPLE N°1\&2}}
% 
% \end{center}
\documentclass[fourier]{Polymaths}

\usepackage[height=240mm,width=173mm,a4paper,twoside]{geometry}

%\usepackage{bbding,xlop}
\usepackage{wasysym}

\renewcommand\thesubsection{}

\usepackage[ps2pdf,colorlinks=orange]{hyperref}

\entete{ Colle MAPLE n°1 \& 2  }{Prise en main de MAPLE}{Lycée Clemenceau - PCSI 2 }

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



\usepackage{listings}

\lstloadlanguages{XCAS}
\lstset{numbers=none,language=XCAS,%
keywordstyle =\color{blue}\bfseries,%basicstyle=\sffamily,%\small,
    backgroundcolor=\color{0.9white}}
   






\begin{document}

\thispagestyle{empty}
\setlength{\parindent}{0mm}
\newcolumntype{A}{>{\arraybackslash}X}

\TITRE{I}{Colle MAPLE I \& II}{Prise en main de MAPLE }{}{Prise en main de MAPLE}{notice.eps}
\vspace{1cm}










\SECTION{Avant de commencer}

MAPLE, comme vous le savez, contient plus de $2\,500$  fonctions
pré-programmées. \'Evidemment, il est absolument impossible de les
aborder toutes en classes préparatoires. Le but de nos TD sera
plutôt, dans un premier temps, de mettre en pratique quelques
notions de base sur la programmation en prenant pour sujets des
fonctions mathématiques simples : nous fabriquerons ainsi <<~à la
main~>>, de nombreuses fonctions qui sont pourtant déjà
pré-définies en langage MAPLE. Il s'agira en fait de découvrir, à
travers des exercices concrets, la syntaxe MAPLE et des
algorithmes de base. Ceci nous permettra, dans un deuxième temps,
d'utiliser les formidables capacités de MAPLE en calcul formel
pour travailler, sous un autre angle qu'en cours, les
merveilleuses notions mathématiques que  vous allez aborder avec
madame Gornet.
L'inconvénient de MAPLE, c'est que ce logiciel n'est pas libre : on ne peut pas savoir comment il marche....et il coute cher. Vous pouvez travailler chez vous sur deux logiciels gratuits : MuPAD et Xcas. Le deuxième, entièrement libre, a l'avantage de traduire les programmes MAPLE assez simples en langage TI89, ce qui peut intéresser certains d'entre vous...
\sm

Un de vos fidèles compagnons pendant ces TD sera le \texttt{?} : en cas de doute sur une fonction MAPLE, il suffira de taper


\begin{lstlisting}
?lafonction;
\end{lstlisting}


 pour voir apparaître une aide très complète
avec de nombreux  exemples d'utilisation\footnote{Vous découvrirez
en même temps pourquoi vous avez été en cours d'anglais depuis
tant d'années.}. Pour revenir à la feuille de calcul, un appui
simultané sur \textit{Ctrl} et $F4$ fera l'affaire.



Quelques conseils 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 STOP 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
\textit{Entrée}. Si vous voulez passer à la ligne sans valider la
ligne précédente, tapez $Shift$ + \textit{Entrée}. Pour revenir
plus haut, utilisez la souris.


\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} 

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.

\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 

\begin{lstlisting}
{ }
\end{lstlisting}



     \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...#
j**2 $ j=1..n;          # plus de problème #
\end{lstlisting} 

  On peut changer un élément de la suite
     \begin{lstlisting}
subs(n=5,'');       #remplacez '' par % dans les versions  ultérieures à MAPLE V.4 #
eval('');
\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}

\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 meilleur 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 \texttt{E:=proc(x)} qui, à un réel
positif $x$, associe sa partie entière.

\exot{Valeur absolue} Déterminez une procédure \texttt{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 \texttt{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 \texttt{sum}, ni les
procédures calulant $n!$ vues précédemment.
\item Déterminez une procédure \texttt{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 \texttt{exp(1)} en MAPLE. \een

\exot{\'Equation du second degré} Déterminez une procédure \texttt{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 \texttt{test:=proc(l)}, \texttt{l}
étant une liste d'entiers, qui teste si ses éléments forment une
suite croissante.

\exot{Coefficients du binôme} 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}


% 
% \begin{lstlisting}
%  z:=array(1..7):
%  z[1]:=-I:
%  for i to 6 do z[i+1]:=z[i]*exp(-I*Pi/4)*sqrt(2):od:
%  M:=array(1..7):
%  for j to 7 do M[j]:=[Re(z[j]),Im(z[j])]; od:
%  P:=[M[k] $ k=1..7]:
%  plot(P);
% \end{lstlisting}
% 











\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 de 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}}}$}

\end{document}