Discussion :

[abel413]

Bonjour à tous,

Ce sujet est un peu l'extension de celui-ci mais il n'est pas nécéssaire de l'avoir forcément parcouru.

J'ai ici un problème assez tordu : d'une part je souhaite détecter certaines choses spécifiques sur un tableau, de l'autre j'ai besoin de faire une boucle for avec un pas variable dépendante de cette détection.

Pour commencer je prend un certain tableau tab en paramètre dont voici le début

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
423	426	123
801	803	123
1523	1528	123
1524	1526	1234
1541	1544	123
1573	1576	123
1573	1576	1234
1743	1747	123
1743	1747	1234
3045	3048	123
3170	3172	123
3170	3172	1234
3236	3241	123
3238	3241	1234
3307	3309	123
3316	3320	123
3353	3361	123
3498	3581	123
3532	3562	1234
6090	6092	123
6310	6325	123
6876	6879	123
6877	6879	1234
7880	7884	123
7901	7908	123
7904	7908	1234
7927	7932	123
9235	9240	123
9854	9858	123
9884	9887	1234
9924	9959	123
10119	10125	123
10119	10123	1234
10314	10316	1234
10319	10323	123
10456	10482	123
10504	10507	123
10504	10507	1234
11889	11895	123
12145	12155	123
12647	12654	123
12647	12653	1234
12700	12704	123
12883	12886	123
12894	12900	123
13167	13169	123
13354	13359	123
13596	13607	123
13599	13606	1234
13621	13623	123
13671	13674	123
13704	13713	123
13807	13812	123
15534	15552	123
15545	15552	1234
15548	15552	12345
16452	16454	123
16474	16479	123
16474	16479	1234
16504	16508	123
19631	19652	123
19641	19647	1234
20196	20202	123
20617	20650	123
20638	20643	12345
20638	20643	123456
20715	20726	1234
20770	20792	123
22419	22423	123
23624	23637	123
23764	23769	123
23793	23796	123
23890	23895	123
23939	23942	123
23975	23979	123
23982	23985	123
24098	24101	123
24207	24210	123
25608	25611	123
25833	25839	123
25849	25852	1234
26026	26154	123
26132	26136	1234
26194	26197	123
26218	26221	123
26239	26246	123
26310	26314	123
26325	26328	1234
26325	26328	12345
26337	26341	123
26352	26357	123
26485	26488	123
26501	26508	123
26519	26522	123
26526	26529	123
26533	26536	123
26875	26879	123
26877	26879	1234
27124	27127	123
27176	27179	123
27188	27190	123
27210	27212	123
27285	27287	123
27513	27520	123
27518	27520	1234
27720	27722	123
28228	28233	123
28993	28995	123
28993	28995	1234
29883	29886	123
30000	30003	123
30409	30417	123
30478	30480	123
30518	30520	123
30943	30968	123
30954	30962	1234
31184	31199	123
31319	31321	123
36268	36270	123
41524	41528	123
41905	41907	123
42200	42202	123
42825	42828	123
45469	45472	123
45496	45535	123
50123	50130	123
51637	51641	1234
51650	51657	123
56424	56428	123
57013	57015	123
57013	57015	1234
57928	57930	123
58072	58083	123
58072	58083	1234
58138	58141	123
59117	59120	123
59150	59154	123
60433	60490	123
60479	60490	1234
60555	60567	123
60636	60640	123
61048	61053	123
61244	61254	123
62270	62274	123
62289	62293	123
62613	62615	123
62698	62701	123
63711	63713	123
64044	64048	123
64913	64915	123
64929	64932	123
65013	65017	123
65174	65176	123
66098	66102	123
72908	72913	1234
72917	72924	123
72974	72979	123
72976	72979	12345
72992	72996	123
73002	73006	123
73013	73016	123
73020	73025	123
73020	73022	1234
73020	73022	12345
73031	73034	123
73032	73034	1234
73039	73041	123
73039	73041	1234
73154	73159	123
73188	73201	123
73189	73193	1234
73277	73287	123
73300	73303	1234
73301	73303	12345
73383	73387	1234
73413	73439	123
73435	73439	1234
77026	77031	123
77063	77201	123
77157	77166	1234
77237	77276	123
77272	77276	1234
77308	77310	1234
77314	77318	123
77330	77333	123
77330	77333	1234
78642	78654	123
79337	79341	123
79377	79379	123
79471	79474	123
79477	79480	123
79507	79509	123
79608	79610	123
79897	79901	123
79899	79901	1234
81462	81467	123
81463	81466	1234
81464	81466	12345
81526	81544	123

J'ai ensuite déterminé certains indices de ce tableau dans un autre vecteur qui correspondent aux lignes consécutives commençant par le même début :

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
indices_meme_debut=
6
7
8
9
11
12
32
33
37
38
41
42
58
59
65
66
88
89
108
109
130
131
133
134
162
163
164
167
168
185
186

Ainsi si vous regardez les 6ème et 7ème lignes de tab vous voyez qu'elles commencent par 1573 toutes les deux. Les indices de indices_debut_fin sont généralement regroupés par 2 (deux lignes consécutives) mais il peut arriver que 3,4 ou même plus de lignes commencent par le même début. Par exemple aux rang 162,163,164 du tableau on a 3 lignes qui commencent par 73020.

Voilà, j'ai besoin de détecter tous ces doublons, de les stocker à chaque fois dans un mini-tableau, de faire des traitement sur eux, et de créer un nouveau tableau avec les doublons traités. Voici le début de mon code de traitement :

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
for i=1:size(indices_meme_debut,1)
 
     Z1=tab(indices_meme_debut(i),:);
 
     Z2=find(tab(:,1)==Z1(1,1));
 
     %On stocke dans tab_doublon les doublons obtenus à un rang donné.
 
     tab_doublon=tab(Z2,:);
 
     %Recherche et élimination des doublons inutiles si tab_doublon
     %contient plus d'une ligne. Sinon on ajoute la ligne telle quelle.
 
     if (size(tab_doublon,1)>0)
 
             %traitement a faire
 
             tab_construit=[tab_construit;tab_doublon];
 
     else
 
         tab_construit=[tab_construit;tab_doublon];
 
     end
 
end
 
end

Dans ce code je parcours le vecteur indices_meme_debut, je stocke dans Z1 la première ligne d'indice indices_meme_debut(i) de tab, dans Z2 je détecte les doublons correspondant que je stocke dans le mini-tableau tab_doublon. Ainsi, pour vous donner un exemple, quand i=1 : dans tab_doublon j'ai le premier doublon apparaissant dans tab qui correspond aux indices 6,7 de indices_meme_debut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tab_doublon=
1573	1576	123
1573	1576	1234

J'ai besoin de n'en garder qu'un seul. C'est à partir d'ici que j'aurai besoin de votre aide :

- Pour commencer je voudrais détecter la ou les lignes de tab_doublon où l'élément de la deuxième colonne est maximal. Cependant comme la taille de tab_doublon est en principe imprévisible (il peut y avoir 2,3,4...ect ligne) comment pourrais-je faire ? J'ai bien essayer quelque chose avec un find, mais ceci marche si je connais la taille de tab_doublon. Par exemple, avec les deux lignes plus haut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

indices=find(tab_doublon(:,2)==max(tab_doublon(1,2),tab_doublon(2,2)));

dans indices je vais recueillir 1 et 2 car 1576 est effectivement la valeur maximale sur la deuxième colonne présente sur les deux lignes. Mais, voilà j'ai fait comme si je connaissais la taille de tab_doublon à l'avance.


- Second problème : une fois que j'ai traité ce tab_doublon (en i=1, je suis rentré dans le if (size(tab_doublon,1)>0)) j'ai besoin de reprendre la boucle for. Mais tel que je l'ai écrite, je vais passer à i=2, ce que je ne veux pas. En réalité je voudrais reprendre le for au second doublon c'est-à-dire à i=3 ce qui correspond au 9 sur le vecteur indices_meme_debut. J'ai donc besoin de sauter les indices inutile. C'est pour cela que je parlais de boucle for avec pas variable.

[le fab]

une première réponse

1/ tu peux écrire ton max comme ceci : max(tab_doublon(:,2))
2/ la fonction max renvoie en deuxième sortie l'index, pas besoin de find

Fabien

[abel413]

EDIT:

Merci bien le_fab : j'ai effectivement bien utilisé cette notation pue le 1/ et pour le 2/ je me suis débrouillé. Il reste le problème du for à pas variable, ce que je détaille maintenant.

Bon j'ai réussi à avancer, je vais le poster le code en espérant qu'il ne vous fasse pas peur puis je vous montrerai un exemple afin de parler des points qui me posent problème. J'ai résolu problème, il reste simplement le problème avec le for variable.

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
tab_doublon=[];
tab_construit=[];
 
 
for i=1:size(indices_meme_debut,1)
 
     %lignes où on aura un même début (Z1) et indices des lignes qui ont le
     %même début (Z2).
 
     Z1=tab(indices_meme_debut(i),:);
 
     Z2=find(tab(:,1)==Z1(1,1));
 
     %On stocke dans tab_doublon les doublons obtenus à un rang donné.
 
     tab_doublon=tab(Z2,:);
 
     %Recherche et élimination des doublons inutiles si tab_doublon
     %contient plus d'une ligne. Sinon on ajoute la ligne telle quelle.
 
     if (size(tab_doublon,1)>0)
 
             %traitement a faire
 
             %On détermine le maximum Z3 sur la deuxième colonne de
             %tab_doublon et sa ou ses position(s) Z4.
 
             Z3=max(tab_doublon(:,2));
             Z4=find(tab_doublon(:,2)==Z3);
 
             %s'il n'y a qu'un seul maximum on élimine les lignes ne
             %comportant pas ce maximum et on conserve celle avec le
             %maximum.
 
             if(numel(Z4)==1)
 
             %mise à 0 des lignes de tab_doublon autre celle où il y a le
             %maximum sur la deuxième colonne et élimination des lignes. On
             %ne conserve donc dans tab_doublon que la ligne qui nous
             %intéresse. avriante avec setdiff ?
 
             for i=1:size(tab_doublon,1)
                   if i~=Z4
                         tab_doublon(i,:)=0;
                   else
                         continue;
                  end
             end
 
             Z5=find(tab_doublon(:,1)==0);
             tab_doublon(Z5,:)=[],
             tab_construit=[tab_construit;tab_doublon];
 
             %S'il y a plusieurs maxima, on regarde la valeur sur la
             %troisième colonne des lignes correspondant à ces maxima.
 
             elseif(numel(Z4)>1)
 
             %Maxima sur la troisième colonne pour les indices (Z4) où on 
             %a des maxima sur la deuxième colonne (Z6) et leurs indices
             %(Z7).
 
             Z6=max(tab_doublon(Z4,3));
             Z7=find(tab_doublon(:,3)==Z6);
 
                %s'il n'y a qu'un seul maxima sur la troisième colonne, on
                %élimine toutes les lignes où il n'y a pas ce maxima et on
                %conserve seulement celle avec le maxima.
 
                if(numel(Z7)==1)
 
                    for i=1:size(tab_doublon,1)
                        if i~=Z7
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
                Z8=find(tab_doublon(:,1)==0);
                tab_doublon(Z8,:)=[],
                tab_construit=[tab_construit;tab_doublon];
 
                %S'il y a plusieurs maxima sur la troisième colonne, on
                %conserve une seule des lignes avec ce maxima et on élimine
                %toutes les autres.
 
                elseif(numel(Z7)>1)
 
                 for i=1:size(tab_doublon,1)
                        if i~=Z7(1)
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
                Z9=find(tab_doublon(:,1)==0);
                tab_doublon(Z9,:)=[],
                tab_construit=[tab_construit;tab_doublon];
 
 
                end
 
 
 
 
 
             end
 
     else
 
         %Si tab_doublon n'a qu'une ligne on l'ajoute telle quelle.
 
         tab_construit=[tab_construit;tab_doublon];
 
     end

Alors voilà, si on reprend tab_doublon et donc i=1 dans la boucle for :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tab_doublon=
1573	1576	123
1573	1576	1234

Le code précédent, va me conserver uniquement la seconde ligne : 1573 1576 1234 et le code va jusqu'à la condition if(numel(Z7)==1) rentre dedans et va jusqu'au tab_construit qui contient donc cette ligne. Maintenant, normalement si je continue la fonction dans le boucle for au début, sur size(indices_meme_debut), on va rentrer en i=2, ce qui ne va pas car cela revient à se positionner dans tab sur la 7ème ligne qui est justement 1573 1576 1234. En fait, je voudrais me positionner sur la 8ème ligne qui est la troisième ligne de indices_meme_debut. En d'autre termes je veux me positionner sur la ligne de tab qui correspond à l'apparition du second doublon. Comme en i=1, le doublon était tab_doublon constitué de deux lignes, j'ai besoin dans le for de sauter les indices inutiles et donc, dans le cas particulier de cet exemple de passer à i=3 au lieu de i=2. Mais bien sûr ceci est variable selon la taille de tab_doublon. Si par exemple tab_doublon aurait était, en i=1, constitué de 3 lignes, j'aurais eu besoin de reprendre la boucle for en i=4 cette fois.

Je sais que c'est compliqué, à faire et à exprimer, mais auriez-vous malgré tout une piste ?

[le fab]

tu ne m'a lu qu'a moitié !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Z3=max(tab_doublon(:,2));
Z4=find(tab_doublon(:,2)==Z3);

peut se remplacer par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[Z3,Z4] = max(tab_doublon(:,2));

sinon pour faire une boucle for à géométrie variable, il faut passer par un while et gestion manuelle de l'index :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
ii=1;
while ii<=size(indices_meme_debut,1)
  ...
  if (size(tab_doublon,1)>0)) 
  ...
    ii = ce que tu veux;
    continue
  end
 
  ...
  ii = ii+1
end

en j'en profite pour te déconseiller l'utilisation de i comme index, car c'est un mot reservé matlab (partie imaginaire d'un nb complexe)

[abel413]

Oui effectivement merci le_fab ma notation est inutile mais bon je l'utilise pour plus de clarté dans ma tête. J'ai donc suivi ta piste et en conséquence j'ai modifié mon code.

Quand j'ai un tab_doublon, je mets seulement les lignes à 0 que je veux éliminer et je ne les supprime plus comme je le faisais plus haut. Cela me permets à la fin d'un if de conserver la taille de tab_doublon en mémoire. Ainsi je peux incrémenter le ii :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
tab_construit_meme_debut=[tab_construit_meme_debut;tab_doublon];
ii=ii+size(tab_doublon,1);

Ainsi par exemple, pour reprendre mes explications plus haut, comme en ii=1 j'avais tab_doublon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tab_doublon=
1573	1576	123
1573	1576	1234

Et qu'avec mon algorithme je veux supprimer la première ligne, maintenant je la conserve en y mettant des 0 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tab_doublon=
0 0 0
1573	1576	1234

Je stocke ceci dans tab_construit_meme_debut et j'incrémente ii qui va donc valoir ii=1 + 2 = 3 comme je le souhaitais et on repart en haut du while. Et ainsi de suite. Je me retrouve donc avec le tableau_construit suivant :

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
0	0	0
1573	1576	1234
0	0	0
1743	1747	1234
0	0	0
3170	3172	1234
10119	10125	123
0	0	0
0	0	0
10504	10507	1234
12647	12654	123
0	0	0
0	0	0
16474	16479	1234
0	0	0
20638	20643	123456
0	0	0
26325	26328	12345
0	0	0
28993	28995	1234
0	0	0
57013	57015	1234
0	0	0
58072	58083	1234
73020	73025	123
0	0	0
0	0	0
0	0	0
73039	73041	1234
0	0	0
77330	77333	1234

Les lignes de 0 sont les lignes qu'il reste à supprimer et cela je peux donc le faire après.

Bref pour résumer, je les supprime et je me retrouve avec le tableau suivant :

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
1573	1576	1234
1743	1747	1234
3170	3172	1234
10119	10125	123
10504	10507	1234
12647	12654	123
16474	16479	1234
20638	20643	123456
26325	26328	12345
28993	28995	1234
57013	57015	1234
58072	58083	1234
73020	73025	123
73039	73041	1234
77330	77333	1234

J'avais isolé toutes les lignes commençant par la même valeur dans indices_meme_debut, puis j'ai fait un tri pour obtenir ce dernier tableau. Donc en gros il s'agit des lignes à conserver. Le problème c'est que je voudrais faire de même en reprenant le tableau que je trie depuis le début et en regardant les lignes où l'élément sur la deuxième colonne est le même. Maintenant ce n'est plus très sorcier, il suffit d'adapter ce code qu'on vient de réaliser. Puis il va rester les cas d'inclusions : si un segment formé de [debut:fin] où debut est sur la première colonne d'une ligne i et fin sur la seconde est inclus dans celui de la ligne i-1 (d'après le triage par rapport à la première colonne il ne peut en être qu'ainsi), j'élimine l'un des deux selon d'autres critères.

Malheureusement comme tu vois je suis en train de traiter 3 cas séparément : même début / même fin / cas d'inclusion ; le pire c'est que je n'aurais pas considérer les éléments qui ne sont pas des doublons, puisqu’il y peut y avoir des lignes sans particularité sur mon tableau initial. Quand bien même je parviens à isoler le tout et à tout rassembler, rien ne me dit qu'il ne faudra pas faire un triage récursif à la fin comme on en avait déjà parlé dans mon autre méthode !

[abel413]

le_fab

Finalement j'ai pu pas mal avancer aujourd'hui ce problème. Au cas où cela t’intéresserait (ou intéresserait quelqu'un d'autre), je vais poster mon code ci-après mais avant j'explique un peu ce que j'ai fait :

- Je prends un grand tableau à 3 colonnes en entrée. Je trie ce tableau par rapport à la première colonne.

- Je détermine les indices des lignes du tableau trié qui commencent par un même début (indices_meme_debut) et de même je détermine les indices des lignes qui ont la même valeur sur la deuxième colonne (indices_meme_fin) mais en supprimant les indice éventuels qui pouvaient déjà figurer dans indices_meme_debut afin de ne pas les compter deux fois.

- Je fais un traitement sur les doublons ayant même début : en gros je recherche un à un tous les doublons ayant même début (dans tab_doublon) ; pour chaque doublon, qui peut avoir 2,3,4 ect lignes, le but est de ne conserver qu'une seule ligne selon certains critères décrit dans mon code. En conséquence je mets à 0 les lignes du tableau d'entrée trié par rapport à la première colonne que je voudrais éliminer et je laisse les autres. A ce stade j'ai parcouru tout le tableau d'entrée, conserver la ligne des doublons ayant même début que je veux et mis à zéro les autres, sans toucher aux autres lignes de tab non concernées.

- Je fais exactement de même avec les doublons ayant même fin sur la deuxième colonne. A ce stade il n'y a plus (normalement) dans tab de doublons ayant même début ou même valeur sur la deuxième colonne.

- Je mets à jour tab en enlevant les lignes que j'avais mises à 0.

- Je traite enfin les cas d'inclusions : je regarde les lignes deux par deux et les valeurs sur les deux premières colonnes. S'il s'avère qu'un [debut:fin] sur une ligne est inclus dans le [debut:fin] de la ligne précédente ou que leur intersection est non vide, j'enlève un des deux doublons trouvés et met à 0 une des deux lignes que je ne conserve pas.

Bref voici le code :

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
function tab=clean_tableau_final_extrema_bis_autre_variante3(tableau_reflux)
tab=[];
 
 
%On se propose dans cette fonction de réaliser autrement le travail de la
%fonction clean_tableau_final_extrema_bis puisque, telle qu'on a écrit
%cette dernière, il est parfois nécéssaire de procéder à un triage récursif
%(clean_tableau_final_extrema_bis_recursif) et on voudrait éviter ceci.
 
if(size(tableau_reflux,1)>1)
 
%On trie le tableau passé en paramètre par rapport à la première
%colonne.
 
tab=sortrows(tableau_reflux,1);
 
%Détermination des doublons à l'aide de la fonction unique.    
 
%Détermination des indices qui correspondent à un même début.
 
tab_1c = tab(:,1);
valeurs_meme_debut=unique(tab_1c(diff(tab_1c)==0));
 
indices_meme_debut=[];
 
for i=1:size(valeurs_meme_debut,1)
    indices_meme_debut=[indices_meme_debut ; find(tab(:,1)==valeurs_meme_debut(i))];
end
 
indices_meme_debut;
 
%Determination des indices qui correspondent à une même fin
 
tab_2c = tab(:,2);
valeurs_meme_fin=unique(tab_2c(diff(tab_2c)==0));
 
indices_meme_fin=[];
 
for i=1:size(valeurs_meme_fin,1)
    indices_meme_fin=[indices_meme_fin ; find(tab(:,2)==valeurs_meme_fin(i))];
end
 
indices_meme_fin;
 
%Il est inutile de conserver les indices déjà comptabilisé dans
%indices_meme_debut. On doit éliminer les indices de indices_meme_fin qui
%ont déjà été traité dans indices_meme_debut, à savoir ceux qui ont aussi
%même début parmi ceux ayant même fin.
 
%Il suffit de trouver les indices de indices_meme_debut qui sont aussi dans
%indices_meme_fin et de les enlever.
 
indices_commun=intersect(indices_meme_debut,indices_meme_fin);
indices_commun_position=[];
for i=1:size(indices_commun)
    indices_commun_position=[indices_commun_position;find(indices_meme_fin==indices_commun(i))];
end
indices_commun_position;        
indices_meme_fin(indices_commun_position,:)=[];
 
%--------------------------------------------------------------------------
 
%Dans cette méthode on se propose de construire le tableau à l'aide d'une
%boucle : pour chaque ligne on détecte les événements concerné, on stocke
%le tout dans un mini-tableau, on élimine ce qu'il faut et on construit le
%nouveau tableau en mettant à la suite les événement retenus. On va faire
%cela en plusieurs étapes : on construit le tab_construit_meme_debut,
%tab_construit_meme_fin puis les cas d'inclusions.  L'idée est aussi de
%mettre à 0 les lignes de tab qu'on ne veut pas garder selon les éléments
%éliminés.
 
%--------------------------------------------------------------------------
 
%ELIMINATION DES EVENEMENTS AYANT MEME DEBUT
 
%Elimination des doublons ayant même début : on conserve le doublon ayant
%la fin la plus grande, ou s'ils ont même fin, le doublon présent sur le
%plus grand nombre de pistes : colonne 3. A la fin on obtient tab_meme_debut
%qui contient le tableau des événements retenus ayant eu même début.
 
tab_doublon=[];
tab_construit_meme_debut=[];
ii=1;
 
if(size(indices_meme_debut,1)>0)
 
while ii<=size(indices_meme_debut,1)
 
     %Initialement on prend ii=1 : le premier doublon correspondant forcément
     %à i=1.
 
     %lignes où on aura un même début (Z1) et indices des lignes qui ont le
     %même début (Z2). Certaines seront mises à 0.
 
     Z1=tab(indices_meme_debut(ii),:);
 
     Z2=find(tab(:,1)==Z1(1,1));
 
     %On stocke dans tab_doublon les doublons obtenus à un rang donné.
 
     tab_doublon=tab(Z2,:);
 
     %Recherche et élimination des doublons inutiles si tab_doublon
     %contient plus d'une ligne. Sinon on ajoute la ligne telle quelle.
 
     if (size(tab_doublon,1)>0)
 
             %On détermine le maximum Z3 sur la deuxième colonne de
             %tab_doublon et sa ou ses position(s) Z4.
 
             Z3=max(tab_doublon(:,2));
             Z4=find(tab_doublon(:,2)==Z3);
 
             %s'il n'y a qu'un seul maximum on élimine les lignes ne
             %comportant pas ce maximum et on conserve celle avec le
             %maximum.
 
             if(numel(Z4)==1)
 
             %mise à 0 des lignes de tab_doublon autre que celle où il y a le
             %maximum sur la deuxième colonne et élimination des lignes. On
             %ne conserve donc dans tab_doublon que la ligne qui nous
             %intéresse. avriante avec setdiff ?
 
             for i=1:size(tab_doublon,1)
                   if i~=Z4
                         tab_doublon(i,:)=0;
                   else
                         continue;
                  end
             end
 
 
             tab_construit_meme_debut=[tab_construit_meme_debut;tab_doublon];
 
             %On doit mettre à 0 les lignes de tab dont l'indice n'est pas 
             %celui d'une ligne nulle sur tab_doublon.
 
             ind=find(tab_doublon(:,1)==0);
             tab(Z2(ind),:)=0;
             ii=ii+size(tab_doublon,1);
 
             %S'il y a plusieurs maxima, on regarde la valeur sur la
             %troisième colonne des lignes correspondant à ces maxima.
 
             elseif(numel(Z4)>1)
 
             %Maxima sur la troisième colonne pour les indices (Z4) où on 
             %a des maxima sur la deuxième colonne (Z6) et leurs indices
             %(Z7).
 
             Z6=max(tab_doublon(Z4,3));
             Z7=find(tab_doublon(:,3)==Z6);
 
                %s'il n'y a qu'un seul maxima sur la troisième colonne, on
                %élimine toutes les lignes où il n'y a pas ce maxima et on
                %conserve seulement celle avec le maxima.
 
                if(numel(Z7)==1)
 
                    for i=1:size(tab_doublon,1)
                        if i~=Z7
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
                %tab_construit_meme_debut=[tab_construit_meme_debut;tab_doublon];
                ind=find(tab_doublon(:,1)==0);
                tab(Z2(ind),:)=0;
                ii=ii+size(tab_doublon,1);
 
                %S'il y a plusieurs maxima sur la troisième colonne, on
                %conserve une seule des lignes avec ce maxima et on élimine
                %toutes les autres.
 
                elseif(numel(Z7)>1)
 
                 for i=1:size(tab_doublon,1)
                        if i~=Z7(1)
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
                %tab_construit_meme_debut=[tab_construit_meme_debut;tab_doublon];
                ind=find(tab_doublon(:,1)==0);
                tab(Z2(ind),:)=0;
                ii=ii+size(tab_doublon,1);    
 
                end         
             end
 
     else
 
         %Si tab_doublon n'a qu'une ligne on l'ajoute telle quelle.
 
         %tab_construit_meme_debut=[tab_construit_meme_debut;tab_doublon];
 
     end
end %end du while
 
%Z=find(tab_construit_meme_debut(:,1)==0);
%tab_construit_meme_debut(Z,:)=[];
 
end
 
%--------------------------------------------------------------------------
 
%ELIMINATION DES EVENEMENTS AYANT MEME FIN
 
%Elimination des doublons ayant même fin : on conserve le doublon ayant
%le debut le plus petit ou s'ils ont même debut, le doublon présent sur le
%plus grand nombre de pistes : colonne 3. Pour l'instant on met les lignes
%à éliminer à 0. 
 
tab_doublon=[];
tab_construit_meme_fin=[];
ii=1;
 
if(size(indices_meme_fin,1)>0)
 
while ii<=size(indices_meme_fin,1)
 
     %Initialement on prend ii=1 : le premier doublon correspondant forcément
     %à i=1.
 
     %lignes où on aura une même fin (Z1) et indices des lignes qui ont la
     %même fin (Z2).
 
     Z1=tab(indices_meme_fin(ii),:);
 
     Z2=find(tab(:,2)==Z1(1,2));
 
     %On stocke dans tab_doublon les doublons obtenus à un rang donné.
 
     tab_doublon=tab(Z2,:);
 
     %Recherche et élimination des doublons inutiles si tab_doublon
     %contient plus d'une ligne. Sinon on ajoute la ligne telle quelle.
 
     if (size(tab_doublon,1)>0)
 
             %On détermine le minimum Z3 sur la première colonne de
             %tab_doublon et sa ou ses position(s) Z4.
 
             Z3=min(tab_doublon(:,1));
             Z4=find(tab_doublon(:,1)==Z3);
 
             %s'il n'y a qu'un seul minimum on élimine les lignes ne
             %comportant pas ce minimum et on conserve celle avec le
             %minimum.
 
             if(numel(Z4)==1)
 
             %mise à 0 des lignes de tab_doublon autre celle où il y a le
             %minimum sur la premiere colonne. On
             %ne conserve donc dans tab_doublon que la ligne qui nous
             %intéresse. variante avec setdiff ?
 
             for i=1:size(tab_doublon,1)
                   if i~=Z4
                         tab_doublon(i,:)=0;
                   else
                         continue;
                  end
             end
 
 
             %tab_construit_meme_fin=[tab_construit_meme_fin;tab_doublon];
             ind=find(tab_doublon(:,1)==0);
             tab(Z2(ind),:)=0;
             ii=ii+size(tab_doublon,1);
 
             %S'il y a plusieurs maxima, on regarde la valeur sur la
             %troisième colonne des lignes correspondant à ces maxima.
 
             elseif(numel(Z4)>1)
 
             %Minima sur la troisième colonne pour les indices (Z4) où on 
             %a des minima sur la deuxième colonne (Z6) et leurs indices
             %(Z7).
 
             Z6=max(tab_doublon(Z4,3));
             Z7=find(tab_doublon(:,3)==Z6);
 
                %s'il n'y a qu'un seul minima sur la troisième colonne, on
                %élimine toutes les lignes où il n'y a pas ce minima et on
                %conserve seulement celle avec le minima.
 
                if(numel(Z7)==1)
 
                    for i=1:size(tab_doublon,1)
                        if i~=Z7
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
                %tab_construit_meme_fin=[tab_construit_meme_fin;tab_doublon];
                ind=find(tab_doublon(:,1)==0);
                tab(Z2(ind),:)=0;
                ii=ii+size(tab_doublon,1);
 
                %S'il y a plusieurs minima sur la troisième colonne, on
                %conserve une seule des lignes avec ce minima et on élimine
                %toutes les autres.
 
                elseif(numel(Z7)>1)
 
                 for i=1:size(tab_doublon,1)
                        if i~=Z7(1)
                            tab_doublon(i,:)=0;
                        else
                            continue;
                        end
                    end
 
 
                %tab_construit_meme_fin=[tab_construit_meme_fin;tab_doublon];
                ind=find(tab_doublon(:,1)==0);
                tab(Z2(ind),:)=0;
                ii=ii+size(tab_doublon,1);    
 
                end         
             end
 
     else
 
         %Si tab_doublon n'a qu'une ligne on l'ajoute telle quelle.
 
         tab_construit_meme_fin=[tab_construit_meme_fin;tab_doublon];
 
     end
end %end du while
 
%Z=find(tab_construit_meme_fin(:,1)==0);
%tab_construit_meme_fin(Z,:)=[];
 
end
 
%--------------------------------------------------------------------------
 
%TRAITEMENT DES CAS D'INCLUSIONS
 
%On met d'abord à jour le tableau tab, qui ne contient plus à ce stade
%d'événement ayant même début ou même fin.
 
Z=find(tab(:,1)==0);
tab(Z,:)=[];
 
%Traitement des cas d'inclusion : les reflux ayant été préalablement
%ordonnés, on repère les cas d'inclusions en faisant l'intersection deux à
%deux des événénements vus comme des intervalles d'entiers.
 
ligne=[];
 
for i=1:size(tab,1)-1
 
    deb=tab(i,1:2);
    fin=tab(i+1,1:2);
 
    if ~isempty(intersect([deb(1):deb(end)],[fin(1):fin(end)]))
 
        %Dans ligne on stocke les indices i-1 du doublon, i étant l'autre
        %doublon à considérer.
 
        ligne=[ligne;i];
 
    end
 
 
end
 
%On doit maintenant faire l'union des lignes i-1 et i trouvées dans le vecteur 
%ligne, et créer le nouvel événement à conserver qui sera 
%[debut le + petit ; fin la plus grande] et on choisit de conserver 
%les impédances qui touchent le plus grand nombre de pistes. On conservera
%la ligne qui touche le plus grand nombre de pistes et on modifiera
%somplement son début et sa fin avec les nouveau debut et fin trouvés.
 
if(numel(ligne)>0)
 
    for i=1:size(ligne,1)
 
    %Dans Z1 on met la première ligne du doublon et dans Z1bis la seconde
    %ligne du doublon.
 
        Z1=tab(ligne(i),:);
        Z1bis=tab(ligne(i)+1,:);
 
    %Dans Z2 on fait l'union des deux événements et on pourra donc
    %considérer le début et la fin de cette union qui sont les bornes du
    %nouvel événement.
 
        Z2=union(Z1(1:2),Z1bis(1:2));
 
    %On choisit de mettre à 0 la ligne qui a le plus petit nombre en 
    %troisième colonne. On supprime cette ligne et on conserve l'autre
    %ligne en modifiant son début et fin avec Z2(1) et Z2(end).
 
        if(Z1(1,3)>=Z1bis(1,3))
 
        tab(ligne(i)+1,:)=0;
        tab(ligne(i),1)=Z2(1);
        tab(ligne(i),2)=Z2(end);
 
        else
 
        tab(ligne(i),:)=0;
        tab(ligne(i)+1,1)=Z2(1);
        tab(ligne(i)+1,2)=Z2(end);
 
        end
 
 
 
    end
 
    Z5=find(tab(:,1)==0);
    tab(Z5,:)=[];
 
end
 
%-------------------------------------------------------------------------
 
%GESTION DES EVENTUELS CAS PROBLEMATIQUES RESTANTS.
 
 
end

Ce que je vais dire maintenant ne pourrait être que cohérent pour le_fab qui m'avait aidé sur ce problème : si maintenant je compare le tableau obtenu à partir de cette fonction avec celui obtenu à partir de la version récursive que j'avais mis en place avec ton aide, il s'avère qu'il reste, dans des cas assez rare 1,2 voire 3 lignes qui n'ont pas été éliminées. En rappliquant la fonction ci-dessus une fois ou deux, je retrouve finalement le même tableau ! C'est donc rassurant : ce que j'ai écrit donne donc le même résultat qu'auparavant. Voilà, mais du coup, j'ai donc l'impression que je vais devoir refaire une récursivité. En fin de compte, cela revient au même que ce que j'ai fait auparavant ! C'est assez décourageant je dois dire. Je me retrouve avec deux fonctions assez différentes mais qui font la même chose.

Bref, je doute que tu aies le courage de parcourir cette longue fonction, mais si tu en as envie, et que tu vois comment je pourrais obtenir les bons résultats...et sinon pense-tu que je puisse faire la récursion directement à l'intérieur de cette fonction même ? En gros c'est toujours la même histoire : j'obtiens un tableau tab avec L ligne en fin de fonction, je dois ré appliquer la fonction jusqu'à ce que le nombre L soit stable.

[le fab]

re

je t'avoue ne pas avoir le courage de plus me plonger dans tout ça
cependant je pense qu'au point ou tu es, la solution consiste à
- prendre une feuille blanche et bien écrire et décrire ce que tu veux
- plancher sur la conception
- recoder de zero

parce que là, j'ai l'impression que tu as reproduit tes anciens problème dans ton nouveau code

m'enfin, heureusement que tu as une solution (récursive) pour faire marcher ton code

Fabien

[abel413]

Oui merci le_fab, effectivement il y a quelque chose qui cloche, mais c'est difficile à voir. Cela doit être faisable sans récursion mais je n'y arrive pas encore.

Comme je le disais hier, je voudrais tester la récursion mais au sein même de ma fonction, nommée clean_tableau_final_extrema_bis_autre_variante3 ; lorsque tu m'avais aidé précédemment à faire une récursion, nous avions opté pour une autre fonction, comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
function tableau_trie = clean_tableau_final_extrema_bis_recursif(tableau)
tableau_trie =clean_tableau_final_extrema_bis(tableau);
if size(tableau_trie,1)~=size(tableau,1)
  tableau_trie = clean_tableau_final_extrema_bis_recursif(tableau_trie);
end

Je faisais alors le triage récursif tant que le nombres de lignes de mon tableau n'était pas stable. Alors certes, je pourrais faire exactement la même chose en remplaçant clea_tableau_final_extrema_bis dans ce code par clean_tableau_final_extrema_bis_autre_variante3 mais j'ai plutôt en tête de faire la récursion dans cette fonction, j'ai donc écrit ceci en fin de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
tab1=clean_tableau_final_extrema_bis_autre_variante3(tab);
 
if(size(tab1,1)~=size(tab,1))
    tab1=clean_final_extrema_bis_autre_variante3(tab1)
end

Mais ceci ne marche pas : tab étant le résultat de ma fonction de triage, je ré applique cette même fonction sur tab en mettant le résultat dans tab1. Puis je compare leur nombre de lignes afin de relancer la fonction si nécessaire. Mais la fonction n'entre jamais dans le if et, pire, elle ne s'arrête apparemment jamais, en restant bloquée sur la ligne tab1. Suis-je donc contraint de faire la récursion en dehors de ma fonction ?

[le fab]

salut

tu fait de la récursivité dans la fonction principal clean_tableau_final_extrema_bis_autre_variante3 si j'ai bien compris

vires la première ligne et ca devrait marcher :
ta première ligne créer une récursivité infinie sans condition de sortie, d'ou le comportement que tu constate

[abel413]

Oui je veux faire de la récursivité dans ma fonction même. Mais si je ne met pas la ligne avec tab1 je ne peux pas faire le if qui compare la taille de tab, tableau obtenu avec ma fonction et ce tab1 qui serait le résultat de ma fonction appliquée sur mon résultat tab. Tu vois le souci ?

Peut-être qu'un while pourrait faire l'affaire sur size(tab,1) mais il faudrait traduire "tant que size(tab,1) varie relancer clean_tableau_extrema_variante" en matlab ce que je ne crois pas être possible.

EDIT:

Pour le moment je réalise la récursivité en dehors, comme on l'avais fait avec mon autre fonction de tri. Donc tout marche impeccablement. Mais bon j'aurais bien aimé faire cette récursivité à l'intérieur de la fonction même.