daily pastebin goal
77%
SHARE
TWEET

Untitled

a guest Feb 24th, 2019 68 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * ManipTableaux.java                    9 jan. 2019
  3.  * IUT info1 2018-2019 groupe1, pas de droits
  4.  */
  5. package info1.methodes;
  6.  
  7. import java.util.Scanner;
  8.  
  9. /**
  10.  * Utilitaires de manipulmations de tableaux de flottants double précision
  11.  * permettant de réaliser différentes opérations : Entrées/Sorties, calcul de statistiques,
  12.  * recherches et tris.
  13.  * @author info1G1
  14.  */
  15. public class ManipTableaux {
  16.  
  17.     /**
  18.      * Demande d'un entier sur la console texte standard
  19.      * avec itération de la demande jusqu'à ce que la donnée soit correcte
  20.      * @param valMin valeur minimale de la donnée
  21.      * @param valMax valeur maximale de la donnée
  22.      * @param libelle présentation de la donnée à entrer
  23.      * @return la valeur correcte saisie sur la console
  24.      * @throws IllegalArgumentException si valMin > valMax
  25.      */
  26.      public static int saiseEntier(int valMin, int valMax, String libelle)
  27.      throws IllegalArgumentException {
  28.  
  29.         /* entier à entrer sur console texte */
  30.         int aEntrer;
  31.  
  32.         /* indicateur de saisie incorrecte */
  33.         boolean nok;
  34.  
  35.         /* Analyse de l'entrée console */
  36.         Scanner entree = new Scanner(System.in);
  37.  
  38.         do {
  39.             System.out.print(libelle + " ? ");
  40.             aEntrer = entree.hasNextInt() ? entree.nextInt()
  41.                                            : valMin -1;  // Erreur
  42.  
  43.             nok = aEntrer < valMin || valMax < aEntrer;
  44.             if (nok) {
  45.                 System.out.println(libelle + " doit être entre " + valMin
  46.                                     + " et " + valMax);
  47.             }
  48.             entree.nextLine();
  49.         } while (nok);
  50.  
  51.         return aEntrer;
  52.     }
  53.  
  54.     /**
  55.      * Vérifier si la valeur saisie par l'utilisateur est correcte
  56.      * et redemande la saisie en cas d'erreur
  57.      * @param aVerifier nombre saisie par l'utilisateur à vérifier
  58.      * @return nombreSaisi le nombre saisi par l'utilisateur
  59.      */
  60.     public static double saisieValide(double aVerifier) {
  61.      
  62.     }
  63.  
  64.  
  65.     /**
  66.      * Saisir sur la console texte une série de nombre mémorisée dans
  67.      * un tableau qui va être rempli.
  68.      * @param aRemplir le tableau dont les valeurs sont saisies, état modifié
  69.      *                 (un tableau vide ne provoque aucune saisie)
  70.      */
  71.     public static void saisieConsole(double[] aRemplir) {
  72.  
  73.         /* indices significatifs pour le tableau aRemplir */
  74.         int parcours;  // indice de parcours
  75.  
  76.         /* Analyse de l'entrée console */
  77.         Scanner entree = new Scanner(System.in);
  78.  
  79.         /* indicateur de saisie incorrecte */
  80.         boolean nok;
  81.  
  82.         /* demande de chaque valeur du début à la fin */
  83.         parcours = 0;  // demande à partir du premier indice
  84.         while (parcours < aRemplir.length) {
  85.             /* demande de l'élément d'indice parcours */
  86.             System.out.print("Entrez le reel n° " + parcours + " : ");
  87.             nok = !entree.hasNextDouble();
  88.             if (nok) {
  89.                  System.out.println("Entrez un flottant de la forme : -1.54e-67, 1.5...");
  90.                  /* on reste sur le même indice de parcours :
  91.                   * redemande le même élément
  92.                   */
  93.             } else {
  94.                  aRemplir[parcours] = entree.nextDouble();
  95.                  parcours++; // passage à l'élément suivant
  96.             }
  97.             entree.nextLine();
  98.         }
  99.     }
  100.  
  101.  
  102.     /**
  103.      * Gestion des exceptions sur les tableaux
  104.      * @return true si une exception est détectée
  105.                false si aucune exception n'est détectée
  106.      * @throws IllegalArgumentException si le tableau est vide
  107.      * @throws IllegalArgumentException si le tableau ne contient que des NaN
  108.      */
  109.     public static boolean exceptionTableau(double[] aDeterminer) {
  110.  
  111.         int compteurNaN; // compte le nombre de NaN dans le tableau
  112.         int i;
  113.  
  114.         boolean ok;      // vérification d'exception excistantes
  115.    
  116.         ok = false;
  117.         /* Test tableau vide */
  118.         if (aDeterminer.length == 0) {
  119.             ok = true;
  120.         }
  121.  
  122.         /* Test vérification contenu tableau (NaN) */
  123.         // on vérifie si la tableau contient des double, on arrête i s'il n'y a pas un double
  124.         for (i = 0; i < aDeterminer.length && Double.isNaN(aDeterminer[i]) ; i++);
  125.  
  126.         if (i == aDeterminer.length) {
  127.             ok = true;
  128.         }
  129.  
  130.         return ok;
  131.  
  132.     }
  133.    
  134.     /**
  135.       * Détermination du minimum d'une série de double
  136.       * qui ont été saisi dans un tableau
  137.       * @param aDeterminer tableau où on doit trouver la valeur minimale
  138.       * @return incide, incide de la valeur minimal du tableau
  139.                         -1 en cas d'echec
  140.       */
  141.     public static int min(double[] aDeterminer) {
  142.    
  143.         int indice;    // indice de la valeur minimal du tableau
  144.  
  145.         /* Calcul d'indicateurs statistiques : min, max */
  146.     double min = Double.POSITIVE_INFINITY;
  147.    
  148.         indice = -1;
  149.         for (int i = 0; i < aDeterminer.length ; i++) {
  150.             if (min > aDeterminer[i]) {
  151.                 indice = i;
  152.                 min = aDeterminer[i];
  153.             }
  154.         }
  155.  
  156.         return indice;
  157.     }
  158.  
  159.     /**
  160.       * Détermination du maximale d'une série de double
  161.       * qui ont été saisi dans un tableau
  162.       * @param aDeterminer tableau où on doit trouver la valeur maximal
  163.       * @return indice, indice de la valeur maximal du tableau
  164.                         -1 en cas d'echec
  165.       */
  166.     public static int max(double[] aDeterminer) {
  167.    
  168.         int indice;  // indice de la valeur maximal du tableau
  169.  
  170.         double max;  // valeur maximale du tableau
  171.  
  172.         /* Calcul d'indicateurs statistiques : min, max */
  173.     max = Double.NEGATIVE_INFINITY;
  174.    
  175.         indice = -1;
  176.         for (int i = 0; i < aDeterminer.length ; i++) {
  177.             if (max < aDeterminer[i]) {
  178.                 indice = i;
  179.                 max = aDeterminer[i];
  180.             }
  181.         }
  182.         return indice;
  183.     }
  184.  
  185.     /**
  186.       * Détermination de la moyenne arithmétique d'une série de double
  187.       * qui ont été saisi dans un tableau
  188.       * @param aDeterminer tableau où on doit calculer la moyenne
  189.       * @return moy moyenne arithmétique des valeurs du tableau
  190.       */
  191.     public static double moyn(double[] aDeterminer) {
  192.    
  193.         int compteurNaN;  // nombre de NaN dans le tableau  
  194.  
  195.     double moyn,      // moyenne arithmétique des valeurs du tableau
  196.                somme;     // somme des valeurs du tableau        
  197.  
  198.         somme = 0.0;
  199.     compteurNaN = 0;
  200.  
  201.         /* Calcul de la somme des nombres en excluant les NaN */
  202.     for (int i = 0; i < aDeterminer.length ; i++) {
  203.         if (!Double.isNaN(aDeterminer[i])) {
  204.         somme += aDeterminer[i];
  205.         } else {
  206.         compteurNaN++;
  207.         }
  208.     }
  209.         /* Détermination de la moyenne */
  210.         if (!Double.isInfinite(somme)) {
  211.             // moyenne normale
  212.             moyn = somme / (aDeterminer.length - compteurNaN);
  213.         } else {
  214.             // moyenne pondérée
  215.             moyn = 0.0;
  216.             for (int i = 0; i < aDeterminer.length ; i++) {
  217.                 if (!Double.isNaN(aDeterminer[i])) {
  218.                     moyn += ( aDeterminer[i] / (aDeterminer.length - compteurNaN) );
  219.                 }  
  220.             }
  221.         }
  222.         return moyn;
  223.     }
  224.  
  225.     /**
  226.      * Recherche d'un valeur dans un tableau
  227.      * @param aChercher présentation de la valeur à chercher
  228.      * @param tableauAChercher tableau dans lequel on doit chercher la valeur
  229.      * @return indice si la valeur existe sinon -1
  230.      */
  231.     public static int rechercheDansTableau(double[] tableauAChercher, String libelle) {
  232.  
  233.         int indice;       // indice de aChercher s'il est trouvé
  234.         double nbCherche; // valeur à chercher dans le tableau
  235.  
  236.         /* Analyseur lexical */
  237.         Scanner entree = new Scanner(System.in);
  238.  
  239.         System.out.print(libelle);
  240.         nbCherche = entree.nextDouble();
  241.  
  242.         indice = -1;
  243.         for (int i = 0; i < tableauAChercher.length ; i++) {
  244.             if (tableauAChercher[i] == nbCherche) {
  245.                 indice = i;
  246.             }
  247.         }
  248.         return indice;
  249.     }
  250.  
  251.     /**
  252.      * Permutation de deux éléments d'un tableau de double
  253.      * @param aPermuter tableau dans lequel on effectue la permutation
  254.      * @param indice1 case à permuter avec la case d'indice 2
  255.      * @param indice2 case à permuter avec la case d'indice 1
  256.      */
  257.     public static void permut2(double[] aPermuter, int indice1, int indice2) {
  258.  
  259.         double temp; // variable temporaire
  260.  
  261.         if (indice1 < aPermuter.length && indice2 < aPermuter.length) {
  262.             temp = aPermuter[indice1];
  263.             aPermuter[indice1] = aPermuter[indice2];
  264.             aPermuter[indice2] = temp;
  265.         } else {
  266.             System.out.println("Permutation impossible !");
  267.         }
  268.    
  269.     }
  270.  
  271.  
  272.  
  273.  
  274.      /**
  275.       * <ul>
  276.       * <li>Entrée console d'une série de flottants mémorisée dans un tableau</li>
  277.       * <li>Sortie texte d'un tableau au format [ elt0 elt1 ... eltk ]</li>
  278.       * <li>Calcul d'indicateurs statistiques : min, max, moyenne arithmétique</li>
  279.       * <li>Recherches séquentielles</li>
  280.       * </ul>
  281.       * @param args non utilisé
  282.       */
  283.      public static void main(String[] args) {
  284.          
  285.          /* intervalle de taille pour la série de nombres */
  286.          final int TAILLE_MIN = 1;
  287.          final int TAILLE_MAX = 10;  
  288.          final int IMPOSSIBLE = -1;    
  289.  
  290.          /* série de nombres à manipuler */
  291.          double[] serie;  
  292.          int taille;  // nombre exact d'éléments demandés à l'utilisateur
  293.  
  294.          /* indicateurs statistiques */
  295.          double min,   // valeur minimale
  296.                 max;   // valeur maximale
  297.  
  298.         double nbCherche; // nombre chercher dans le tableau
  299.  
  300.         /* Analyse de l'entrée console */
  301.         Scanner entree = new Scanner(System.in);
  302.                        
  303.  
  304.         /* demande de la taille */
  305.         taille = saiseEntier(TAILLE_MIN, TAILLE_MAX, "le nombre d'éléments");
  306.          
  307.  
  308.         /* demande des éléments un par un du premier au dernier */
  309.         serie = new double[taille];
  310.         saisieConsole(serie);  // fonction
  311.  
  312.  
  313.         /* Sortie texte d'un tableau au format [ elt0 elt1 ... eltk ] */
  314.         System.out.print("Voici la série :\n[ ");
  315.         for (double valeur : serie) {
  316.             System.out.print(valeur + " ");
  317.         }
  318.         System.out.println(']');
  319.  
  320.  
  321.         /* Gestion des execptions et valeur de retour */
  322.          System.out.println("\n **** Statistique Min, Max, Moyenne ****");
  323.         if (exceptionTableau(serie)) {
  324.             System.out.println("-1 : valeur par defaut");
  325.         } else {
  326.             /* minimum et maximum des nombre du tableau */
  327.             min = serie[min(serie)];
  328.             max = serie[max(serie)];
  329.  
  330.         if (min > max) {
  331.              min = max = Double.NaN;
  332.         }
  333.  
  334.         System.out.printf("Min  = %e \nMax  = %e \nMoyn = %e \n", min, max, moyn(serie));
  335.  
  336.         }
  337.  
  338.         /* Recherche d'un élément dans le tableau */
  339.         System.out.println("\n **** Recherche d'une valeur ****");
  340.         System.out.println("valeur trouvée à l'indide: " + rechercheDansTableau(serie, "Entrez une valeur à chercher: "));
  341.  
  342.  
  343.         /* Permuter deux case du tableau */
  344.         System.out.println("\n **** Permutation de 2 valeurs ****");
  345.         permut2(serie, 0, 1);
  346.            
  347.         System.out.print("Voici la série :\n[ ");
  348.         for (double valeur : serie) {
  349.             System.out.print(valeur + " ");
  350.         }
  351.         System.out.println(']');
  352.  
  353.  
  354.     }
  355. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top