Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 8 sur 8
  1. #1
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut Modélisation objet (éléments musicaux)

    Bonjour,
    J'écris un compositeur virtuel interactif.
    Je souhaite écrire une partie de mon programme grâce à la modélisation orienté objet.

    Pour le moment, j'ai défini :

    Un type Category_Type : (défini la classe d'instrument)
    Code ada :
    1
    2
    3
    4
    5
    6
     type Category_Type is (Off, Drums_Kit, Global,
                              Bass, Lead, Synth_Hard, Synth_Soft,
                              Motion, Strings_N_Pads, Keyboard, Guitare_N_Pluck,
                              Bell_N_Decay, Hit_N_Drum, S_E, Arp_Seq,
                              Split, Audio_In, Vocoder, User);

    Un type Form_Type : (défini la forme musicale)
    Code ada :
    1
    2
    3
    4
    5
    type Form_Type is (Null_Item,
                          Classical, Electro, Jazz,
                          Acid, Techno, Hardtech, Tribe,
                          Hardcore, Trance, Minimal, DnB);

    Un type Num_Type : (défini le nombre de temps dans une mesure)
    Code ada :
    1
    2
    subtype Num_Type is Positive range 1..16;

    Un type Den_Type : (défini la résolution d'un temps, si on joue à la croche ou autre)
    Code ada :
    1
    2
    subtype Den_Type is Positive range 1..16;


    Un type Step_Seq_Type : défini un tableau de vecteur de C.long)
    Code ada :
    1
    2
    3
    4
    5
    6
    7
    8
    package Longs_Vectors is new Ada.Containers.Vectors(positive,
                                                           long,
                                                           "=");
    use Longs_Vectors;
    
    type Step_Seq_Type is array (Natural range <>) of Vector;
    type Step_Seq_Access is access Step_Seq_Type;

    Ce que je voudrais, c'est écrire autant de fonction ou procédure que de forme*Catégorie pour composer une séquence de pas en fonction des caractéristique de mon objet (forme*Catégorie)

    Comment procéderiez vous ?

  2. #2
    Nouveau Membre du Club
    Inscrit en
    octobre 2010
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : octobre 2010
    Messages : 21
    Points : 29
    Points
    29

    Par défaut

    Bonjour,

    S'il fallait utiliser de l'objet, je proposerais quelque chose comme un type "instrument jouable" qui aurait un Category_Type et un Form_Type en disciminant. Les types fils de cet "instrument jouable" auraient alors tout le loisir d'ajouter une contrainte au discriminant du type père.

    Cependant, s'il y a un unique comportement par couple (Forme * Catégorie), faire des méthodes qui contiendraient juste un case qui se contenterait d'appeler la "bonne" méthode à chaque fois me paraît plus approprié. En effet, si le type n'est pas tagged, il est toujours possible de créer un type dérivé qui pourra tout autant ajouter des contraintes au discriminant, tout en assurant un comportement unique pour chaque (Forme * Catégorie).

  3. #3
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par Jaizu Voir le message
    Bonjour,

    S'il fallait utiliser de l'objet, je proposerais quelque chose comme un type "instrument jouable" qui aurait un Category_Type et un Form_Type en disciminant. Les types fils de cet "instrument jouable" auraient alors tout le loisir d'ajouter une contrainte au discriminant du type père.

    Bonsoir, merci d'abord, jaizu.

    En effet j'ai implémenté une pseudo solution, parce qu'elle ne fonctionne pas avec des méthode utilisable pour plusieur tuple (fome * catégorie)

    Avec Ada ça donnerait quoi ta soluce ?

  4. #4
    Nouveau Membre du Club
    Inscrit en
    octobre 2010
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : octobre 2010
    Messages : 21
    Points : 29
    Points
    29

    Par défaut

    En Ada, ça donnerait :

    Code ada :
    1
    2
    3
    type Instrument(Form : Form_Type; Category : Category_Type) is abstract tagged null record; -- pas forcé d'être abstrait et "null record"
    
    type Bidule is new Instrument(Form => Null_Item, Category => Off) with null record;

    Et ainsi de suite, avec à chaque fois la surcharge des méthodes à surcharger bien sûr.

  5. #5
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Je vais peut-être faire quelque chose comme ça cette fois, la dernière fois j'avais avancé avec d'autres solutions ou pas, parce que je recommence donc.

    J'avais oublié de te dire merci, alors un grand merci jaizu !

  6. #6
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    bonjour à tous, bonjour Jaizu si tu est parmi les lecteurs.

    Je crois que j'ai fait une grosse bêtise, mais j'espère en venant ici que vous allez me sortir de mon ignorance plutôt que de me dire que je me suis lamentablement planté.

    Voilà, j'ai écrit ceci pour le moment :

    Code :
    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
     type Composer_Type;
    
    
       task type Compositor_Type (Composer : access Composer_Type;
                                  Form     : Form_Type;
                                  Category : Valid_Category_type) is
          pragma Storage_Size (16777216);
          entry Initialize(Samples_Set : in Samples_Set_Type);
          entry Train(Converged : in Real);
          entry Start(Date : in Time; Tempo : in Long_Float);
          entry Stop;
          entry Halt;
          entry Respond(Text : in String; Feedback : out String_access; Channel : in Channel_Type; sequence : out Seq_Vectors.vector);
       end Compositor_Type;
    
       type Composer_Type (Form     : Form_Type;
                           Category : Valid_Category_Type) is limited
    
          record
    
             Network                : Network_Type(Form, Category);
             Compositor             : Compositor_Type(Composer_Type'Access, Form, Category);
          end record;
    
       type Composer_Access is access all Composer_Type;

    Donc, je me trouve avec une tache paramétrée dans laquelle j'aimerai appeler une fonction "compose" pour chacune des combinaison Form*category.

    Mais je me trouve devant une erreur.

    J'aurais aimer à présent pouvoir utiliser un type dans le genre de celui décrit par Jaizu.

    Voici ce que j'ai écrit dans un paquetage Arche

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package Mal.Arche is
    
       type Arche_Type(Form : Form_Type; Category : Category_Type) is tagged null record;
    
       type CLASSICAL_BASS_Type is new Arche_Type(Form => CLASSICAL, Category => BASS) with null record;
       type CLASSICAL_LEAD_Type is new Arche_Type(Form => CLASSICAL, Category => LEAD) with null record;
       type CLASSICAL_SYNTH_HARD_Type is new Arche_Type(Form => CLASSICAL, Category => SYNTH_HARD) with null record;
       type CLASSICAL_SYNTH_SOFT_Type is new Arche_Type(Form => CLASSICAL, Category => SYNTH_SOFT) with null record;
       type CLASSICAL_MOTION_Type is new Arche_Type(Form => CLASSICAL, Category => MOTION) with null record;
    
       function Compose (Arche : in CLASSICAL_BASS_Type'Class) return Seq_Vectors.Vector;
       function Compose (Arche : in CLASSICAL_LEAD_Type'Class) return Seq_Vectors.Vector;
       function Compose (Arche : in CLASSICAL_SYNTH_HARD_Type'Class) return Seq_Vectors.Vector;
       function Compose (Arche : in CLASSICAL_SYNTH_SOFT_Type'Class) return Seq_Vectors.Vector;
       function Compose (Arche : in CLASSICAL_MOTION_Type'Class) return Seq_Vectors.Vector;
    Mais Gnat me dis clairement :
    mal-rhetorica.adb:396:49: no candidate interpretations match the actuals:
    mal-rhetorica.adb:396:57: expected type "JAZZ_DRUMS_KIT_Type'Class" defined at mal-arche.ads:55
    mal-rhetorica.adb:396:57: found type "Arche_Type" defined at mal-arche.ads:3
    mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:107
    mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:106
    mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:105

    J'ai déclaré ma variable dans mal-rhetorica ainsi :
    Code :
    Arche : Arche_Type(Form, Category);
    J'ai aussi essayer de spécifier des sous-type à la place de type dérivé, mais j'obtiens également une erreur.


    Comment faire, si vous avez une idée, je suis preneur. Merci dans tout les cas.

  7. #7
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Je viens d'essayer également de passer une type access Arche_Type'class à mon composer, que j'initialise avec le type dérivé mais j'obtiens encore une erreur.

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     type Composer_Type;
    
    
       task type Compositor_Type (Composer : access Composer_Type;
                                  Arche : access Arche_Type'class) is
          pragma Storage_Size (16777216);
          entry Initialize(Samples_Set : in Samples_Set_Type);
          entry Train(Converged : in Real);
          entry Start(Date : in Time; Tempo : in Long_Float);
          entry Stop;
          entry Halt;
          entry Respond(Text : in String; Feedback : out String_access; Channel : in Channel_Type; sequence : out Seq_Vectors.vector);
       end Compositor_Type;
    
       type Composer_Type (Arche : access Arche_Type'class) is limited
    
          record
    
             Network                : Network_Type;
             Compositor             : Compositor_Type(Composer_Type'Access, Arche);
          end record;
    
       type Composer_Access is access all Composer_Type;
    Puis à l'initialisation :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     for Form in Form_Type loop
                for Category in Valid_Category_Type loop
                   case Form is
                      when CLASSICAL =>
                         case Category is
                            when BASS =>
                               BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_BASS_Type);
                            when LEAD =>
                               BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_LEAD_Type);
                            when SYNTH_HARD =>
                               BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_SYNTH_HARD_Type);
                            when SYNTH_SOFT =>
                               BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_SYNTH_SOFT_Type);
                            when MOTION =>
                               BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_MOTION_Type);

    Mais à l'appel de compose Gnat me dit :
    no candidate interpretations match the actuals:
    mal-rhetorica.adb:396:63: expected type "JAZZ_DRUMS_KIT_Type" defined at mal-arche.ads:55
    mal-rhetorica.adb:396:63: found type "Arche_Type'Class" defined at mal-arche.ads:3
    mal-rhetorica.adb:396:63:

    Je crois que je suis planté là.

  8. #8
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    926
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 926
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Pour le moment j'ai casté mon type Arche avec un gros case.
    Je suis certain de m'être planté quand même.

    Mais je vais résoudre cette discussion, on reviendra peut-être sur le sujet demain ou lus tard.

    Merci pour votre aide.

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •