Utilisation d'un while sur la taille d'un tableau

**abel413** · 10/07/2013, 10h01

Bonjour à tous,

J'ouvre ce sujet afin d'avoir votre avis sur un problème que je rencontre : dans le cadre des programmes que je développe je suis amené à utiliser une fonction de triage sur un tableau :

Code :

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

tab_50Hz_trier=clean_tableau_final_extrema_calcul_pente(tab_50Hz);

Cette fonction prend en paramètre un certain tableau tab_50Hz que je trie d'une certaine façon. Je ne pense pas qu'il soit nécessaire de détailler le tri du tableau.
Ce qui me gène c'est qu'en appliquant cette fonction, je me retrouve avec un tab_50_Hz_trier mais il reste toutefois des cas parasites si bien que ce tableau obtenu doit à nouveau être trié avec la même fonction :

Code :

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

tab_50Hz_trier=clean_tableau_final_extrema_calcul_pente(tab_50Hz_trier);

Le problème qui se pose est que selon les données rentrées le nombre de triage peut varier et je considère que le triage est terminé quand la première taille du tableau de sortie est stable. Par exemple admettons que tab_50Hz initial est de taille 340x3. J'applique la fonction clean une fois et j'obtiens tab_50Hz_trier qui est alors de taille 320x3 puis une autre fois, 317x3 et ensuite si je l'applique à nouveau le 317 reste le même : le tableau n'a plus besoin d'être trier.

Bref ce que je voudrais exprimer c'est : faire le triage jusqu'à ce que la première taille du tableau, i.e. son nombre de lignes ne varie plus. Avec l'exemple précédent, le triage doit d'arrêter lorsque le nombre de lignes est 317. Voilà mais je n'arrive pas à exprimer ceci sur Matlab.

**Jerome Briot** · 10/07/2013, 10h41

Montre nous ce que tu as déjà essayé de coder, même si c'est faux.

**abel413** · 10/07/2013, 11h39

Dut, j'ai justement fait exprès de ne pas montrer ce que j'ai fait puisque le code fonctionne mais il reste des cas parasites qui eux ne sont pas traités. C'est cela le problème. Je crains que si je commence à expliquer tout ce que j'ai fait, je vais en avoir pour énormément de posts et je pense que c'est complètement inutile. D'ailleurs ce que je demandais initialement est tout aussi inutile puisque même si je parviens à trier un nombre de fois suffisant pour que le nombre de lignes ne varie plus, au regard des différents tests que j'effectue jusque-là, il subsiste des cas qui eux ne seront pas éliminés puisque je ne les ai tout simplement pas éliminé quand il le fallait.

Ce que je te propose c'est de t'expliquer un des codes de façon syntaxique puis je le posterai ensuite, mais je ne voudrais pas en fait que tu commences à l'étudier car je suis assez sûr qu'il est correct, c'est-à-dire qu'il fait ce que je veux mais il reste des cas parasites.

BUT DU CODE :

Tableau de 11 colonnes en entrée. Éliminer ce que j'appelle des doublons sur les deux premières colonnes, cette élimination dépendant de certains critères sur d'autres colonnes. Pour une ligne donnée, sur les colonnes 6 à 11 j'ai des nombres et parfois il y a le nombre 1E36 parfois non. Ce nombre est important pour la suite et ne peut apparaître, pour une ligne donnée, que sur les colonnes 6 à 11.

A éliminer :

- cas où même début, même fin sur les deux premières colonnes : par exemple si je trouve 100 200 sur une ligne et 100 200 sur une autre je ne dois garder qu'une des lignes ;

- cas où même début mais pas même fin : exemple sur une ligne 100 200 et sur une autre 100 204 : je dois conserver la ligne où il y a le moins de 1E36, et s'il y en a le même nombre, je prend l'intervalle le plus long, soit 100 204 ici.

- cas où même fin mais pas même début : exemple 100 200 et 98 200, je fais pareil et s'il y a le même nombre de 1E36, je conserve l'intervalle le plus grand : 98 200.

- cas d'inclusions : si un intervalle est inclus dans un autre autre (toujours par rapport au 2 premières colonnes sur une ligne donnée), par exemple 100 200 et 105 170, on a l'intervalle [105 :170] inclus dans [100:200], dans ce cas je prend la fin la plus grande et le début le plus petit, soit 100 200 et je conserve les valeurs sur les 6 dernières colonnes où il y a le moins de 1E36. S'il y en le même, je considère encore un autre critère que je ne vais pas détailler.

FONCTIONNEMENT DU CODE :

Il prend en paramètre un tableau de 11 colonnes. Au début je trie le tableau par rapport à la 1ère colonne seulement. J'élimine alors les cas où même début, même fin, puis je traite les 3 autres cas détaillés ci-dessus dans l'ordre.

Le problème c'est qu'après tout ceci il peut rester des cas "parasites" : en gros il semble que la fonction n'élimine pas tout ce que je veux. Ce que je cherche donc à faire c'est, à défaut de pouvoir la corriger, c'est "rattraper" le coup en cherchant les derniers cas problématiques restant qui font partie de la catégorie A éliminer : ci-dessus. Voilà donc si tu peux m'aider, c'est de deux façons : comprendre déjà pourquoi je n'élimine pas tous les cas. J'ai ma petite idée malgré tout : tout est basé sur le triage initial par rapport à la première colonne. D'autre part je ne sais pas comment repérer les derniers cas parasites restants, ce que je voudrais faire en toute fin de code.

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
function tab=clean_tableau_final(tableau_reflux)
tab=tableau_reflux;
 
%Cette fonction prend en paramètre le tableau contenant tous les reflux sur
%3,4,5,6 pistes et par domaine. Il s'agit de trier ce tableau qui
%comportera des doublons : on conservera le doublon (deb fin) pour lequel
%un maximum de pistes sont atteintes.
 
%On tri d'abord le tableau par rapport à la première colonne
 
if(size(tableau_reflux,1)>1)
    Y=sortrows(tableau_reflux,1);
 
%On calcule le diff de ce tableau.
 
    Y1=diff(Y);
    tab=Y;
 
%Doublons consécutifs : ils sont obtenus lorsque les 5 premiers éléments 
%d'une ligne de Y1 sont nuls.
 
    Y2=find((Y1(:,1)==0) & (Y1(:,2)==0) & (Y1(:,3)==0) & (Y1(:,4)==0) & (Y1(:,5)==0));
        if(numel(Y2)>0)
            Y(Y2,:)=[];
            tab=Y;
        else
            tab=Y;
        end
 
%Il reste à présent à traiter les doublons restant : 
 
%Traitement des doublons commençant au même endroit mais ne s'achevant pas
%au même endroit.
 
%On choisit pour l'instant de conserver le doublon qui est prèsent sur le
%plus grand nombre de pistes.
 
    Z=diff(tab);
 
    Z1=find(Z(:,1)==0);
 
    if(numel(Z1)>0)
 
 
%On met à 0 toutes les lignes à supprimer
 
           for k=1:size(Z1,1)
                   Z2=tab(Z1(k),:);
                   Z2bis=tab(Z1(k)+1,:);
                   Z3=find(Z2==1E36);
                   Z3bis=find(Z2bis==1E36);
 
                    if ((numel(Z3)==0) | (numel(Z3)<numel(Z3bis)))
                        tab(Z1(k)+1,:)=0;
                    elseif ((numel(Z3bis)==0) | (numel(Z3bis)<numel(Z3)))
                        tab(Z1(k),:)=0;
                    elseif (numel(Z3)==numel(Z3bis))
 
                        if(Z2(2)>Z2bis(2))
                             tab(Z1(k)+1,:)=0;
                        else
                             tab(Z1(k),:)=0;
                        end
 
 
 
                    end
 
               end
 
                    Z4=find(tab(:,1)==0);
                    tab(Z4,:)=[];
 
 
        else
            tab;
    end
 
 
%Traitement des doublons ne commençant pas au même endroit mais s'achevant
%au même endroit. On procède de même mais en regardant les zéros sur la
%deuxième colonne.
 
    Z=diff(tab);
 
    Z1=find(Z(:,2)==0);
 
    if(numel(Z1)>0)
 
 
%On met à 0 toutes les lignes à supprimer
 
           for k=1:size(Z1,1)
                   Z2=tab(Z1(k),:);
                   Z2bis=tab(Z1(k)+1,:);
                   Z3=find(Z2==1E36);
                   Z3bis=find(Z2bis==1E36);
 
                    if ((numel(Z3)==0) | (numel(Z3)<numel(Z3bis)))
                        tab(Z1(k)+1,:)=0;
                    elseif ((numel(Z3bis)==0) | (numel(Z3bis)<numel(Z3)))
                        tab(Z1(k),:)=0;
                    elseif (numel(Z3)==numel(Z3bis))
 
                        if(Z2(1)<Z2bis(1))
                             tab(Z1(k)+1,:)=0;
                        else
                             tab(Z1(k),:)=0;
                        end
 
 
 
                    end
 
               end
 
                    Z4=find(tab(:,1)==0);
                    tab(Z4,:)=[];
 
 
        else
            tab;
    end
 
%Traitement des cas d'inclusions : on regarde les inclusions deux à deux.
%On prend le début le plus petit et la fin la plus grande et on conserve le
%plus grand nombre de pistes.
 
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 met à 0 toutes les lignes à supprimer
 
if(numel(ligne)>0)
 
           for k=1:size(ligne,1)
                   Z2=tab(ligne(k),:);
                   Z2bis=tab(ligne(k)+1,:);
                   Z2bis2=union(Z2(1:2),Z2bis(1:2));
                   Z3=find(Z2==1E36);
                   Z3bis=find(Z2bis==1E36);
 
                   if ((numel(Z3)==0) | (numel(Z3)<numel(Z3bis)))
                        tab(ligne(k)+1,:)=0;
                        tab(ligne(k),1)=Z2bis2(1);
                        tab(ligne(k),2)=Z2bis2(end);
                   elseif ((numel(Z3bis)==0) | (numel(Z3bis)<numel(Z3)))
                        tab(ligne(k),:)=0;
                        tab(ligne(k)+1,1)=Z2bis2(1);
                        tab(ligne(k)+1,2)=Z2bis2(end);
                   elseif (numel(Z3)==numel(Z3bis))
 
                       %Ici on a un cas d'inclusion avec même nombre de
                       %pistes : on change le début et fin et on garde le
                       %cas où le reflux démarre sur la plus petite piste,
                       %ou les pistes si ce sont les mêmes.
 
                       switch numel(Z3)
 
                       %Cas de 3 pistes
 
                           case 3
 
                           %Si la première pistes affectée sur Z3 est avant
                           %la première piste affectée sur Z3bis, on
                           %conserve la ligne == Z3. Sinon on conserve
                           %celle ==Z3bis en modifiant début et fin.
 
                           if(Z3(1)<=Z3bis(1))
 
                                tab(ligne(k)+1,:)=0;
                                tab(ligne(k),1)=Z2bis2(1);
                                tab(ligne(k),2)=Z2bis2(end);
 
                           elseif(Z3(1)>Z3bis(1))
                                tab(ligne(k),:)=0;
                                tab(ligne(k)+1,1)=Z2bis2(1);
                                tab(ligne(k)+1,2)=Z2bis2(end);
                           end
 
                      %Cas de 4 pistes.
 
                           case 4
 
                          if(Z3(1)<=Z3bis(1))
 
                                tab(ligne(k)+1,:)=0;
                                tab(ligne(k),1)=Z2bis2(1);
                                tab(ligne(k),2)=Z2bis2(end);
 
                           elseif(Z3(1)>Z3bis(1))
                                tab(ligne(k),:)=0;
                                tab(ligne(k)+1,1)=Z2bis2(1);
                                tab(ligne(k)+1,2)=Z2bis2(end);
                          end
 
                       %Cas de 5 pistes.
 
                           case 5
 
                           if(Z3(1)<=Z3bis(1))
 
                                tab(ligne(k)+1,:)=0;
                                tab(ligne(k),1)=Z2bis2(1);
                                tab(ligne(k),2)=Z2bis2(end);
 
                           elseif(Z3(1)>Z3bis(1))
                                tab(ligne(k),:)=0;
                                tab(ligne(k)+1,1)=Z2bis2(1);
                                tab(ligne(k)+1,2)=Z2bis2(end);
                           end
 
                       %Cas de 6 pistes : on supprime une des deux lignes. 
 
                           case 6
                                tab(ligne(k)+1,:)=0;
                                tab(ligne(k),1)=Z2bis2(1);
                                tab(ligne(k),2)=Z2bis2(end);
 
                       end
                   end
           end
 
           Z4=find(tab(:,1)==0);
           tab(Z4,:)=[];
 
end
 
 
 
 
 
 
%Traitement des cas parasites : il peut rester quelques cas parasites pas
%forcément bien trié : même début, même fin. 
 
 
else   
 
    return
 
end
 
end

**le fab** · 10/07/2013, 14h21

Envoyé par abel413

car je suis assez sûr qu'il est correct, c'est-à-dire qu'il fait ce que je veux mais il reste des cas parasites.

c'est un peu bizarre comme phrase mais bon ...

j'ai la flemme de lire ton code, mais du coup une solution "simple" pourrait être d'encapsuler ta fonction de tri dans une fonction récursive, qui s’appelle elle même jusqu'à ce que la taille du tableau ne varie plus
pas ce qui a de plus optimisé, mais ca marcherait et c'est simple à mettre en place

sinon malgré ce que tu dis, il doit y avoir une coquille dans ton code, que je verrai bien dans les incréments d'index quand tu parcours ton tableau et que tu saute une ligne ... mais bon, j'ai la flemme de lire le code

**abel413** · 10/07/2013, 16h03

le_fab

Merci, et je comprends bien que tu ais la flemme, c'est pour cela que je ne voulais pas montrer le code. Comme je le constatais moi-même, le fait que je fasse récursivement la fonction n'est pas une bonne chose puisque c'est "impropre" en quelque sorte. Ce que je voudrais c'est l'appliquer une fois et c'est tout. Il se trouve qu'en discutant avec mon tuteur, en faisant des tests, je comprends d'où peuvent provenir les erreurs.

Par exemple si je me donne la séquence suivante sur les deux premières colonnes:

Code :

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

Avec le code que j'ai je cherche déjà les cas où il y a même début et une fin différente. Donc ici je vais détecter les trois premières lignes. Cependant je fais la détection en lisant les lignes dans l'ordre deux par deux. Ainsi je détecterai les doublons : (1 8 1 9) puis (1 9 1 7) mais pas (1 8 1 7) puisqu'ils sont espacés de deux lignes. Donc, voilà si pour une certaine raison je conserve 1 8 dans le premier cas et 1 7 dans l'ordre je me retrouve donc avec :

Code :

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

Tel que j'ai structuré mon code, je cherche ensuite les cas où la fin est la même pas le début. Je conserve donc 1 8 et 1 7 qui ne sont pas concernés. Enfin, quand je passe au cas d'inclusions, comme [1:7] est dans [1:8], normalement c'est bon j'en enlève un.

Bref là cela marche, mais il arrive que non et je ne comprends pas bien pourquoi. En revanche si avant le cas d'inclusion je me retrouvais avec :

Code :

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

Il est clair que après le traitement des inclusions je me retrouverais par exemple avec :

Code :

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

En triant à nouveau j'éliminerai ce qui pose problème mais c'est assez "impropre" comme je l'ai dis plus haut. Enfin, bon, j'aimerais bien savoir comment tu écrirais cette solution récursive malgré tout, car il n'est pas certain qu'avec ma version (7.0.1.24704 (R14) Service Pack 1) ce soit possible. En tout je crois que le problème vient du fait que je traite les cas en regardant les lignes successives deux à deux.

**le fab** · 10/07/2013, 16h28

Envoyé par abel413

le_fab Enfin, bon, j'aimerais bien savoir comment tu écrirais cette solution récursive malgré tout, car il n'est pas certain qu'avec ma version (7.0.1.24704 (R14) Service Pack 1) ce soit possible. En tout je crois que le problème vient du fait que je traite les cas en regardant les lignes successives deux à deux.

en gros quelque chose comme

Code :

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

1
2
3
4
5
function tableau_trie = supertri(tableau)
tableau_trie = montri(tableau);
if size(tableau_trie)~=size(tableau)
  tableau_trie = supertri(tableau_trie);
end

en ajoutant quand même une autre condition de sortie au cas ou !

c'est peut être pas sur que ça soit très propres, ça fait des siècles que je n'ai pas écrit une fonction récursive

**abel413** · 11/07/2013, 08h48

Merci le_fab pour cette réponse mais j'ai peur de ne pas bien comprendre. Si ta fonction "supertri" est l'équivalent de ma fonction clean_tableau_final, que désigne lors la fonction "montri" ? Tel que tu l'as écris j'ai l'impression qu'il y a deux fonctions.

**le fab** · 11/07/2013, 09h10

en fait "montri" est ta fonction clean_tableau_final et "supertri" la fonction qui l'encapsule de manière récursive

**abel413** · 11/07/2013, 09h34

Donc tu voudrais dire que j'écrirais quelque chose comme :

Code :

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

1
2
3
4
5
function tableau_trie = supertri(tableau)
tableau_trie = clean_tableau_final(tableau);
if size(tableau_trie)~=size(tableau)
  tableau_trie = supertri(tableau_trie);
end

Et qu'à la place d'appeler clean_tableau_final j'appelle supertri dans une fonction où j'appelais seulement clean_tableau_final ?

EDIT:

J'ai donc fait comme suit, d'abord je crée la fonction clean_tableau_recursif comme suit :

Code :

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

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

Puis là où je dois appeler la fonction clean_tableau_final je fais comme suit :

Code :

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

1
2
 
tab_50Hz_trier=clean_tableau_recursif(tab_50Hz);

Cela a l'air de fonctionner ! Qu'en dis-tu ? D'autre part pense-tu que l'on puisse effectuer cette opération autrement que récursivement ?

**le fab** · 11/07/2013, 13h51

salut

c'est ca

en fait j'ai l'impression que tu peux "débugguer" ton code
il semblerait que tu ais un soucis quelque part

cependant, comme tu avances que plusieurs appels consécutifs à ta fonction résout ton problème, alors la solution que je te propose "n'est pas absurde" :
ca marche et c'est rapide à mettre en place

après en terme de perf, c'est probablement pas top, et en terme de résultat, cela ne l'est que si effectivement comme tu le constates plusieurs appel consécutifs à ta fonction règle vraiment le problème

après à toi de voir si cette solution te convient (perf, résultat) et/ou si tu as le temps d'investiguer dans ta fonction principale pourquoi elle ne fait pas ce que tu voudrais qu'elle fasse directement

Fabien

**abel413** · 12/07/2013, 09h55

le_fab

Oui, effectivement j'applique ce triage récursif car comme je l'ai expliqué dans mon avant dernier message avec l'exemple, mon code trie en regardant toujours deux lignes deux à deux et dans l'ordre. Et donc s'il y a "trop" de doublons, un premier triage ne suffit pas. Alors, certes, ma fonction de triage est "défectueuse" en quelque sorte , mais étant donné tout le temps que j'ai passé à l'écrire et que je ne sais pas comment la modifier, cette astuce de récursivité me paraît assez bonne. De plus, en général, les données avec lesquelles je travaille sont telles qu'un premier triage élimine "quasiment" tous les doublons que j'ai répertoriés plus haut. Des tests sur une bonne centaine de fichier montrent que le triage récursif nécessite, dans ma situation, jamais plus de 2 triages supplémentaires et cela pour éliminer encore 3 ou 4 lignes en gros. Ainsi ma fonction initiale est "approximativement" bonne.

Pour finir je sais donc clairement pourquoi ma fonction de tri non récursive ne marche pas : c'est parce que pour chacun des types de doublons répertoriés je recherche toujours ces derniers en comparant les lignes 2 à 2. Il faudrait donc, à mon avis dés le départ rechercher les doublons autrement mais j'ignore comment faire concrètement. Tout est basé sur le fait que j'ai trié par rapport à la première colonne, ce qui, en principe, aide à trouver les doublons 2 par 2, ce qui s'avère finalement approximativement vraie puisqu'il reste quelques cas parasites éliminables par récursivité.

Bref, peut-être que tu peux m'aider à "reconstruire" autrement ma fonction. Si on prend l'exemple :

Code :

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

Ceci serait, par exemple le résultat du triage par rapport à la première colonne de ce code :

Code :

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

Donc si j'applique ma fonction sur ma variante triée avec appel récursif je vais me retrouver peut-être avec (moyennant les conditions sur les autres colonnes) :

Code :

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

Mais bon avant d'en arriver à cela, ce que j'aimerais savoir c'est s'il serait possible dans la version non triée :

Code :

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

de détecter déjà les doublons ayant même début mais une fin différente : soit ici 1 8 , 1 7 et 1 9 mais ceci sans devoir trier par rapport à la première colonne. Si on arrive à faire ceci ce serait déjà pas mal.

**le fab** · 12/07/2013, 11h09

oula
j'avoue que j'ai du mal avec ce que tu veux faire

tu as une solution qui marche, reste dessus, et quand tu aura du temps éventuellement repart de zero sur ta fonction de base

Fab

edit : une piste

Code :

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

1
2
3
4
5
6
7
8
9
10
 
toto = [1 8
        2 6
        1 9
        4 10
        3 9
        1 7];
toto_1s = sort(toto(:,1));
idx_doublon = toto(:,1) ==  unique(toto_1s(diff(toto_1s)==0));
toto(idx_doublon ,:)

retourne

Code :

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

**abel413** · 12/07/2013, 11h57

D'accord merci le_fab ! Je n'avais jamais entendu parlé de cette fonction unique. Je vais donc essayer de reprendre une nouvelle fonction en partant de ta piste. Cela dit, étant donné que je dois également avancer sur mon projet et que la version récursive fonctionne, je ne suis pas certain d'avancer sur la variante immédiatement ou après. En tout cas, je viendrais poursuivre la discussion ici si je rencontre des soucis.

**abel413** · 12/07/2013, 12h27

Bon en fait, je commence un peu la nouvelle fonction à l'instant. Voici le début du code que je suis en train d'entamer :

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
function tab=clean_tableau_final_extrema_bis_autre_variante(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);
indices_meme_debut=unique(tab_1c(diff(tab_1c)==0));
 
end

Cette fonction prend en paramètre un tableau de la forme suivante :

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
423	426	123
801	803	123
1523	1528	123
1541	1544	123
1573	1576	123
1743	1747	123
3045	3048	123
3170	3172	123
3236	3241	123
3307	3309	123
3316	3320	123
3353	3361	123
3498	3581	123
6090	6092	123
 
%ect : en fait ceci est dans l'ordre mais il faut tenir compte du fait que mon tableau paramètre est lui-même un ensemble de tableaux les uns après les autres.

La troisième colonne n'importe pas pour le moment, le problème se réduit au deux premières colonnes. Donc ce que je fais simplement : je trie ce tableau par rapport à la première colonne, stocké dans tab, ce qui donne ici (en prenant quelques valeurs au début):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
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

Ensuite je fais ce que tu me proposes et dans "indices_meme_debut" j'aurais souhaité avoir les indices des positions qui correspondent donc aux doublons ayant même début, mais au lieu de cela j'ai les valeurs des débuts de ces doublons :

Code :

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

EDIT:

Bon j'ai réussi à faire ce que je voulais mais d'une manière impropre avec des boucles. Peut-être peut-on faire autrement ?

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
function tab=clean_tableau_final_extrema_bis_autre_variante(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 mais une fin
%différente.
 
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
 
%Dans indices_meme_debut on a donc les positions de tous les doublons
%commençant par le même début.
 
%Détermination des indices qui correspondent à un début différent mais 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
 
end

En gros j'utilise unique pour avoir les valeurs des doublons, en l’occurrence ceux de même fin ou même début (cf doublons sur les colonnes 1 ou 2) et à l'aide des deux boucles for je stocke les indices des doublons présents dans tab. Enfin bon, en y réfléchissant ne suis-je pas en train de refaire ce que j'ai fait moi-même dans ma fonction plus haut ? Au final je trie au départ par rapport à la première colonne ou la deuxième et je cherche les doublons. J'ai l’impression qu'en allant progressivement je vais refaire ce que j'ai fait dans ma fonction et que j'aurais toujours le problème des doublons restant et donc qu'il faudra trier récursivement.

**le fab** · 12/07/2013, 14h58

salut
regarde un peu mieux la solution que j'ai poster, la réponse à tes questions est dedans !

pas besoin de boucle, pas besoin de find(à mois que tu préfère avoir un indexage linéaire), et pour le premier code tu as oublier la condition "==", c'est pour ça que tu récupère les valeur au lieu des indices

**abel413** · 12/07/2013, 15h22

le_fab

Justement je n'ai pas oublié la condition avec ==, je l'ai enlevé en fait.

Dans le code que tu m'as proposé, dans idx_doublon on ne récupère pas des indices mais 0 ou 1. Il est vrai que là où il y a des 1 on a des doublons et la position de ces 1 donne bien les indices. Mais, en fait pour reprendre ce même exemple, j'aimerais plutôt récupérer dans idx_doublon les valeurs effectives des indices : c'est-à-dire ici 1,3 et 6.

**le fab** · 12/07/2013, 15h39

c'est normal, tu récupères l'indexage logique des doublons
pour récupérer l'indexage linéaire, il faut encadrer la condition d'un find

Code :

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

idx_doublon = find(toto(:,1) ==  unique(toto_1s(diff(toto_1s)==0)));

en enlevant le ==, tu récupère les valeurs des doublons

cf

**abel413** · 15/07/2013, 09h11

Bonjour,

le_fab : merci de ces précisions mais il semble qu'il y ait malheureusement un problème de dimensions. Voici me début de la fonction de tri :

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
function tab=clean_tableau_final_extrema_bis_autre_variante2(tableau_reflux)
tab=[];
 
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 mais une fin
%différente.
 
tab_1c = tab(:,1);
indices_meme_debut= find(tab(:,1) ==  unique(tab_1c(diff(tab_1c)==0)));
 
end

Le tableau passé en paramètre est tableau_reflux de taille 199*3 ; je mets dans tab la version triée de ce tableau par rapport à la première colonne et dans tab_1c la première colonne de ce nouveau tab. Ensuite je recherche les indices qui m'intéressent avec ta méthode. Cependant j'ai donc l'erreur suivante :

Code :

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

1
2
3
4
5
?? Error using ==> eq
Matrix dimensions must agree.
 
Error in ==> clean_tableau_final_extrema_bis_autre_variante2 at 23
indices_meme_debut= find(tab(:,1) ==  unique(tab_1c(diff(tab_1c)==0)));

Effectivement la taille de unique(tab_1c(diff(tab_1c)==0)) est 15*1 tandis que celle de tab(:,1) est 199*1, est-ce cela qui pose problème ? Il en va de même si je ne trie pas tableau_reflux et que j'écris :

Code :

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

1
2
3
 tab=tableau_reflux;
tab_1c = sort(tab(:,1));
indices_meme_debut= find(tab(:,1) ==  unique(tab_1c(diff(tab_1c)==0)));

EDIT IMPORTANT :

Pour le moment je suis reparti sur l'autre méthode avec les boucles for qui génèrent les indices que je veux (de toute façon les boucles sont instantanées et c'est ce qui critère qui est le plus important). Je me retrouve déjà confronté au cœur du problème dont je t'avais fait part lorsque tu m'as aidé à réaliser une fonction récursive.. Je vais récapituler dans un premier temps ce que je fais : je détermine dans indices_meme_debut les indices qui m'intéresse, c'est-à-dire les indices des doublons ayant 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
33
 
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

