From 874db94a5d5e65031bd85f2260104585f4fc0770 Mon Sep 17 00:00:00 2001 From: Benjamin Date: Wed, 8 Apr 2026 10:42:58 +0200 Subject: [PATCH] Finish Nettoyage Moyenne --- src/ecoparasite/nettoyage/Nettoyage.java | 98 ++++++++++--------- src/ecoparasite/poisson/MackerelSerra.java | 91 +++++++++++++++++ .../ecoparasite/nettoyage/NettoyageTest.java | 16 ++- 3 files changed, 158 insertions(+), 47 deletions(-) create mode 100644 src/ecoparasite/poisson/MackerelSerra.java diff --git a/src/ecoparasite/nettoyage/Nettoyage.java b/src/ecoparasite/nettoyage/Nettoyage.java index d922b71..ebb4ac2 100644 --- a/src/ecoparasite/nettoyage/Nettoyage.java +++ b/src/ecoparasite/nettoyage/Nettoyage.java @@ -1,80 +1,90 @@ package ecoparasite.nettoyage; +import ecoparasite.completion.Completion; import ecoparasite.poisson.Poisson; +import java.util.ArrayList; +import java.util.Collections; import java.util.HashSet; +import java.util.function.BiConsumer; +import java.util.function.Function; /** * Class Définissant les méthodes statics de Nettoyage des données */ public class Nettoyage { - /** - * Methode Static de nettoyage des valeurs abérrante et absurde - * @param tablePoisson Un Hashset de Poisson contenant nos données - * @return Le Hashset de Poisson une fois qu'il est nettoyé - */ + /* public static HashSet nettoiePoissonMean(HashSet tablePoisson){ - Double mean = mean(tablePoisson); //Moyenne - Double ecart = ecartType(tablePoisson); // Ecart Type + Double mean = Completion.calculateMean(tablePoisson,Poisson::getInfestation); //Moyenne - Double z = 0.0; + ArrayList infest = new ArrayList<>(); + for (Poisson p : tablePoisson) { + if (p.getInfestation() != null){ //Test des valeurs null pour les Tests Unitaires. Je ne devrais pas en avoir. + infest.add(p.getInfestation()); + } + } + + Collections.sort(infest); + + int quartIndex = infest.size()/4; + Double firstQuart = infest.get(quartIndex); + Double thirdQuart = infest.get(quartIndex *3); + Double IQR = thirdQuart - firstQuart; for (Poisson p : tablePoisson) { - z = ( p.getInfestation() - mean ) / ecart; - if ( z >= 2.5 ) { - p.setInfestation(mean); + if (p.getInfestation() == null) { + p.setInfestation(mean); //Fonction codé en dur pour éviter des problèmes dans les Tests Unitaires : Completion devrais etre fait et valeur null ne devrait pas exister + } + else { + if (p.getInfestation() < firstQuart - (IQR * 1.5) || p.getInfestation() > thirdQuart + (IQR * 1.5)) { + p.setInfestation(mean); + } } } return tablePoisson; } + */ /** - * Methode Privée permettant de calculer la moyenne - * @param tablePoisson Un Hashset de Poisson contenant nos données - * @return Un Double correspondant à la moyenne + * Permet de remplacer les valeurs inexistantes d'un paramètre d'un HashSet par la moyenne des autres valeurs (non nulles). + * Exemple d'utilisation : T = Poisson, V = Double, getValue = Poisson::getInfestation, setValue = Poisson::setInfestation. + * + * @param list La liste de données cobaye. + * @param getValue La fonction (Getter) qui permet d'obtenir la valeur que l'on veut vérifier + * @param setValue La fonction (Setter) qui permet de remplacer la valeur si null. + * @return Le HashSet avec les valeurs remplacés. + * @param Le type de données cobaye. Exemple : Poisson, Population + * @param Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double. */ - private static Double mean(HashSet tablePoisson){ + public static HashSet nettoieColumnsMoyenne(HashSet list, Function getValue, BiConsumer setValue ){ - Double mean = 0.0; + Double mean = Completion.calculateMean(list, getValue); - for (Poisson p : tablePoisson){ - mean += p.getInfestation(); + ArrayList array = new ArrayList<>(); + for ( T item : list) { + if (getValue.apply(item)!= null){ //Test des valeurs null pour les Tests Unitaires. Je ne devrais pas en avoir. + array.add(getValue.apply(item).doubleValue()); + } } - return mean / tablePoisson.size(); - } + Collections.sort(array); - /** - * Methode Privée permettant de calculer la variance - * @param tablePoisson Un Hashset de Poisson contenant nos données - * @return Un Double correspondant à la variance - */ - private static Double variance(HashSet tablePoisson){ + int quartIndex = array.size()/4; + Double firstQuart = array.get(quartIndex); + Double thirdQuart = array.get(quartIndex *3); + Double IQR = thirdQuart - firstQuart; - Double vari = 0.0; - Double mean = mean(tablePoisson); - - for (Poisson p : tablePoisson) { - vari += Math.pow( (p.getInfestation() - mean), 2); + for(T item : list){ + if( getValue.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getValue.apply(item).doubleValue() > thirdQuart + (IQR * 1.5)){ + setValue.accept( item, (V) mean); + } } - return vari / tablePoisson.size(); - } - - /** - * Methode Privée permettant de calculer l'écart-type - * @param tablePoisson Un Hashset de Poisson contenant nos données - * @return Un Double correspondant à l'écart-type - */ - private static Double ecartType(HashSet tablePoisson){ - - Double vari = variance(tablePoisson); - - return Math.sqrt(vari); + return list; } diff --git a/src/ecoparasite/poisson/MackerelSerra.java b/src/ecoparasite/poisson/MackerelSerra.java new file mode 100644 index 0000000..8a95c1d --- /dev/null +++ b/src/ecoparasite/poisson/MackerelSerra.java @@ -0,0 +1,91 @@ +package ecoparasite.poisson; + +import ecoparasite.input.DataParsing; +import ecoparasite.input.InvalidParsingException; +import ecoparasite.input.RawData; +import ecoparasite.input.RawDataOverflow; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Objects; + +import static java.lang.Double.valueOf; + +public class MackerelSerra extends Poisson implements DataParsing { + + /** + * Constructeur de MackerelSerra + * @param length + * @param infestation + */ + public MackerelSerra(String id, Double length, Double infestation) { + super(id, length, null, infestation); + } + + /** + * Implémentation de la fonction parse de DataParsing. + * Renvoie un tableau de poissons à partir d'un RawData. + * + * @param data Notre RawData + * @param parseTypeId L'ID du type de parsing, ignoré ici. + * @return Le tableau de poissons. + * @throws RawDataOverflow Si on a un dépassement de données dans notre RawData. + * @throws InvalidParsingException + */ + public static HashSet parse(RawData data, int parseTypeId) throws RawDataOverflow, InvalidParsingException { + return MackerelSerra.parse(data); + } + + /** + * Implémentation de la fonction parse de Dataparsing + * @param data Notre RawData. + * @return tableau des poissons + * @throws RawDataOverflow Si on a un dépassement de données dans notre RawDataOverflow. + */ + public static HashSet parse(RawData data) throws RawDataOverflow { + + HashMap temp = new HashMap<>(); + + HashSet fishSet; + fishSet = new HashSet<>(); + + for (int i = 0; i < data.getData().getFirst().size(); i++) { + + temp = data.getEntry(i); + + String id = !Objects.equals(temp.get("id"), "") ? (temp.get("id")) : null; + Double size = !Objects.equals(temp.get("LT"), "") ? valueOf(temp.get("LT")) : null; + Double infes = !Objects.equals(temp.get("Total"), "") ? valueOf(temp.get("Total")) : null; + + Poisson newP = new MackerelSerra(id,size,infes); + newP.setFishParts( MackerelSerra.parsePartiePoisson(temp) ); + fishSet.add(newP); + } + + + return fishSet; + } + + /** + * + * @param entry + * @return + */ + private static HashSet parsePartiePoisson(HashMap entry){ + + HashSet response = new HashSet<>(); + + + for( String k: entry.keySet() ){ + if( k.contains("Foie") || k.contains("Abdomen") || k.contains("Visceres") || k.contains("Autres")){ + String bodyPart = k; + Double value = !Objects.equals(entry.get(k), "") ? valueOf(entry.get(k)) : null; + PartiePoisson p = new PartiePoisson(bodyPart, value); + response.add(p); + } + } + + return response; + } + +} diff --git a/tests/ecoparasite/nettoyage/NettoyageTest.java b/tests/ecoparasite/nettoyage/NettoyageTest.java index faa7515..b08d9e3 100644 --- a/tests/ecoparasite/nettoyage/NettoyageTest.java +++ b/tests/ecoparasite/nettoyage/NettoyageTest.java @@ -6,23 +6,33 @@ import ecoparasite.input.InputFileException; import ecoparasite.input.RawData; import ecoparasite.input.RawDataOverflow; import ecoparasite.poisson.Mackerel; +import ecoparasite.poisson.MackerelSerra; import ecoparasite.poisson.Poisson; import org.junit.jupiter.api.Test; import java.util.HashSet; +import java.util.function.BiConsumer; +import java.util.function.Function; class NettoyageTest { @org.junit.jupiter.api.Test void nettoiePoissonMean() throws InputFileException, RawDataOverflow { - RawData test = InputFactory.readData("testNettoie.csv"); + RawData test = InputFactory.readData("test2.csv", ","); - HashSet testp = Mackerel.parse(test); + HashSet testp = MackerelSerra.parse(test); System.out.println(testp); - testp = Nettoyage.nettoiePoissonMean(testp); + Function getInfes = Poisson::getInfestation; + BiConsumer setInfes = Poisson::setInfestation; + + testp = Completion.completeColumnsMoyenne( testp, getInfes, setInfes ); + + System.out.println(testp); + + testp = Nettoyage.nettoieColumnsMoyenne( testp, getInfes, setInfes ); System.out.println(testp); }