Merge remote-tracking branch 'origin/Ben8Avril' into Ben8Avril

src/ecoparasite/LectureEval.java

@@ -1,15 +1,20 @@
 package ecoparasite;
 
+import ecoparasite.completion.Completion;
 import ecoparasite.input.InputFactory;
 import ecoparasite.input.InputFileException;
 import ecoparasite.input.RawData;
 import ecoparasite.input.RawDataOverflow;
+import ecoparasite.nettoyage.Nettoyage;
+import ecoparasite.poisson.Poisson;
 import ecoparasite.population.Population;
 import ecoparasite.population.PopulationArgInterval;
 import ecoparasite.population.PopulationArgs;
 
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 public class LectureEval {
 
@@ -90,6 +95,28 @@ public class LectureEval {
             System.out.println(p);
         }
 
+        // Complétion de la masse.
+        Function<Population,Double> getWeight = population -> {
+            return population.getTotal().getWidth() != null ? population.getTotal().getWidth().transformToDouble() : null;
+        };
+        BiConsumer<Population,Double> setWeight = (population, aDouble) -> {
+            population.getTotal().setWidth(new PopulationArgInterval(aDouble,aDouble));
+        };
+
+        // Complétion de la masse.
+        pop = Completion.completeColumnsMoyenne(pop, getWeight, setWeight);
+        System.out.println("---");
+        for( Population p: pop){
+            System.out.println(p);
+        }
+
+        // Nettoyage de la masse.
+        pop = Nettoyage.nettoieColumnsMoyenne(pop, getWeight, setWeight, false);
+        System.out.println("---");
+        for( Population p: pop){
+            System.out.println(p);
+        }
+
     }
 
 }

src/ecoparasite/nettoyage/Nettoyage.java

@@ -15,17 +15,18 @@ import java.util.function.Function;
 public class Nettoyage {
 
     /**
-     * Permet de remplacer les valeurs inexistantes d'un paramètre d'un HashSet par la moyenne des autres valeurs (non nulles).
+     * Permet de remplacer les valeurs abérrantes 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.
+     * @param allowNegative Savoir si une valeur négative est forcément aberrant.
      * @return Le HashSet avec les valeurs remplacés.
      * @param <T> Le type de données cobaye. Exemple : Poisson, Population
      * @param <V> Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double.
      */
-    public static <T,V extends Number> HashSet<T> nettoieColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue ){
+    public static <T,V extends Number> HashSet<T> nettoieColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue, boolean allowNegative ){
 
         Double mean = Completion.calculateMean(list, getValue);
 
@@ -44,7 +45,7 @@ public class Nettoyage {
         Double IQR =  thirdQuart - firstQuart;
 
         for(T item : list){
-            if( getValue.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getValue.apply(item).doubleValue() > thirdQuart + (IQR * 1.5)){
+            if( getValue.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getValue.apply(item).doubleValue() > thirdQuart + (IQR * 1.5) || ( !allowNegative && getValue.apply(item).doubleValue() < 0 ) ){
                 setValue.accept( item, (V) mean);
             }
         }
@@ -52,5 +53,77 @@ public class Nettoyage {
         return list;
     }
 
+    /**
+     * Polymorphisme de la fonction précédente. Autorise les valeurs abérrantes à être négative.
+     * @param list
+     * @param getValue
+     * @param setValue
+     * @return
+     * @param <T>
+     * @param <V>
+     *
+     * @see Nettoyage::nettoieColumnsMoyenne
+     */
+    public static <T,V extends Number> HashSet<T> nettoieColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue){
+        return nettoieColumnsMoyenne(list, getValue, setValue, true);
+    }
 
+    /**
+     * Permet de remplacer les valeurs abérrantes d'un paramètre d'un HashSet à l'aide d'une regression linéaire, corrélation entre deux valeurs.
+     * Exemple d'utilisation : T = Poisson, V = Double, getX = Poisson::getWidth, getY = Poisson::getInfes, setY = Poisson::setInfes
+     *
+     * @param list La liste de données cobaye.
+     * @param getX La fonction (Getter) qui permet d'obtenir les données du X de notre regression linéaire.
+     * @param getY La fonction (Getter) qui permet d'obtenir la valeur que l'on veut vérifier
+     * @param setY La fonction (Setter) qui permet de remplacer la valeur si null.
+     * @param allowNegative Savoir si une valeur négative est forcément aberrant.
+     * @return Le HashSet avec les valeurs remplacés.
+     * @param <T> Le type de données cobaye. Exemple : Poisson, Population
+     * @param <V> Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double.
+     */
+    public static <T,V extends Number> HashSet<T> nettoieColumnsLinear(HashSet<T> list, Function<T,V> getX, Function<T,V> getY, BiConsumer<T,V> setY, boolean allowNegative ){
+
+        double meanX =  Completion.calculateMean(list, getX);
+        double meanY =  Completion.calculateMean(list, getY);
+
+        double a = Completion.calculateLinearA(list,getX,getY,meanX,meanY);
+        double b = Completion.calculateLinearB(meanX,meanY,a);
+
+        ArrayList<Double> array = new ArrayList<>();
+        for ( T item : list) {
+            if (getY.apply(item)!= null){ //Test des valeurs null pour les Tests Unitaires. Je ne devrais pas en avoir.
+                array.add(getY.apply(item).doubleValue());
+            }
+        }
+
+        Collections.sort(array);
+
+        int quartIndex = array.size()/4;
+        Double firstQuart = array.get(quartIndex);
+        Double thirdQuart = array.get(quartIndex *3);
+        Double IQR =  thirdQuart - firstQuart;
+
+        for(T item : list){
+            if( getY.apply(item) == null || getY.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getY.apply(item).doubleValue() > thirdQuart + (IQR * 1.5) || ( !allowNegative && getY.apply(item).doubleValue() < 0 ) ){
+                Double value = a * getX.apply(item).doubleValue() + b;
+                setY.accept( item, (V) value );
+            }
+        }
+
+        return list;
+    }
+
+    /**
+     * Polymorphisme de la fonction nettoyage de colonne linéaire avec par défaut, l'autorisation des valeurs négatives.
+     * @param list
+     * @param getX
+     * @param getY
+     * @param setY
+     * @return
+     * @param <T>
+     * @param <V>
+     */
+    public static <T,V extends Number> HashSet<T> nettoieColumnsLinear(HashSet<T> list, Function<T,V> getX, Function<T,V> getY, BiConsumer<T,V> setY){
+        return nettoieColumnsLinear(list, getX, getY, setY, true);
+    }
 }

src/ecoparasite/population/PopulationArgs.java

@@ -187,10 +187,10 @@ public class PopulationArgs {
         return String.format( "Année: %d, N: %d, Length: %f, Width: %f, Prevalence: %f, IC: %f, Intensity: %f, Abondance: %f, Zone: %s",
               this.year,
               this.number,
-              this.length != null ? this.length.transformToDouble() : 0.0,
+              this.length != null ? this.length.transformToDouble() : null,
-              this.width != null ? this.width.transformToDouble() : 0.0,
+              this.width != null ? this.width.transformToDouble() : null,
-              this.prevalence != null ? this.prevalence.transformToDouble() : 0.0,
+              this.prevalence != null ? this.prevalence.transformToDouble() : null,
-              this.ic != null ?  this.ic.transformToDouble() : 0.0,
+              this.ic != null ?  this.ic.transformToDouble() : null,
               this.intensity,
               this.abondance,
               this.zone

tests/ecoparasite/nettoyage/NettoyageTest.java

@@ -37,4 +37,26 @@ class NettoyageTest {
         System.out.println(testp);
     }
 
+    @org.junit.jupiter.api.Test
+    void nettoieColumnsLinear() throws InputFileException, RawDataOverflow {
+
+        RawData test = InputFactory.readData("test2.csv", ",");
+
+        HashSet<Poisson> testp = MackerelSerra.parse(test);
+
+        System.out.println(testp);
+
+        Function<Poisson,Double> getLength = Poisson::getLength;
+        Function<Poisson,Double> getInfes = Poisson::getInfestation;
+        BiConsumer<Poisson,Double> setInfes = Poisson::setInfestation;
+
+        testp = Completion.completeColumnsLinear( testp, getLength, getInfes, setInfes );
+
+        System.out.println(testp);
+
+        testp = Nettoyage.nettoieColumnsLinear( testp, getLength, getInfes, setInfes, false );
+
+        System.out.println(testp);
+    }
+
 }