Modélisation de la Lune, catalogues d'étoiles

Rigel – étape 6

1 Introduction

Le but de cette sixième étape, la dernière de la première partie du projet, est double : premièrement, modéliser le mouvement de la Lune dans l'espace, et deuxièmement écrire le code permettant de représenter des catalogues d'étoiles et d'astérismes, et charger leur contenu depuis un fichier.

Notez que cette étape devra être rendue deux fois :

  1. pour le rendu testé habituel (délai : 3 avril, 17h00),
  2. pour le rendu intermédiaire (délai : mercredi 8 avril, 17h00).

Le deuxième de ces rendus sera corrigé par lecture de votre code pour les étapes 1 à 6, et il vous faudra donc soigner sa qualité et sa documentation. Il est conseillé de lire notre guide à ce sujet.

Attention: notez bien le fait que le rendu intermédiaire aura lieu un jour inhabituel, puisque le 8 avril est un mercredi et pas un vendredi !

2 Concepts

2.1 Position de la Lune

De tous les objets célestes que nous modéliserons dans ce projet, la Lune est de loin celui dont la position est la plus difficile à calculer. En effet, la trajectoire de la Lune est fortement influencée à la fois par la Terre et par le Soleil.

Comme d'habitude le calcul de la position de la Lune se base sur un certain nombre de constantes valables pour l'époque J2010 et résumées dans la table 1 ci-dessous. Les constantes représentant des angles sont données en degrés, comme dans le livre de référence, et doivent donc être converties en radians avant utilisation.

Tableau 1 : Constantes lunaires pour l'époque J2010
Nom Valeur Signification
\(l_0\) 91.929336° Longitude moyenne
\(P_0\) 130.143076° Longitude moyenne au périgée
\(N_0\) 291.682547° Longitude du nœud ascendant
\(i\) 5.145396° Inclinaison de l'orbite
\(e\) 0.0549 Excentricité de l'orbite

Le calcul de la position consiste une fois encore à déterminer successivement la valeur d'un certain nombre de variables pour enfin obtenir la position écliptique de la Lune. Ces variables, résumées dans la table 2 ci-dessous, sont assez nombreuses dans le cas de la Lune en raison du grand nombre de termes de correction, dont le but est de tenir compte de l'influence du Soleil sur la trajectoire lunaire.

Tableau 2 : Variables utilisées dans le calcul de la position de la Lune
Nom Unité Signification
\(D\) jour Jours depuis l'époque J2010
\(l\) radian Longitude orbitale moyenne
\(l^\prime\) radian Longitude orbitale corrigée
\(l^{\prime\prime}\) radian Longitude orbitale vraie
\(M_m\) radian Anomalie moyenne
\(M_m^\prime\) radian Anomalie corrigée
\(E_v\) radian Évection
\(A_e\) radian Correction de l'équation annuelle
\(A_3\) radian Correction 3
\(A_4\) radian Correction 4
\(E_c\) radian Correction de l'équation du centre
\(V\) radian Variation
\(N\) radian Longitude moyenne du nœud ascendant
\(N^\prime\) radian Longitude corrigée du nœud ascendant
\(\lambda_m\) radian Longitude écliptique
\(\beta_m\) radian Latitude écliptique

En plus de ces variables spécifiques à la Lune, deux variables spécifiques au Soleil sont également utilisées dans les calculs ci-dessous : l'anomalie moyenne du Soleil \(M_{☉}\) et la longitude écliptique (géocentrique) du Soleil \(\lambda_{☉}\). Leur valeur est donnée par le modèle du Soleil décrit à l'étape précédente.

Le calcul de la position de la Lune peut être découpé en deux grandes étapes : dans un premier temps, la longitude orbitale de la Lune est déterminée ; ensuite, sa position écliptique est calculée. Ces deux étapes sont décrites dans les deux sections qui suivent.

2.1.1 Calcul de la longitude orbitale

La première partie du calcul consiste à déterminer la longitude orbitale de la Lune, c-à-d sa longitude dans son plan orbital.

