\documentclass[10pt,a4paper,landscape]{report}
%\usepackage[height=250mm,width=183mm]{geometry}
\usepackage[width=260mm,height=178mm]{geometry}
\usepackage{preambule}
\usepackage[upright]{fourier}
\usepackage[boldsans]{ccfonts}
\usepackage{beton,euler,luximono}
\usepackage{bbding}
 \usepackage{wasysym,marvosym,keystroke}

\graphicspath{{/home/moi/Figures/}}
\entete{TD Maple n°1}{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\small\itshape,breaklines=true,frame=trBL,framerule=1pt,framesep=4pt,rulesep=1pt,backgroundcolor=\color{white}}
}


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

% \setcounter{NumLecon}{0}
%          \TITREC{TD Maple }{Initiation }{0.9white}
        

\begin{center}
  \fbox{\vtabplus \huge \bfseries TD MAPLE n°1 \hspace{5cm} PROGRAMMATION}
\end{center}


\vspace{1cm}


\setlength{\columnsep}{20pt}
\begin{multicols}{2}

\maple 

\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 \verb+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
\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{Listes et séquences}



\subsection{Listes}

Les  listes  sont un  type  de  variable  particulier que  peut  manipuler
MAPLE.  Une  liste se  présente sous la  forme d'une suite  d'objets
séparés par des virgules entre crochets~:

\begin{lstlisting}
> L:=[1,2,a,g,maman,ln(5),3/2,x->3*x+2,[7,9]]
\end{lstlisting}

Cette suite est ORDONNÉE. Ses éléments sont donc numérotés.
On peut en extraire un élément particulier~:

\begin{lstlisting}
> L[5]
\end{lstlisting}


ou bien tous les éléments de la liste~:

\begin{lstlisting}
op(L)
\end{lstlisting}

ou bien une sous-liste~:

\begin{lstlisting}
> L[3..6];
\end{lstlisting}


On peut connaître la taille d'une liste~:

\begin{lstlisting}
> nops(L);
\end{lstlisting}

On peut ajouter un élément à une liste~:

\begin{lstlisting}
> L:=[op(L),nouveau]
\end{lstlisting}


On peut \emph{concaténer} deux listes~:

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



La liste vide se note~:

\begin{lstlisting}
> V:=[];
> nops(V);
\end{lstlisting}

On peut  effectuer des  opérations sur  une liste car  c'est un  type de
variable comme un autre~:


\begin{lstlisting}
> S:=L1+[op(L2),d];
> P:=3*L1;
\end{lstlisting}


\subsection{Les séquences}

Elles ressemblent aux listes mais sans les crochets. La différence majeure
est pourtant  qu'on ne peut pas  créer des séquences  de séquences alors
qu'on peut créer des listes de listes.

Plus accessoirement,  on peut modifier  un élément d'une liste  à l'aide
d'une affectation mais ce n'est pas possible pour une séquence~:

\begin{lstlisting}
> S:=a,b,c,d,e,f;
> S[3];
> S[3]:=4;
> L:=[S];
> L[3]:=4;
> L;
\end{lstlisting}


En général, elles servent à fabriquer des listes...


\begin{lstlisting}
> S1:=10,20,30,40,50,60;
> S2:=seq(10*k,k=3..10);
> S3:=10*k $ k=2..9;
> S4:= m $ 5;
\end{lstlisting}




\section{Tests}



\subsection{Expressions booléennes}

Une algèbre de Boole est un  ensemble contenant deux éléments et muni de
deux lois de composition interne ET et OU.

En informatique, un  booléen est un type de  variable à deux états~:~\og
true\fg{} et \og false\fg{} sur MAPLE.

Les  opérateurs logiques  sont \verb+and+  et  \verb+or+. Il  y a  aussi
\verb+not+ qui donne la négation.

Par exemple~:

\begin{lstlisting}
> (3>2) and (2=5);
> (3>2) or (2=5);
> (3>2) and not (2=5);
\end{lstlisting}

On   peut   tester   l'ordre    et   l'égalité   avec   des   opérateurs
relationnels~:~\texttt{<, <=, >, >=, =, <>}.

Quand  une   expression  ne   contient  pas  \verb+and+,   \verb+or+  ou
\verb+not+, il faut utiliser \verb+evalb+ ou \verb+is+~:



\begin{lstlisting}
> evalb(3>2);
\end{lstlisting}

%\begin{figure}[!h]
  \begin{DANGER}[type de nombre]
    On  ne  peut  comparer   que  des  nombres  de  type  \verb+numeric+
    (i.e. \verb+integer+, \verb+float+ et \verb+fraction+)~:

\begin{lstlisting}
> evalb(3>2.);
> evalb(3>7/2);
> evalb(sqrt(2)>1);
> evalb(sqrt(2.)>1);
\end{lstlisting}
    \end{DANGER}
%  \end{figure}





\subsection{\texttt{if...then...else}}

On  utilise   la  valeur  d'un   test  pour  exécuter   une  instruction
conditionnelle dont la syntaxe est~:

\begin{center}

  \textbf{if} condition \textbf{then} instruction1 \textbf{else} instruction2 \textbf{fi};
\end{center}

Par exemple~:

\begin{lstlisting}
> if (3>2) then print('bonjour') else print('salut') fi;
> if (3<2) then print('bonjour') else print('salut') fi;
\end{lstlisting}



On peut écrire des instructions conditionnelles en cascade~:

\begin{center}

  \textbf{if}  condition1  \textbf{then} instruction1  \textbf{elif}
  condition2 \textbf{then} instruction2 \textbf{else} instruction3 \textbf{fi};

\end{center}


Par exemple~:

\begin{lstlisting}
> a:=1; b:=1; c:=1;

> if (b^2-4*a*c>0)
     then print(`2 solutions réelles`)
  elif (b^2-4*a*c=0)
     then print(`1 solution réelle`)
     else print(`2 solutions complexes conjuguées`)
  fi;
\end{lstlisting}



\section{Procédures}

Une  procédure est une  fonction à  la syntaxe  précise dépendant  de la
donnée d'une série d'arguments et d'une série d'instructions.

La syntaxe générale est~:

\begin{lstlisting}
> nom:=proc(argument1::type1,argument2::type2,.....)
  local var1, var2,... ;
  instructions
  end:
\end{lstlisting}


Les principaux  types sont \verb+float+,  \verb+integer+, \verb+negint+,
\verb+nonnegint+, \verb+fraction+, \verb+list+, etc.

Consultez l'aide~:~\verb+?type;+

Les variables locales sont celles  introduites dans la procédure et dont
les noms seront \og désaffectés\fg{} à la fin de la procédure.


\begin{figure}[!h]
  \begin{DANGER}[première ligne]
    Pas de point-virgule sur la première ligne contenant \verb+proc+~!
    \end{DANGER}
  \end{figure}

Par exemple~:

\begin{lstlisting}
> Table:=proc(n::posint)
  local T,k;
  T:=[seq(n*k,k=1..10)];
  printf("La table de %a est %a",n,T)
  end:
\end{lstlisting}

Vous pourrez regarder la  syntaxe de \verb+printf+. L'usage des \verb+%a+
indique qu'on va les remplacer  dans l'ordre par les variables formelles
qui sont listées après les  guillemets. Pour avoir des nombres flottants
on utilise \verb+%f+.


Par exemple, pour obtenir la table de 5 on tape~:

\begin{lstlisting}
> Table(5);
\end{lstlisting}


On a souvent besoin du résultat  d'une procédure et la petite phrase \og
pour faire joli\fg{} peut être gênante.

On préférera une procédure de cette forme~:

\begin{lstlisting}
> Table:=proc(n::posint)
  local k;
  RETURN([seq(n*k,k=1..10)])
  end:
\end{lstlisting}

On peut ainsi afficher le deuxième élément de la table de 5~:

\begin{lstlisting}
> Table(5)[2];
\end{lstlisting}

Que donne \verb+Table(-5)+~?

On peut utiliser une structure conditionnelle~:

\begin{lstlisting}
> parite:=proc(n::integer)
   if (irem(n,2)=0)
     then RETURN(`pair`)
     else RETURN(`impair`)
   fi
  end:
\end{lstlisting}



À votre avis, que renvoie \verb+irem(a,b)+ ?







\section{Programmation impérative}

C'est le type de programmation  le plus répandu. On agit directement sur
la mémoire de l'ordinateur pour essayer de l'économiser à l'aide d'affectations.  Nous verrons
que cela peut poser certains problèmes.


\subsection{Boucles itératives}

On veut effectuer une action  un certain nombre de fois~;~on utilise une
instruction du type~:

\begin{lstlisting}
for var from debut to fin by increment do 
    instructions;
od; 
\end{lstlisting}


Par exemple~:

\begin{lstlisting}
> Somme:=proc(n::posint)
  local S,k;
  S:=0;
   for k from 1 to n by 1 do
     S:=S+2*k-1; 
   od;
 RETURN(S)
 end:
\end{lstlisting}



On peut arrêter  l'itération dès qu'une condition a  été réalisée (et se
passer du \verb+to+)~:


\begin{lstlisting}
> Produit:=proc(n::posint)
  local P,k;
  P:=1;
   for k from 1 while P<n do
     P:=P*k; 
    print(k,P);
   od;
 end:
\end{lstlisting}

Expliquez....


On peut même se passer du \verb+for+~:

\begin{lstlisting}
> quoquo:=proc(a::nonnegint,b::posint)
  local q;
  q:=1;
    while q*b<=a do
      q:=q+1;
    od;
  RETURN(q-1);
  end:
\end{lstlisting}

Expliquez...

\section{Programmation récursive}


On créé des procédures qui s'appellent elles-mêmes, un peu selon le 
principe des suites  définies par une relation $u_{n+1}=f(u_n)$ mais
de manière plus générale.


Reprenons un exemple du paragraphe précédent~:

\begin{lstlisting}
> Somme_r:=proc(n::posint)
    if n=1 then 1
    else Somme_r(n-1)+2*n-1;
    fi;
end:
\end{lstlisting}

Il  faut connaître  un  cas simple  et  un moyen  de  simplifier un  cas
compliqué...

On   peut   obtenir   les   résultats   intermédiaires   avec   l'option
\verb+remember+ et en demandant le quatrième opérande de la procédure~:

\begin{lstlisting}
> Somme_r:=proc(n::posint)
    option remember;
    if n=1 then 1
    else Somme_r(n-1)+2*n-1;
    fi;
end:
\end{lstlisting}

Puis~:

\begin{lstlisting}
Somme_r(9);
op(4,eval(Somme_r));
\end{lstlisting}


Cette option est malgré tout plus intéressante dans le cas de récursions
multiples~:~les calculs  intermédiaires étant  stockés, ils n'ont  pas à
être recalculés et cela gagne du temps.

Par  exemple,  pour la  suite  de  Fibonacci $u_{n+2}=u_{n+1}+u_n$  avec
$u_0=u_1=1$~:

\begin{lstlisting}
> fibo:=proc(n::nonnegint)
   option remember;
   if n=0 then RETURN(1);
     elif n=1 then RETURN(1);
     else RETURN(fibo(n-1)+fibo(n-2));
   fi
  end:
\end{lstlisting}


Sans l'option \texttt{remember}, \verb+fibo(30)+  prend pas mal de temps
mais est instantané quand on l'ajoute~:~à ne pas oublier...


\section{Exercices}



\exot{Partie entière}

Trouver un algorithme récursif  puis un algorithme impératif déterminant
la partie entière d'un entier.

\begin{itemize}
\item dans le cas récursif, on  se souviendra que la partie entière d'un
  nombre  appartenant à  $[0;1[$  est nulle,  que  $[x]=1+[x-1]$ et  que
  $[x]=-1+[x+1]$~;
\item dans le  cas impératif, on partira de zéro et  on se promènera sur
  l'axe des réels en faisant des pas de longueur 1.
\end{itemize}



\exot{Calculs de sommes}


Donner des  procédures impératives et récursives  prenant comme argument
une  fonction $f$  un  entier $n_0$  et  un entier  $n$  et qui  calcule
$\ds\sum_{k=n_0}^nf(k)$.



\exot{Maximum}

Donner des procédures impératives  et récursives donnant le maximum d'une
liste de nombres réels quelconques.



\exot{Tête et queue}

La tête d'une liste est son premier élément. La queue d'une liste est la
sous-liste  créée  en  lui  coupant  la  tête.  Donnez  deux  procédures
\verb+tete(liste)+ et \verb+queue(liste)+.
\exot{Test de croissance}


Donner des procédures impératives et récursives déterminant si une liste
donnée est croissante. On pourra éventuellement utiliser \verb+tete+ et \verb+queue+.

\exot{Dichotomie}


Pour résoudre une équation  du type $f(x)=0$, on recherche graphiquement
un intervalle $[a,b]$ où la fonction semble changer de signe.

On note ensuite $m$ le milieu du segment $[a,b]$. On évalue le signe de $f(m)$.

Si c'est  le même  que celui  de $f(a)$ on  remplace $a$  par $m$  et on
recommence.  Sinon, c'est $b$  qu'on remplace  et on  recommence jusqu'à
obtenir la précision voulue.

Donner  une procédure  récursive puis  une procédure  impérative prenant
comme arguments une fonction $f$, les bornes de l'intervalle d'étude $a$
 et $b$ et une précision de calcul $eps$.

\exot{Méthode des parties proportionnelles}


Il peut  être parfois plus efficace  de ne plus considérer  le milieu de
$[a;b]$ mais l'abscisse  de l'intersection de la droite  passant par les
points  $(a,f(a))$  et $(b,f(b))$  avec  l'axe  des abscisses.  Modifiez
légèrement vos procédures précédentes et comparez.



\exot{Algorithme de Héron}

\textsc{Héron} d'Alexandrie a trouvé une méthode permettant de déterminer
une approximation de la racine  carrée d'un nombre positif vingt siècles
avant l'apparition des ordinateurs.

Si  $x_n$  est une  approximation  strictement  positive  par défaut  de
$\sqrt{a}$, alors $a/x_n$ est  une approximation par excès de $\sqrt{a}$
(pourquoi~?) et vice-versa.

La    moyenne   arithmétique    de   ces    deux    approximations   est
$\frac{1}{2}\left(x_n+\frac{a}{x_n}\right)$  et constitue  une meilleure
approximation que les deux précédentes.

On  peut  montrer c'est  une  approximation  par  excès (en  développant
$\left(x_n-\sqrt{a}\right)^2$ par exemple).

On obtient  naturellement un algorithme... Donnez  une version récursive
puis impérative prenant en argument  le nombre dont on cherche la racine
carrée, une première approximation $x_0$ et une précision \verb+eps+.


\exot{Calcul de 300 décimales de $\pi$}


Posons $e_n=1+\frac{1}{1!}+\frac{1}{2!}+\cdots+\frac{1}{n!}$

Alors on a aussi
\[e_n=1+1+\frac{1}{2}\left(1+\frac{1}{3}\left(1+\frac{1}{4}\left(\cdots \left(\frac{1}{n-1}\left(1+\frac{1}{n}\right)\right)\right)\right)\right)\]


Un           exercice           classique           montre           que
$e-e_n \ie \frac{n+2}{n+1}\frac{1}{(n+1)!}$.

Ainsi,   pour  $n=167$,   on   obtiendra  $300$   bonnes  décimales   au
moins~:~trouvez-les~!


\exot{Méthode des rectangles}

Trouvez une version récursive  et une version impérative d'un algorithme
calculant  une   approximation  d'une  intégrale  par   la  méthode  des
rectangles étant donné $f$, les bornes $a$ et $b$ et \texttt{dx}

\end{multicols}

% \pagebreak

% \printindex

\end{document}
%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: 
