Surcharge de constructeur - tableaux multidimensions

Version imprimable

Voir 40 message(s) de cette discussion en une page

19/05/2011, 15h33
hegros

Citation:

Envoyé par kheironn

Interface à la place d'héritage... ?

Ou une solution comme celle de DonQuiche sans interface ni héritage.

Citation:

Envoyé par kheironn

Mais, il est vrai que pour définir l'architecture ou la solution à apporter depend du contexte Une classe avec des tableaux à 1 ou n dim ? Que fait cette classe ? Voilà la question.

Il me semble qu'il a parlé de générer un vecteur de nombres aléatoires. Je ne pense pas qu'une seule classe encapsulant un tableau de double soit suffisant et que la méthode de distribution de ce vecteur doit s'y trouver. Je te rejoindrais pour utiliser un pattern strategy (pour définir la fonction de distribution)dans une classe "distribution"
19/05/2011, 15h36
DonQuiche

C'est bien ça le problème... En l'état cette classe se contente de fournir des constructeurs pour divers dimensions et une implémentation de IEnumerable<T>. Voilà pourquoi on a seulement besoin de méthodes de création retournant un IEnumerable<T>. S'il n'y aucun autre besoin, pas besoin d'en faire plus et de fournir une batterie de classes (You aren't gonna need it et principe du moindre effort)

@hegros
Quel que soit le nombre de dimensions, tant qu'en surface les besoins se résument à celui d'un IEnumerable, je ne vois aucune raison pour que ça ne marche pas, que ce soit en termes de mémoire ou autre. :)
19/05/2011, 15h55
hegros

Citation:

Envoyé par DonQuiche

S'il n'y aucun autre besoin, pas besoin d'en faire plus et de fournir une batterie de classes (You aren't gonna need it et principe du moindre effort)

Il a quand même parler de distribution de vecteur de nombre aléatoire et de tracer des points et des variables ;)
19/05/2011, 16h06
DonQuiche

Ouaip mais les nombres aléatoires sont générés à la construction de l'objet. Quant au traçage, c'est au niveau de la consommation et, apparemment, ça ne nécessite aucune autre interface pour les consommateurs que IEnumerable.
:P
19/05/2011, 16h17
hegros

Citation:

Envoyé par DonQuiche

Ouaip mais les nombres aléatoires sont générés à la construction de l'objet

Qu'est-ce qui te fais penser à cela dans les dires ou le code du posteur si ce n'est le principe du moindre effort :)

Intéressant ces échanges même si je n'y comprends encore pas grand chose. Je ne suis qu'un "utilisateur" lambda, certainement pas un ingénieur en informatique, je ne "connais" de C# et de la programmation en général que ce que j'ai lu à droite à gauche. Par ailleurs, en tant que mauvais programmeur, mes codes se sont toujours limités à fonctionner, et non à être conceptuellement parfaits, efficaces etc.

De ce fait, j'apprécie beaucoup les échanges qui ont suivi ma question naïve puisque cela me permet de comprendre un peu mieux (ou d'essayer de comprendre) la philosophie derrière, et donc de peut-être m'améliorer un peu, je l'espère.