Attention : pour rester fidèle au livre de référence, les constantes angulaires apparaissant dans les équations ci-dessous sont exprimées en degrés. Comme d'habitude, il faut les convertir en radians avant de les utiliser.

On commence par déterminer la longitude orbitale moyenne de la Lune :

\[ l = 13.1763966°\times D + l_0 \]

qui nous permet de calculer l'anomalie moyenne de la Lune :

\[ M_m = l - 0.1114041° \times D - P_0 \]

Ensuite, plusieurs termes de correction doivent être déterminés, qui ont pour but de tenir compte de l'influence du Soleil sur la trajectoire de la Lune :

\begin{align*} E_v &= 1.2739°\times \sin\left(2(l - \lambda_{☉}) - M_m\right)\\ A_e &= 0.1858°\times \sin M_{☉}\\ A_3 &= 0.37°\times \sin M_{☉} \end{align*}

En les combinant à l'anomalie moyenne, on peut obtenir l'anomalie corrigée :

\[ M_m^\prime = M_m + E_v - A_e - A_3 \]

qui nous permet de calculer deux autres termes de correction :

\begin{align*} E_c &= 6.2886°\times \sin M_m^\prime\\ A_4 &= 0.214°\times \sin 2M_m^\prime \end{align*}

pour obtenir la longitude orbitale corrigée :

\[ l^\prime = l + E_v + E_c - A_e + A_4 \]

On en détermine un dernier terme correcteur, la variation :

\[ V = 0.6583°\times\sin 2(l^\prime - \lambda_{☉}) \]

ce qui nous permet enfin d'obtenir la longitude orbitale vraie de la Lune :

\[ l^{\prime\prime} = l^\prime + V \]

2.1.2 Calcul de la position écliptique

Une fois la longitude orbitale de la Lune déterminée, le calcul de sa position écliptique n'est plus très compliqué. Il faut tout d'abord déterminer la longitude moyenne et la longitude corrigée du nœud ascendant :

\begin{align*} N &= N_0 - 0.0529539°\times D\\ N^\prime &= N - 0.16°\times\sin M_{☉} \end{align*}

pour finalement pouvoir calculer la longitude et la latitude écliptique de la Lune :

\begin{align*} \lambda_m &= \arctan\left[\frac{\sin(l^{\prime\prime} - N^\prime)\cos i}{\cos(l^{\prime\prime} - N^\prime)}\right] + N^\prime\\[0.5em] \beta_m &= \arcsin\left[\sin(l^{\prime\prime} - N^\prime)\sin i\right] \end{align*}

Référence : Practical Astronomy with your Calculator or Spreadsheet, §65

2.2 Phase de la Lune

La phase de la Lune se détermine facilement au moyen de sa longitude orbitale vraie et de la longitude écliptique du Soleil :

\[ F = \frac{1 - \cos(l^{\prime\prime} - \lambda_{☉})}{2} \]

Pour mémoire, la valeur obtenue est comprise dans l'intervalle [0, 1] et donne la portion du disque lunaire qui est vue comme illuminée depuis la Terre : 0 correspond à la nouvelle Lune, 1 à la pleine Lune.

Référence : Practical Astronomy with your Calculator or Spreadsheet, §67

2.3 Taille angulaire de la Lune

Pour déterminer la taille angulaire de la Lune, on commence par calculer la distance entre la Terre et la Lune. L'unité utilisée ici est particulière, puisqu'il s'agit de la longueur du demi-grand axe de l'orbite :

\[ \rho = \frac{1-e^2}{1 + e\,\cos(M_m^\prime + E_c)} \]

La taille angulaire s'obtient ensuite par simple division :

\[ \theta = \frac{\theta_0}{\rho} \]

où \(\theta_0 = 0.5181°\) est la taille angulaire de la Lune vue depuis la Terre à une distance égale au demi-grand axe de l'orbite. (Cette distance vaut environ 384401 km, mais cela n'a aucune influence sur les calculs ci-dessus.)

Référence : Practical Astronomy with your Calculator or Spreadsheet, §69

2.4 Catalogue d'étoiles

Comme nous l'avons vu à l'étape précédente, de nombreux catalogues d'étoiles ont été établis au cours de l'histoire, et les plus importants d'entre eux sont désormais librement disponibles sous forme numérique.

Pour ce projet, nous utiliserons une version simplifiée du catalogue HYG, qui résulte de la compilation de trois catalogues célèbres : le catalogue Hipparcos, le catalogue de Yale et de catalogue de Gliese.

Ce catalogue peut être téléchargé sur la page Web de l'auteur de la compilation, mais nous vous fournissons plus bas la version à utiliser pour ce projet. Il s'agit d'une version simplifiée et allégée, ne contenant que les étoiles de magnitude inférieure ou égale à 6, qui sont celles visibles à l'œil nu dans les meilleures conditions d'observation.

Le catalogue HYG est fourni sous la forme d'un fichier dit CSV — pour comma-separated values, c-à-d « valeurs séparées par une virgule ». Ce format de fichier est très souvent utilisé en informatique, mais n'est pas défini très précisément.

En général, un fichier CSV est un fichier textuel décrivant le contenu d'un (et un seul) tableau rectangulaire, composé d'un certain nombre de lignes et de colonnes. Chaque ligne du fichier contient les données d'une ligne du tableau, à l'exception de la première, qui est généralement une ligne d'en-tête donnant les noms des colonnes. Dans tous les cas, les différentes colonnes sont séparées les unes des autres au moyen d'une virgule.

Par exemple, un fichier CSV contenant les trois lignes suivantes : 

hip,proper,ra,dec,mag
24436,Rigel,5.242298,-8.201640,0.180
27989,Betelgeuse,5.919529,7.407063,0.450

représente la table d'étoiles ci-dessous :

hip proper ra dec mag
24436 Rigel 5.242298 -8.201640 0.180
27989 Betelgeuse 5.919529 7.407063 0.450

où hip est le numéro Hipparcos, proper le nom propre (en anglais), ra l'ascension droite (en heures), dec la déclinaison (en degrés) et mag la magnitude de chacune des étoiles.

Le catalogue HYG n'est rien d'autre qu'une plus grande version de cette table, constituée à la fois de plus de colonnes — 37 en tout — et de plus de lignes — près de 120000 dans la version complète. La signification des 37 colonnes est données dans la documentation du catalogue, mais pour ce projet nous n'utiliserons que celles données dans la table ci-dessous :

Tableau 3 : Colonnes utiles du catalogue HYG
No Nom Signification
2 hip Numéro Hipparcos
7 proper Nom propre
14 mag Magnitude
17 ci Indice de couleur B-V
24 rarad Ascension droite en radians
25 decrad Déclinaison en radians
28 bayer Désignation de Bayer
30 con Nom abrégé de la constellation

Le numéro donné est le numéro de la colonne, qui va de 1 (!) à 37. Ainsi, le numéro Hipparcos se trouve dans la seconde colonne.

La désignation de Bayer est constituées des 2 ou 3 lettres initiales du nom latin de la lettre grecque correspondante — p.ex. Bet pour β —, éventuellement suivies d'un tiret et d'un chiffre. Le nom abrégé de la constellation est quant à lui formé de trois initiales du nom latin de la constellation — p.ex. Ori pour Orion.

Notez bien que le catalogue HYG inclut l'ascension droite et la déclinaison dans différentes unités : en heures/degrés et en radians. Les valeurs en radians, contenues dans les colonnes 24 (rarad) et 25 (decrad) sont celles qui conviennent le mieux aux conventions utilisées dans le projet, et donc celles que nous utiliserons.

2.5 Catalogue d'astérismes

Les astérismes ne sont généralement pas décrits par les catalogues d'étoiles, d'une part car aucune liste officielle de ces astérismes n'existe, et d'autre part car différentes cultures reconnaissent des astérismes différents.

