/*
 * ManipTableaux.java                    9 jan. 2019
 * IUT info1 2018-2019 groupe1, pas de droits
 */
package info1.methodes;

import java.util.Scanner;

/**
 * Utilitaires de manipulmations de tableaux de flottants double précision
 * permettant de réaliser différentes opérations : Entrées/Sorties, calcul de statistiques,
 * recherches et tris.
 * @author info1G1
 */
public class ManipTableaux {

    /**
     * Demande d'un entier sur la console texte standard
     * avec itération de la demande jusqu'à ce que la donnée soit correcte
     * @param valMin valeur minimale de la donnée
     * @param valMax valeur maximale de la donnée
     * @param libelle présentation de la donnée à entrer
     * @return la valeur correcte saisie sur la console
     * @throws IllegalArgumentException si valMin > valMax
     */
     public static int saiseEntier(int valMin, int valMax, String libelle)
     throws IllegalArgumentException {

        /* entier à entrer sur console texte */
        int aEntrer;

        /* indicateur de saisie incorrecte */
        boolean nok;

        /* Analyse de l'entrée console */
        Scanner entree = new Scanner(System.in);

        do {
            System.out.print(libelle + " ? ");
            aEntrer = entree.hasNextInt() ? entree.nextInt()
                                           : valMin -1;  // Erreur

            nok = aEntrer < valMin || valMax < aEntrer;
            if (nok) {
                System.out.println(libelle + " doit être entre " + valMin
                                    + " et " + valMax);
            }
            entree.nextLine();
        } while (nok);

        return aEntrer;
    }

    /**
     * Vérifier si la valeur saisie par l'utilisateur est correcte
     * et redemande la saisie en cas d'erreur
     * @param aVerifier nombre saisie par l'utilisateur à vérifier
     * @return nombreSaisi le nombre saisi par l'utilisateur
     */
    public static double saisieValide(double aVerifier) {

    }


    /**
     * Saisir sur la console texte une série de nombre mémorisée dans
     * un tableau qui va être rempli.
     * @param aRemplir le tableau dont les valeurs sont saisies, état modifié
     *                 (un tableau vide ne provoque aucune saisie)
     */
    public static void saisieConsole(double[] aRemplir) {

        /* indices significatifs pour le tableau aRemplir */
        int parcours;  // indice de parcours

        /* Analyse de l'entrée console */
        Scanner entree = new Scanner(System.in);

        /* indicateur de saisie incorrecte */
        boolean nok;

        /* demande de chaque valeur du début à la fin */
        parcours = 0;  // demande à partir du premier indice
        while (parcours < aRemplir.length) {
            /* demande de l'élément d'indice parcours */
            System.out.print("Entrez le reel n° " + parcours + " : ");
            nok = !entree.hasNextDouble();
            if (nok) {
                 System.out.println("Entrez un flottant de la forme : -1.54e-67, 1.5...");
                 /* on reste sur le même indice de parcours :
                  * redemande le même élément
                  */
            } else {
                 aRemplir[parcours] = entree.nextDouble();
                 parcours++; // passage à l'élément suivant
            }
            entree.nextLine();
        }
    }


    /**
     * Gestion des exceptions sur les tableaux
     * @return true si une exception est détectée
               false si aucune exception n'est détectée
     * @throws IllegalArgumentException si le tableau est vide
     * @throws IllegalArgumentException si le tableau ne contient que des NaN
     */
    public static boolean exceptionTableau(double[] aDeterminer) {

        int compteurNaN; // compte le nombre de NaN dans le tableau
        int i;

        boolean ok;      // vérification d'exception excistantes

        ok = false;
        /* Test tableau vide */
        if (aDeterminer.length == 0) {
            ok = true;
        }

        /* Test vérification contenu tableau (NaN) */
        // on vérifie si la tableau contient des double, on arrête i s'il n'y a pas un double
        for (i = 0; i < aDeterminer.length && Double.isNaN(aDeterminer[i]) ; i++);

        if (i == aDeterminer.length) {
            ok = true;
        }

        return ok;

    }

    /**
      * Détermination du minimum d'une série de double
      * qui ont été saisi dans un tableau
      * @param aDeterminer tableau où on doit trouver la valeur minimale
      * @return incide, incide de la valeur minimal du tableau
                        -1 en cas d'echec
      */
    public static int min(double[] aDeterminer) {

        int indice;    // indice de la valeur minimal du tableau

        /* Calcul d'indicateurs statistiques : min, max */
	double min = Double.POSITIVE_INFINITY;

        indice = -1;
        for (int i = 0; i < aDeterminer.length ; i++) {
            if (min > aDeterminer[i]) {
                indice = i;
                min = aDeterminer[i];
            }
        }

        return indice;
    }

    /**
      * Détermination du maximale d'une série de double
      * qui ont été saisi dans un tableau
      * @param aDeterminer tableau où on doit trouver la valeur maximal
      * @return indice, indice de la valeur maximal du tableau
                        -1 en cas d'echec
      */
    public static int max(double[] aDeterminer) {

        int indice;  // indice de la valeur maximal du tableau

        double max;  // valeur maximale du tableau

        /* Calcul d'indicateurs statistiques : min, max */
	max = Double.NEGATIVE_INFINITY;

        indice = -1;
        for (int i = 0; i < aDeterminer.length ; i++) {
            if (max < aDeterminer[i]) {
                indice = i;
                max = aDeterminer[i];
            }
        }
        return indice;
    }

