[POO] Modélisation d'une bascule.

Marsh Posté le 11-01-2013 à 22:37:36

Bonjour,
Comment modéliser une bascule orienté objet ?
A votre bon coeur. Merci. :jap:

Marsh Posté le 11-01-2013 à 22:37:36

Marsh Posté le 11-01-2013 à 23:47:56

Je suis parti sur un modèle je vais voir à l'usure.

edit : pour des raison d'éuilibre j'ai modifié mon code initial

Spécification.

Code :

package My_Lib.Bascules is
   
   
   type Adjustement_Type is (Left, Right, Adjust);
   
   subtype Board_Adjustement_Type is Adjustement_Type range Left..Right;
   
   
   type Bascule_Type is tagged private;
   
   ----------------------------------------------------------
   -- Adjuster les plateaux d'une bascule par pondÃ©ration. --
   ----------------------------------------------------------
   procedure Ponderation(Bascule : in out Bascule_Type'Class;
             Board       : in Adjustement_Type;
             Ponderation : in Float);
   
   
   Board_Overflow : exception;
   -- Levée si la pondération excède la capacité machine.
   
   -----------------------------------------
   -- Obtenir l'ajustement d'une bascule. --
   -----------------------------------------
   function Adjustement(Bascule : in Bascule_Type'Class;Adjustement : in Adjustement_type) return Float;
   
   ---------------------------------
   -- Mettre les plateaux à  zéro. --
   ---------------------------------
   procedure Reset(Bascule : in out Bascule_Type'Class);
   
   
   -------------------------------------------------
   -- Obtenir le l'ajustement maximum et minimum. --
   -------------------------------------------------
   function Max(Bascule : in Bascule_Type'Class) return Adjustement_Type;
   function Min(Bascule : in Bascule_Type'Class) return Adjustement_Type;
   
   
private
   
   
   type Ponderations_Type is array (Adjustement_Type) of Float;
     
   type Bascule_Type is tagged
      record
     Ponderations : Ponderations_Type := (others => 0.0);
      end record;
   
   
   
end My_Lib.bascules;

Implémentation

Code :

package body My_Lib.Bascules is
   
   
   
   -------------------------------------------------
   -- Obtenir le l'ajustement maximum et minimum. --
   -------------------------------------------------
   function Max(Bascule : in Bascule_Type'Class) return Adjustement_Type is
   begin
      
      if Bascule.Ponderations(Right) >  Bascule.Ponderations(Left) then
     return Right;
      elsif Bascule.Ponderations(Left) >  Bascule.Ponderations(Right) then
     return Left;
      else
     return Adjust;
      end if;
   end Max;
   function Min(Bascule : in Bascule_Type'Class) return Adjustement_Type is
   begin
      
      if Bascule.Ponderations(Right) <  Bascule.Ponderations(Left) then
     return Right;
      elsif Bascule.Ponderations(Left) <  Bascule.Ponderations(Right) then
    return Left;
      else
     return Adjust;
      end if;
   end Min;
   
 
   
   
   ----------------------------------------------------------
   -- Adjuster les plateaux d'une bascule par pondération. --
   ----------------------------------------------------------
   procedure Ponderation(Bascule : in out Bascule_Type'Class;
             Board       : in Adjustement_Type;
             Ponderation : in Float) is
   begin
      
      Bascule.Ponderations(Board) := Bascule.Ponderations(Board) + Ponderation;
      case Board is
     when Left =>
        Bascule.Ponderations(Right) := Bascule.Ponderations(Right) - Ponderation;
        Bascule.Ponderations(Left) := Bascule.Ponderations(Left) + Ponderation;        
     when Right =>
        Bascule.Ponderations(Left) := Bascule.Ponderations(Left) - Ponderation;
        Bascule.Ponderations(Right) := Bascule.Ponderations(Right) + Ponderation;        
        
     when Adjust =>
        if Bascule.Ponderations(Adjust) > Ponderation then
           Bascule.Ponderations(Left) := Bascule.Ponderations(Left) - Ponderation;        
        elsif Ponderation > Bascule.Ponderations(Adjust) then
           Bascule.Ponderations(Right) := Bascule.Ponderations(Right) + Ponderation;        
        else           
           return;
        end if;
        
      end case;
      if Max(Bascule) /= Adjust then
     Bascule.Ponderations(Adjust) := abs(Bascule.Ponderations(Bascule.Max) -
                           Bascule.Ponderations(Bascule.Min));
      end if;
   exception
      when Constraint_Error =>
     raise Board_Overflow;
   end Ponderation;
      
   ----------------------------------------
   -- Obtenir l'ajustement d'une bascule --
   ----------------------------------------
   function Adjustement(Bascule : in Bascule_Type'Class;Adjustement : in Adjustement_type) return Float is
   begin   
      
      return Bascule.Ponderations(Adjustement);
   end Adjustement;
      ---------------------------------
   -- Mettre les plateaux à  zero. --
   ---------------------------------
   procedure Reset(Bascule : in out Bascule_Type'Class) is
   begin
      
      Bascule.Ponderations := (others => 0.0);
   end Reset;
end My_Lib.bascules;

Et j'ai écrit une procédure principale à la recherche de l'équilibre.

Code :

with My_Lib.Bascules;
use My_Lib.Bascules;
 
with Ada.Text_Io, Ada.Float_Text_Io;
use Ada.Text_Io, Ada.Float_Text_Io;
 
with Ada.Numerics.Float_Random;
use Ada.Numerics.Float_Random;
 
procedure Main is
   
   
   Bascule : Bascule_Type;
   
   Ponderation_Left,
   Ponderation_Right,
   Ponderation_Adjust : Float := 1.0;
   
   
   Float_Gen : Generator;
   
begin
   
   Reset(Float_Gen);
   Ada.Text_Io.Put("Enter initial ponderation : " );
   Ada.Float_Text_Io.Get(Ponderation_Left);
   Ponderation(Bascule, Left, Ponderation_Left);
   Ada.Text_Io.Put("Initial ponderation set to : " );
   Ada.Float_Text_Io.put(Adjustement(Bascule, Left));
   New_Line;
   loop      
      Ponderation_Adjust := Adjustement(Bascule, Adjust);            
      Put("Adjustement Ponderation := " );
      Ada.Float_Text_Io.Put(Ponderation_Adjust);                        
      
      exit when Ponderation_Adjust = 0.0;
      Ponderation_Adjust := Random(Float_Gen);
      Put("Adjustement min : " & Adjustement_Type'Image(Bascule.Min));
      Ponderation(Bascule, Bascule.Min, Ponderation_Adjust);
      New_Line;
   end loop;
end Main;

C'est rigolo. :lol: :hello:

Message édité par Profil supprimé le 12-01-2013 à 01:23:19

Marsh Posté le 12-01-2013 à 01:48:23

Moins rigolo mais plus fonctionnel :

Avec ça comme ça :

Code :

----------------------------------------------------------                                                                              
   -- Adjuster les plateaux d'une bascule par pondération. --                                                                              
   ----------------------------------------------------------                                                                              
   procedure Ponderation(Bascule : in out Bascule_Type'Class;
                         Board       : in Adjustement_Type;
                         Ponderation : in Float) is
   begin
 
      Bascule.Ponderations(Board) := Bascule.Ponderations(Board) + Ponderation;
      case Board is
         when Left =>
            Bascule.Ponderations(Right) := Bascule.Ponderations(Right) - Ponderation;
            Bascule.Ponderations(Left) := Bascule.Ponderations(Left) + Ponderation;
         when Right =>
            Bascule.Ponderations(Left) := Bascule.Ponderations(Left) - Ponderation;
            Bascule.Ponderations(Right) := Bascule.Ponderations(Right) + Ponderation;
 
         when Adjust =>
            Bascule.Reset;
      end case;
      if Max(Bascule) /= Adjust then
         Bascule.Ponderations(Adjust) := abs(Bascule.Ponderations(Bascule.Max) -
                                               Bascule.Ponderations(Bascule.Min));
      end if;
   exception
      when Constraint_Error =>
         raise Board_Overflow;
   end Ponderation;

On termine quand l'adjust de la bascule égale la ponderation.

Marsh Posté le 12-01-2013 à 17:52:15

J'ai écris ce prototype de bascule, pour peser les mots.

Oui mais faut pas oublier que c'est dans une architecture hiérarchisé.

Schema

-------------------------------------------------------------------------
-- Nous sommes tous logé à la même enseigne. --
-------------------------------------------------------------------------
Maître mot

Mot gauche Mot droit.

Mot gauche Mot droit/Mot Gauche Mot droit

Une arbre binaire, typiquement (devoir, apprécier, déprécier), ... etc

Message édité par Profil supprimé le 12-01-2013 à 18:06:20

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed

Name *

Email *

URL

Message *