Il est toutefois possible de trouver des catalogues des astérismes occidentaux, et pour ce projet nous utiliserons une version simplifiée d'un catalogue établi par Dominic Ford à partir du livre The Stars: A New Way To See Them de H. A. Rey. Ce catalogue peut être téléchargé sur la page Web du projet, mais nous vous en fournissons plus bas une version simplifiée et adaptée à nos besoins.

La version simplifiée que nous utiliserons est un fichier textuel très simple, mais qui n'est pas au format CSV. Chaque ligne du fichier, la première comprise, est constituée d'une liste de numéros Hipparcos d'étoiles appartenant à un même astérisme, séparés par une virgule.

Par exemple, la ligne 95 de ce fichier est la suivante : 

24436,27366,26727,27989,28614,29426,28716

Elle décrit un astérisme auquel appartiennent à la fois Rigel (en première position) et Bételgeuse (en quatrième position).

3 Mise en œuvre Java

Parmi les classes à réaliser plus bas figurent celles permettant de charger les catalogues d'étoiles et d'astérismes que nous utiliserons pour ce projet. Les fichiers les contenant vous sont fournis sous la forme d'une archive Zip à importer dans votre projet en suivant nos instructions pour IntelliJ ou pour Eclipse.

Dans tous les cas, prenez soin d'importer correctement l'archive, cela est capital ! Le répertoire resources qu'elle contient doit être un répertoire « frère » du répertoire src, c-à-d situé au même niveau que lui dans la hiérarchie. De plus, dans IntelliJ vous devez impérativement marquer le répertoire comme Resources Root (voir point 7 de notre guide), et dans Eclipse vous devez impérativement l'ajouter au Build Path (voir points 5 à 7 de notre guide).

Attention : si vous importez de manière incorrecte ce répertoire resources dans votre projet, il est probable que ce dernier ne fonctionne pas correctement lors des tests manuels qui seront effectués à la fin du semestre. Cela pourrait vous faire perdre un très grand nombre de points, donc prenez garde à ce qui précède et, en cas de doute, demandez de l'aide.

3.1 Type énuméré MoonModel

Le type énuméré MoonModel du paquetage ….astronomy, public et immuable, contient un seul élément nommé MOON et représentant un modèle de la Lune. Ce type énuméré implémente l'interface CelestialObjectModel<Moon>.

La seule méthode publique de MoonModel est la méthode at de l'interface CelestialObjectModel, qui retourne la Lune à un instant donné. Notez qu'aucune technique n'a été donnée plus haut pour déterminer la magnitude de la Lune, et le modèle utilise toujours 0. Cette valeur, bien entendu incorrecte, n'est pas utilisée dans la suite du projet, et importe donc peu.

3.2 Classe StarCatalogue

La classe StarCatalogue du paquetage ….astronomy, publique, finale et immuable, représente un catalogue d'étoiles et d'astérismes. Elle offre un unique constructeur public :

  • StarCatalogue(List<Star> stars, List<Asterism> asterisms), qui construit un catalogue constitué des étoiles stars et des astérismes asterisms, ou lève IllegalArgumentException si l'un des astérismes contient une étoile qui ne fait pas partie de la liste d'étoiles.

En plus de ce constructeur, la classe StarCatalogue offre les méthodes publiques suivantes :

  • List<Star> stars(), qui retourne la liste des étoiles du catalogue,
  • Set<Asterism> asterisms(), qui retourne l'ensemble des astérismes du catalogue,
  • List<Integer> asterismIndices(Asterism asterism), qui retourne la liste des index — dans le catalogue — des étoiles constituant l'astérisme donné, ou lève IllegalArgumentException si l'astérisme donné ne fait pas partie du catalogue.

Attention : asterismIndices ne doit pas retourner le numéro Hipparcos des étoiles de l'astérisme, mais bien leur index dans la liste d'étoiles du catalogue, telle qu'elle est retournée par la méthode stars. Par exemple, si Rigel apparaît à l'index 1019 dans cette liste, alors l'astérisme décrit par la ligne 95 du catalogue d'astérisme (voir §2.5) doit avoir 1019 comme premier élément — et pas 24436.

3.2.1 Conseils de programmation

Le moyen le plus simple et le plus efficace de mettre en œuvre StarCatalogue consiste à lui ajouter un attribut (privé) contenant une table associative dont les clefs sont les astérismes et les valeurs sont les listes d'index correspondantes. De la sorte, asterisms peut simplement retourner une vue sur les clefs de cette table, et asterismIndices peut simplement utiliser la méthode get de cette table pour en extraire la liste des index de l'astérisme donné.

3.3 Classe StarCatalogue.Builder

La classe Builder, imbriquée statiquement dans la class StarCatalogue, publique et finale, représente un bâtisseur de catalogue d'étoiles.

Cette classe possède un constructeur par défaut qui initialise le bâtisseur de manière à ce que le catalogue en construction soit initialement vide. Elle offre de plus les méthodes publiques suivantes :

  • Builder addStar(Star star), qui ajoute l'étoile donnée au catalogue en cours de construction, et retourne le bâtisseur,
  • List<Star> stars(), qui retourne une vue non modifiable — mais pas immuable — sur les étoiles du catalogue en cours de construction,
  • Builder addAsterism(Asterism asterism), qui ajoute l'astérisme donné au catalogue en cours de construction, et retourne le bâtisseur,
  • List<Asterism> asterisms(), qui retourne une vue non modifiable — mais pas immuable — sur les astérismes du catalogue en cours de construction,
  • Builder loadFrom(InputStream inputStream, Loader loader) throws IOException, qui demande au chargeur loader (voir §3.4) d'ajouter au catalogue les étoiles et/ou astérismes qu'il obtient depuis le flot d'entrée inputStream, et retourne le bâtisseur, ou lève IOException en cas d'erreur d'entrée/sortie,
  • StarCatalogue build(), qui retourne le catalogue contenant les étoiles et astérismes ajoutés jusqu'alors au bâtisseur.

Un exemple d'utilisation de la méthode loadFrom est donné plus bas, à la §3.7, mais il est conseillé de lire encore les deux sections qui suivent avant de le consulter.

3.4 Interface Loader

L'interface Loader, imbriquée dans la classe StarCatalogue, publique, représente un chargeur de catalogue d'étoiles et d'astérismes.

La seule méthode publique (et abstraite) de cette interface est :

  • void load(InputStream inputStream, Builder builder) throws IOException, qui charge les étoiles et/ou astérismes du flot d'entrée inputStream et les ajoute au catalogue en cours de construction du bâtisseur builder, ou lève IOException en cas d'erreur d'entrée/sortie.

3.5 Type énuméré HygDatabaseLoader

Le type énuméré HygDatabaseLoader du paquetage ….astronomy, public et immuable, contient un seul élément nommé INSTANCE et représentant un chargeur de catalogue HYG. Il implémente l'interface StarCatalogue.Loader.

