ecoparasite-data-analyse/src/ecoparasite/completion/Completion.java

package ecoparasite.completion;

import ecoparasite.input.InputFactory;
import ecoparasite.input.InputFileException;
import ecoparasite.input.RawData;
import ecoparasite.input.RawDataOverflow;
import ecoparasite.poisson.Mackerel;
import ecoparasite.poisson.Poisson;

import java.util.HashSet;
import java.util.concurrent.Callable;
import java.util.function.*;

/**
 * Permet de faire de la complétion de données.
 * Si une valeur est manquante, elle sera remplacé par la moyenne ou par regression linéaire.
 */
public class Completion {

    /**
     * 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 <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> completeColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue ){

        Double mean = calculateMean(list, getValue);
        for(T item : list){
            if( getValue.apply(item) == null ){
                setValue.accept( item, (V) mean);
            }
        }

        return list;
    }

    /**
     * Permet de calculer la moyenne d'une donnée des valeurs non nulles.
     * @param list La liste de données cobaye.
     * @param getValue La fonction qui permet d'obtenir la valeur de notre champ.
     * @return La moyenne calculé.
     * @param <T> Le type de données cobaye/ Exemple : Poisson
     * @param <V> Le type de la donnée à vérifier, doit être un wrapper Number. Exemple : Double.
     */
    public static <T,V extends Number> double calculateMean(HashSet<T> list, Function<T,V> getValue ){

        double mean = 0.0;
        int i = 0;

        for( T item : list ){
            V value = getValue.apply(item);
            if( value != null) {
                mean += value.doubleValue();
                i++;
            }
        }

        return mean / i;
    }

    /**
     * Permet de remplacer les valeurs inexistantes par les valeurs les plus probables avec une regression linéaire
     * @param list La liste des données
     * @param getX Le getter de la valeur en x
     * @param getY Le getter de la valeur en y
     * @param setY Le Setter de la valeur en y qui est à compléter
     * @return Une liste des valeurs compléters
     * @param <T> Le type des données de la liste
     * @param <V> Le type des données numériques
     */
    public static <T,V extends Number> HashSet<T> completeColumnsLinear(HashSet<T> list, Function<T,V> getX,  Function<T,V> getY, BiConsumer<T,V> setY ){

        double meanX =  calculateMean(list, getX);
        double meanY =  calculateMean(list, getY);

        double a = calculateLinearA(list,getX,getY,meanX,meanY);
        double b = calculateLinearB(meanX,meanY,a);

        for(T item : list){
            if( getY.apply(item) == null && getX.apply(item) != null ){
                Double value = a * getX.apply(item).doubleValue() + b;
                setY.accept( item, (V) value );
            }
        }

        return list;
    }

    /**
     * Permet de calculer le coefficient A de notre regression linéaire.
     * @param list
     * @param getX
     * @param getY
     * @param meanX
     * @param meanY
     * @return La valeur du a de la formule de regression linéaire
     * @param <T>
     * @param <V>
     */
    public static <T,V extends Number> double calculateLinearA(
            HashSet<T> list,
            Function<T,V> getX,
            Function<T,V> getY,
            double meanX,
            double meanY
    ){
        double numerateur = 0.0;
        double denominateur = 0.0;

        for( T item : list ){
            if( getX.apply(item) == null || getY.apply(item) == null ){
                continue;
            }
            numerateur += ( getX.apply(item).doubleValue() - meanX ) * ( getY.apply(item).doubleValue() - meanY );
            denominateur += ( getX.apply(item).doubleValue() - meanX ) * ( getX.apply(item).doubleValue() - meanX );
        }
        return numerateur / denominateur;
    }

    /**
     * Permet de calculer b dans une regression linéaire
     * @param meanX
     * @param meanY
     * @param valueA
     * @return La valeur de b dans la formule de regression linéaire
     */
    public static double calculateLinearB(
            double meanX,
            double meanY,
            double valueA
    ){
        return meanY - valueA * meanX;
    }

}