\documentclass[11pt,landscape]{report}
\usepackage[width=250mm,height=183mm]{geometry}
\usepackage{preambule}
\usepackage[upright]{fourier}


\entete{Programmation XCAS 3- \NomLecon }{\thesec - \NomSection}{Lycée Jean Perrin -
 Atelier de programmation}


\lstset{numbers=none,language=XCAS,xleftmargin=10pt,%
keywordstyle=\color{0.2white}\usefont{OT1}{cmtt}{b}{n},basicstyle=\ttfamily\footnotesize\color{0.2white},%
commentstyle=\normalfont\scriptsize\slshape,breaklines=true,backgroundcolor=\color{0.9white}}







\graphicspath{{/home/moi/Photos/Maths/}{/home/moi/Figures/FigSTI/}}

\begin{document}

\thispagestyle{empty}
\setlength{\parindent}{0mm}

\setcounter{NumLecon}{2}

\TITRE{}{Programmation}{Boucles et tests}{}{}{nains.eps}
\vspace{1cm}



\begin{multicols}{2}


\section{Sept  manières de calculer \mg{$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 Xcas.

\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.  Notons \texttt{p} le
produit et \texttt{k} l'entier qui part de 1 et qui augment d'une unité jusqu'à atteindre 7. Cela donne

\begin{lstlisting}
 p:=1; for( k:=1; k<=7; k:=k+1)\{p:=p*k;\}
\end{lstlisting}

 
\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 Xcas traite les listes. Il faudra bien distinguer \bel
    \item les \textbf{ensembles} ($set$) qui sont des collections <<~ \textsl{non classées}~>> d'expressions
 toutes différentes séparées par des virgules et encadrées
 d'accolades.
\begin{lstlisting}
 ens1:=set[2,4,1]; ens2:=set[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}
 set[]
\end{lstlisting}

     \item les \textbf{suites} ($sequence$) qui sont des collections
     <<~\textsl{classées}~>>  d'expressions   (c'est  à  dire   avec  un
     premier, un deuxième, etc.), 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)
\end{lstlisting}

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

     
\begin{lstlisting}
 m$5
\end{lstlisting}

     \item les \textbf{listes} ($list$) qui sont des collections
     \textsl{classé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;
\end{lstlisting}

     
\begin{lstlisting}
 l1:=[s1]; l2:=[s2]; // une liste est une suite entre crochets
\end{lstlisting}

     
\begin{lstlisting}
 size(l2); //nombre d'opérandes 
\end{lstlisting}

     
\begin{lstlisting}
 l2[3]; l2[0]; // notez bien que le premier opérande porte le numéro 0 
\end{lstlisting}

     
\begin{lstlisting}
 l2[2..4]
\end{lstlisting}

     
\begin{lstlisting}
 select (x->x>0,l1); remove(x->x<0,l1);
\end{lstlisting}

     
\begin{lstlisting}
  subsop(l1,2=32); subsop(l2,'3=NULL'); //pour substituer ou supprimer un opérande 
\end{lstlisting}

     
\begin{lstlisting}
 map(l2,cos);
\end{lstlisting}

     
\begin{lstlisting}
 zip((x,y)->x*y,l1,l2);
\end{lstlisting}


     \el

\sm

Cela donne 
\begin{lstlisting}
 rm_all_vars()} 
 l:=[k$( k=1..7)]; p:=1; for( k:=1; k<=7; k:=k+1){p:=p*l[k];} 
\end{lstlisting}

\item Nous pouvons utiliser une boucle $while$

\begin{lstlisting}
 rm_all_vars()
 p:=1; k:=1; while( k<7){k:=k+1; p:=p*k}  
\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}
rm_all_vars() // je ne vous le dirai plus

fact(n):={\\ local p,k; // nous aurons besoin de variables locales i.e. internes à la procédure 
  p:=1; 
  for( k:=1; k<= n;k:=k+1){ p:=p*k ;} 
} // termine la procédure

\end{lstlisting}


\begin{lstlisting}
 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(n):={
  if (n==0){1} // un test $if...else$ pour régler le cas de 0!
  else{n*factr(n-1)}
}
\end{lstlisting}

\begin{lstlisting}
 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{\`A vous de jouer...}

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

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

\exot{Moyenne} Déterminez une procédure \texttt{moy(l)} permettant de calculer la moyenne
des éléments d'une liste \texttt{l}  de nombres réels. Il faut commencer
par calculer la somme des opérandes de la liste puis diviser par le nombre d'opérandes de la liste.





% \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(n)} qui, à un entier
% naturel $n$, associe $S_n$. 
% \item Déterminez une procédure \texttt{seuil(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 Xcas. \een

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


\end{multicols}


% \exot{ \'Etude des branches infinies}
% Nous  allons écrire un  programme étudiant  les branches  infinies d'une
% fonction numérique.  Voici un bref rappel de cours :
% si $f(x)/x$ admet une limite finie $a$ en l'infini et si $f(x)-ax$ admet
% une limite finie $b$, alors $\CR_f$ admet la droite $D$ d'équation $y=ax+b$ comme asymptote au voisinage de l'infini.


% Il va falloir utiliser pas mal de tests if. Il va d'abord falloir demander à XCAS 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);}

% % Ensuite, il va falloir tester la réponse : $a$ est réel ou infini ? La limite existe ou n'existe pas ? 

% % Nous allons maintenant  construire une procédure \texttt{branche(f)} qui
% % renvoie  l'éventuelle asymptote  de la  courbe $\CR_f$.  Elle contiendra
% % deux  variables  locales $a$  et  $b$.   Nous utiliserons  l'instruction
% % \texttt{return} qui quitte la procédure et évite les \texttt{else}. Je vous livre le début

% % 
% \begin{lstlisting}
%  branche(f):=\{}
% % 
% \begin{lstlisting}
%  local a,b;}
% % 
% \begin{lstlisting}
%  a:=limit(f(x)/x,x=+infinity):}
% % 
% \begin{lstlisting}
%  if (a==undef) return "pas d'asymptote";\\
% % $\vdots$\\
% % return "asymptote d'equation y=("+a+")*x+"+b;\\
% % \}}
% % \`A vous d'imaginer ce qui manque...

% % On rentrera ensuite par exemple \texttt{branche(x->(x\p 3+9)/(x\p 2-1))}

% % \exot{Autres pistes...}
% % \'A  vous  d'imaginer un  programme  qui  étudie  la dérivabilité  d'une
% % fonction  $f$ en  un  point, le  sens  de variation  d'une fonction,  la
% % résolution de l'équation $x^3+px+q$ à la Bombelli-Cardano, etc.

\end{document}