La seule méthode publique de ce type énuméré est la méthode load provenant de l'interface Loader décrite ci-dessus. Cette méthode ajoute au bâtisseur de catalogue toutes les étoiles obtenues du catalogue HYG en utilisant le contenu des colonnes de la manière suivante, où la valeur par défaut mentionnée est celle à utiliser si la colonne est vide :

  • le numéro Hipparcos de l'étoile est obtenu de la colonne hip (0 par défaut),
  • le nom de l'étoile est obtenu de la colonne proper si elle n'est pas vide, et sinon par concaténation de la colonne bayer (? par défaut [point d'interrogation]), d'une espace et de la colonne con, qui n'est jamais vide,
  • les coordonnées équatoriales de l'étoile sont obtenues des colonnes rarad et decrad, qui ne sont jamais vides,
  • la magnitude de l'étoile est obtenue de la colonne mag (0 par défaut),
  • l'indice de couleur B-V est obtenu de la colonne ci (0 par défaut).

3.5.1 Conseils de programmation

Pour lire les lignes du catalogue HYG, dont le contenu est encodé en ASCII, il suffit d'empiler deux lecteurs au-dessus du flot d'entrée fourni à la méthode load :

  1. un InputStreamReader utilisant le jeu de caractères US_ASCII, pour correctement transformer les octets du flot en caractères,
  2. un BufferedReader, pour (en quelque sorte) transformer le flot de caractères en flot de lignes, que l'on peut lire au moyen de la méthode readLine.

Pour découper les lignes en leur 37 colonnes, le plus simple est d'utiliser la méthode split de String, en lui passant la virgule (,) comme chaîne de séparation1.

Pour connaître l'index des colonnes dont le contenu doit être extrait, vous pouvez soit définir des constantes en vous référant à la table 3, soit définir un type énuméré privé, imbriqué dans la classe du chargeur, et possédant un membre pour chaque colonne. Cela fait, vous pouvez utiliser la méthode ordinal de ces membres pour connaître le numéro de la colonne les contenant. Si vous désirez utiliser cette solution, voici les noms de tous les membres des colonnes du catalogue HYG, dans l'ordre : 

ID, HIP, HD, HR, GL, BF, PROPER, RA, DEC, DIST, PMRA, PMDEC,
RV, MAG, ABSMAG, SPECT, CI, X, Y, Z, VX, VY, VZ,
RARAD, DECRAD, PMRARAD, PMDECRAD, BAYER, FLAM, CON,
COMP, COMP_PRIMARY, BASE, LUM, VAR, VAR_MIN, VAR_MAX;

Pour transformer les chaînes contenant des nombres en ces nombres, utilisez les méthodes statiques Double.parseDouble ou Integer.parseInt. Notez que ces méthodes lèvent une exception si la chaîne qu'on leur passe est invalide, mais vous pouvez faire l'hypothèse que ce ne sera pas le cas.

3.6 Type énuméré AsterismLoader

Le type énuméré AsterismLoader du paquetage ….astronomy, public et immuable, contient un seul élément nommé INSTANCE et représentant un chargeur de catalogue d'astérismes. Il implémente l'interface StarCatalogue.Loader et sa seule méthode publique est la méthode load provenant de cette interface.

3.6.1 Conseils de programmation

La plupart des conseils de programmation donnés à la section précédente s'appliquent également ici. En particulier, sachez que le contenu du fichier contenant le catalogue d'astérismes est aussi encodé en ASCII.

3.7 Tests

Comme d'habitude, nous ne vous fournissons plus de tests mais un fichier de vérification de signatures contenu dans une archive Zip à importer dans votre projet.

Il convient toutefois de dire quelques mots sur les tests que vous pouvez effectuer pour valider votre calcul de la position de la Lune, et ceux que vous pouvez effectuer pour les chargeurs de catalogues, ce que font les deux sections qui suivent.

3.7.1 Position de la Lune

Le livre de référence contient comme d'habitude un calcul détaillé de la position de la Lune, à la §65, p. 166.

Attention toutefois : cet exemple contient des erreurs dues au fait que certaines valeurs ont été obtenues au moyen de modèles plus précis que ceux référencés. Au moyen du corrigé, la position écliptique de la Lune que nous obtenons pour cet exemple est :

\begin{align*} \lambda_m &= 214.862515°\\ \beta_m &= 1.716257° \end{align*}

où les valeurs ont été arrondies à 6 décimales, comme dans le livre.

3.7.2 Accès aux catalogues

Pour tester les classes de chargement de catalogues (HygDatabaseLoader et AsterismLoader), il vous faut savoir comment obtenir un flot d'entrée donnant accès aux catalogues.

Si vous les avez correctement importé dans votre projet, et pensé à ajouter le répertoire resources à votre projet (Mark Directory as > Resources Root dans IntelliJ, Build Path > Use as Source Folder dans Eclipse), la méthode getResourceAsStream de la classe Class devrait faire l'affaire.

L'embryon de classe de test ci-dessous vous montre comment procéder. Notez que le nom utilisé pour accéder au fichier contenant le catalogue HYG est /hygdata_v3.csv, et la barre oblique (/) initiale est indispensable ! De même, le fichier contenant le catalogue d'astérismes s'obtient en passant la chaîne /asterisms.txt à la méthode getResourceAsStream. 

class HygDatabaseLoaderTest {
  private static final String HYG_CATALOGUE_NAME =
    "/hygdata_v3.csv";

  @Test
  void hygDatabaseIsCorrectlyInstalled() throws IOException {
    try (InputStream hygStream = getClass()
	   .getResourceAsStream(HYG_CATALOGUE_NAME)) {
      assertNotNull(hygStream);
    }
  }

  @Test
  void hygDatabaseContainsRigel() throws IOException {
    try (InputStream hygStream = getClass()
	   .getResourceAsStream(HYG_CATALOGUE_NAME)) {
      StarCatalogue catalogue = new StarCatalogue.Builder()
	.loadFrom(hygStream, HygDatabaseLoader.INSTANCE)
	.build();
      Star rigel = null;
      for (Star s : catalogue.stars()) {
	if (s.name().equalsIgnoreCase("rigel"))
	  rigel = s;
      }
      assertNotNull(rigel);
    }
  }
}

Le premier test vérifie que getResourceAsStream retourne une valeur non nulle, ce qui devrait être le cas si vous avez correctement importé les catalogues dans votre projet. Si ce test échoue, relisez la procédure décrite au début de la §3 et vérifiez que vous avez bien effectué toutes les étapes.

Le second test charge le catalogue HYG et vérifie qu'il contient bien (au moins) une étoile nommée Rigel.

4 Résumé

Pour cette étape, vous devez :

  • écrire les classes, interfaces et types énumérés MoonModel, StarCatalogue, StarCatalogue.Builder, StarCatalogue.Loader, HygDatabaseLoader et AsterismLoader selon les instructions données plus haut,
  • tester votre code,
  • documenter la totalité des entités publiques que vous avez définies,
  • rendre votre code au plus tard le 3 avril 2020 à 17h00, via le système de rendu.

Ce rendu est un rendu testé, auquel 18 points sont attribués, au prorata des tests unitaires passés avec succès. Notez que la documentation de votre code ne sera pas évaluée avant le rendu intermédiaire. Dès lors, si vous êtes en retard, ne vous en préoccupez pas pour l'instant.

N'attendez surtout pas le dernier moment pour effectuer votre rendu, car vous n'êtes pas à l'abri d'imprévus. Souvenez-vous qu'aucun retard, aussi insignifiant soit-il, ne sera toléré !

Notes de bas de page

1

Il faut noter deux choses au sujet de l'utilisation de la méthode split pour découper les colonnes du fichiers CSV.

Premièrement, cette technique simple ne fonctionne pas avec tous les fichiers CSV, car le format CSV autorise la présence de virgules à l'intérieur d'une colonne, pour peu que son contenu soit entouré de guillemets. Toutefois, le fichier CSV que nous lisons ici ne possède pas de colonnes de ce type, et nous pouvons donc ignorer cela.

Deuxièmement, la chaîne qui est passée à split est interprétée comme une expression régulière (regular expression, souvent abrégé regexp), et pas comme une simple chaîne. Dans notre cas, cela ne change rien car la virgule que nous utilisons comme séparateur n'est pas un caractère particulier dans une telle expression. Nous pouvons donc faire l'hypothèse que la chaîne passée à split est une chaîne normale.

Il est toutefois bon de garder à l'esprit le fait que split interprète la chaîne comme une expression régulière, car cela peut réserver des surprises. Ainsi, dans l'extrait de programme suivant : 

String[] parts = "a.b.c".split(".");

le tableau parts contient … 0 éléments, et pas les chaînes a, b et c comme on pourrait le croire. Cela est dû au fait que le point (.) est interprété de manière particulière dans une expression régulière.

Le concept d'expression régulière ne sera pas examiné dans ce cours, mais vous sera présenté plus tard dans votre cursus.