in

Le Manuel Ultime des Ndarrays : Maîtriser l’Art du Calcul Scientifique avec Rust | par Mahmoud 🦀 | Mai 2023


UNE VUE D’ENSEMBLE DES STRUCTURES DE DONNÉES INTÉGRÉES À RUST ET UNE PLONGÉE PROFONDE DANS LA BIBLIOTHÈQUE NDARRAY

Rust est devenu extrêmement populaire dans le monde entier en tant que langage de programmation, et cela n’est pas sans raison. De plus, en ce qui concerne l’analyse de données en particulier, Rust se distingue de ses pairs par ses capacités exceptionnelles dans ce domaine. La vaste gamme de bibliothèques ainsi que les outils solides font de Rust l’option préférée de nombreux professionnels travaillant sur des ensembles de données complexes aujourd’hui. De plus, savoir comment stocker vos données est essentiel si vous souhaitez utiliser Rust pour l’analyse de données ou d’autres tâches connexes.

Dans cet article, nous aborderons en détail une bibliothèque Rust essentielle pour l’analyse de données, à savoir ndarray. ndarray permet aux utilisateurs de manipuler de grandes matrices et tableaux multi-dimensionnels tout en offrant une vaste sélection d’opérations mathématiques pouvant être effectuées sur eux.

Avant de plonger spécifiquement dans ndarray, examinons différentes structures de données intégrées à Rust et pourquoi Rust est un langage si exceptionnel pour l’analyse de données en général.

STRUCTURES DE DONNÉES INTÉGRÉES À RUST

Dans cette section, nous examinerons les concepts fondamentaux et les outils puissants qui forment l’ossature de ce langage de programmation Rust fantastique. Nous aborderons en particulier les bases des structures de données en Rust, notamment les vecteurs, les tuples, les ensembles et les hashmaps, pour avoir une compréhension solide de leur fonctionnement et de la manière dont ils peuvent être utilisés pour résoudre des problèmes réels.

1. Vecteurs

Les vecteurs, connus sous le nom de “listes” dans certains langages de programmation tels que Python, sont partout; des listes de courses simples aux instructions de recettes plus complexes, ils nous aident à suivre les choses et à les retrouver lorsque nous en avons besoin. En programmation, les vecteurs sont une structure de données essentielle utilisée dans d’innombrables applications, prenant de nombreuses formes et de tailles différentes.

Création d’un vecteur

En Rust, les vecteurs sont des structures de données essentielles, et vous pouvez les créer en utilisant différentes approches. Pour créer un vecteur vide, vous pouvez appeler la fonction Vec::new() et ajouter une annotation de type, car Rust ne sait pas quels éléments vous avez l’intention de stocker en lui :

“`
let v: Vec = Vec::new();
“`

De manière alternative, vous pouvez utiliser la macro vec! pour créer un nouveau vecteur avec des valeurs initiales:

“`
let v = vec![1, 2, 3];
“`

Le compilateur Rust a la capacité d’inférer le type de vecteur à partir de ses valeurs initiales, éliminant ainsi la spécification manuelle. Après avoir créé un vecteur, vous avez diverses options pour le modifier en fonction de vos besoins.

Accès aux éléments des vecteurs

En Rust, nous pouvons accéder aux valeurs stockées dans un vecteur de deux manières : soit par indexation, soit en utilisant la méthode get(). Explorons ces deux méthodes, ainsi que quelques exemples de code !

Tout d’abord, considérons le vecteur suivant v avec quelques valeurs :

“`
let v = vec![“pomme”, “banane”, “cerise”, “datte”];
“`

L’opérateur d’indexation [] peut être utilisé pour récupérer une valeur spécifique à partir d’un vecteur. Pour accéder à l’élément initial, considérons l’exemple suivant :

“`
let second = &v[1];
println!(“Le second élément est {}”, second);
“`

Ici, nous créons une référence & vers le premier élément du vecteur en utilisant l’indexation avec []. Lorsqu’on essaie d’accéder à un index qui n’existe pas, le compilateur Rust déclenche une erreur et entraîne une erreur dans le programme.

Nous pouvons utiliser la fonction get(), qui produit une Option<&T> plutôt qu’une référence, pour éviter cela. Voici comment cela fonctionne:

“`
let v = vec![(“pomme”, 3),(“banane”, 2),(“cerise”, 5),(“date”, 1)];
let quantity = v.get(2).map(|(_, q)| q);match quantity {
Some(q) => println!(“Il y a {} cerises”, q),
None => println!(“Cerises non trouvées”),
}
“`

En appelant v.get(2), le programme générera un type Option<&T>, produisant un résultat positif sous forme de Some si l’élément est présent, ou un résultat négatif sous forme de None. Nous pouvons utiliser une expression de correspondance pour gérer efficacement les deux scénarios. En utilisant ces techniques, vous pouvez facilement accéder aux éléments dans des vecteurs Rust.

Itération sur les valeurs

En Rust, itérer à travers un vecteur est une tâche courante qui peut être exécutée de deux manières : en utilisant des références immuables et mutables, ce qui nous permet d’effectuer des actions sur chaque élément de vecteur individuellement. Pour mieux comprendre, explorons les deux méthodes à l’aide d’exemples de code !

“`
let fruits = vec![(“pomme”, 3), (“banane”, 2), (“orange”, 5), (“pêche”, 4)];
let mut sum = 0;
for (_, num) in &fruits {
sum += num;
}
let avg = sum as f32 / fruits.len() as f32;
println!(“La moyenne des seconds éléments est {}”, avg);
“`

Dans le code ci-dessus, nous utilisons l’opérateur & pour obtenir une référence immuable pour chaque élément dans le vecteur. Ensuite, nous affichons la valeur de chaque élément en utilisant la macro println!.

De plus, la fonction iter() crée un itérateur pour les valeurs de vecteurs. En utilisant cette technique, nous pouvons obtenir des références mutables à chaque valeur du vecteur, nous permettant d’ajouter 10 de manière transparente.

“`
let mut values = vec![10, 20, 30, 40, 50];
for value in values.iter_mut() {
*value += 10;
}
println!(“Le vecteur modifié est {:?}”, values);
“`

Nous pouvons parcourir efficacement une partie des éléments du vecteur en utilisant une boucle for et une plage. Pour illustrer ce concept, considérons l’exemple de code suivant qui montre comment utiliser une boucle for pour obtenir des références immuables pour obtenir uniquement trois éléments d’un vecteur donné avant de les mettre en sortie sur le terminal.

“`
let values = vec![10, 20, 30, 40, 50];
for value in &values[0..3] {
println!(“La valeur est {}”, value);
}
“`

En utilisant la fonction enumerate() de Rust, nous pouvons facilement parcourir un vecteur et obtenir ses valeurs et ses indices correspondants. L’exemple de code ci-dessous montre comment utiliser la méthode enumerate() pour récupérer des références immuables pour chaque élément dans un vecteur basé sur des valeurs i32 tout en imprimant simultanément leurs indices et leurs valeurs respectifs.

“`
let values = vec![10, 20, 30, 40, 50];
for (index, value) in values.iter().enumerate() {
println!(“La valeur à l’index {} est {}”, index, value);
}
“`

En utilisant ces techniques, vous pouvez facilement itérer et manipuler des éléments dans les vecteurs Rust !

Modifier un vecteur

La polyvalence des vecteurs de Rust réside dans sa capacité à se redimensionner dynamiquement, permettant l’ajout ou la suppression d’éléments lors de l’exécution. Cette section explorera différentes approches pour modifier et mettre à jour des vecteurs dans Rust.

Ajout d’éléments

Nous pouvons ajouter des éléments à un vecteur en utilisant la méthode push(), qui ajoute un élément à la fin du vecteur :

“`
let mut v = vec![“pomme”, “banane”, “orange”];
v.push(“mangue”);
println!(“{:?}”, v);
“`

L’exemple ci-dessus implique la création d’un vecteur de trois éléments, suivi de l’ajout de “mangue” à la fin avec une opération push. Finalement, nous affichons le vecteur modifié sur le terminal via la macro println!.
Alternativement, nous pouvons utiliser la méthode insert

What do you think?

Leave a Reply

Your email address will not be published. Required fields are marked *

Application de v̩rification de commande GA4 РAudit de vos donn̩es de conversion ecommerce de suivi dans GA4

BonjourDéco