\documentclass[french,10pt,a4paper]{article}
\usepackage[T1]{fontenc} % pour avoir des accents
\usepackage{amsmath}
\usepackage{amsthm} 
\usepackage{amsfonts}
\usepackage{babel}
\usepackage[dvips]{graphics}
\pagestyle{headings} 
\frenchspacing

\def\vsp   {\vspace{2 ex}}
\def\vvsp  {\vspace{4 ex}}
\def\vvvsp {\vspace{6 ex}}

\newtheorem{exercice}{Exercice}

\begin{document}

\begin{large}{\bf 
Université Claude-Bernard Lyon 1 \\
DESS SITN - Tronc commun \\
\rule{\textwidth}{0.25pt}} 
\end{large}
 
\vspace{-1.5 ex}
\hfill Octobre 2003

\begin{large}{\bf
\begin{center}
Outil informatique, TP3
\end{center} }
\end{large}

\emph{On trouvera des compléments d'information dans le document
  joint; en particulier, certains des exercices y sont partiellement
  corrigés.}

\section{Utilisation des classes java standard (\texttt{Number}, \texttt{Float} \texttt{ArrayList}, ...)}

Rappel: dans ce TP comme dans tous les suivants, on demande d'écrire
pour chaque classe \texttt{Bla} un programme de test \texttt{BlaTest}
et un petit programme de démonstration \texttt{BlaDemo}. Le
\texttt{Makefile} devra être adapté pour lancer ces programmes de
manière appropriée. Enfin, toutes les fonctions et méthodes publiques
de doivent être documentée au format javadoc.

\begin{exercice}
  Compléter le squelette de la classe \texttt{Statistics}, avec les
  fonctions statistiques usuelles pour les séries numériques (moyenne,
  variance, écart-type). Chacune de ces fonctions prendra comme
  paramètre un tableaux d'objets (ArrayList).
\end{exercice}

Remarque: on aurait pu se contenter d'utiliser les types de base java
(\texttt{float}, \texttt{float[]}. Pour le moment, l'intérêt principal
d'utiliser les classes est d'écrire du code \emph{générique}: les
fonctions statistiques ainsi implantées fonctionnent aussi bien avec
des flottants, des doubles, des nombres rationnels; en bref avec toute
classe qui hérite de Number et qui implante la division.

\begin{exercice}
  Compacter le fichier "Stat.class" dans un fichier ".jar" ou ".zip"
  et exécuter directement le contenu du fichier compacté. Tester les
  différentes possibilités évoquées dans l'annexe 2 du document
  \texttt{doc.pdf}
\end{exercice}
\section{Écriture d'une nouvelle classe}

On suppose maintenant que l'on développe un gros programme de
statistique qui nécessite d'accéder très souvent à la moyenne de
chaque série numérique. Il serait dommage de recalculer à chaque fois
cette moyenne; on veut donc la stocker d'une fois sur l'autre. En
anglais, on dirait mettre la moyenne dans un \emph{cache}. D'un autre
côté, il ne serait pas très pratique de devoir stocker séparément la
série numérique et sa moyenne (à chaque fois que l'on passe la série à
une fonction, il faudrait passer la moyenne avec).

Pour palier à cela, on peut regrouper la série numérique et sa moyenne
dans une unique \emph{structure de donnée}. Pour que l'utilisateur
n'ait pas besoin de savoir comment est organisée cette structure de
donnée, on peut associer à cette structure de donnée des
\emph{méthodes}; l'une de ces méthodes renverra la moyenne de la série
numérique et ainsi de suite. On appelle cela \emph{encapsuler} les
données. L'avantage, c'est que l'on peut changer l'implantation à tout
moment de manière transparente pour l'utilisateur. Par exemple, on
peut décider de calculer la moyenne dès la création de la série
numérique, ou au contraire attendre, et la calculer au vol lors du
premier appel à la méthode moyenne (stratégie \emph{paresseuse}). Il
n'est pas forcément évident de savoir dès le début de la conception du
programme quelle est la meilleure stratégie; en encapsulant les
données, on se donne la liberté de changer de stratégie en cours de
route.

Dans la pratique, une série numérique est essentiellement un tableau
de nombres, avec quelques informations supplémentaires (les valeurs
déjà calculées pour la moyenne, l'écart type, ...), et quelques
méthodes supplémentaires pour accéder à ces informations. Il est donc
naturel de définir une nouvelle classe \texttt{NumericalSeries} qui
hérite de \texttt{ArrayList}.

\begin{exercice}
  Compléter le squelette de la classe \texttt{NumericalSeries}.
\end{exercice}

On est dans une situation où les informations dans la structure de
donnée doivent être cohérentes entre elles. Il est très important
d'exprimer explicitement ce type de contrainte, sous la forme d'un
\emph{invariant} (cf.  le commentaire dans la classe
\texttt{NumericalSeries}), et de s'assurer que toutes les opérations
conservent cette cohérence interne. La encore l'encapsulation permet
de garantir que l'utilisateur n'accède pas directement aux
informations, et ne risque donc pas de casser (volontairement ou non)
leur cohérence interne.

\begin{exercice}
  Pour ceux qui veulent aller plus loin.
  
  La classe \texttt{ArrayList}, et donc la classe
  \texttt{NumericalSeries} contient des méthodes pour rajouter ou
  modifier des éléments.  Lorsqu'une telle opération a lieu, la valeur
  de la moyenne que l'on a stockée devient incorrecte (on dit que ces
  opérations invalident le cache), et on risque de renvoyer un
  résultat complètement faux à l'utilisateur. Surcharger ces méthodes
  pour qu'elles recalculent, ou au moins détruise, les informations
  stockées incorrectes.
\end{exercice}

On s'intéresse maintenant à des séries numériques affectées de poids
entiers.
\begin{exercice}
  Implanter une classe \texttt{WeightedNumericalSeries} pour ces
  séries numériques. Cette classe héritera de
  \texttt{NumericalSeries}, en rajoutant le tableau des poids à la
  structure de donnée, et en surchargeant de manière appropriée les
  méthodes statistiques. L'objectif est de réutiliser le maximum de
  fonctionnalités de \texttt{NumericalSeries}.
\end{exercice}

\end{document}

\vsp
{\bf 2} En incluant des commentaires dans le programme {\tt Stat}, générer, au moyen de Javadoc une documentation sur cette classe.

\vsp
{\bf 3} 

\vsp
{\bf 4-} Sur le modèle de la classe {\tt Liste}, créer une structure de pile (une pile est une liste qui permet seulement d'ajouter au début ({\em empiler}) et de supprimer au début ({\em dépiler})).


\vsp
{\bf 5-} Modifier l'implantation de la liste de  {\tt LListe}, en la basant sur la classe 
{\tt Vector} puis sur la classe{\tt  ArrayList} (à la place de {\tt  LinkedList}.

Comparer les performances des implantations des listes au moyen des 3 classes précédentes {\tt Vector, ArrayList, LinkedList}. Par exemple on peut essayer de créer un liste en insérant 1000 éléments au début, ou à la fin, ou à une place aléatoire ... ( La classe {\tt Math}  possède une méthode {\tt random} permettant de générer des valeurs aléatoires )

\vsp
{\bf 6-} Dans la classe {\tt Arbre}, modifier la fonction {\tt main} pour pouvoir générer de façon aléatoire un arbre possédant 1000 sommets.

Ecrire une méthode permettant de compter les feuilles de l'arbre.

\vsp
{\bf 7-} Modifier la classe {\tt ArbreSyntax} pour qu'elle puisse traiter des réels, et permette l'utilisation d'une fonction telle que {\tt sinus}.

\vsp
{\bf 8-} Compiler et tester la classe {\tt Evalc} qui permet d'évaluer une expression arithmétique. 

Etudier les possibilités de la classe {\tt JEP} en cherchant le site Internet qui la diffuse.


\end{document}
