Discussion :

[Seabirds]

Salut à toutes et à tous ! Bonne année et bonne santé !!!

J'ai codé quelques classes, qui ont pour but de construire un objet un peu compliqué, où pleins d'objets sont imbriqués les uns dans les autres. Je fais des tests unitaires avec la librairie boost, et je suis circonspect sur le fait de devoir recopier tout le code des classes composites dès que je veux tester les classes englobantes (je sais pas si c'est le bon vocabulaire ).

Question 1:La structure finale est censée représenter un modèle mathématique un peu compliqué par nature, mais je ne sais pas si avoir un objet-monolithe plein de sous-composantes est le bon moyen de coder ça. En tout cas c'est galère à construire, et ça m'inquiète un peu.

Votre avis ? Des liens ?

Question 2 : Si "la complexité c'est parfois nécessaire", y'a-t'il une "jolie" méthode pour dealer au mieux avec ça ? J'ai jeté un coup d'oeil au patron fabrique, mais ça ne me satisfait pas pleinement. (ou alors j'ai mal compris).

Merci à tou(te)s pour vos conseils !

[ternel]

Il nous faut un peu plus de détails pour pouvoir te répondre correctement.

Une factory sert à créer des choses dont on ne connait pas le type exact, mais un type commun à toutes les possibilités (leur interface, en somme).

Dans ton cas, tu sais précisément ce que tu veux, mais pas comment le dire.
La composition de morceaux indépendants est une bonne solution.

Par exemple, une classe de voiture peut contenir (en privé...) un réservoir, un bloc moteur (possédant une admission d'essence, et produisant une puissance, ou une poussée), une boite de vitesse (convertissant la poussée en vitesse en tour de par minutes), et des roues (permettant de convertir la vitesse angulaire en vitesse linéaire).

Ton modèle possède forcément deux types d'informations:

• des caractéristiques fixes: les constantes, les formules.
• des propriétés variables: pour ma voiture, ce sont la quantité d'essence dans le réservoir, la vitesse angulaire courante, la pression d'embrayage, le rapport de vitesse sélectionné, etc.

Détermine les propriétés fixes de ton modèle et vois comment les séparer en petits groupes. Chaque groupe sera un objet, certains pouvant avoir la même classe, au besoin. Ces objets seront probablement des membres de ton modèle mathématique (si tu en fais une grosse classe)

[Seabirds]

Merci de ta réponse
Le modèle en question est bayésien. Une fonction paramétrée est reliée aux priors utilisés via la classe KaryTree (qui est chargée de représenter le réseau bayésien). Puis ces sous-modèles sont associés aux données sur lesquelles ils seront appliqués plus tard. Ils sont ensuite associés dans des modèles un peu plus généraux (BayesianEnvironmentalModel) dans le but d'être moyennés ou regressés ... enfin bref, le but étant d'obtenir des variables réponses utilisables dans des modèles de simulation génétiques, démographiques ou autres...

Voilà le bout de code pour l'instanciation le plus abouti qui fonctionne ( il y a déjà un peu de factorisation à faire... quand j'aurai les idées plus claires et que le code aura un peu avancé).
Le dernier objet créé sera à terme encore utilisé/réutilisé par composition (still need work...).
Toutes les classes concrètes (FunctionLinear, Uniform, WeightedArithmeticMean...) sont des classes-jouets dérivant de classes abstraites.

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
67
68
69
70
71
72
73
74
75
   // First model
    // Temperature data example
    matrix<double> mTemp (3, 3);
    for (unsigned i = 0; i < mTemp.size1 (); ++ i)
        for (unsigned j = 0; j < mTemp.size2 (); ++ j)
            mTemp (i, j) = 3 * i + j;
 
    // First node created
    FunctionLinear lin1(0, 3.2);
    KaryTree node1(lin1);
 
    // Prior definition for parameter a
    Uniform p1(0,100);
    PriorFunctionForAModelParameter dt2 (p1, "a");
    KaryTree node2 (dt2);
    node1.AddAChild (node2);
 
    // Prior definition for parameter b
    Uniform p2 (0,100);
    PriorFunctionForAModelParameter dt3 (p2, "b");
    KaryTree node3 (dt3);
    node1.AddAChild (node3);
 
    BayesianModel model1 (node1);
    pairDataAndModel tempModel (mTemp, model1);
 
    // Second model
    // Pluviometry
    matrix<double> mRain (3, 3);
    for (unsigned i = 0; i < mRain.size1 (); ++ i)
        for (unsigned j = 0; j < mRain.size2 (); ++ j)
            mRain (i, j) = 2 * i + j;
 
    // First node created
    FunctionLinear lin2(0, 3.2) ;
    KaryTree node1_2(lin2) ;
 
    // Prior definition for parameter a
    Uniform p1_2(0,100) ;
    PriorFunctionForAModelParameter dt2_2(p1_2, "a") ;
    KaryTree node2_2(dt2_2) ;
    node1_2.AddAChild(node2_2) ;
 
    // Prior definition for parameter b
    Uniform p2_2(0,100) ;
    PriorFunctionForAModelParameter dt3_2(p2_2, "b") ;
    KaryTree node3_2(dt3_2) ;
    node1_2.AddAChild(node3_2) ;
 
    BayesianModel model2(node1_2) ;
    pairDataAndModel RainModel (mRain, model2) ;
 
    //Reduction dimension method
    std::vector<double> w {1.0, 2.0};
    WeightedArithmeticMean wMean(w);
 
    KaryTree wnode1 (wMean);
 
    Uniform wp1 (0, 10);
    PriorFunctionForAModelParameter wdt1 (wp1, "w1");
    KaryTree wnode2 (wdt1);
    wnode1.AddAChild (wnode2);
 
    Uniform wp2 (0,10);
    PriorFunctionForAModelParameter wdt2 (wp2, "w2");
    KaryTree wnode3 (wdt2);
    wnode1.AddAChild (wnode3);
 
    BayesianModel reducModel(wnode1) ;
 
    // Submodels
    EnvDataNameAndModel modelMap = {{"temperature", tempModel}, {"pluviometry", RainModel} } ;
 
    // Environmental model
    BayesianEnvironmentalModel envModel (reducModel, modelMap);

[ternel]

Ah mais oui, KaryTree... je n'avais pas fais le lien.

Je commence à me dire que ton problème, ce n'est pas le code, mais la clarté de ce que tu veux faire.

Concrêtement, fais-tu un programme ou une bibliothèque? Dans quel but précis?
Réfléchis non pas à comment écrire ton code technique, mais à comment tu veux qu'on s'en serve.

[Seabirds]

Hééé oui le fameuuux KaryTree...

Concrêtement, fais-tu un programme ou une bibliothèque? Dans quel but précis?

Dans un premier temps, je veux juste écrire un programme pour mes recherches perso.

Le but du programme c'est :
1) définir un modèle paramétré de génération de données écologiques/génétiques
2) sachant le modèle, simuler ces données en grand nombre
3) faire une inférence pour retrouver les valeurs de paramètres les plus probables (celles qui minimisent la distance données simulées / données réelles )
4) comparer différents modèles (donc retour au step 1)

Vu que c'est pour l'instant juste pour moi :
- je pense pouvoir me permettre quelques trucs pas forcément très propres...
- j'ai besoin de flexibilité pour ne pas être figé dans un modèle donné. En effet, la grosse structure générale risque d'être passée régulièrement à la moulinette.
- j'ai besoin du minimum syndical pour le confort d'utilisation, pour faciliter le choix de modèle et de données, la génération de rapports (automatiques ?), les analyses etc...
- je n'en suis pas au GUI (lol), mais si y'avait une manière sympa de manipuler les classes de mon modèle et l'accès aux données, ça serait chouette.

Une fois que la structure du modèle est donnée, le reste est un peu plus direct. En tout cas c'est moins embêtant à construire.

Cependant, à ma connaissance , le type de modèle que j'essaie d'implémenter n'est pour l'instant pas disponible (en tout cas pas en code ouvert, sinon je galèrerais pas autant ). Donc y'a des chances que ça finisse par être rendu disponible (sous quelle forme, je sais pas trop) ... mais vu le rythme d'avancée, c'est pas pour demain, et c'est pas le plus urgent, rassurons-nous

[ternel]

Bien.

L'interface publique de toute classe doit être conçue de l'extérieure, c'est à dire en prenant uniquement en considération le code de l'utilisateur de la classe.

Ecris le main() de ton programme, en remplaçant les entrées utilisateurs par des constantes.
Ca va t'obliger à définir les fonctions publiques de la classe à créer. Cherche à les rendre les plus simples possible.
Il faudra aussi prendre soin à donner un maximum de possibilités de configuration, par les arguments des fonctions ou les paramètres template de la classe.