Discussion :

[Phantom_Lord21]

Bonjour ceci est en quelque sorte un "follow-up" sur mon dernier "post". Je dois implanter une méthode mais je ne sais pas comment m'y prendre...

Voici les 3 classes et la signature des méthodes qui sont d'ailleurs déjà implémentées...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 class  client (n : string) (d :int) (c :float*float) =
  object
    val nom = n
    val demande = d
    val coordonnees = c
    method get_nom = nom 
    method get_demande = demande
    method get_coordonnees = coordonnees 
 
  end
 
 
 class itineraire =  
  let num = ref 1 in
    fun (c : int) ->
  object(this)
    val numero = !num  
    val capacite = c
    val mutable demande_totale = 0 
    val mutable distance_totale = 0.0 
    val mutable liste_clients : client list = []
    method get_numero = numero
    method get_capacite = capacite 
    method get_demande_totale = demande_totale
    method get_distance_totale = distance_totale
    method get_liste_clients = liste_clients
    method set_demande_totale (d : int) = demande_totale <- d
    method set_distance_totale (dis : float) = distance_totale <- dis
    method set_liste_clients  (l : client list) = liste_clients <- l
 
    (*method client_existe : string -> bool
    method calculer_demandeTotale : int
    method calculer_distanceTotale : float
    method ajouter_client  : client -> unit
    method supprimer_client : string -> unit
    method inserer_client : client -> unit
    method afficher_itineraire : unit*)   
 
       initializer
      num := !num + 1 ;
 
  end 
 
 
 class  plan =
  let num = ref 1 in
  object(this)
    val nom_plan = "p" ^ string_of_int(!num) 
    val mutable liste_itineraires : itineraire list = []
    method get_nom_plan = nom_plan
    method get_liste_itineraires = liste_itineraires
    method set_liste_itineraires (l : itineraire list) = liste_itineraires <- l
 
 (*method client_existe :string -> bool
    method retourner_client : string -> client
    method itineraire_existe : int -> bool
    method ajouter_itineraire : itineraire -> unit
    method retourner_itineraire : int -> itineraire
    method retourner_itineraire_client : string -> itineraire
    method retourner_ICRM : itineraire
    method calculer_distanceTotale : float
    method afficher_plan : unit*)
 
    initializer
      num := !num + 1 ;      
  end

Ma question concerne method generer_nouveau_plan : client list -> plan
dans la classe plan.
Cette méthode prend une liste de clients (let l = [c1; c2; c15; c16];; en exemple) à supprimer d'un plan et par la suite les réinsère un à un (dans l'ordre de la liste) dans les itinéraires du plan de sorte à minimiser la distance totale du plan (calculé avec la méthode "calculer_distanceTotale". La méthode utilise la méthode "inserer_client" de la classe itinéraire qui elle-même insère le client au bon endroit dans un itinéraire de sorte à minimiser sa distance totale...
Quand tous les clients ont été insérés de sorte à minimiser la distance totale, le plan est retourné tel que prévu par la signature de la méthode "generer_nouveau_plan"

Est-ce que quelqu'un a une idée sur la façon d'implémenter cette méthode??

La logique dirait qu'il faut que j'insère le 1er client de la liste dans chaque itinéraire, un à la fois, que je calcule la distance totale ainsi obtenue et que je sélectionne la meilleure insertion. Puis, je recommence pour tous les autres clients de la liste... Le problème c'est que je n'arrive pas à implémenter ce comportement...

Merci à l'avance pour vos commentaires et suggestions

[gasche]

Pourquoi utiliser des classes et des méthodes ?

La programmation orientée objet est un art délicat, où il est beaucoup plus facile de se planter que d'avoir un programme agréable à maintenir. En OCaml, c'est en plus une pratique minoritaire, la communauté préférant en général un style plus fonctionnel (même si les deux ne sont pas incompatibles).

Ton code n'est pas très bon d'un point de vue POO (getters/setters partout, pas d'encapsulation..) ni d'un point de vue fonctionnel (état global, effets de bords dans toute l'interface...). Je pense que tu devrais essayer, surtout si tu es débutant, de te plier aux usages Caml habituels : tes données définis dans des types de données riches, et des fonctions qui les manipulent. L'organisation objet ne t'apporte rien.


Pour tea questions, il nous manque des informations. Que font ajouter_client/inserer_client ? Comment calcule-t-on la distance totale sur un itinéraire ? Que fait calculer_distance_totale ?

[Phantom_Lord21]

@bluestorm

Ceci est dans le cadre d'un travail... c'est pas moi qui décide des choses malheureusement

Que font ajouter_client/inserer_client ?
ajouter_client ne fait qu'insérer un client à la suite dans la liste de clients d'un itinéraire précis tandis qu'inserer_client l'insère dans la liste à la position qui fera que la distance totale de l'itinéraire sera moindre. Cette méthode, je l'ai déjà codée et c'est ce qu'il faut utiliser pour optimiser la méthode generer_nouveau_plan...


Comment calcule-t-on la distance totale sur un itinéraire ?
Chaque client possède des coordonnées (x,y) si on veut alors il suffit de faire la somme des distances entre chaque "point". Le départ et l'arrivée sont à (0,0). Cette fonction je l'ai déjà codée aussi.


Que fait calculer_distance_totale ?
Dans le cas de la classe itinéraire, elle calcule la distance totale pour le trajet de l'itinéraire (selon la liste de clients). Pour la classe plan, elle calcule la somme des distances des trajets de chaque itinéraire. C'est ni plus ni moins qu'une sommation de la distance totale pour chaque itinéraire...


Tant qu'à y être au cas où c'est pas clair:
Un itinéraire contient une liste de clients
Un plan contient une liste d'itinéraires

Merci pour ton "feedback" c'est très apprécié
S'il y a autres choses, n'hésitez pas
Merci!