\setcounter{chapter}{1}
\chapterimage{scilab}
\chaptertext{Scilab  est un  logiciel libre,  multiplateforme  de calcul
numérique  orienté  informatique  industrielle et  ingénierie.  Certains
d'entre vous l'utiliseront peut-être dans leurs TIPE...

Nous l'utiliserons pour notre part en analyse numérique et en probabilités.
}



\scilab
\chapter{Scilab for dummies}





\section{Avant de commencer}

SCILAB est téléchargeable rapidement à l'adresse suivante:

\begin{center}
  
\href{http://www.scilab.org/}{http://www.scilab.org/}
\end{center}


Le  logiciel  est accompagné  d'une  documentation  très complète.  Vous
pouvez compléter votre apprentissage  en parcourant «~Le guide du calcul
avec des logiciels libres~» paru chez Dunod en 2008 :-)

De nombreux TP sont présents sur le site de Scilab  référencé ci-dessus.


Il  faut savoir  que scilab,  comme  matlab, est  basé sur  un noyau  de
fonctions   en   Fortran   ou   en   C  déjà   compilées   donc   rapides
d'utilisation.  En revanche,  tout ce  que vous  créerez  vous-même sera
interprété  ce   qui  ralentira  l'exécution  par   rapport  à  d'autres
langages. De  plus, la gestion  des nombres n'est pas  toujours optimale
car ils sont codés en complexes double précision ce qui peut être lourd.

\section{Scilab comme super-calculatrice}

\subsection{Les opérations de base}

Scilab peut fonctionner de manière classique:

%@Commande-1
\begin{lstlisting} 
 -->  3+2
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{5}\)\\ 
%  \vspace{0.2cm}

Si on ajoute un «;~» à la  fin de la ligne, celle-ci est lue par SCILAB
mais le résultat n'est pas affiché:~c'est le mode silencieux.

Mais Scilab  fait du calcul  numérique;~les résultats sont  donc donnés
sous forme de \emph{nombres à virgule flottante}:

%@Commande-2
\begin{lstlisting} 
 -->  1+sqrt(2) 
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{2.4142136}\)\\ 
%  \vspace{0.2cm}

sachant  que  \texttt{sqrt} désigne  la  racine  carrée  (SQare RooT  en
anglais...).

\begin{remarque}[Navigation et historique]
    On ne  peut pas recommencer  un calcul en  plaçant le curseur  de la
    souris sur une ligne précédente  déjà évaluée. En revanche, avec les
    touches  \PgUp et  \PgDown, on  peut naviguer  dans  l'historique et
    réafficher des commandes précédentes.
  \end{remarque}
  
Par défaut, les  résultats sont affichés avec 10  caractères. Pour avoir
plus de précision, on utilise \texttt{format}:

%@Commande-3
\begin{lstlisting} 
 --> format(20);  1+sqrt(2)
 \end{lstlisting}
 \hspace{15mm}\(\mathtt{2.41421356237309492}\)\\ 
  \vspace{0.2cm}

On peut  vouloir utiliser l'écriture scientifique  d'un nombre:~il faut
préciser l'option \texttt{'e'}:


%@Commande-5
\begin{lstlisting} 
 -->  format('e',20); 1+sqrt(2)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{2.4142135623731D+00}\)\\ 
 \vspace{0.1cm}


Le \texttt{D+00} signifie mathématiquement $\times 10^0$.

On   peut  revenir  à   la  configuration   par  défaut   avec  l'option
\texttt{'v'}:

%@Commande-7
\begin{lstlisting} 
 -->  format('v',10)
 \end{lstlisting}

Certaines constantes utiles sont déjà implémentées comme $\pi$:

%@Commande-8
\begin{lstlisting} 
 -->  %pi
 \end{lstlisting}
\hspace{15mm}\(\mathtt{3.1415927}\)\\ 
 \vspace{0.1cm}

et $\exp(1)$:

%@Commande-9
\begin{lstlisting} 
 -->  %e
 \end{lstlisting}
\hspace{15mm}\(\mathtt{2.7182818}\)\\ 
 \vspace{0.1cm}

Pour  les fonctions usuelles,  la syntaxe  est assez  standard. Veuillez
toutefois noter que le logarithme népérien se note \texttt{log}:



%@Commande-10
\begin{lstlisting} 
 -->  log(%e^2)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{2}\)\\ 
 \vspace{0.1cm}
% %@Commande-11
% \begin{lstlisting} 
%  -->  cos(%pi/3)
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{0.5}\)\\ 
%  \vspace{0.1cm}


Notez une particularité des logiciels de calcul numérique:

%@Commande-12
\begin{lstlisting} 
 -->  sin(%pi)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{1.225D-16}\)\\ 
 \vspace{0.1cm}

C'est le «~zéro~» fixé par Scilab qui est affiché...

On peut faire malgré tout des calculs avec des nombres plus petits:

%@Commande-13
\begin{lstlisting} 
 --> 1D-25 - 1D-26
 \end{lstlisting}
\hspace{15mm}\(\mathtt{9.000D-26}\)\\ 
 \vspace{0.1cm}


La valeur du «~zéro~» de Scilab est donnée par \verb+%eps+:

%@Commande-14
\begin{lstlisting} 
 -->  %eps
 \end{lstlisting}
\hspace{15mm}\(\mathtt{2.220D-16}\)\\ 
 \vspace{0.1cm}


Cela peut jouer des tours pour l'addition:

%@Commande-15
\begin{lstlisting} 
 -->  N=1D30; P=1D10;
 \end{lstlisting}

%@Commande-16
\begin{lstlisting} 
 -->  N-N+D
 \end{lstlisting}

%@Commande-17
\begin{lstlisting} 
 -->  N+D-N
 \end{lstlisting}



Il  faudra   donc  faire  attention   au  moment  de  faire   des  tests
d'égalité. Vous pouvez étudier la norme  IEEE 754 plus en détail ou même
envisager un TIPE sur l'arithmétique des flottants en informatique...


On peut travailler  avec des nombre complexes, le  nombre de carré $-1$
se notant \verb+%i+:

%@Commande-18
\begin{lstlisting} 
 -->  (3+%i)^2
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{8+i*6}\)\\ 
%  \vspace{0.1cm}

%@Commande-19
\begin{lstlisting} 
 -->  abs(1+%i)
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{1.4142136}\)\\ 
%  \vspace{0.1cm}



\subsection{Un brin d'informatique}

\subsubsection{Types}

Scilab travaille  avec des objets de  différents types et  ne les traite
pas de la même manière. Il faut distinguer:
\begin{itemize}
\item les réels et les complexes;
\item les  booléens:~\verb+%T+ pour vrai (True) et  \verb+%F+ pour faux (False);
\item les polynômes;
\item les chaînes de caractères entre apostrophes;
\item les listes;
\item les fonctions;
\item et bien d'autres encore...
\end{itemize}

On obtient le type d'un objet avec \texttt{typeof}:

%@Commande-22
\begin{lstlisting} 
 -->  typeof(%e)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{constant}\)\\ 
 \vspace{0.1cm}

%@Commande-23
\begin{lstlisting} 
 -->  typeof('%e')
 \end{lstlisting}
\hspace{15mm}\(\mathtt{string}\)\\ 
 \vspace{0.1cm}

\subsubsection{Opérateurs}

Scilab possède les  opérateurs arithmétiques habituels \texttt{(+), (-),
  (*),  (/)}  mais  aussi   une  division  inversée  \verb+(\)+  et  les
opérateurs pointés dont nous parlerons plus tard.

Il  sera également important  d'utiliser les  opérateurs \emph{booléens}
qui testent  l'égalité \texttt{(==)}, la  non-égalité \texttt{(<>)}, les
inégalités strictes et larges \texttt{(<), (>), (<=), (>=)}. Le résultat
est un booléen (\verb+%T+ ou \verb+%F+):

% %@Commande-24
% \begin{lstlisting} 
%  -->  3>3
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{F}\)\\ 
%  \vspace{0.1cm}

% %@Commande-25
% \begin{lstlisting} 
%  -->  3>=3
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{T}\)\\ 
%  \vspace{0.1cm}

%@Commande-26
\begin{lstlisting} 
 -->  1+%eps/2==1
 \end{lstlisting}
\hspace{15mm}\(\mathtt{T}\)\\ 
 \vspace{0.1cm}

Ce dernier résultat s'explique du  fait que la différence entre les deux
termes est inférieure à \verb+%eps+


Enfin il existe des opérateurs logiques qui seront également utiles dans
les  tests:~la  négation   (\verb+~+),  l'opérateur  ET  (\verb+&+)  et
l'opérateur OU (\verb+|+). Par exemple:


%@Commande-27
\begin{lstlisting} 
 --> ~(3<3) == (3>=3)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{T}\)\\ 
 \vspace{0.1cm}

La négation de $3<3$ est bien $3\se 3$.

% %@Commande-28
% \begin{lstlisting} 
%  -->  3<3 & 3==3 
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{F}\)\\ 
%  \vspace{0.1cm}

% En effet, l'une des affirmations est fausse.

% %@Commande-29
% \begin{lstlisting} 
%  -->  3<3 | 3==3 
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{T}\)\\ 
%  \vspace{0.1cm}

% En effet, au moins l'une des affirmations est fausse.


\subsubsection{Affectation}

Pour donner un nom à une  case mémoire où nous voulons stocker un objet,
on utilise \texttt{(=)}:

%@Commande-30
\begin{lstlisting} 
 -->  a=3;
 \end{lstlisting}

%@Commande-31
\begin{lstlisting} 
 -->  a^2
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{9}\)\\ 
%  \vspace{0.1cm}

%@Commande-32
\begin{lstlisting} 
 -->  ans^2
 \end{lstlisting}
% \hspace{15mm}\(\mathtt{81}\)\\ 
%  \vspace{0.1cm}

La commande  \texttt{ans} reprend  en effet le  résultat de  la commande
précédente.

La commande  \texttt{who} permet de rappeler quelles  sont les variables
affectées.

Pour supprimer une variable affectée, on utilise \texttt{clear}:

%@Commande-33
\begin{lstlisting} 
 -->  clear a
 \end{lstlisting}


La  commande \texttt{clear}  utilisée  toute seule  effacera toutes  les
variables affectées.



\subsection{Définir une fonction}

On peut définir toutes sortes  de fonctions, d'une ou plusieurs variables,
numériques ou non à l'aide de la syntaxe suivante:

%@Commande-34
\begin{lstlisting} 
--> function y=truc(x)
     y=x*log(x)
   endfunction
 \end{lstlisting}

On utilise ensuite la fonction créée de manière naturelle:

%@Commande-37
\begin{lstlisting} 
 -->  truc(2)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{1.3862944}\)\\ 
 \vspace{0.1cm}


\section{L'objet de base de Scilab: la matrice}


\subsection{Utilisation d'une matrice ligne}

Même si  on ne s'en  aperçoit pas tout  de suite, tout est  matrice pour
Scilab.

  Occupons-nous  d'abord  des  matrices-ligne.



Par exemple, nous voulons  obtenir les valeurs
prises par une fonction en certaines valeurs:


%@Commande-38
\begin{lstlisting} 
 --> va = [1 3 74 100*%pi]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}1&3&74&314.15927\end{matrix}}\)\\ 
 \vspace{0.1cm}

Si on veut que ces valeurs soient incrémentées régulièrement:

%@Commande-39
\begin{lstlisting} 
 --> x = [0:2:11]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&2&4&6&8&10\end{matrix}}\)\\ 
 \vspace{0.1cm}

On obtient ainsi  une suite arithmétique de nombres  de premier terme 0,
de raison 2 et inférieurs à 11.


Par défaut, l'incrément est de 1:

%@Commande-40
\begin{lstlisting} 
 --> y = [0:9]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&1&2&3&4&5&6&7&8&9\end{matrix}}\)\\ 
 \vspace{0.1cm}


L'incrément peut être négatif et non entier:

%@Commande-41
\begin{lstlisting} 
 --> X = [0:-2.5:-13]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&-2.5&-5&-7.5&-10&-12.5\end{matrix}}\)\\ 
 \vspace{0.1cm}

On a  facilement les  valeurs de quelques  suites obtenues à  partir des
précédentes:

%@Commande-42
\begin{lstlisting} 
 -->  x^2
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&4&16&36&64&100\end{matrix}}\)\\ 
 \vspace{0.1cm}

% %@Commande-43
% \begin{lstlisting} 
%  -->  X^2
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{\begin{matrix}0&6.25&25&56.25&100&156.25\end{matrix}}\)\\ 
%  \vspace{0.1cm}

On peut extraire une valeur de ces matrices:

%@Commande-44
\begin{lstlisting} 
 -->  x(3)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{4}\)\\ 
 \vspace{0.1cm}

ou une partie de ces valeurs:

%@Commande-45
\begin{lstlisting} 
 -->  x(1:3)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&2&4\end{matrix}}\)\\ 
 \vspace{0.1cm}


Le dernier élément d'une matrice est obtenu à l'aide de \$:

\begin{lstlisting}[caption={}]
--> x($)
\end{lstlisting}

On  peut  extraire  des  composantes  vérifiant une  condition  avec  la
commande \texttt{find} qui renvoie les rangs répondant à la demande:

%@Commande-46
\begin{lstlisting} 
 -->  find(x>5)
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}4&5&6\end{matrix}}\)\\ 
 \vspace{0.1cm}

On peut ajouter une valeur à une matrice:

%@Commande-47
\begin{lstlisting} 
 -->  Xnew=[X,32]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&-2.5&-5&-7.5&-10&-12.5&32\end{matrix}}\)\\ 
 \vspace{0.1cm}

ou concaténer deux matrices:

%@Commande-48
\begin{lstlisting} 
 -->  GrandX=[x,[1 2]]
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&2&4&6&8&10&1&2\end{matrix}}\)\\ 
 \vspace{0.1cm}


On  peut  effectuer des  opérations  entre  ces  vecteurs. Par  exemple,
essayons de les multiplier terme à terme:

%@Commande-49
\begin{lstlisting} 
 -->  x*X
 \end{lstlisting}

Attention!  Les opérateurs arithmétiques \texttt{(*), (/)} et (\verb+\+)
effectuent  des  opérations sur  des  \emph{matrices}. Souvenez-vous  que ces opérations
n'ont presque rien à voir avec celles sur les entiers.  En
particulier, $a*b\neq b*a$ en général.

Pour effectuer ces dernières opérations «~terme à terme~», il faut utiliser les
opérateurs pointés sans  oublier de laisser une espace  entre le premier
terme et le point:

%@Commande-50
\begin{lstlisting} 
 -->  x .*X
 \end{lstlisting}
\hspace{15mm}\(\mathtt{\begin{matrix}0&-5&-20&-45&-80&-125\end{matrix}}\)\\ 
 \vspace{0.1cm}


Des  matrices particulières  peuvent être  utiles:  \verb+zeros(m,n)+ et
\verb+ones(m,n)+ renvoient des matrices  remplies respectivement de 0 et
de 1.


\medskip

Pour extraire des lignes ou des colonnes ou des éléments particuliers:
\begin{lstlisting}[caption={}]
A=[1,2,3;
   4,5,6;
   7,8,9]
A(1,3)
A(1,:)
A(:,1)
A($,:)
\end{lstlisting}

\section{Les graphiques}

On commence par  créer un vecteur de 10000  valeurs régulièrement espacées
entre 0 et 100:


%@Commande-59
\begin{lstlisting} 
 -->  x=linspace(0,100,10000);
 \end{lstlisting}


On aurait pu aussi bien poser:

\begin{lstlisting}
 --> x=0:.01:100
\end{lstlisting}


Nous  voulons  obtenir  la   représentation  graphique  de  la  fonction
$x\mapsto x\cdot \sin(x)$ sur  $[0 ; 100]$:

%@Commande-60
\begin{lstlisting} 
 -->  plot(x,x .*sin(x))
 \end{lstlisting}

\begin{center}
 \includegraphics[width=0.6\linewidth]{CHAP0-001}
\end{center}

Pour  rajouter d'autres  courbes  sur la  figure,  nous avons  plusieurs
possibilités:

\begin{itemize}
\item demander une autre courbe:

%@Commande-61
\begin{lstlisting} 
 -->  plot(x,x)
 \end{lstlisting}
%@Commande-62
\begin{lstlisting} 
 -->  plot(x,-x)
 \end{lstlisting}

\item soit tout demander en  même temps. Pour éviter les superpositions,
  il  faut  donc  effacer  la  figure précédente  grâce  à  la  commande
  \texttt{clf}:


%@Commande-63
\begin{lstlisting} 
 -->  clf; plot(x,x .*sin(x),x,x,x,-x)
 \end{lstlisting}


\end{itemize}


On peut modifier  le style des courbes à partir des  menus de la fenêtre
graphique ou en ligne de commandes:

%@Commande-64
\begin{lstlisting} 
 -->  X=linspace(-%pi,%pi,20);
 \end{lstlisting}


ou bien 

\begin{lstlisting}
 --> X=-%pi:%pi/10:%pi
\end{lstlisting}



%@Commande-65
\begin{lstlisting} 
 -->  clf;  plot(X,sin(X),"+-b")
 \end{lstlisting}


L'option  \verb|+-b|  signifie qu'on  représente  chaque  point par  une
croix (+), qu'on les relie par un trait continu (-), en bleu (b).

\begin{center}
 \includegraphics[width=0.6\linewidth]{CHAP0-003}
\end{center}


Il existe d'autres raccourcis:
{\small
\begin{center}
             \begin{tabularx}{0.75\textwidth}{Y{7}}
	     \whline
Couleur & jaune & magenta & cyan & rouge & vert & bleu & blanc & noir \\
\hline
Symbole & y & m & c & r & g & b & w & k\\
             

             \whline
             \end{tabularx}
             \end{center}
}



\begin{center}
             \begin{tabularx}{0.75\textwidth}{Y{3}}
	     \whline
Ligne & plein & tirets & pointillés & mixte \\
\hline
Symbole & {\Large \ttfamily -} &  {\Large \ttfamily --} &  {\Large \ttfamily : } & {\Large \ttfamily -. } \\             

             \whline
             \end{tabularx}
             \end{center}


\begin{center}
             \begin{tabularx}{0.75\textwidth}{Y{4}}
	     \whline
Point & plus & rond & astérique & point & croix \\
\hline
Symbole &  {\Large \ttfamily +} & {\Large \ttfamily o} & {\Large \ttfamily *} & {\Large \ttfamily  . }& {\Large \ttfamily x}\\            

             \whline
             \end{tabularx}
             \end{center}




N'hésitez pas  à explorer l'aide  sur \texttt{gce} et  \texttt{gda} pour
plus de \og configurabilité\fg{}.



\section{La programmation}


\subsection{Les tests}

\subsubsection{Si...alors...sinon}

Construisons  par exemple une  fonction donnant  la valeur  absolue d'un
nombre\footnote{Cette  fonction existe  déjà  sur Scilab  (\texttt{abs})
  mais il nous faut un exemple simple...}

%@Commande-66
\begin{lstlisting} 
 --> function y = ABS(x)
       if x >= 0 then
        y=x
      else
        y=-x
      end
   endfunction
\end{lstlisting}

% Demandons par exemple la valeur absolue de $-2$:


% %@Commande-73
% \begin{lstlisting} 
%  -->  ABS(-2)
%  \end{lstlisting}
% \hspace{15mm}\(\mathtt{2}\)\\ 
%  \vspace{0.1cm}

En indentant son programme pour mettre en valeur les différentes structures créées, on le rend plus lisible.

\subsubsection{Éditeur de programme}

Il existe un éditeur de texte dédié à Scilab (onglet \texttt{Editor}) qui permet de travailler à part sur son programme avant de l'éxécuter.

\begin{center}
  \includegraphics[width=0.7\linewidth]{Editeur}
\end{center}

On clique alors sur \texttt{Execute -> Load into scialb} ou on appuie sur \Ctrl + \keystroke{L} pour exécuter le programme et l'envoyer vers Scilab. Si une erreur est décelée, le \og débuggeur\fg{} est là pour vous aider à la déceler.


De retour dans Scilab, on appuis sur \Enter et on peut utiliser la fonction ABS comme tout à l'heure. Cela ne sera vraiment utile que pour de longs programmes.

On  peut  également, depuis  l'éditeur,  enregistrer  le programme  puis
utiliser la commande \texttt{exec le\_chemin\_vers\_le\_fichier.sci}:

%@Commande-74
\begin{lstlisting} 
 --> exec ./ABS.sci
 \end{lstlisting}

\subsubsection{Emploi de return et de elseif}

Dans l'exemple précédent il n'y avait qu'une seule alternative: $x$ ou $-x$.

Intéressons-nous maintenant à des programmes dont les structures conditionnelles sont imbriquées.

Par exemple, construisons une fonction \texttt{Sol} qui donne les solutions d'une équations du second degré de la forme $ax^2+bx+c=0$. On pourrait construire notre programme comme précédemment:



\begin{lstlisting}
function y=Sol(a,b,c)
d=b^2-4*a*c
  if d>0 then
    y=[(-b-sqrt(d))/(2*a) (-b+sqrt(d))/(2*a)] 
  else
    if d<0 then
      y=[(-b-%i*sqrt(-d))/(2*a) (-b+%i*sqrt(-d))/(2*a)]
    else
      y=-b/(2*a)
    end
  end
endfunction 
\end{lstlisting}


Cependant, il faut être très prudent et ne pas oublier de \texttt{end} et bien savoir se retrouver dans l'imbrication de conditions.

Il existe un moyen plus efficace qui permet de rester dans le même test:
la commande \texttt{elseif}:

\begin{lstlisting}
function y=Sol(a,b,c)
d=b^2-4*a*c
  if d>0 then
    y=[(-b-sqrt(d))/(2*a) (-b+sqrt(d))/(2*a)] 
  elseif d<0 then
      y=[(-b-%i*sqrt(-d))/(2*a) (-b+%i*sqrt(-d))/(2*a)]
  else
      y=-b/(2*a)
  end
endfunction 
\end{lstlisting}


% Un moyen qui peut parfois s'avérer encore plus efficace est d'utiliser \texttt{return} qui permet de sortir d'un programme et de gagner ainsi du temps de compilation:

% \begin{lstlisting}
% function y=Sol(a,b,c)
% d=b^2-4*a*c
%   if d>0 then
%     y=[(-b-sqrt(d))/(2*a) (-b+sqrt(d))/(2*a)] 
%     return(y)
%   end
%   if d<0 then 
%     y=[(-b-%i*sqrt(-d))/(2*a) (-b+%i*sqrt(-d))/(2*a)]
%     return(y)
%   end
%   y=-b/(2*a)
% endfunction 
% \end{lstlisting}

\subsection{Boucles for}



Par exemple, calculons la somme S des 25 premiers entiers. Il faut commencer par initialiser S:

%@Commande-75
\begin{lstlisting} 
 -->  S=0;  
 \end{lstlisting}

%@Commande-76
\begin{lstlisting} 
 -->  for i=1:25 do S=S+i; end
 \end{lstlisting}

Rappelez-vous que \texttt{1:25} crée la liste des entiers de 1 à 25. L'emploi du mode silencieux après le \texttt{S=S+i} permet d'éviter d'afficher tous les résultats intermédiaires.

On peut aussi boucler sur les éléments d'une matrice.

\subsection{Boucles while}




Reprenons le calcul de la somme des 25 premiers entiers:

%@Commande-78
\begin{lstlisting} 
 -->  S=0; i=1;
 \end{lstlisting}

%@Commande-79
\begin{lstlisting} 
 -->  while i<=25 do S=S+i; i=i+1; end
 \end{lstlisting}

% %@Commande-80
% \begin{lstlisting} 
%  -->  S
%  \end{lstlisting}






\subsection{Récursion}


Il est également possible de créer des fonctions récursives. Du fait des
divers appels de la même fonction,  Scilab va vous envoyer sans cesse ce
message:

\begin{lstlisting}[caption={}]
Attention: redéfinition de la fonction: truc.
Utilisez funcprot(0) pour éviter ce message
\end{lstlisting}

On lui obéit... Que fait cette fonction:

\begin{lstlisting}[caption={}]
function y = h(p,x)
  if p==[] then y = 0
  else y = p(1) + x*h(p(2:$),x)
  end
endfunction
\end{lstlisting}

sachant qu'elle s'utilise ainsi:


\begin{lstlisting}[caption={}]
-->h([1 2 3],2)
 ans  =
 
    17.  
\end{lstlisting}


Que pensez-vous alors de ces deux-là:

\begin{lstlisting}[caption={}]
function y = dh(p,t,acc)
  if p == [] then y = acc
  else y = dh(p(1:$-1),t,p($) + t * acc) 
  end
endfunction

function y = hb(p,t)
  y = dh(p,t,0)
endfunction
\end{lstlisting}


\vfill

\eject

% \section{Probabilités et statistiques}

% Voici quelques outils qui nous serons utiles en TD.

% \verb+rand(l,c)+ renvoie une matrice de  l lignes et c colonnes dont les
% coefficients sont des nombres  de $[0,1[$ aléatoirement choisis selon la
% distribution uniforme.

% Par exemple, pour simuler $\numprint{100}$  sorties d'un dé à six faces,
% on peut faire:

% \begin{lstlisting}[caption={}]
% -->m=floor(6*rand(10,10)+1)
% \end{lstlisting}

% \begin{Verbatim}
% m  =
 
%     1.    4.    6.    4.    2.    6.    5.    3.    6.    4.  
%     1.    5.    2.    6.    5.    6.    5.    6.    5.    5.  
%     6.    2.    1.    1.    5.    1.    4.    6.    5.    2.  
%     5.    1.    1.    1.    4.    2.    5.    2.    1.    1.  
%     2.    1.    5.    5.    4.    4.    3.    6.    6.    4.  
%     5.    3.    1.    2.    6.    6.    6.    1.    5.    6.  
%     3.    5.    1.    3.    3.    2.    3.    2.    6.    2.  
%     3.    3.    2.    5.    1.    3.    1.    1.    6.    2.  
%     2.    5.    5.    1.    4.    5.    4.    4.    3.    4.  
%     3.    6.    4.    1.    3.    5.    6.    5.    6.    3.  
% \end{Verbatim}


% La fonction \verb+tabul(mat)+ est très  pratique: elle renvoie une matrice de
% deux colonnes avec les valeurs prises par les coefficients de \verb+mat+
% sur la première colonne et leurs effectifs respectifs sur la deuxième.

% \begin{lstlisting}[caption={}]
% t = tabul(m)
% \end{lstlisting}

% Pour obtenir  une représentation graphique sous forme  d'un diagramme en
% bâtons, on utilise \verb+bar(liste des abs,liste des ord)+:

% \begin{lstlisting}[caption={}]
% -->bar(t(:,1),t(:,2))
% \end{lstlisting}

% On peut préférer un camembert (une tarte en anglais...)

% \begin{lstlisting}[caption={}]
% -->pie(r(:,2),r(:,1),string(r(:,1)))
% \end{lstlisting}


%%% Local Variables: 
%%% TeX-master: "PolyMapleMPstar_12_13"
%%% End: 