Ceci étant dit, puisqu'on est dedans, voici la classe telle que je l'ai construite. Elle me permet de générer un tableau de nombres aléatoires selon une distribution choisie (deux cas disponibles ici). Je l'ai interfacé avec IEnumerable afin de pouvoir directement tracer les points avec un controle MSChart. Par ailleurs, j'ai ajouté une méthode de contrôle qui me trace dans le chart actuel la fonction de distribution pour m'assurer que les nombres générés suivent la bonne distribution. Si j'en crois les différents posts, cette méthode ne devrait pas être un des buts de la classe. Par contre, est-ce que de façon conceptuelle il était plus correct que cette méthode calcule la fonction de distribution (sans la tracer) et retourne finalement le tableau de la distribution ? Ou bien est-ce qu'une telle fonction devrait être effectuée en dehors de la classe (auquel cas la classe n'a plus réellement d'intérêt puisque c'est uniquement un tableau) ?

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
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
private class NbAleaUnif : IEnumerable
        {
            private double[] tab_alea; //tableau des nombres aléatoires
            private int dimension; //dimension du tableau
 
 
            public NbAleaUnif(int dim, string distribution) //constructeur
            {
                dimension = dim;
                tab_alea = new double[dim];
                Random alea = new Random(); //générateur de nombres aléatoires
 
                if (distribution.Equals("uniform"))
                {                    
                    for (int i = 0; i < dim; i++)
                    {
                        tab_alea[i] = alea.NextDouble();
                    }
                }
 
                if (distribution.Equals("gaussian"))
                {
                    if((int)(dim%2)!=0)
                        dim++;
                    double[] buff = new double[dim];
                    double r1, r2, s;
 
                    for (int i=0; i < dim/2 ; i++)
                    {
                        do
                        {
                            r1 = 2 * alea.NextDouble() - 1;
                            r2 = 2 * alea.NextDouble() - 1;
                            s = r1 * r1 + r2 * r2;
                        } while (s > 1.0 || s == 0.0);
                        buff[2*i] = r1*Math.Sqrt(-2*Math.Log(s)/s);
                        buff[2*i+1] = r2*Math.Sqrt(-2*Math.Log(s)/s);
                    }
                    Array.Copy(buff,tab_alea,dimension);
                }
            }
 
            public double Max { get { return tab_alea.Max(); } }
 
            public double Min { get { return tab_alea.Min(); } }
 
            public int dim { get { return dimension; } }
 
            public IEnumerator GetEnumerator()
            {
                return new nombreAleatoireEnumerator(tab_alea);
            }
 
            private class nombreAleatoireEnumerator : IEnumerator
            {
                private int _index;
                private double[] _alea;
 
                public nombreAleatoireEnumerator(double[] numbers)
                {
                    _alea = numbers;
                    _index = -1;
                }
 
                public void Reset()
                {
                    _index = -1;
                }
 
                public bool MoveNext()
                {
                    _index++;
                    return _index < _alea.Length;
                }
 
                public object Current
                {
                    get { if(this._index < _alea.Length)
                              return _alea[_index];
                          else throw new IndexOutOfRangeException();
                    }
                }
            }
 
            public void histo(int n,ref System.Windows.Forms.DataVisualization.Charting.Chart chart)
            {
                double[] _histo = new double[n];
                double[] _X = new double[n];
                double min = tab_alea.Min();
                double max = tab_alea.Max();
                double delta = (max-min)/n;
                int indice;
 
                for (int i = 0; i < n; i++)
                {
                    indice = 0;
                    while (indice < tab_alea.Length)
                    {
                        if (tab_alea[indice] > (min + i * delta) && tab_alea[indice] < (min + (i + 1) * delta))
                        {
                            _histo[i]++;
                        }
                        indice++;
                    }
                    _X[i] = min + i * delta;
                    _histo[i] = _histo[i] / tab_alea.Length;
                }
                chart.Series.Add("tata");       
                chart.Series["tata"].Points.DataBindXY(_X, _histo);
            }
        }

Merci pour vos commentaires très instructifs !

Oui je pense que la méthode histo n'a rien à faire ici (principe de faible couplage,de forte cohésion et de responsabilité unique) de même que dans ton constructeur le code de génération de nombre aléatoire en fonction de ta string n'a rien à faire ici (toujours les mêmes principes) il devrait être dans une autre classe qui correspondrait à ta strategy de distribution.

DonQuiche, tu avais raison il utilise un algorithme de génération de nombres dans le constructeur :aie:

En fait je voyais plus un truc comme première solution
Code:

1 2 3 4 5 6 7 8 9 10 public class NbAleaUnif { public NbAleaUnif (IEnumerable<double> nombres) { //allocation et affectation au tableau } } NbAleaUnif alea = new NbAleaUnif (Distribution.Genere(TypeDistribution,100));
ou en seconde solution dans le constructeur
Code:

1 2 3 4 5 6 public NbAleaUnif(int dim, string distribution) //constructeur { MyStrategy = new StrategyDistrbution(distribution); tab_alea = MyStrategy.Distribuer(dim); }

Je rejoins (comme n'importe qui je pense) Hegros sur la séparation des opérations UI par rapport aux données : la seule chose qui justifierait de les mélanger ainsi serait les performances, si un tel pb se posait vraiment (sur un tableau, une boucle for(i < array.Length) causera la suppression des vérifications de bornes et sera plus rapide qu'un foreach). Sur la séparation de la distribution et du vecteur, c'est davantage sujet à discussions. L'avantage est d'avoir un seul constructeur (rendant aisé le calcul des min et max au moment de la construction par exemple). On peut imaginer des variantes.

Pour la question de savoir si tu dois garder une classe ou simplement créer une méthode renvoyant ou un tableau ou un énumérable, tu as depuis ton précédent code rajouté des propriétés : min, max et dimension (mais cette dernière n'est pas utilisée visiblement). Du coup, la classe se justifie désormais, même si, en l'état, il serait facile de se passer de ses propriétés puisque Linq fournit déjà des opérations Min et Max, sur lesquelles tu t'appuies (mais, à l'avenir, tu pourrais changer l'implémentation de ces propriétés pour calculer les min et max lors de la construction de la classe). A toi de voir...

Enfin, deux petit détails : mieux vaudrait utiliser un IEnumerable<double>, pour des questions de performances (dans l'implémentation actuelle, chaque entier devra être boxé lors de l'énumération). Ensuite, pourquoi se casser la tête à créer un énumérateur personnalisé ? Le code suivant serait tout à fait équivalent depuis l'extérieur et aussi bien plus simple et tout aussi performant :
Code:

1 2 3 4 5 // Marche aussi en version générique : tab_alea renvoie un énumérateur générique qui implémente aussi la version non-générique. public IEnumerator GetEnumerator() { return tab_alea.GetEnumerator(); }

Voir 40 message(s) de cette discussion en une page