doc/developpez/modules/modules.tex

   1 \part{Modules de la bibliothèque standard Nit}
   2
   3 \chapter{Kernel}
   4 Le module |kernel| est à la base de toute la hiérarchie objet de Nit, c'est donc un module de base. Par exemple, il contient les classes fondamentales tel que |Bool|, |Char|, |Float|, |Int|, |Object|...
   5
   6 Faisons un tour rapide des classes principales du module |kernel| :
   7 \begin{description}
   8     \item[Object]C'est la super classe implicite de toutes les classes en Nit : toutes ces méthodes sont donc héritées par toutes les classes.
   9     \item[Bool]Représente les booléens. Les seules instances possibles de cette classe sont |true| et |false|. Les booléens sont souvent utilisés dans les branchements conditionnels et les boucles.
  10     \item[Char]Représente les caractères.
  11     \item[Comparable]C'est l'ancêtre de toutes les classes qui peuvent être comparés selon un ordre total.
  12     \item[Discrete]L'ancêtre de toutes les classes représentant des ensembles dénombrables comme les entiers ou l'alphabet.
  13     \item[Float]Représente les nombres à virgule flottante.
  14     \item[Int]Représente les nombres entiers.
  15 \end{description}
  16
  17 Les classes du module |kernel| sont fréquemment raffinées dans les autres modules de la librairie standard.
  18
  19 \chapter{String}
  20 Ce module introduit les classes permettant de manipuler les chaînes de caractères.
  21
  22 La classe principale du module string est |String|.
  23
  24 Le module string raffine les classes |Array|, |Collection|, |Float|, |Int|, |Map| et |Object| pour y rajouter la méthode |to_s|.
  25
  26 \chapter{Maths}
  27 Le module math raffine les classes Object, Int et Float pour y rajouter une série de méthodes en rapport avec les mathématiques. Elle est automatiquement importée avec la libraire standard.
  28
  29 \section{Variables mathématiques}
  30 Le module math raffine la classes Object pour lui rajouter la méthode |pi| (3.141592) :
  31 \lstinputlisting[language=Nit]{./modules/listings/pi1_c.nit}
  32
  33 \section{Fonctions trigonométriques}
  34 Les méthodes sin(), cos(), tan(), asin(), acos(), atan() permettent d'effectuer les opérations trigonométriques.Les angles doivent être exprimés en radians. Pour convertir des degrés en radian, il suffit de les multiplier par pi/180.
  35
  36 Exemple :
  37 \lstinputlisting[language=Nit]{./modules/listings/cos1_c.nit}
  38
  39 \section{Exponentielles et puissances}
  40 Les méthodes |pow|, |exp| et |sqrt| permettent de calculer des puissances, des exponentielles et des racines carrées.
  41
  42 Exemple :
  43 \lstinputlisting[language=Nit]{./modules/listings/exp1_c.nit}
  44
  45 \chapter{Collections}
  46 Les collections sont des objets qui permettent de gérer des ensembles d'objets. Ces ensembles de données peuvent être définis avec plusieurs caractéristiques : la possibilité de gérer des doublons, de gérer un ordre de tri, etc. Chaque objet contenu dans une collection est appelé un élément.
  47
  48 Les collections sont basées sur le principe de la généricité que nous avons déjà abordé.
  49
  50 \section{Interfaces des collections}
  51 \subsection{Interface Collection}
  52 Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle est la super interface de plusieurs interfaces de la libraire standard. Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
  53
  54 Cette interface définit plusieurs méthodes :
  55
  56 \begin{tabularx}{\linewidth}{|c|X|}
  57     \hline
  58     Méthode & Rôle \\
  59     \hline
  60     count(E):Int & Nombre d'occurrence d'un élément dans une collection. \\
  61     \hline
  62     has(E):Bool & Vérifie si un élément se trouve dans la collection. \\
  63     \hline
  64     has\_only(E):Bool & Vérifie si la collection contient seulement l'élément précisé. \\
  65     \hline
  66     is\_empty:Bool & Vérifie si la collection est vide. \\
  67     \hline
  68     iterate & Itère sur chaque élément de la collection. \\
  69     \hline
  70     iterator:Iterator[E] & Retourne un itérateur associé à la collection. \\
  71     \hline
  72     length & Retourne le nombre d'élément contenu dans la collection. \\
  73     \hline
  74 \end{tabularx}
  75
  76 Cette interface représente un minimum commun pour les objets qui gèrent des collections.
  77
  78 \subsection{Interface Iterator}
  79 Cette interface définit des méthodes pour des objets capables de parcourir les données d'une collection :
  80
  81 \begin{tabularx}{\linewidth}{|c|X|}
  82     \hline
  83     Méthode & Rôle \\
  84     \hline
  85     is\_ok & Indique s'il reste au moins un élément à parcourir dans la collection. \\
  86     \hline
  87     item & Renvoie l'élément courant de la collection.  \\
  88     \hline
  89     next & Saute au prochain élément de la collection. \\
  90     \hline
  91 \end{tabularx}
  92
  93 Un exemple d'utilisation de l'iterator :
  94 \lstinputlisting[language=Nit]{./modules/listings/iterator1_s.nit}
  95
  96 \subsection{Interface RemovableCollection}
  97 Cette interface introduit des méthodes permettant de retirer des éléments d'une collection :
  98
  99 \begin{tabularx}{\linewidth}{|c|X|}
 100     \hline
 101     Méthode & Rôle \\
 102     \hline
 103     clear & Retire tous les éléments de la collection. \\
 104     \hline
 105     remove(E) & Retire l'élément précisé de la collection.  \\
 106     \hline
 107     remove\_all(E) & Retire toutes les occurrences de l'élément précisé de la collection. \\
 108     \hline
 109 \end{tabularx}
 110
 111 \subsection{Interface SimpleCollection}
 112 Cette interface introduit des méthodes permettant d'ajouter des éléments dans une collection :
 113
 114 \begin{tabularx}{\linewidth}{|c|X|}
 115     \hline
 116     Méthode & Rôle \\
 117     \hline
 118     add(E) & Ajoute l'élément dans la collection. \\
 119     \hline
 120     add\_all(Collection[E]) & Ajoute tous les éléments dans la collection. \\
 121     \hline
 122 \end{tabularx}
 123
 124 \section{Séquences}
 125 Les séquences sont des collections indexées et ordonnées. La notion d'index est importante, elle précise que chaque valeur est associé à une sorte d'étiquette numérique permettant de la retrouver. L'ordre de la séquence est donc induit par l'ordre des étiquettes.
 126
 127 L'interface Sequence introduit les méthodes suivantes :
 128
 129 \begin{tabularx}{\linewidth}{|c|X|}
 130     \hline
 131     Méthode & Rôle \\
 132     \hline
 133     append(Collection[E]) & Ajoute tous les éléments de la collection passée en paramètre à la fin de la séquence. \\
 134     \hline
 135     first:E & Retourne le premier élément de la séquence. \\
 136     \hline
 137     first=(E) & Définie le premier élément de la séquence. \\
 138     \hline
 139     last:E & Retourne le dernier élément de la séquence. \\
 140     \hline
 141     last=(E) & Définie le dernier élément de la séquence. \\
 142     \hline
 143     pop:E & Retourne et retire le dernier élément de la séquence. \\
 144     \hline
 145     push(E) & Ajoute l'élément à la fin de la séquence. \\
 146     \hline
 147     shift:E & Retourne et retire le premier élément de la séquence. \\
 148     \hline
 149     unshift(E) & Ajoute l'élément au début de la séquence. \\
 150     \hline
 151 \end{tabularx}
 152
 153 L'interface Sequence est implémentée par les tableaux et les listes.
 154
 155 \subsection{Listes}
 156 Les listes sont des Collections qui autorisent des doublons dans les éléments de la liste, elle acceptent aussi des éléments |null|. Les listes étant aussi des séquences, elles sont donc indexées et ordonnées, un élément de la liste peut donc être accédé directement à partir de son index. C'est aussi une implémentation concrète de Séquence, elle peut donc être instanciée et utilisée directement.
 157
 158 La classe liste représente une liste doublement chaînée : l'ajout d'un élément peut se faire seulement au début ou à la fin de la collection.
 159
 160 Voici un exemple d'utilisation d'une liste :
 161 \lstinputlisting[language=Nit]{./modules/listings/list1_c.nit}
 162
 163 \subsection{Tableaux}
 164 Les tableaux représentent des collections d'objets dont la taille est dynamique. Les tableaux sont gérées grâce à la classe Array.
 165
 166 Chaque objet de type Array gère une capacité qui est le nombre total d'élément qu'il est possible d'insérer avant d'agrandir le tableau. Cette capacité a donc une relation avec le nombre d'éléments contenus dans la collection. Lors d'un ajout dans la collection, cette capacité et le nombre d'éléments de la collection déterminent si le tableau doit être agrandi. Si un nombre important d'élément doit être ajouté, il est possible de forcer l'agrandissement de cette capacité avec la méthode |enlarge|. Son usage évite une perte de temps liée au recalcul de la taille de la collection.
 167
 168 Exemple :
 169 \lstinputlisting[language=Nit]{./modules/listings/array1_c.nit}
 170
 171 Un constructeur permet de préciser la capacité initiale :
 172 \lstinputlisting[language=Nit]{./modules/listings/array2_c.nit}
 173
 174 \section{Ensembles}
 175 Un ensemble (Set) est une collection qui n'autorise pas l'insertion de doublons.
 176
 177 L'interface Set définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite de l'interface Collection mais elle ne définie pas de nouvelle méthode. Pour déterminer si un élément est déjà inséré dans la collection, la comparaison est basée sur les valeurs des éléments.
 178
 179 L'interface Set possède deux implémentations concrètes :
 180
 181 \begin{description}
 182     \item[ArraySet] Implémentation basée sur les tableaux.
 183     \item[HashSet] Implémentation basée sur une table de hachage.
 184 \end{description}
 185
 186 Exemple avec l'implémentation ArraySet :
 187 \lstinputlisting[language=Nit]{./modules/listings/set1_c.nit}
 188
 189 \section{Collections gérées sous la forme clé/valeur}
 190 Ce type de collection gère les éléments avec deux entités : une clé et une valeur associée. La clé doit être unique donc il ne peut y avoir de doublons. En revanche la même valeur peut être associée à plusieurs clés différentes.
 191
 192 \subsection{Interface Map}
 193 L'interface Map définit les méthodes d'une collection gérant des ensembles clés => valeur. Elle hérite de l'interface Collection et introduit ou redéfinit les méthodes suivantes :
 194
 195 \begin{tabularx}{\linewidth}{|c|X|}
 196     \hline
 197     Méthode & Rôle \\
 198     \hline
 199     [](K):E & Retourne l'élément E correspondant à la clé K. \\
 200     \hline
 201     []=(K, E) & Définit l'élément E à la clé K. \\
 202     \hline
 203     has\_key(K):Bool & Indique si un élément existe à la clé K. \\
 204     \hline
 205     recover\_with(Map[K, E]) & Ajoute chaque valeur de la Map passée en paramètre dans la Map courante. En cas de conflit de clé, la valeur de la Map courante est remplacée par celle en paramètre.  \\
 206     \hline
 207     remove\_at(K) & Retire l'élément correspondant à la clé K. \\
 208     \hline
 209 \end{tabularx}
 210
 211 L'interface Map possède une implémentation concrète basée sur une table de hachage, HashMap.
 212
 213 Voici un exemple d'utilisation d'une HashMap :
 214 \lstinputlisting[language=Nit]{./modules/listings/hashmap1_c.nit}
 215
 216 \section{Tri des collections}
 217 Pour trier les collections, Nit propose la classe abstraite AbstractSorter. Elle apporte des fonctionnalités de tri pour les tableaux mais doit être spécialisée pour pouvoir être utilisée.
 218
 219 \begin{tabularx}{\linewidth}{|c|X|}
 220     \hline
 221     Méthode & Rôle \\
 222     \hline
 223     compare(E, E):Int & Méthode abstraite de comparaison. \\
 224     \hline
 225     sort(Array[E]) & Trie le tableau passé en paramètre. \\
 226     \hline
 227 \end{tabularx}
 228
 229 La méthode compare doit être redéfinie dans une sous classe afin de pouvoir être utilisée.
 230
 231 Nit propose une implémentation par défaut basée sur les comparables : ComparableSorter.
 232
 233 Voici un exemple de son utilisation :
 234 \lstinputlisting[language=Nit]{./modules/listings/sorter1_c.nit}
 235