Discussion :

[lalalala75]

J'ai la méthode suivante, j'ai besoin de faire une modification de telle sorte à avoir un tableau searchPoints non pas de type double mais supportant deux types de valeurs "entières" pour la première colonne pour servir d'index et "réelles" pour la deuxième colonne correspondante à l'index de la première colonne. Et si je définis une méthode de trie qui me permet de trier un tel tableau par ordre décroissant de la deuxième colonne,comment procéder pour maintenir chaque valeur réelle indexée par sa valeur entière??? merci beaucoup d'avance

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 public void run() {
        double searchPoints[][] = new double[n][var + 1];
 
        for (int i = 0; i < n; i++) {
            double[] tmpX = new double[var];
            for (int j = 0; j < var; j++) {
                searchPoints[i][j] = this.random(upperLimit, lowerLimit);
                tmpX[j] = searchPoints[i][j];
            }
            double tmp = function(tmpX);
            searchPoints[i][var] = tmp;
        }
 
        for (int itr = 1; itr <= iteration; itr++) {
            sort(searchPoints);
 
            for (int i = 0; i < e; i++) {
                double[] x = new double[var];
                double[] x_best = new double[var];
                for (int j = 0; j < var; j++) {
                    x[j] = searchPoints[i][j];
                    x_best[j] = x[j];
                }
                double f = searchPoints[i][var];
                double f_best = f;
 
                for (int indx = 0; indx < nep; indx++) {
                    double[] x_elite = new double[var];
                    for (int j = 0; j < var; j++) {
                        x_elite[j] = this.random(x[j] + ngh, x[j] - ngh);
                    }
                    double f_elite = function(x_elite);
                    if (f_elite > f_best) {
                        for (int j = 0; j < var; j++) {
                            x_best[j] = x_elite[j];
                        }
                        f_best = f_elite;
                    }
                }
 
                for (int j = 0; j < var; j++) {
                    searchPoints[i][j] = x_best[j];
                }
                searchPoints[i][var] = f_best;
 
            }
 
            for (int i = e; i < m; i++) {
                double[] x = new double[var];
                double[] x_best = new double[var];
                for (int j = 0; j < var; j++) {
                    x[j] = searchPoints[i][j];
                    x_best[j] = x[j];
                }
                double f = searchPoints[i][var];
                double f_best = f;
 
                for (int indx = 0; indx < nsp; indx++) {
                    double[] x_elite = new double[var];
                    for (int j = 0; j < var; j++) {
                        x_elite[j] = this.random(x[j] + ngh, x[j] - ngh);
                    }
                    double f_elite = function(x_elite);
                    if (f_elite > f_best) {
                        for (int j = 0; j < var; j++) {
                            x_best[j] = x_elite[j];
                        }
                        f_best = f_elite;
                    }
                }
 
                for (int j = 0; j < var; j++) {
                    searchPoints[i][j] = x_best[j];
                }
                searchPoints[i][var] = f_best;
 
            }
 
            for (int i = m; i < n; i++) {
                double[] tmpX = new double[var];
                for (int j = 0; j < var; j++) {
                    searchPoints[i][j] = this.random(upperLimit, lowerLimit);
                    tmpX[j] = searchPoints[i][j];
                }
                searchPoints[i][var] = function(tmpX);
            }
        }
 
        sort(searchPoints);
 
        for (int j = 0; j < var; j++) {
            optimalPoint[j] = searchPoints[0][j];
        }
        optimalPoint[var] = -searchPoints[0][var];
    }

[Adpar]

Bonjour,

Je te conseille de regarder du côté de la Map, ça permet de stocker quelque chose de la forme :

clef => valeur

Un peu de doc ici : http://docs.oracle.com/javase/1.4.2/.../util/Map.html

[Mathieu.J]

La Map ne permet pas un tri sur les valeurs.

Je ne vois pas en standard un objet qui pourrait convenir à 100%

Clé => Valeur
Tri sur la valeur
Garder l'accès par la clé peut importe le tri


Mais c'est facile à coder.

[lalalala75]

Salut, Mathieu.J s'il te plait est ce que vous pouvez mieux m'expliquer? merci d'avance

[sofiene D]

bnonjour

essaye d'utiliser un tableau de String ,apres tu fait la conversion Double.parseDouble(String val) et Integer.parseInt(String val)

[Adpar]

Si tu as besoin de faire un tri j'aurai fait comme ça :

Un tableau (ou une collection) pour tes clefs, et un tableau (ou une collection) pour tes valeurs.

Lorsque tu ajoutes une valeur, tu ajoutes obligatoirement une clef aussi.

Si tu tries :

Tu inter-changes la valeur à l'indice i de ton tableau de valeur avec celle qui est à l'indice i + 12. Tu inter-changes aussi la clef à l'indice i de ton tableau de clef avec l'indice i + 12.

Rien de bien compliqué vu que, normalement, tu as le même nombre de clef que de valeurs...