Skip to content
Extraits de code Groupes Projets
Valider 7944ad3a rédigé par Loïc Wikle DUBARD's avatar Loïc Wikle DUBARD
Parcourir les fichiers

j'avais oublié les mli

parent 9ac3087f
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
......@@ -13,17 +13,17 @@ all: main tests
tests: test_phase1.out test_phase2.out
phase1: src/phase1.ml src/main_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase1.ml main_phase1.ml)
phase1: src/phase1.mli src/phase1.ml src/main_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase1.mli phase1.ml main_phase1.ml)
phase2: src/phase2.ml src/main_phase2.ml
(cd src ; ocamlc -o ../build/$@ phase2.ml main_phase2.ml)
phase2: src/phase2.mli src/phase2.ml src/main_phase2.ml
(cd src ; ocamlc -o ../build/$@ phase2.mli phase2.ml main_phase2.ml)
test_phase1.out: src/phase1.ml src/test_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase1.ml test_phase1.ml)
test_phase1.out: src/phase1.mli src/phase1.ml src/test_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase1.mli phase1.ml test_phase1.ml)
test_phase2.out: src/phase1.ml src/test_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase2.ml test_phase2.ml)
test_phase2.out: src/phase2.mli src/phase1.ml src/test_phase1.ml
(cd src ; ocamlc -o ../build/$@ phase2.mli phase2.ml test_phase2.ml)
clean:
rm -rf *.cmi *.cmo
......
# IPF-S3
Le but de ce projet est de maximiser le flux de café entre le bar de l'ENSIIE (considéré idéalement comme une source infinie de café) et le bureau de M. Forest (considéré effectivement comme un puits infini de café).
\ No newline at end of file
Le but de ce projet est de maximiser le flux de café entre le bar de l'ENSIIE (considéré idéalement comme une source infinie de café) et le bureau de M. Forest (considéré effectivement comme un puits infini de café).
## Compilation
Pour tout compiler (phase1, phase2, tests phase1, tests phase2): `make`
pour nettoyer les fichiers de compilation : `make clean`
pour compiler uniquement la phase 1 (par exemple) `make phase1`
pour compiler uniquement les tests de la phase 1 (par ex) : `make tests_phase1.out`
pour compiler juste les tests : `make tests`
## Utilisation
Exemple d'utilisation de la phase 1 sur un fichier de test
`build/phase1 phase1/input.txt`
La sortie sera affichée sur la sortie standard.
Exemple d'utilisation de la phase 1 sur un fichier de test
`build/phase2 phase2/input.txt`
\relax
\providecommand\hyper@newdestlabel[2]{}
\bbl@beforestart
\catcode `:\active
\catcode `;\active
\catcode `!\active
\catcode `?\active
\providecommand\HyperFirstAtBeginDocument{\AtBeginDocument}
\HyperFirstAtBeginDocument{\ifx\hyper@anchor\@undefined
\global\let\oldcontentsline\contentsline
\gdef\contentsline#1#2#3#4{\oldcontentsline{#1}{#2}{#3}}
\global\let\oldnewlabel\newlabel
\gdef\newlabel#1#2{\newlabelxx{#1}#2}
\gdef\newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}}
\AtEndDocument{\ifx\hyper@anchor\@undefined
\let\contentsline\oldcontentsline
\let\newlabel\oldnewlabel
\fi}
\fi}
\global\let\hyper@last\relax
\gdef\HyperFirstAtBeginDocument#1{#1}
\providecommand\HyField@AuxAddToFields[1]{}
\providecommand\HyField@AuxAddToCoFields[2]{}
\babel@aux{french}{}
\babel@aux{french}{}
\@writefile{toc}{\contentsline {section}{\numberline {1}Phase 1 : les plus courts chemins}{2}{section.1}\protected@file@percent }
\@writefile{toc}{\contentsline {paragraph}{make\_graphe n channel : }{2}{section*.3}\protected@file@percent }
\@writefile{toc}{\contentsline {paragraph}{chemins s g : }{2}{section*.4}\protected@file@percent }
\@writefile{toc}{\contentsline {paragraph}{plus\_court\_chemins s p c : }{3}{section*.5}\protected@file@percent }
\@writefile{toc}{\contentsline {section}{\numberline {2}Phase 2 : maximiser le flux}{3}{section.2}\protected@file@percent }
Ce diff est replié.
\BOOKMARK [1][-]{section.1}{Phase 1 : les plus courts chemins}{}% 1
\BOOKMARK [1][-]{section.2}{Phase 2 : maximiser le flux}{}% 2
Fichier ajouté
Fichier ajouté
\documentclass[french]{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[french]{babel}
\selectlanguage{french}
\usepackage{amsmath}
\usepackage{float}
\usepackage{amssymb}
\usepackage{hyperref}
\usepackage{xcolor}
\usepackage{graphicx}
\usepackage[a4paper]{geometry}
\usepackage{minted}
\usepackage{listings}
\hypersetup{
colorlinks,
linkcolor={red!50!black},
citecolor={blue!50!black},
urlcolor={blue!80!black}
}
\author{Loïc DUBARD}
\title{Rapport du projet de programmation fonctionnelle 2 : \\
\textbf{Trafic de café pour Mr Forest}}
\begin{document}
\maketitle
\tableofcontents
\clearpage
\section*{Introduction}
(Extrait du sujet)\\
Le but de ce projet est de maximiser le flux de café entre le bar de l'ENSIIE (considéré idéalement comme une source infinie de café) et le bureau de M. Forest (considéré effectivement comme un puits infini de café).\\
Dans le monde moderne de l'enseignement en école d'ingénieur nécessite de maximiser ce flux pour des raisons évidentes. Votre projet se développera en plusieurs étapes :\\
\begin{itemize}
\item dans un premier temps, étant donnée une représentation adaptée du plan de l'école, vous chercherez les chemins les plus rapides (les plus courts), de la source au puits,\\
\item dans un second temps, après avoir pris en compte la capacité des différents couloirs et escaliers, vous chercherez à trouver un moyen de maximiser le flux possible de café. Votre programme disposera d'un temps fini pour répondre.
\end{itemize}
\section{Phase 1 : les plus courts chemins}
Pour la phase 1, je code tout dans src/phase1.ml. Je choisi de faire une map de set pour modéliser le graphe dans cette partie, d'où la création des modules Graphe, Clesliste et le type graph de cette manière :
\begin{verbatim}
module Graphe = Map.Make(String)
module Clesliste = Set.Make(String)
type graph = Clesliste.t Graphe.t
\end{verbatim}
Ensuite, j'ai besoin de lire le fichier donné en argument. La doc de Ocaml me donne les fonctions open\_in et input\_line. \\
Je commence par lire les 3 premières ligne du fichier, la première me donne la chaine de caractères correspondant à la source, la deuxième celle du puits, enfin la troisième ligne correspond au nombre de chemin élémentaires donc au nombre de lignes qui suivent (je le note n ici).\\
\paragraph{make\_graphe n channel : }
Puis avec la fonction récursive make\_graphe qui prends en argument ce nombre n et le channel d'entrée et je remplie le graphe initialisé à 'empty' au fur et à mesure que je lis les lignes suivantes du fichier, en m'arrêtant quand j'arrive à n=0.\\
\paragraph{chemins s g : } N'ayant pas pris le cours de graphe au S3, pour trouver le plus court chemin de source à puits, j'ai choisi d'implémenter naïvement un algorithme qui liste tous les chemins qui partent de s dans le graphe g. Cette fonction retourne une liste de listes de sommets (string). \\
Le principe est simple : récursivement pour un sommet s donné, rajoute s à chaque chemin de la liste les chemins partant de chacun de ces successeurs. Si cette liste est vide crée une liste de liste composée uniquement de s.\\
\paragraph{plus\_court\_chemins s p c : } Enfin je filtre la liste (notée c ici) pour ne garder que les chemins partant de s et arrivant en p et je calcul le minimum des longueurs de tous les chemins noté m ici. Cette fonction retourne alors la liste des chemins de longueur égale à m.
Pour l'affichage j'utilise la fonction List.iter sur la liste obtenue en faisant un String.concat " " elt sur chaque élément.
\section{Phase 2 : maximiser le flux}
Pour cette phase, j'ai choisi d'utiliser une map de map pour modéliser le graphe :
\begin{verbatim}
module Graphe = Map.Make(String)
module Arreteliste = Map.Make(String)
type arreteliste_t = int Arreteliste.t
type graphe_t = arreteliste Graphe.t
\end{verbatim}
\end{document}
\babel@toc {french}{}
\babel@toc {french}{}
\contentsline {section}{\numberline {1}Phase 1 : les plus courts chemins}{2}{section.1}%
\contentsline {paragraph}{make\_graphe n channel : }{2}{section*.3}%
\contentsline {paragraph}{chemins s g : }{2}{section*.4}%
\contentsline {paragraph}{plus\_court\_chemins s p c : }{3}{section*.5}%
\contentsline {section}{\numberline {2}Phase 2 : maximiser le flux}{3}{section.2}%
......@@ -29,4 +29,4 @@ let _ =
in
let liste_result = plus_courts_chemins source puits liste_chemins
in
List.map f liste_result
\ No newline at end of file
List.iter f liste_result
\ No newline at end of file
......@@ -4,11 +4,63 @@
*)
(*
* définition du type graphe qui est une map de liste dont les clés sont des string
* définition du type graphe qui est une map de liste dont les clés sont des strings
*)
module Graphe = Map.Make(String)
module Clesliste = Set.Make(String)
(* module type Graphe =
sig
type key = String.t
type t = string Map.Make(String).t
val empty : t
val mem : key -> t -> bool
val add : key -> string -> t -> t
val iter : (key -> string -> unit) -> t -> unit
val fold : (key -> string -> 'b -> 'b) -> t -> 'b -> 'b
val find : key -> t -> string
end
module type MySet =
sig
type t = Set.Make(String).t
type elt = String.t
val empty : t
val elements : t -> elt list
val add : elt -> t -> t
end
module MakeGraph () =
struct
type key = String.t
type t = string Map.Make(String).t
let empty = Graph.empty
let mem = Graph.mem
let add = Graph.add
let iter = Graph.iter
let fold = Graph.fold
let find = Graph.find
end
*)
module Graphe :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end = Map.Make(String)
module Clesliste :
sig
type t = Set.Make(String).t
type elt = String.t
val empty : t
val elements : t -> elt list
val add : elt -> t -> t
end = Set.Make(String)
type graphe_t = Clesliste.t Graphe.t
(*
* [make_graphe n]
......@@ -24,9 +76,8 @@ let rec make_graphe n file =
let g = make_graphe (n-1) file
in
if (Graphe.mem a g)
then let l = Graphe.find a g in
let f = Graphe.remove a g in
Graphe.add a (Clesliste.add b l) f
then let l = Graphe.find a g in
Graphe.add a (Clesliste.add b l) g
else Graphe.add a (Clesliste.add b (Clesliste.empty)) g
| _ -> failwith("erreur dans le graphe !")
......
(*
* fichier : phase1.mli
* auteur : dubard loïc
*)
module Graphe :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end
module Clesliste :
sig
type t = Set.Make(String).t
type elt = String.t
val empty : t
val elements : t -> elt list
val add : elt -> t -> t
end
type graphe_t = Clesliste.t Graphe.t
(*
* [make_graphe n]
* @ensures : retourne le "graphe" à n arrètes correspondant au fichier ouvert dans le channel file
*)
val make_graphe : int -> in_channel -> graphe_t
(*
* [liste_sommets g]
* @ensures : la listes des clés du graphe g
*)
val liste_sommets : graphe_t -> Clesliste.t
(*
* [chemins s g] donne la liste de tous les chemins du graphe g partants de s, un chemin étant une liste de sommets
*)
val chemins : string -> graphe_t -> string list list
(*
* [plus_court_chemin s p c] renvoie la liste des plus courts chemins de s à p de la liste de chemins c
*)
val plus_courts_chemins : string -> string -> string list list -> string list list
\ No newline at end of file
......@@ -6,9 +6,35 @@
(*
* définition du type graphe qui est une map de liste dont les clés sont des string
*)
module Graphe = Map.Make(String)
module Arreteliste = Map.Make(String)
module Graphe :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end = Map.Make(String)
module Arreteliste :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end = Map.Make(String)
type arreteliste_t = int Arreteliste.t
type graphe_t = arreteliste_t Graphe.t
(*
* [make_graphe n]
......
module Graphe :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end
module Arreteliste :
sig
type key = String.t
type 'a t = 'a Map.Make(String).t
val empty : 'a t
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val find : key -> 'a t -> 'a
val remove : key -> 'a t -> 'a t
end
type arreteliste_t = int Arreteliste.t
type graphe_t = arreteliste_t Graphe.t
val make_graphe : int -> in_channel -> int Arreteliste.t Graphe.t
val liste_sommets : 'a Arreteliste.t -> Arreteliste.key list
val chemins : Graphe.key -> 'a Arreteliste.t Graphe.t -> Graphe.key list list
val filtre : 'a -> 'a -> 'a list list -> 'a list list
val capacite : Arreteliste.key list -> 'a Arreteliste.t Graphe.t -> 'a
val graphe_capacites_residuelles : Graphe.key list -> int -> int Arreteliste.t Graphe.t -> int Arreteliste.t Graphe.t
val indice_chemin_max : Arreteliste.key list list -> 'a Arreteliste.t Graphe.t -> int -> int -> 'a -> int
val remove_from_list : int -> 'a list -> 'a list
val liste_sommets_graphe : 'a Graphe.t -> Graphe.key list
val reverse_graphe : int Arreteliste.t Graphe.t -> int Arreteliste.t Graphe.t -> Graphe.key list -> int Arreteliste.t Graphe.t
val flot_maximal : Graphe.key list list -> int Arreteliste.t Graphe.t -> int Arreteliste.t Graphe.t
val debit_maximal : int Arreteliste.t Graphe.t -> Graphe.key -> int
val nb_arrete : 'a Arreteliste.t Graphe.t -> int
......@@ -6,4 +6,8 @@ let puits = input_line file (* 2eme ligne *)
let n = int_of_string (input_line file)
let g = make_graphe n file
\ No newline at end of file
0% Chargement en cours ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter