ENIB S5-OBJ_Rust Rappels - Rappels sur Rust

{} Création du projet

{} Structure Measurement

Une station météorologique est constituée d'un ensemble de relevés effectués au cours du temps.
Dans ce laboratoire, nous utiliserons un jeu de données simplifié dans lequel chaque relevé est constitué uniquement :

l'année de la mesure ;
la température moyenne annuelle, exprimée en degrés Celsius ;
la pluviométrie annuelle, exprimée en millimètres, correspondant à la quantité totale de pluie tombée au cours de l'année.

Avant d'écrire le moindre code, réfléchissez à la manière de représenter un relevé en Rust.

Quel type de donnée vous semble le plus adapté pour représenter un relevé météorologique ? Pourquoi ?

Nous utiliserons naturellement une structure.

Créez un nouveau module weather_station (fichier weather_station.rs) dans lequel seront regroupés les types liés aux stations météorologiques.
Ajoutez dans ce module une structure Measurement représentant un relevé météorologique.
Une mesure possède trois données membres :

year, de type u16 ;
temperature, de type f32 ;
rainfall, de type f32.

Faites précéder la structure par l'attribut Rust :

#[derive(Debug, Clone, Copy)]

Contrairement aux objets manipulés dans les laboratoires précédents, un relevé météorologique ne possède pas d'invariant particulier.

Faut-il encapsuler les données membres de Measurement ? Justifiez votre réponse.
(Vous pourrez comparer votre réponse avec celle concernant la structure WeatherStation dans la section suivante.)

Déclarez ensuite un bloc impl et fournissez une fonction d'initialisation :

pub fn new(year: u16, temperature: f32, rainfall: f32) -> Self

Cette fonction doit construire et retourner un nouvel objet Measurement.

Dans le fichier main.rs, commencez par déclarer le module weather_station :

mod weather_station;

Créez ensuite quelques mesures correspondant à différentes années puis affichez-les à l'aide de l'affichage de débogage.
Par exemple :

Measurement { year: 2022, temperature: 13.6, rainfall : 991.0 }
Measurement { year: 2023, temperature: 14.1, rainfall : 1200.0 }
Measurement { year: 2024, temperature: 14.3, rainfall : 708, 5 }

Compilez et exécutez votre programme avant de poursuivre.

{} Structure WeatherStation

Une station météorologique ne se résume pas à une seule mesure.
Au fil des années, elle accumule un ensemble de relevés qu'il sera ensuite possible d'analyser.
Nous allons maintenant représenter une station météo capable de mémoriser toutes les mesures qui lui sont associées.

Avant d'écrire cette nouvelle structure, réfléchissez aux questions suivantes :
Quelles informations une station météorologique doit-elle mémoriser ?
Quel type de donnée permet de stocker un nombre quelconque de mesures ?

Nous utiliserons un vecteur (Vec) pour mémoriser les relevés.
Déclarez dans le module weather_station une structure WeatherStation contenant les deux données membres suivantes :

name, une chaîne de caractères (String) contenant le nom de la station ;
measurements, un vecteur (Vec<Measurement>) contenant les relevés météorologiques.

Contrairement à Measurement, cette nouvelle structure représente un objet plus complexe.

Les données membres de WeatherStation doivent-elles être publiques ? Pourquoi ?

La structure devra être accessible depuis les autres modules, mais ses données membres resteront encapsulées.

Déclarez ensuite un bloc impl et fournissez une fonction d'initialisation :

pub fn new(name: &str) -> Self

Cette fonction reçoit le nom de la station et crée une station ne contenant encore aucune mesure.

Quelle doit être la taille du vecteur measurements juste après la construction d'une station ?

Testez cette nouvelle structure dans main().
Créez une station appelée "Brest" puis affichez-la à l'aide de l'affichage de débogage.
Le résultat doit être similaire à :

WeatherStation {
    name: "Brest",
    measurements: [],
}

Une première difficulté
Vous constaterez que le compilateur refuse probablement d'afficher votre objet.

Pourquoi Measurement pouvait-il être affiché avec println!("{:?}", ...), mais pas encore WeatherStation ?

Modifiez votre structure afin de permettre son affichage de débogage.
Compilez et exécutez votre programme avant de poursuivre.

{3.1} Ajouter des mesures

{3.2} Informations sur la station

{3.3} Accéder aux mesures de la station

{3.4} Charger une station depuis un fichier

Nous souhaitons maintenant utiliser de véritables données météorologiques, calculées à partir de relevés quotidiens couvrant la période de 1950 à aujourd'hui.
Ces données vous sont fournies dans des fichiers CSV.

Chaque fichier CSV contient les informations suivantes :

year;temperature;rainfall
1950;11.8;991.9
1951;11.6;1116.6
1952;11.6;895.5
...

Nous allons maintenant créer directement une station météorologique à partir d'un tel fichier.
Cette fonction constitue un deuxième constructeur.
Au lieu de créer une station vide avec new() puis d'y ajouter les mesures une à une, elle crée directement une station initialisée à partir du contenu d'un fichier.

Ajoutez à WeatherStation la fonction associée suivante :

pub fn load(path: &str) -> Result<Self, Box<dyn Error>>

Comme la fonction new, cette fonction ne possède pas de paramètre self, car elle n'agit pas sur une instance existante.

Cette fonction doit :

ouvrir le fichier CSV ;
créer une nouvelle station météorologique ;
lire les mesures contenues dans le fichier ;
ajouter chaque mesure à la station ;
renvoyer la station ainsi construite.

Le chargement d'un fichier pouvant échouer (fichier inexistant, erreur de lecture, données invalides...), cette fonction renvoie un Result.

Pour implémenter la fonction load(), inspirez-des exemples fournis dans cette note✍.

Modifiez ensuite le programme principal afin de charger une station depuis le fichier brest.csv✍.

let station = WeatherStation::load("data/brest.csv")?;

Utilisez ensuite les méthodes développées précédemment afin d'afficher :

le nom de la station ;
le nombre de mesures.

{} Statistiques

Jusqu'à présent, WeatherStation avait pour rôle de stocker et de charger les mesures météorologiques.
Nous allons maintenant écrire des fonctions permettant d'analyser ces données.

Ces traitements ne modifient pas la station et pourraient être appliqués à n'importe quelle collection de mesures.
Nous les regrouperons donc dans un module statistics.

Ajoutez à votre projet un nouveau fichier statistics.rs.

{4.1} Température et pluviométrie moyennes

Nous souhaitons calculer la température moyenne d'un ensemble de mesures.
Ajoutez la fonction suivante :

pub fn average_temperature(measurements: &[Measurement]) -> Option<f32>

Cette fonction reçoit une slice de mesures et renvoie leur température moyenne.
Avant de commencer, réfléchissez au cas particulier suivant.

Que doit renvoyer la fonction si la slice ne contient aucune mesure ?

Comme nous l'avons vu précédemment, Rust utilise le type générique Option pour représenter une valeur qui peut être absente.
La fonction devra donc :

renvoyer Some(temperature) si la slice contient au moins une mesure (où temperature est la température moyenne calculée) ;
renvoyer None si la slice est vide.

Pour réaliser ce calcul :

parcourez toutes les mesures de la slice ;
calculez la somme des températures ;
renvoyez leur moyenne.

Testez ensuite votre fonction dans main(). Par exemple, vous devez affichier :

Average temperature : 12.8 °C

Pourquoi le paramètre est-il de type &[Measurement] et non Vec ?

Remarque
La solution précédente utilise une boucle, ce qui est parfaitement adapté pour découvrir le langage.
Une version plus idiomatique peut être obtenue à l'aide des itérateurs de la bibliothèque standard (iter(), map() et sum()) dans un style fonctionnel✍.

Exercice
En vous inspirant de average_temperature(), implémentez la fonction suivante :

pub fn average_rainfall(measurements: &[Measurement]) -> Option<f32>

Cette fonction calcule la pluviométrie moyenne d'une collection de mesures.
Écrivez d'abord une version utilisant une boucle, puis proposez une version plus en style fonctionnel utilisant les itérateurs.
Lisez la note précédente pour avoir des indices.

{4.2} Rechercher l'année la plus chaude

{5} Exploiter des données réelles