Tel que c'est codé, il se trouve que si l'on prend par deux ces indices on obtient un doublon : par exemple 6,7 est un doublon sur le tableau en paramètre : les lignes 6 et 7 commencent bien par le même nombre : 1573. De même pour 8,9. Seulement voilà, et c'est là le fond du problème : dans le cas idéal les doublons sont pris par deux 6,7 / 8,9 /11 12 ect MAIS il arrive que j'ai des doublons triples, quadruples ect c'est-à-dire que je n'ai pas deux lignes qui forment un doublon mais trois, quatre...cela se repère sur indices_meme_debut : il y a le triplet 162,163,164 ; en effet les trois lignes correspondantes du tableau commencent toutes par 73020. En gros il "manque" 161 pour compléter le tout.

Je ne sais pas exactement comment procéder pour l'instant. Je me suis lancé dans une histoire d'imparité et de parité des indices mais sans parvenir à quelque chose qui fonctionne. En fait l'idée que je n'arrive pas à mettre en pratique et où tu pourrais m'aider : c'est pour un indice i qui prend part à un doublon, sachant que les indices sont donnés dans l'ordre j'ai besoin de trouver tous les indices qui suivent tels que la ligne du tableau en paramètre comporte même début. Par exemple si i=6, j'ai besoin i=7 : doublon 6,7. Pour i=162, il me faut trouver 163,164. Enfin bon j'ai beaucoup de mal à exprimer l'algorithme.

**le fab** · 15/07/2013, 10h46

salut

en effet je suis allé un peu vite dans le bout de code que je t'ai donné
je suis parti de ton exemple, ou il y a 3 doublons, basés sur le même chiffre (1), et donc, unique(tab_1c(diff(tab_1c)==0)) ne renvoie qu'un chiffre, et c'est pour ca que ca marche

dans ton exemple ce même code t'en renvoie 15, et donc ca ne marche plus

il faut donc passer par une boucle sur les valeurs retournées par unique(tab_1c(diff(tab_1c)==0)) (ou par une fonction du type arrayfun), de manière à rechercher les index de doublons pour chaque famille de doublon (les doublons commençant par 1, par 3 ...)

Fabien

**abel413** · 15/07/2013, 11h03

Oui merci le_fab, c'est effectivement avec une boucle que j'ai procédé :

Code :

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

1
2
3
4
5
6
7
8
9
10
ab_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;

Je récupère dans indices_meme_debut les indices qui m'intéresse (cf EDIT précédent). Disons que ceci me convient, n'en parlons plus, car c'est relativement rapide. Maintenant comme je l'ai dit précédemment, les doublons qui m'intéresse commencent tous à un rang impair. J'ai donc écrit la suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
if(numel(indices_meme_debut)>0)
 
    %On ne parcourt que les indices impairs qui sont toujours le début d'un
    %doublon. On s'arrête à l'avant dernier doublon.
 
    for i=1:2:size(indices_meme_debut)-1
 
        %On stocke dans Z1 et Z1bis les lignes i et i+1 d'un doublon.
 
        Z1=tab(indices_meme_debut(i),:);
        Z1bis=tab(indices_meme_debut(i)+1,:);

Dans Z1 j'ai une ligne du doublon (qui est d'indice impair) et dans Z2 la ligne suivante (d'indice pair donc). A ce stade je sais donc que les lignes Z1 et Z1bis de tab commencent par la même valeur (ce que je recherchais) MAIS j'ignore s'il n'existe pas une ou plusieurs lignes suivantes commençant aussi par la même valeur. Par exemple, pour redire à nouveau les choses, au rang i=25, Z1 et Z1bis commencent au même endroit mais aussi la ligne suivante, tab(indices_meme_debut(i)+2,

(c'est le triplet 162,163,164 dont je parlais avant : en i=25 j'ai détecté 162,163 mais pas 164). Voilà donc mon souci serait de réaliser une sorte d'indexage linéaire ou autre chose qui pour un i donné me donnerait tous les i suivant tels que le début est le même. Saurais-tu faire cela ?

En gros Z1(1,1) est la valeur du début commun et j'ai besoin de rechercher tous les indices de tab où la première ligne commence par Z1(1,1), quelque chose comme find(tab(:,1)==Z1(1,1)) semble marcher.

Utilisation d'un while sur la taille d'un tableau

MATLAB

Discussions similaires

Partager

Partager