    /**
      * Détermination de la moyenne arithmétique d'une série de double
      * qui ont été saisi dans un tableau
      * @param aDeterminer tableau où on doit calculer la moyenne
      * @return moy moyenne arithmétique des valeurs du tableau
      */
    public static double moyn(double[] aDeterminer) {

        int compteurNaN;  // nombre de NaN dans le tableau

	double moyn,      // moyenne arithmétique des valeurs du tableau
               somme;     // somme des valeurs du tableau

        somme = 0.0;
	compteurNaN = 0;

        /* Calcul de la somme des nombres en excluant les NaN */
	for (int i = 0; i < aDeterminer.length ; i++) {
	    if (!Double.isNaN(aDeterminer[i])) {
		somme += aDeterminer[i];
	    } else {
		compteurNaN++;
	    }
	}
        /* Détermination de la moyenne */
        if (!Double.isInfinite(somme)) {
            // moyenne normale
            moyn = somme / (aDeterminer.length - compteurNaN);
        } else {
            // moyenne pondérée
            moyn = 0.0;
            for (int i = 0; i < aDeterminer.length ; i++) {
                if (!Double.isNaN(aDeterminer[i])) {
                    moyn += ( aDeterminer[i] / (aDeterminer.length - compteurNaN) );
                }
            }
        }
        return moyn;
    }

    /**
     * Recherche d'un valeur dans un tableau
     * @param aChercher présentation de la valeur à chercher
     * @param tableauAChercher tableau dans lequel on doit chercher la valeur
     * @return indice si la valeur existe sinon -1
     */
    public static int rechercheDansTableau(double[] tableauAChercher, String libelle) {

        int indice;       // indice de aChercher s'il est trouvé
        double nbCherche; // valeur à chercher dans le tableau

        /* Analyseur lexical */
        Scanner entree = new Scanner(System.in);

        System.out.print(libelle);
        nbCherche = entree.nextDouble();

        indice = -1;
        for (int i = 0; i < tableauAChercher.length ; i++) {
            if (tableauAChercher[i] == nbCherche) {
                indice = i;
            }
        }
        return indice;
    }

    /**
     * Permutation de deux éléments d'un tableau de double
     * @param aPermuter tableau dans lequel on effectue la permutation
     * @param indice1 case à permuter avec la case d'indice 2
     * @param indice2 case à permuter avec la case d'indice 1
     */
    public static void permut2(double[] aPermuter, int indice1, int indice2) {

        double temp; // variable temporaire

        if (indice1 < aPermuter.length && indice2 < aPermuter.length) {
            temp = aPermuter[indice1];
            aPermuter[indice1] = aPermuter[indice2];
            aPermuter[indice2] = temp;
        } else {
            System.out.println("Permutation impossible !");
        }

    }




     /**
      * <ul>
      * <li>Entrée console d'une série de flottants mémorisée dans un tableau</li>
      * <li>Sortie texte d'un tableau au format [ elt0 elt1 ... eltk ]</li>
      * <li>Calcul d'indicateurs statistiques : min, max, moyenne arithmétique</li>
      * <li>Recherches séquentielles</li>
      * </ul>
      * @param args non utilisé
      */
     public static void main(String[] args) {

         /* intervalle de taille pour la série de nombres */
         final int TAILLE_MIN = 1;
         final int TAILLE_MAX = 10;
         final int IMPOSSIBLE = -1;

         /* série de nombres à manipuler */
         double[] serie;
         int taille;  // nombre exact d'éléments demandés à l'utilisateur

         /* indicateurs statistiques */
         double min,   // valeur minimale
                max;   // valeur maximale

        double nbCherche; // nombre chercher dans le tableau

        /* Analyse de l'entrée console */
        Scanner entree = new Scanner(System.in);


        /* demande de la taille */
        taille = saiseEntier(TAILLE_MIN, TAILLE_MAX, "le nombre d'éléments");


        /* demande des éléments un par un du premier au dernier */
        serie = new double[taille];
        saisieConsole(serie);  // fonction


        /* Sortie texte d'un tableau au format [ elt0 elt1 ... eltk ] */
        System.out.print("Voici la série :\n[ ");
        for (double valeur : serie) {
            System.out.print(valeur + " ");
        }
        System.out.println(']');


        /* Gestion des execptions et valeur de retour */
         System.out.println("\n **** Statistique Min, Max, Moyenne ****");
        if (exceptionTableau(serie)) {
            System.out.println("-1 : valeur par defaut");
        } else {
            /* minimum et maximum des nombre du tableau */
            min = serie[min(serie)];
            max = serie[max(serie)];

	    if (min > max) {
	         min = max = Double.NaN;
	    }

	    System.out.printf("Min  = %e \nMax  = %e \nMoyn = %e \n", min, max, moyn(serie));

        }

        /* Recherche d'un élément dans le tableau */
        System.out.println("\n **** Recherche d'une valeur ****");
        System.out.println("valeur trouvée à l'indide: " + rechercheDansTableau(serie, "Entrez une valeur à chercher: "));


        /* Permuter deux case du tableau */
        System.out.println("\n **** Permutation de 2 valeurs ****");
        permut2(serie, 0, 1);

        System.out.print("Voici la série :\n[ ");
        for (double valeur : serie) {
            System.out.print(valeur + " ");
        }
        System.out.println(']');


    }
}