From 4f50dfeea0cfc94cd936918bec684fb1d18ae8d8 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 3 Apr 2024 10:07:26 +0200 Subject: [PATCH 01/23] Initial maven MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Configuration maven + Début bibliothèque test. --- src/main/java/DataFrame.java | 44 ++++++++++++++++++++++++++ src/main/java/Main.java | 15 +++++++++ src/main/java/pandajava/java/Main.java | 7 ---- src/main/ressources/example1.csv | 5 +++ 4 files changed, 64 insertions(+), 7 deletions(-) create mode 100644 src/main/java/DataFrame.java create mode 100644 src/main/java/Main.java delete mode 100644 src/main/java/pandajava/java/Main.java create mode 100644 src/main/ressources/example1.csv diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java new file mode 100644 index 0000000..20f18d7 --- /dev/null +++ b/src/main/java/DataFrame.java @@ -0,0 +1,44 @@ +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class DataFrame { + private List data; + private String[] columns; + + public DataFrame(Object[][] data, String[] columns) { + this.data = new ArrayList<>(Arrays.asList(data)); + this.columns = columns; + } + + public DataFrame(String csvFilePath) throws IOException { + this.data = new ArrayList<>(); + BufferedReader br = new BufferedReader(new FileReader(csvFilePath)); + String line; + boolean firstLine = true; + while ((line = br.readLine()) != null) { + if (firstLine) { + // La première ligne est les noms des colonnes + this.columns = line.split(","); + firstLine = false; + } else { + // Les autres lignes sont les données + String[] rowData = line.split(","); + data.add(rowData); + } + } + br.close(); + } + + + public void display() { + System.out.println(Arrays.toString(columns)); + for (Object[] row : data) { + System.out.println(Arrays.toString(row)); + } + + } +} diff --git a/src/main/java/Main.java b/src/main/java/Main.java new file mode 100644 index 0000000..57003f2 --- /dev/null +++ b/src/main/java/Main.java @@ -0,0 +1,15 @@ +package pandajava.java; +import java.io.IOException; + +public class Main { + public static void main(String[] args) { + // try { + // DataFrame df = new DataFrame("src/main/resources/example1.csv"); + // df.display(); + // } catch (Exception e) { + // e.printStackTrace(); + // } + System.out.println("Hello, World!"); + + } +} \ No newline at end of file diff --git a/src/main/java/pandajava/java/Main.java b/src/main/java/pandajava/java/Main.java deleted file mode 100644 index 9085a77..0000000 --- a/src/main/java/pandajava/java/Main.java +++ /dev/null @@ -1,7 +0,0 @@ -package pandajava.java; - -public class Main { - public static void main(String[] args) { - System.out.println("Hello world!"); - } -} \ No newline at end of file diff --git a/src/main/ressources/example1.csv b/src/main/ressources/example1.csv new file mode 100644 index 0000000..1c8e11e --- /dev/null +++ b/src/main/ressources/example1.csv @@ -0,0 +1,5 @@ +Nom,Âge,Note +Alice,20,85 +Bob,21,75 +Charlie,19,90 +Dave,22,80 From d85be2bed0dfb6b0014f95d90a4a8f714fa1e064 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Wed, 3 Apr 2024 10:38:52 +0200 Subject: [PATCH 02/23] Lecture et affichage csv MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ajout de la classe DataFrame pour la manipulation de données tabulaires La classe DataFrame permet de créer un DataFrame à partir de données en mémoire ou d'un fichier CSV. Elle contient également une méthode display() pour afficher les données du DataFrame. La méthode de construction DataFrame(String csvFilePath) permet de charger les données à partir d'un fichier CSV, en utilisant la première ligne comme noms de colonnes et les lignes suivantes comme données. --- src/main/java/Main.java | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 57003f2..72eac68 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,15 +1,12 @@ -package pandajava.java; import java.io.IOException; - public class Main { public static void main(String[] args) { - // try { - // DataFrame df = new DataFrame("src/main/resources/example1.csv"); - // df.display(); - // } catch (Exception e) { - // e.printStackTrace(); - // } - System.out.println("Hello, World!"); + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + df.display(); + } catch (Exception e) { + e.printStackTrace(); + } } } \ No newline at end of file From 9d8e0c6dff9dde9ef1627471913892a47efeff2a Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 3 Apr 2024 11:12:56 +0200 Subject: [PATCH 03/23] DisplayFirst() + DisplayLast() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ajout des méthodes displayFirst() et displayLast() pour afficher les premières et dernières lignes du DataFrame Les méthodes displayFirst(int numRows) et displayLast(int numRows) ont été ajoutées à la classe DataFrame. La méthode displayFirst() permet d'afficher les premières lignes du DataFrame en spécifiant le nombre de lignes à afficher (numRows). Si le nombre de lignes demandé est supérieur au nombre total de lignes dans le DataFrame, elle affiche seulement les lignes disponibles. La méthode displayLast() permet d'afficher les dernières lignes du DataFrame en spécifiant le nombre de lignes à afficher (numRows). Elle détermine le point de départ pour afficher les lignes en fonction du nombre de lignes demandé et du nombre total de lignes dans le DataFrame. --- src/main/java/DataFrame.java | 30 ++++++++++++++++++++++++++++++ src/main/java/Main.java | 5 ++++- 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 20f18d7..d1dfebd 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -32,6 +32,36 @@ public DataFrame(String csvFilePath) throws IOException { } br.close(); } + + public void displayFirst(int numRows) { + // Affiche numRows les premières lignes du DataFrame + for (String column : columns) { + System.out.print(column + "\t"); + } + System.out.println(); + for (int i = 0; i < numRows && i < data.size(); i++) { + Object[] row = data.get(i); + for (Object cell : row) { + System.out.print(cell + "\t"); + } + System.out.println(); + } + } + + public void displayLast(int numRows) { + // Affiche numRows les dernières lignes du DataFrame + for (String column : columns) { + System.out.print(column + "\t"); + } + System.out.println(); + for (int i = Math.max(0, data.size() - numRows); i < data.size(); i++) { + Object[] row = data.get(i); + for (Object cell : row) { + System.out.print(cell + "\t"); + } + System.out.println(); + } + } public void display() { diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 72eac68..1080425 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -3,7 +3,10 @@ public class Main { public static void main(String[] args) { try { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - df.display(); + df.displayFirst(1); + System.out.println(); + df.displayLast(1); + // df.display(); } catch (Exception e) { e.printStackTrace(); } From 19cbf49cacef1139f66c0d2d127fb6036e392d71 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 09:55:57 +0200 Subject: [PATCH 04/23] selectRows(int[] indices) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Modification de la classe DataFrame pour ajouter la méthode selectRows(int[] indices) qui permet de sélectionner les lignes spécifiées par les indices fournis. La méthode vérifie d'abord que les indices sont valides, puis parcourt chaque index pour ajouter les lignes correspondantes aux données sélectionnées. Enfin, elle crée et retourne un nouveau DataFrame contenant les lignes sélectionnées. --- src/main/java/DataFrame.java | 27 +++++++++++++++++++++++++++ src/main/java/Main.java | 5 +++-- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index d1dfebd..9d74413 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -65,10 +65,37 @@ public void displayLast(int numRows) { public void display() { + // Affiche toutes les données du DataFrame System.out.println(Arrays.toString(columns)); for (Object[] row : data) { System.out.println(Arrays.toString(row)); } } + + public DataFrame selectRows(int[] indices) { + // Sélectionne les lignes spécifiées par les indices + // Vérifie que les indices fournis sont valides + if (indices == null || indices.length == 0) { + System.out.println("Aucun indice spécifié pour la sélection des lignes."); + return null; + } + // Initialise une liste pour stocker les données sélectionnées + List selectedData = new ArrayList<>(); + // Parcourt les indices spécifiés + for (int index : indices) { + // Vérifie que l'index est valide + if (index >= 0 && index < data.size()) { + // Ajoute la ligne correspondante aux données sélectionnées + selectedData.add(data.get(index)); + } else { + System.out.println("L'indice " + index + " est invalide."); + } + } + // Convertit la liste en tableau pour créer un nouveau DataFrame + Object[][] selectedDataArray = selectedData.toArray(new Object[selectedData.size()][]); + // Retourne un nouveau DataFrame contenant les lignes sélectionnées + return new DataFrame(selectedDataArray, columns); + } + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 1080425..5a95816 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -3,10 +3,11 @@ public class Main { public static void main(String[] args) { try { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - df.displayFirst(1); + // df.displayFirst(1); System.out.println(); - df.displayLast(1); + // df.displayLast(1); // df.display(); + df.selectRows(new int[]{0, 2}).display(); } catch (Exception e) { e.printStackTrace(); } From ed7a3177b9b441473238a732a54620eac47fb781 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 10:06:16 +0200 Subject: [PATCH 05/23] selectColumns(String[] labels) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implémentation de la méthode selectRows(int[] indices) dans la classe DataFrame. Cette méthode permet de sélectionner les lignes spécifiées par les indices fournis. Elle vérifie d'abord que les indices sont valides, puis parcourt chaque index pour ajouter les lignes correspondantes aux données sélectionnées. Enfin, elle crée et retourne un nouveau DataFrame contenant les lignes sélectionnées. --- src/main/java/DataFrame.java | 32 ++++++++++++++++++++++++++++---- src/main/java/Main.java | 1 + 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 9d74413..2fc5a78 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -21,11 +21,11 @@ public DataFrame(String csvFilePath) throws IOException { boolean firstLine = true; while ((line = br.readLine()) != null) { if (firstLine) { - // La première ligne est les noms des colonnes + // La première ligne correspond aux noms des colonnes this.columns = line.split(","); firstLine = false; } else { - // Les autres lignes sont les données + // Les autres lignes correspondent aux données String[] rowData = line.split(","); data.add(rowData); } @@ -34,7 +34,7 @@ public DataFrame(String csvFilePath) throws IOException { } public void displayFirst(int numRows) { - // Affiche numRows les premières lignes du DataFrame + // Affiche numRows premières lignes du DataFrame for (String column : columns) { System.out.print(column + "\t"); } @@ -49,7 +49,7 @@ public void displayFirst(int numRows) { } public void displayLast(int numRows) { - // Affiche numRows les dernières lignes du DataFrame + // Affiche numRows dernières lignes du DataFrame for (String column : columns) { System.out.print(column + "\t"); } @@ -97,5 +97,29 @@ public DataFrame selectRows(int[] indices) { // Retourne un nouveau DataFrame contenant les lignes sélectionnées return new DataFrame(selectedDataArray, columns); } + + public DataFrame selectColumns(String[] labels) { + // Sélectionne les colonnes spécifiées par les labels + int[] selectedIndices = new int[labels.length]; + // Parcourt les labels spécifiés + for (int i = 0; i < labels.length; i++) { + for (int j = 0; j < columns.length; j++) { + if (columns[j].equals(labels[i])) { + selectedIndices[i] = j; + break; + } + } + } + // Initialise un tableau pour stocker les données sélectionnées + Object[][] selectedData = new Object[data.size()][labels.length]; + for (int i = 0; i < data.size(); i++) { + for (int j = 0; j < labels.length; j++) { + selectedData[i][j] = data.get(i)[selectedIndices[j]]; + } + } + // Crée et retourne un nouveau DataFrame contenant les colonnes sélectionnées + return new DataFrame(selectedData, labels); + } + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 5a95816..d096477 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -8,6 +8,7 @@ public static void main(String[] args) { // df.displayLast(1); // df.display(); df.selectRows(new int[]{0, 2}).display(); + df.selectColumns(new String[]{"Nom"}).display(); } catch (Exception e) { e.printStackTrace(); } From 6994297c4cb5350b3722b8f8cf6fce0fca956153 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 10:21:16 +0200 Subject: [PATCH 06/23] calculateMean(String columnName) + example2.csv + example3.csv MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ajout de deux fichiers de tests. Ajout de la méthode calculateMean à la classe DataFrame pour calculer la moyenne des valeurs dans une colonne spécifiée. Si la colonne n'existe pas, un message est affiché. La variable mean est déclarée en tant que double pour assurer une précision décimale appropriée lors du calcul de la moyenne et est renvoyé. --- src/main/java/DataFrame.java | 15 +++++++++++++++ src/main/java/Main.java | 5 ++++- src/main/ressources/example1.csv | 2 +- src/main/ressources/example2.csv | 6 ++++++ src/main/ressources/example3.csv | 6 ++++++ 5 files changed, 32 insertions(+), 2 deletions(-) create mode 100644 src/main/ressources/example2.csv create mode 100644 src/main/ressources/example3.csv diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 2fc5a78..c839ecd 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import java.util.stream.Collectors; public class DataFrame { private List data; @@ -121,5 +122,19 @@ public DataFrame selectColumns(String[] labels) { return new DataFrame(selectedData, labels); } + public double calculateMean(String columnName) { + int columnIndex = Arrays.asList(columns).indexOf(columnName); + double mean = 0; // Déclaration de mean en tant que double + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream().map(row -> Double.parseDouble(row[columnIndex].toString())).collect(Collectors.toList()); + // Calcule la moyenne + mean = values.stream().mapToDouble(Double::doubleValue).average().orElse(Double.NaN); + return mean; + } + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index d096477..bb2d1f2 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -2,13 +2,16 @@ public class Main { public static void main(String[] args) { try { - DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame df = new DataFrame("src/main/ressources/example3.csv"); // df.displayFirst(1); System.out.println(); // df.displayLast(1); // df.display(); df.selectRows(new int[]{0, 2}).display(); df.selectColumns(new String[]{"Nom"}).display(); + double meanAge = df.calculateMean("Age"); + System.out.println("Moyenne de l'âge : " + meanAge); + } catch (Exception e) { e.printStackTrace(); } diff --git a/src/main/ressources/example1.csv b/src/main/ressources/example1.csv index 1c8e11e..6793f8c 100644 --- a/src/main/ressources/example1.csv +++ b/src/main/ressources/example1.csv @@ -1,4 +1,4 @@ -Nom,Âge,Note +Nom,Age,Note Alice,20,85 Bob,21,75 Charlie,19,90 diff --git a/src/main/ressources/example2.csv b/src/main/ressources/example2.csv new file mode 100644 index 0000000..fdcccd4 --- /dev/null +++ b/src/main/ressources/example2.csv @@ -0,0 +1,6 @@ +EmployeeID,FirstName,LastName,Department,Salary +201,Robert,Miller,IT,60000 +202,Sarah,Davis,HR,55000 +203,John,Anderson,Finance,62000 +204,Emily,Martin,Marketing,58000 +205,Matthew,Thompson,Sales,63000 diff --git a/src/main/ressources/example3.csv b/src/main/ressources/example3.csv new file mode 100644 index 0000000..2073e3c --- /dev/null +++ b/src/main/ressources/example3.csv @@ -0,0 +1,6 @@ +ID,Name,Age,Score +1,John,25,85 +2,Amy,28,90 +3,Michael,30,75 +4,Susan,27,88 +5,David,29,82 From 19e6c8b81686f2ce327d514c78fd34ccf23154cf Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 10:30:05 +0200 Subject: [PATCH 07/23] calculateMinimum(String columnName) + calculateMaximum(String columnName) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ajout des méthodes calculateMinimum(String columnName) et calculateMaximum(String columnName) à la classe DataFrame pour permettre le calcul du minimum et du maximum des valeurs dans une colonne spécifiée. Ces méthodes recherchent l'index de la colonne, vérifient son existence, puis récupèrent les valeurs de la colonne pour trouver respectivement le minimum et le maximum. Les valeurs minimum et maximum sont renvoyées. --- README.md | 4 ++++ src/main/java/DataFrame.java | 32 ++++++++++++++++++++++++++++++++ src/main/java/Main.java | 6 ++++++ 3 files changed, 42 insertions(+) diff --git a/README.md b/README.md index 71cda2d..1ad4921 100644 --- a/README.md +++ b/README.md @@ -1 +1,5 @@ # DevOpsProjet + +Commande : +mvn -B package --file pom.xml +mvn exec:java -Dexec.mainClass="Main" \ No newline at end of file diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index c839ecd..be62dcf 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -136,5 +136,37 @@ public double calculateMean(String columnName) { return mean; } + public double calculateMinimum(String columnName) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream() + .map(row -> Double.parseDouble(row[columnIndex].toString())) + .collect(Collectors.toList()); + // Trouve la valeur minimale + return values.stream().mapToDouble(Double::doubleValue).min().orElse(Double.NaN); + } + + public double calculateMaximum(String columnName) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream() + .map(row -> Double.parseDouble(row[columnIndex].toString())) + .collect(Collectors.toList()); + // Trouve la valeur maximale + return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); + } + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index bb2d1f2..34f59ab 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -12,6 +12,12 @@ public static void main(String[] args) { double meanAge = df.calculateMean("Age"); System.out.println("Moyenne de l'âge : " + meanAge); + // Calcul du minimum et du maximum de l'âge + double minAge = df.calculateMinimum("Age"); + double maxAge = df.calculateMaximum("Age"); + System.out.println("Minimum de l'âge : " + minAge); + System.out.println("Maximum de l'âge : " + maxAge); + } catch (Exception e) { e.printStackTrace(); } From 997e199cf0cf3377da39ca9585be9c905a4b14df Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 10:58:17 +0200 Subject: [PATCH 08/23] format Javadoc Modification de DataFrame.java pour qu'il soit Javadoc compatible. --- src/main/java/DataFrame.java | 61 +++++++++++++++++++++++++++++++++--- 1 file changed, 56 insertions(+), 5 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index be62dcf..75c11d4 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -6,26 +6,41 @@ import java.util.List; import java.util.stream.Collectors; +/** + * Une classe représentant un DataFrame pour la manipulation de données tabulaires. + */ public class DataFrame { private List data; private String[] columns; + /** + * Constructeur prenant des données et des colonnes en tant que paramètres. + * + * @param data Les données du DataFrame. + * @param columns Les noms des colonnes. + */ public DataFrame(Object[][] data, String[] columns) { this.data = new ArrayList<>(Arrays.asList(data)); this.columns = columns; } + /** + * Constructeur prenant un chemin de fichier CSV comme paramètre pour charger les données. + * + * @param csvFilePath Le chemin du fichier CSV. + * @throws IOException En cas d'erreur lors de la lecture du fichier. + */ public DataFrame(String csvFilePath) throws IOException { this.data = new ArrayList<>(); BufferedReader br = new BufferedReader(new FileReader(csvFilePath)); String line; boolean firstLine = true; while ((line = br.readLine()) != null) { - if (firstLine) { + if (firstLine) { // La première ligne correspond aux noms des colonnes this.columns = line.split(","); firstLine = false; - } else { + } else { // Les autres lignes correspondent aux données String[] rowData = line.split(","); data.add(rowData); @@ -34,8 +49,13 @@ public DataFrame(String csvFilePath) throws IOException { br.close(); } + /** + * Affiche les premières lignes du DataFrame. + * + * @param numRows Le nombre de lignes à afficher. + */ public void displayFirst(int numRows) { - // Affiche numRows premières lignes du DataFrame + // Affiche numRows premières lignes du DataFrame for (String column : columns) { System.out.print(column + "\t"); } @@ -49,6 +69,11 @@ public void displayFirst(int numRows) { } } + /** + * Affiche les dernières lignes du DataFrame. + * + * @param numRows Le nombre de lignes à afficher. + */ public void displayLast(int numRows) { // Affiche numRows dernières lignes du DataFrame for (String column : columns) { @@ -63,8 +88,10 @@ public void displayLast(int numRows) { System.out.println(); } } - + /** + * Affiche toutes les données du DataFrame. + */ public void display() { // Affiche toutes les données du DataFrame System.out.println(Arrays.toString(columns)); @@ -74,6 +101,12 @@ public void display() { } + /** + * Sélectionne les lignes spécifiées par les indices. + * + * @param indices Les indices des lignes à sélectionner. + * @return Un nouveau DataFrame contenant les lignes sélectionnées. + */ public DataFrame selectRows(int[] indices) { // Sélectionne les lignes spécifiées par les indices // Vérifie que les indices fournis sont valides @@ -99,6 +132,12 @@ public DataFrame selectRows(int[] indices) { return new DataFrame(selectedDataArray, columns); } + /** + * Sélectionne les colonnes spécifiées par les labels. + * + * @param labels Les noms des colonnes à sélectionner. + * @return Un nouveau DataFrame contenant les colonnes sélectionnées. + */ public DataFrame selectColumns(String[] labels) { // Sélectionne les colonnes spécifiées par les labels int[] selectedIndices = new int[labels.length]; @@ -122,6 +161,12 @@ public DataFrame selectColumns(String[] labels) { return new DataFrame(selectedData, labels); } + /** + * Calcule la moyenne des valeurs dans la colonne spécifiée. + * + * @param columnName Le nom de la colonne pour laquelle calculer la moyenne. + * @return La moyenne des valeurs de la colonne. + */ public double calculateMean(String columnName) { int columnIndex = Arrays.asList(columns).indexOf(columnName); double mean = 0; // Déclaration de mean en tant que double @@ -151,7 +196,13 @@ public double calculateMinimum(String columnName) { // Trouve la valeur minimale return values.stream().mapToDouble(Double::doubleValue).min().orElse(Double.NaN); } - + + /** + * Calcule la valeur maximale dans la colonne spécifiée. + * + * @param columnName Le nom de la colonne pour laquelle calculer la valeur maximale. + * @return La valeur maximale de la colonne. + */ public double calculateMaximum(String columnName) { // Obtient l'index de la colonne int columnIndex = Arrays.asList(columns).indexOf(columnName); From 2544fa07468a0b6c433f077f9c292321217d27db Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Wed, 10 Apr 2024 14:25:50 +0200 Subject: [PATCH 09/23] Configuration maven pour ajout des tests --- pom.xml | 28 ++++++++++++++++++++++-- src/test/java/minimal/DataFrameTest.java | 12 ++++++++++ 2 files changed, 38 insertions(+), 2 deletions(-) create mode 100644 src/test/java/minimal/DataFrameTest.java diff --git a/pom.xml b/pom.xml index a006db5..c9130a3 100644 --- a/pom.xml +++ b/pom.xml @@ -1,7 +1,7 @@ + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 pandajava.java @@ -13,4 +13,28 @@ 17 + + + junit + junit + 4.13.2 + test + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + org.apache.maven.surefire + surefire-junit47 + 3.2.5 + + + + + \ No newline at end of file diff --git a/src/test/java/minimal/DataFrameTest.java b/src/test/java/minimal/DataFrameTest.java new file mode 100644 index 0000000..3f37791 --- /dev/null +++ b/src/test/java/minimal/DataFrameTest.java @@ -0,0 +1,12 @@ +package minimal; + +import static org.junit.Assert.assertTrue; +import org.junit.Test; + + +public class DataFrameTest { + @Test + public void test1() { + assertTrue(true); + } +} From 798e641bd3f83fa511e051081324ed3fc82b1d92 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 14:54:23 +0200 Subject: [PATCH 10/23] Premier tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mise en place de deux premiers tests pour vérifier que la construction de notre dataframe ne provoque pas d'erreur. --- src/main/java/Main.java | 19 ++++++++-------- src/test/java/DataFrameTest.java | 28 ++++++++++++++++++++++++ src/test/java/minimal/DataFrameTest.java | 12 ---------- 3 files changed, 38 insertions(+), 21 deletions(-) create mode 100644 src/test/java/DataFrameTest.java delete mode 100644 src/test/java/minimal/DataFrameTest.java diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 34f59ab..c77463d 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -3,20 +3,21 @@ public class Main { public static void main(String[] args) { try { DataFrame df = new DataFrame("src/main/ressources/example3.csv"); - // df.displayFirst(1); + df.displayFirst(1); System.out.println(); + System.out.println("ID\tName\tAge\tScore\n1\tJohn\t25\t85\n"); // df.displayLast(1); // df.display(); - df.selectRows(new int[]{0, 2}).display(); - df.selectColumns(new String[]{"Nom"}).display(); - double meanAge = df.calculateMean("Age"); - System.out.println("Moyenne de l'âge : " + meanAge); + // df.selectRows(new int[]{0, 2}).display(); + // df.selectColumns(new String[]{"Nom"}).display(); + // double meanAge = df.calculateMean("Age"); + // System.out.println("Moyenne de l'âge : " + meanAge); // Calcul du minimum et du maximum de l'âge - double minAge = df.calculateMinimum("Age"); - double maxAge = df.calculateMaximum("Age"); - System.out.println("Minimum de l'âge : " + minAge); - System.out.println("Maximum de l'âge : " + maxAge); + // double minAge = df.calculateMinimum("Age"); + // double maxAge = df.calculateMaximum("Age"); + // System.out.println("Minimum de l'âge : " + minAge); + // System.out.println("Maximum de l'âge : " + maxAge); } catch (Exception e) { e.printStackTrace(); diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java new file mode 100644 index 0000000..ecde579 --- /dev/null +++ b/src/test/java/DataFrameTest.java @@ -0,0 +1,28 @@ + +import org.junit.Test; +import java.io.IOException; + +import static org.junit.Assert.*; +import static org.junit.Assert.assertNotNull; + +public class DataFrameTest { + + @Test + public void testDFnotnull() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + assert(df != null); + } + + @Test + public void testDFdisplay() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + df.display(); + } + + // @Test + // public void testDFdisplayFirst() throws IOException { + // DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + // String response = df.displayFirst(1); + // assertEquals(response, "ID\tName\tAge\tScore\n1\tJohn\t25\t85"); + // } +} diff --git a/src/test/java/minimal/DataFrameTest.java b/src/test/java/minimal/DataFrameTest.java deleted file mode 100644 index 3f37791..0000000 --- a/src/test/java/minimal/DataFrameTest.java +++ /dev/null @@ -1,12 +0,0 @@ -package minimal; - -import static org.junit.Assert.assertTrue; -import org.junit.Test; - - -public class DataFrameTest { - @Test - public void test1() { - assertTrue(true); - } -} From 712d510a7649d6e3e906bb463bda949df90b3897 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 15:27:51 +0200 Subject: [PATCH 11/23] Ajout de test min/max/moyenne Ajout de test pour les fonction de min max et mean. --- src/main/java/DataFrame.java | 7 +++++ src/main/java/Main.java | 4 +-- src/test/java/DataFrameTest.java | 50 +++++++++++++++++++++++++++----- 3 files changed, 52 insertions(+), 9 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 75c11d4..f06ccd8 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -218,6 +218,13 @@ public double calculateMaximum(String columnName) { // Trouve la valeur maximale return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); } + public String getDataAsString() { + StringBuilder stringBuilder = new StringBuilder(); + for (Object[] row : data) { + stringBuilder.append(Arrays.toString(row)).append("\n"); + } + return stringBuilder.toString(); + } } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index c77463d..4cb258d 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -2,10 +2,10 @@ public class Main { public static void main(String[] args) { try { - DataFrame df = new DataFrame("src/main/ressources/example3.csv"); + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); df.displayFirst(1); System.out.println(); - System.out.println("ID\tName\tAge\tScore\n1\tJohn\t25\t85\n"); + System.out.println("Nom\tAge\tNote\nAlice\t20\t85\n"); // df.displayLast(1); // df.display(); // df.selectRows(new int[]{0, 2}).display(); diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index ecde579..b814f19 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -1,11 +1,17 @@ import org.junit.Test; + +import java.io.ByteArrayOutputStream; import java.io.IOException; +import java.io.PrintStream; import static org.junit.Assert.*; -import static org.junit.Assert.assertNotNull; + + public class DataFrameTest { + + @Test public void testDFnotnull() throws IOException { @@ -19,10 +25,40 @@ public void testDFdisplay() throws IOException { df.display(); } - // @Test - // public void testDFdisplayFirst() throws IOException { - // DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - // String response = df.displayFirst(1); - // assertEquals(response, "ID\tName\tAge\tScore\n1\tJohn\t25\t85"); - // } + @Test + public void testDFdisplayFirst() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + PrintStream ps = new PrintStream(baos); + PrintStream old = System.out; + System.setOut(ps); + df.displayFirst(1); + System.out.flush(); + System.setOut(old); + String response = baos.toString(); + + assertTrue(response.matches("Nom\\s*\\t\\s*Age\\s*\\t\\s*Note\\s*\\n\\s*Alice\\s*\\t\\s*20\\s*\\t\\s*85\\s*\\n")); + } + + @Test + public void testDFcalculateMean() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double meanAge = df.calculateMean("Age"); // Calcule la moyenne d'âge + assertEquals(20.5, meanAge, 0.001); + } + + @Test + public void testDFcalculateMinimum() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double minScore = df.calculateMinimum("Age"); // Calcule le score minimum + assertEquals(19.0, minScore, 0.001); + } + + @Test + public void testDFcalculateMaximum() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double maxScore = df.calculateMaximum("Age"); // Calcule le score maximum + assertEquals(22.0, maxScore, 0.001); + } } From d0629958c4c5d74dc4b4d80659028e1bc5afe6d2 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 15:33:07 +0200 Subject: [PATCH 12/23] Ajout testDFcalculateMeanNonexistentColumn Ajout d'un test de cas limite. --- src/test/java/DataFrameTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index b814f19..908bc44 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -61,4 +61,12 @@ public void testDFcalculateMaximum() throws IOException { double maxScore = df.calculateMaximum("Age"); // Calcule le score maximum assertEquals(22.0, maxScore, 0.001); } + + @Test + public void testDFcalculateMeanNonexistentColumn() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double meanNonexistent = df.calculateMean("NonexistentColumn"); + assertTrue(Double.isNaN(meanNonexistent)); // Vérifie que la moyenne est NaN pour une colonne inexistante + } + } From 058d0995e5f256ef47382850ef0af4569f9f9b29 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Wed, 10 Apr 2024 18:49:51 +0200 Subject: [PATCH 13/23] Ajout de test Test sur execption max et min Test De displayLast --- src/main/java/DataFrame.java | 8 +------- src/main/java/Main.java | 7 ++++--- src/test/java/DataFrameTest.java | 34 ++++++++++++++++++++++++++++++-- 3 files changed, 37 insertions(+), 12 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index f06ccd8..88ebea2 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -13,6 +13,7 @@ public class DataFrame { private List data; private String[] columns; + /** * Constructeur prenant des données et des colonnes en tant que paramètres. * @@ -218,13 +219,6 @@ public double calculateMaximum(String columnName) { // Trouve la valeur maximale return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); } - public String getDataAsString() { - StringBuilder stringBuilder = new StringBuilder(); - for (Object[] row : data) { - stringBuilder.append(Arrays.toString(row)).append("\n"); - } - return stringBuilder.toString(); - } } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 4cb258d..ca36b30 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -5,10 +5,11 @@ public static void main(String[] args) { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); df.displayFirst(1); System.out.println(); - System.out.println("Nom\tAge\tNote\nAlice\t20\t85\n"); - // df.displayLast(1); + // System.out.println("Nom\tAge\tNote\nAlice\t20\t85\n"); + df.displayLast(1); // df.display(); - // df.selectRows(new int[]{0, 2}).display(); + df.selectRows(new int[]{0, 2}).display(); + // df.selectColumns(new String[]{"Nom"}).display(); // double meanAge = df.calculateMean("Age"); // System.out.println("Moyenne de l'âge : " + meanAge); diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index 908bc44..28c59ef 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -51,14 +51,14 @@ public void testDFcalculateMean() throws IOException { @Test public void testDFcalculateMinimum() throws IOException { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - double minScore = df.calculateMinimum("Age"); // Calcule le score minimum + double minScore = df.calculateMinimum("Age"); // Calcule l'age minimum assertEquals(19.0, minScore, 0.001); } @Test public void testDFcalculateMaximum() throws IOException { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - double maxScore = df.calculateMaximum("Age"); // Calcule le score maximum + double maxScore = df.calculateMaximum("Age"); // Calcule l'age maximum assertEquals(22.0, maxScore, 0.001); } @@ -69,4 +69,34 @@ public void testDFcalculateMeanNonexistentColumn() throws IOException { assertTrue(Double.isNaN(meanNonexistent)); // Vérifie que la moyenne est NaN pour une colonne inexistante } + @Test + public void testDFcalculateMinimumNonexistentColumn() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double minNonexistent = df.calculateMinimum("NonexistentColumn"); + assertTrue(Double.isNaN(minNonexistent)); // Vérifie que le minimum est NaN pour une colonne inexistante + } + + @Test + public void testDFcalculateMaximumNonexistentColumn() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + double maxNonexistent = df.calculateMaximum("NonexistentColumn"); + assertTrue(Double.isNaN(maxNonexistent)); // Vérifie que le maximum est NaN pour une colonne inexistante + } + + @Test + public void testDFdisplayLast() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + PrintStream ps = new PrintStream(baos); + PrintStream old = System.out; + System.setOut(ps); + df.displayLast(1); + System.out.flush(); + System.setOut(old); + String response = baos.toString(); + assertTrue(response.matches("Nom\\s*\\t\\s*Age\\s*\\t\\s*Note\\s*\\n\\s*Dave\\s*\\t\\s*22\\s*\\t\\s*80\\s*\\n")); + } + + + } From b131084dc0f2c4ce1ccb18cae003b8c7e4ec6854 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Sat, 13 Apr 2024 17:00:38 +0200 Subject: [PATCH 14/23] Ajout ilter(String columnName, double seuil) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ajout de la méthode getData() pour récupérer les données du DataFrame. Cette méthode retourne la liste des tableaux d'objets représentant les lignes de données actuellement stockées dans le DataFrame. De plus, la méthode filter qui permet de filtrer les lignes du DataFrame en fonction d'une condition simple à été ajouté . Cette méthode prend en compte le nom de la colonne et un seuil, et retourne un nouveau DataFrame contenant les lignes où la valeur dans cette colonne est supérieure au seuil donné." --- src/main/java/DataFrame.java | 57 ++++++++++++++++++++++++++++++++ src/main/java/Main.java | 10 ++++-- src/test/java/DataFrameTest.java | 18 +++++++++- 3 files changed, 81 insertions(+), 4 deletions(-) diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 88ebea2..29ad3e1 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -13,6 +13,15 @@ public class DataFrame { private List data; private String[] columns; + /** + * Obtient les données du DataFrame. + * + * @return Les données du DataFrame. + */ + public List getData() { + return data; + } + /** * Constructeur prenant des données et des colonnes en tant que paramètres. @@ -220,5 +229,53 @@ public double calculateMaximum(String columnName) { return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); } + /** + * Filtrer les lignes du DataFrame en fonction d'une condition simple. + * + * @param columnName Le nom de la colonne à filtrer. + * @param seuil Le seuil à comparer. + * @return Un nouveau DataFrame contenant les lignes filtrées. + */ + public DataFrame filter(String columnName, double seuil) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return null; + } + + // Initialise une liste pour stocker les données filtrées + List filteredData = new ArrayList<>(); + // Parcourt les lignes du DataFrame + for (Object[] row : data) { + // Récupère la valeur de la colonne + Object value = row[columnIndex]; + // Vérifie si la valeur est supérieure au seuil + if (value instanceof String) { + try { + // Tente de convertir la valeur en Double + Double numericValue = Double.parseDouble((String) value); + // Vérifie si la valeur convertie est supérieure au seuil + if (numericValue > seuil) { + // Ajoute la ligne au DataFrame filtré + filteredData.add(row); + } + } catch (NumberFormatException e) { + // Gère les valeurs qui ne peuvent pas être converties en Double + System.out.println("La valeur '" + value + "' dans la colonne '" + columnName + "' n'est pas un nombre valide."); + } + } else if (value instanceof Double && (Double) value > seuil) { + // Si la valeur est déjà de type Double, vérifie simplement si elle est supérieure au seuil + filteredData.add(row); + } + } + // Convertit la liste en tableau pour créer un nouveau DataFrame + Object[][] filteredDataArray = filteredData.toArray(new Object[filteredData.size()][]); + // Retourne un nouveau DataFrame contenant les lignes filtrées + return new DataFrame(filteredDataArray, columns); + } + + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index ca36b30..2315e31 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -3,12 +3,12 @@ public class Main { public static void main(String[] args) { try { DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - df.displayFirst(1); + // df.displayFirst(1); System.out.println(); // System.out.println("Nom\tAge\tNote\nAlice\t20\t85\n"); - df.displayLast(1); + // df.displayLast(1); // df.display(); - df.selectRows(new int[]{0, 2}).display(); + // df.selectRows(new int[]{0, 2}).display(); // df.selectColumns(new String[]{"Nom"}).display(); // double meanAge = df.calculateMean("Age"); @@ -19,6 +19,10 @@ public static void main(String[] args) { // double maxAge = df.calculateMaximum("Age"); // System.out.println("Minimum de l'âge : " + minAge); // System.out.println("Maximum de l'âge : " + maxAge); + DataFrame filteredDataFrame = df.filter("Age", 21); + // Affichage du DataFrame filtré + System.out.println("\nDataFrame filtré :"); + filteredDataFrame.display(); } catch (Exception e) { e.printStackTrace(); diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index 28c59ef..895d7aa 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -11,7 +11,6 @@ public class DataFrameTest { - @Test public void testDFnotnull() throws IOException { @@ -97,6 +96,23 @@ public void testDFdisplayLast() throws IOException { assertTrue(response.matches("Nom\\s*\\t\\s*Age\\s*\\t\\s*Note\\s*\\n\\s*Dave\\s*\\t\\s*22\\s*\\t\\s*80\\s*\\n")); } + @Test + public void testFilter() throws IOException { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame filteredDataFrame = df.filter("Age", 25); + // Vérifie que le DataFrame filtré n'est pas null + assertNotNull(filteredDataFrame); + // Vérifie que le DataFrame filtré contient le nombre attendu de lignes + // Remplacez 0 par le nombre attendu de lignes dans votre DataFrame filtré + // En fonction des données de votre fichier CSV + assertEquals(0, filteredDataFrame.getData().size()); + + // Ajoutez d'autres assertions au besoin pour vérifier le contenu du DataFrame filtré + } } + + + + From e98f6794ca17457946b8908b7c654c8d9fcf8d13 Mon Sep 17 00:00:00 2001 From: ar0x18 Date: Sat, 13 Apr 2024 17:11:19 +0200 Subject: [PATCH 15/23] Update readme --- README.md | 12 +++++++++++- src/main/java/DataFrame.java | 1 + src/test/java/DataFrameTest.java | 21 +++++++++++++++++++++ 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 1ad4921..6a00398 100644 --- a/README.md +++ b/README.md @@ -2,4 +2,14 @@ Commande : mvn -B package --file pom.xml -mvn exec:java -Dexec.mainClass="Main" \ No newline at end of file +mvn exec:java -Dexec.mainClass="Main" + +Afficher tout le dataframe = ok : display() +Afficher seulement les premieres lignes = ok : displayFirst(int numRows) +Afficher seulement les dernieres lignes = ok : displayLast(int numRows) + +Un sous-ensemble de lignes a partir de leur index = ok : selectRows(int[] indices) +Un sous-ensemble de colonnes en utilisant les labels = ok : selectColumns(String[] labels) +mecanisme de selection avance = ok : filter(String columnName, double seuil) + +Statistiques sur un dataframe = ok : calculateMaximum(String columnName) / calculateMinimum(String columnName) / calculateMean(String columnName) \ No newline at end of file diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index 29ad3e1..c9ba6b6 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -21,6 +21,7 @@ public class DataFrame { public List getData() { return data; } + /** diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index 895d7aa..d53ef2e 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -111,6 +111,27 @@ public void testFilter() throws IOException { // Ajoutez d'autres assertions au besoin pour vérifier le contenu du DataFrame filtré } + + @Test + public void testGetData() throws Exception { + // Création d'un DataFrame avec des données fictives + Object[][] testData = { + {"Alice", 20, 85}, + {"Bob", 22, 90}, + {"Charlie", 25, 88} + }; + String[] columns = {"Name", "Age", "Score"}; + DataFrame df = new DataFrame(testData, columns); + + // Obtention des données à partir du DataFrame + Object[][] data = df.getData(); + + // Vérification que les données obtenues sont identiques aux données d'origine + assertEquals(testData.length, data.length); + for (int i = 0; i < testData.length; i++) { + assertArrayEquals(testData[i], data[i]); + } + } } From 7e0ee1c6eeaa292aefabbfd66065088d64cb7113 Mon Sep 17 00:00:00 2001 From: AEtheve <30652308+AEtheve@users.noreply.github.com> Date: Sun, 14 Apr 2024 17:19:02 +0200 Subject: [PATCH 16/23] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 71cda2d..d8b6aaf 100644 --- a/README.md +++ b/README.md @@ -1 +1 @@ -# DevOpsProjet +![Badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2FAEtheve%2F73adb891918b248bf5cd39afb416ee7c%2Fraw%2Ftest.json) From db623eecb66879c1abe01c6e5f11ed5fbad5de40 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 17:19:10 +0200 Subject: [PATCH 17/23] Add dynamic coverage badge --- .github/workflows/maven.yml | 35 +++++++++++++++++++++++------------ 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index 7bde2a7..57ddf61 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -20,16 +20,27 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - name: Set up JDK 17 - uses: actions/setup-java@v3 + - name: Get the Numbers + id: get_coverage + run: | + COVERAGE=40 + if [ $COVERAGE -lt 70 ]; then + COLOR=red + elif [ $COVERAGE -lt 90 ]; then + COLOR=orange + else + COLOR=green + fi + echo "::set-output name=COVERAGE::$COVERAGE" + echo "::set-output name=COLOR::$COLOR" + + + - name: Create the Badge + uses: schneegans/dynamic-badges-action@v1.7.0 with: - java-version: '17' - distribution: 'temurin' - cache: maven - - name: Build with Maven - run: mvn -B package --file pom.xml - - # # Optional: Uploads the full dependency graph to GitHub to improve the quality of Dependabot alerts this repository can receive - # - name: Update dependency graph - # uses: advanced-security/maven-dependency-submission-action@571e99aab1055c2e71a1e2309b9691de18d6b7d6 + auth: ${{ secrets.GIST_SECRET }} + gistID: 73adb891918b248bf5cd39afb416ee7c + filename: test.json + label: Coverage + message: ${{ steps.get_coverage.outputs.COVERAGE }}% + color: ${{ steps.get_coverage.outputs.COLOR }} \ No newline at end of file From 6b5c1074095fd20af31b0dbc6359abb143626d2a Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 17:24:15 +0200 Subject: [PATCH 18/23] Update README.md --- README.md | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/README.md b/README.md index d8b6aaf..35a8607 100644 --- a/README.md +++ b/README.md @@ -1 +1,32 @@ +# Bibliothèque d'Analyse de Données en Java + +![workflow](https://github.com/AEtheve/DevOpsProjet/actions/workflows/maven.yml/badge.svg) ![Badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2FAEtheve%2F73adb891918b248bf5cd39afb416ee7c%2Fraw%2Ftest.json) + + +## Description +Ce projet vise à développer une bibliothèque Java pour la manipulation et l'analyse de données. Inspirée par des outils tels que Pandas en Python, cette bibliothèque permettra de créer et de manipuler des structures de données complexes et d'effectuer des analyses statistiques. + +## Fonctionnalités +- Création de Dataframes à partir de collections Java ou de fichiers CSV. +- Affichage complet ou partiel des Dataframes. +- Sélection et filtrage de données basés sur des critères spécifiques. +- Calculs statistiques de base sur les colonnes des Dataframes. + +## Usage + +```python +//TODO +``` + +## Outils et Technologies +- **Git** pour le contrôle de version. +- **Maven** pour la gestion des dépendances et la construction du projet. +- **JUnit** pour les tests unitaires. +- **JaCoCo** pour l'évaluation de la couverture de code. + +## Workflow Git +Nous utilisons le workflow Feature Branch. Chaque nouvelle fonctionnalité (ou bugfix) est développée dans une branche séparée. + +## Intégration Continue +Un pipeline CI/CD est mis en place avec GitHub Actions pour automatiser les tests et la couverture de code à chaque push et Pull/Merge Request. \ No newline at end of file From 901f1c4edf74c0c85c175504668ad4c40df2e340 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 19:26:01 +0200 Subject: [PATCH 19/23] Jacoco report --- pom.xml | 20 ++++++++++++++++ src/test/java/DataFrameTest.java | 40 ++++++++++++++++---------------- 2 files changed, 40 insertions(+), 20 deletions(-) diff --git a/pom.xml b/pom.xml index c9130a3..bbe3419 100644 --- a/pom.xml +++ b/pom.xml @@ -35,6 +35,26 @@ + + org.jacoco + jacoco-maven-plugin + 0.8.8 + + + prepare-agent + + prepare-agent + + + + report + test + + report + + + + \ No newline at end of file diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index d53ef2e..776c6f2 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -112,26 +112,26 @@ public void testFilter() throws IOException { // Ajoutez d'autres assertions au besoin pour vérifier le contenu du DataFrame filtré } - @Test - public void testGetData() throws Exception { - // Création d'un DataFrame avec des données fictives - Object[][] testData = { - {"Alice", 20, 85}, - {"Bob", 22, 90}, - {"Charlie", 25, 88} - }; - String[] columns = {"Name", "Age", "Score"}; - DataFrame df = new DataFrame(testData, columns); - - // Obtention des données à partir du DataFrame - Object[][] data = df.getData(); - - // Vérification que les données obtenues sont identiques aux données d'origine - assertEquals(testData.length, data.length); - for (int i = 0; i < testData.length; i++) { - assertArrayEquals(testData[i], data[i]); - } - } + // @Test + // public void testGetData() throws Exception { + // // Création d'un DataFrame avec des données fictives + // Object[][] testData = { + // {"Alice", 20, 85}, + // {"Bob", 22, 90}, + // {"Charlie", 25, 88} + // }; + // String[] columns = {"Name", "Age", "Score"}; + // DataFrame df = new DataFrame(testData, columns); + + // // Obtention des données à partir du DataFrame + // Object[][] data = df.getData(); + + // // Vérification que les données obtenues sont identiques aux données d'origine + // assertEquals(testData.length, data.length); + // for (int i = 0; i < testData.length; i++) { + // assertArrayEquals(testData[i], data[i]); + // } + // } } From 55986af4b8931ffd984cabfa520de212291ebfa5 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 19:51:30 +0200 Subject: [PATCH 20/23] get number from jacoco report --- .github/workflows/maven.yml | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index 57ddf61..5184108 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -1,3 +1,5 @@ + + # This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven @@ -18,7 +20,6 @@ jobs: build: runs-on: ubuntu-latest - steps: - name: Get the Numbers id: get_coverage @@ -38,6 +39,32 @@ jobs: - name: Create the Badge uses: schneegans/dynamic-badges-action@v1.7.0 with: +<<<<<<< Updated upstream +======= + java-version: '17' + distribution: 'temurin' + cache: maven + - name: Build with Maven + run: mvn -B package --file pom.xml + - name: Tests + id: get_coverage + run: | + COVERAGE=$(sed -nE 's/^.*Total<([^>]+>){4}([^<]*).*$/\2/p' target/site/jacoco/index.html | sed -nE 's/[^0-9]*([0-9]+).*/\1/p') + if [ $COVERAGE -lt 70 ]; then + COLOR=red + elif [ $COVERAGE -lt 90 ]; then + COLOR=orange + else + COLOR=green + fi + echo "::set-output name=COVERAGE::$COVERAGE" + echo "::set-output name=COLOR::$COLOR" + + + - name: Create the Badge + uses: schneegans/dynamic-badges-action@v1.7.0 + with: +>>>>>>> Stashed changes auth: ${{ secrets.GIST_SECRET }} gistID: 73adb891918b248bf5cd39afb416ee7c filename: test.json From 1fe14e95819d69b4ab08f18217752bfc265b94d7 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 19:56:15 +0200 Subject: [PATCH 21/23] matches every branch --- .github/workflows/maven.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index 5184108..7fbbabc 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -12,9 +12,11 @@ name: Java CI with Maven on: push: - branches: [ "main" ] + branches: + - '**' pull_request: - branches: [ "main" ] + branches: + - '**' jobs: build: From c0d791baef7c806265d8b0fa6c89081eac702917 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Sun, 14 Apr 2024 19:58:49 +0200 Subject: [PATCH 22/23] Update maven.yml --- .github/workflows/maven.yml | 36 +++++------------------------------- 1 file changed, 5 insertions(+), 31 deletions(-) diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index 7fbbabc..51aff27 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -1,13 +1,3 @@ - - -# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven - -# This workflow uses actions that are not certified by GitHub. -# They are provided by a third-party and are governed by -# separate terms of service, privacy policy, and support -# documentation. - name: Java CI with Maven on: @@ -15,34 +5,19 @@ on: branches: - '**' pull_request: - branches: + branches: - '**' + jobs: build: runs-on: ubuntu-latest steps: - - name: Get the Numbers - id: get_coverage - run: | - COVERAGE=40 - if [ $COVERAGE -lt 70 ]; then - COLOR=red - elif [ $COVERAGE -lt 90 ]; then - COLOR=orange - else - COLOR=green - fi - echo "::set-output name=COVERAGE::$COVERAGE" - echo "::set-output name=COLOR::$COLOR" - - - - name: Create the Badge - uses: schneegans/dynamic-badges-action@v1.7.0 + - uses: actions/checkout@v3 + - name: Set up JDK 17 + uses: actions/setup-java@v3 with: -<<<<<<< Updated upstream -======= java-version: '17' distribution: 'temurin' cache: maven @@ -66,7 +41,6 @@ jobs: - name: Create the Badge uses: schneegans/dynamic-badges-action@v1.7.0 with: ->>>>>>> Stashed changes auth: ${{ secrets.GIST_SECRET }} gistID: 73adb891918b248bf5cd39afb416ee7c filename: test.json From ca5b103b5b6490a9fccf1304e2a7a566011278e2 Mon Sep 17 00:00:00 2001 From: Alexis Etheve Date: Mon, 15 Apr 2024 15:09:44 +0200 Subject: [PATCH 23/23] Delete Main Class --- src/main/java/Main.java | 32 -------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 src/main/java/Main.java diff --git a/src/main/java/Main.java b/src/main/java/Main.java deleted file mode 100644 index 2315e31..0000000 --- a/src/main/java/Main.java +++ /dev/null @@ -1,32 +0,0 @@ -import java.io.IOException; -public class Main { - public static void main(String[] args) { - try { - DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - // df.displayFirst(1); - System.out.println(); - // System.out.println("Nom\tAge\tNote\nAlice\t20\t85\n"); - // df.displayLast(1); - // df.display(); - // df.selectRows(new int[]{0, 2}).display(); - - // df.selectColumns(new String[]{"Nom"}).display(); - // double meanAge = df.calculateMean("Age"); - // System.out.println("Moyenne de l'âge : " + meanAge); - - // Calcul du minimum et du maximum de l'âge - // double minAge = df.calculateMinimum("Age"); - // double maxAge = df.calculateMaximum("Age"); - // System.out.println("Minimum de l'âge : " + minAge); - // System.out.println("Maximum de l'âge : " + maxAge); - DataFrame filteredDataFrame = df.filter("Age", 21); - // Affichage du DataFrame filtré - System.out.println("\nDataFrame filtré :"); - filteredDataFrame.display(); - - } catch (Exception e) { - e.printStackTrace(); - } - - } -} \ No newline at end of file