Commit 41525411 authored by david's avatar david
Browse files

Ajout des fichiers Java du TP1

parent 8d4214dc
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;
}
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
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");
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment