Ajout des fichiers Java du TP1

TP1/Java/Analyzer.java

+import java.io.*;
+import java.util.ArrayList;
+
+/**
+    Classe utilisée pour faire des statistiques élémentaires
+    sur une séquence d'opérations.
+ */
+public class Analyzer {
+
+    /**
+        Constructeur de la classe analyse
+        Complexité en temps/espace, pire et meilleur cas : O(1)
+     */
+    public Analyzer() {
+        cost = new ArrayList<Double>();
+        cumulative_cost = new ArrayList<Double>();
+        cumulative_square = 0.;
+    }
+
+    /**
+        Ajoute un coût, une valeur à l'analyse.
+        Complexité en temps/espace, pire cas : O(size)
+        Complexité en temps/espace, meilleur cas : O(1)
+        Complexité amortie : O(1)
+        @param x est la valeur que l'on souhaite ajouter à l'analyse.
+     */
+    void append(double  x){
+        cost.add(x);
+        cumulative_cost.add( (!cumulative_cost.isEmpty()) ? cumulative_cost.get(cumulative_cost.size()-1)+x : x);
+        cumulative_square += x*x;
+    }
+
+    /**
+        Renvoie la somme des coûts enregistrés dans cette analyse.
+        Complexité en temps/espace, meilleur cas : O(1)
+        @returns la somme des coûts enregistrés dans cette analyse.
+     */
+    double get_total_cost(){
+        return cumulative_cost.get(cumulative_cost.size()-1);
+    }
+
+    /**
+        Renvoie le coût amorti d'une opération.
+        Complexité en temps/espace, meilleur cas : O(1)
+        @param pos est l'indice de l'opération pour laquelle on veut connaître le coût amorti.
+        @returns le coût amorti d'une opération.
+     */
+    double get_amortized_cost(int pos){
+        return (pos > 0)? cumulative_cost.get(pos)/pos : cumulative_cost.get(pos);
+    }
+
+    /**
+        Renvoie la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
+        Complexité en temps/espace, meilleur cas : O(1)
+        @returns la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
+     */
+    double get_average_cost(){
+        if(cumulative_cost.isEmpty())
+            throw new RuntimeException("List is empty");
+        return cumulative_cost.get(cumulative_cost.size()-1)/cumulative_cost.size();
+    }
+
+    /**
+        Renvoie la variance des coûts de toutes les opérations enregistrées dans l'analyse.
+        Complexité en temps/espace, meilleur cas : O(1)
+        @returns la variance des coûts de toutes les opérations enregistrées dans l'analyse.
+     */
+    double get_variance(){
+        double mean, mean_square;
+        mean = get_average_cost();
+        mean_square = mean * mean;
+        return cumulative_square - mean_square;
+    }
+
+    /**
+        Renvoie l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
+        Complexité en temps/espace, meilleur cas : O(1)
+        @returns l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
+     */
+    double get_standard_deviation(){
+        return Math.sqrt(get_variance());
+    }
+
+    /**
+        Sauvegarde la liste des coûts et des coûts amortis dans un fichier.
+        Complexité en temps, meilleur/pire cas : O(size)
+        @param path est le chemin du fichier dans lequel la sauvegarde est faite.
+     */
+    void save_values(String path){
+        int i;
+        File file = new File(path);
+        FileWriter fr = null;
+        try {
+            fr = new FileWriter(file);
+            for (i = 0; i < cost.size(); ++i){
+                fr.write(i+" "+cost.get(i)+" "+get_amortized_cost(i)+"\n");
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }finally{
+            //close resources
+            try {
+                fr.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+        Affiche la liste des coûts et des coûts amortis sur la sortie standard.
+        Complexité en temps, meilleur/pire cas : O(size)
+     */
+    void plot_values(){
+        int i;
+        for (i = 0; i < cost.size(); ++i){
+            System.out.println(i+" "+cost.get(i)+" "+get_amortized_cost(i));
+        }
+    }
+
+
+    // Coût de chaque opération. Peut représenter du temps ou une autre mesure.
+    private ArrayList<Double> cost;
+    // Coût cumulatif. La case i contient la somme des coûts des i premières opérations.
+    // Permet de calculer le coût amorti d'une opération.
+    private ArrayList<Double> cumulative_cost;
+    // Carré du coût cumulatif. Sert à calculer la variance. On ne garde que la dernière valeur.
+    private double cumulative_square;
+
+
+}

TP1/Java/ArrayListProxy.java

+import java.util.ArrayList;
+
+/**
+ Cette classe est un proxy pour les ArrayList, c'est à dire les tableaux dynamiques en Java.
+ On utilise cette classe afin d'avoir le contrôle sur la gestion de la mémoire.
+ */
+public class ArrayListProxy<T> {
+
+    /**
+        Constructeur de la classe des tableaux dynamiques.
+        Complexité en temps/espace, pire et meilleur cas : O(1)
+     */
+    public ArrayListProxy() {
+        this.capacity = 4;
+        this.data = new ArrayList<T>(this.capacity);
+    }
+
+    /**
+     Ajoute une valeur dans le tableau.
+     Complexité en temps/espace, pire cas : O(size)
+     Complexité en temps/espace, meilleur cas : O(1)
+     Complexité amortie : O(1)
+     @param x est la valeur que l'on souhaite ajouter.
+     @returns true si le tableau a été agrandit, false sinon
+     */
+    boolean append(T x){
+        boolean memory_allocation = false;
+        if( enlarging_capacity() ){
+            memory_allocation = true;
+            capacity *= 2;
+            data.ensureCapacity( capacity );
+        }
+        data.add(x);
+        return memory_allocation;
+    }
+
+    /**
+     Supprime la dernière valeur du tableau.
+     Complexité en temps, pire cas : O(size)
+     Complexité en temps, meilleur cas : O(1)
+     Complexité amortie : O(1)
+     @returns true si le tableau a été réduit, false sinon
+     */
+    boolean pop_back(){
+        boolean memory_reduction = false;
+        if(!data.isEmpty()){
+            if( reducing_capacity() ){
+                memory_reduction = true;
+                capacity /= 2;
+                data.ensureCapacity( capacity );
+            }
+            data.remove(data.size()-1);
+        }
+        return memory_reduction;
+    }
+
+    /**
+     Renvoie la valeur située à la position donnée par l'utilisateur.
+     Complexité en temps/espace, pire cas : O(1)
+     @param pos est la l'indice de la case on l'utilisateur veut connaître la valeur.
+     @returns la valeur située à la position donnée par l'utilisateur.
+     */
+    T get(int pos){
+        return data.get(pos);
+    }
+
+    /**
+     Renvoie le nombre d'éléments stockés dans le tableau.
+     Complexité en temps/espace, pire cas : O(1)
+     @returns le nombre d'éléments stockés dans le tableau.
+     */
+    int get_size(){
+        return data.size();
+    }
+
+    /**
+     Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
+     @returns true si le tableau doit être agrandi, false sinon.
+     */
+    private boolean enlarging_capacity() {
+        return data.size() >= (capacity * 3)/4;
+    }
+
+    /**
+     Cette fonction détermine la règle selon laquelle un espace mémoire plus petit sera alloué ou non.
+     @returns true si le tableau doit être réduit, false sinon.
+     */
+    private boolean reducing_capacity(){
+        return data.size() <= capacity/4 && data.size() >4;
+    }
+
+    // Tableau dynamique en Java. Sa capacité réelle est masquée, mais on peut avoir un contrôle dessus.
+    private ArrayList<T> data;
+    // Capacité réelle du tableau data.
+    private int capacity;
+}
\ No newline at end of file

TP1/Java/Main.java

+import java.util.Random;
+
+public class Main {
+
+    public static void main(String[] args) {
+        int i, time_ind = 0, pop_ind = 0;
+        // Tableau dynamique.
+        ArrayListProxy<Integer> a = new ArrayListProxy<Integer>();
+        // Analyse du temps pris par les opérations.
+        Analyzer time_analysis = new Analyzer();
+        // Analyse du nombre de copies faites par les opérations.
+        Analyzer copy_analysis = new Analyzer();
+        long before, after;
+        // Booléen permettant de savoir si une allocation a été effectuée.
+        boolean memory_allocation;
+
+
+        for(i = 0; i < 1000000 ; i++){
+            // Ajout d'un élément et mesure du temps pris par l'opération.
+            before = System.nanoTime();
+            memory_allocation = a.append(i);
+            after = System.nanoTime();
+
+            // Enregistrement du temps pris par l'opération
+            time_analysis.append(after - before);
+            // Enregistrement du nombre de copies efféctuées par l'opération.
+            // S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
+            copy_analysis.append( (memory_allocation == true)? i: 1);
+        }
+
+        // Affichage de quelques statistiques sur l'expérience.
+        System.err.println("Total cost : "+time_analysis.get_total_cost());
+        System.err.println("Average cost : "+time_analysis.get_average_cost());
+        System.err.println("Variance :"+time_analysis.get_variance());
+        System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
+
+        // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
+        time_analysis.save_values("../dynamic_array_time_java.plot");
+        copy_analysis.save_values("../dynamic_array_copy_java.plot");
+
+    }
+}