Discussion :

[Corsaire_1]

Bonjour à tous,

Peut-être que cette question pourra aider à résoudre la question que j'avais posée dans le post d'hier...

Je possède un fichier texte de quatre colonnes (x,y,z,T). Je souhaiterais comment créer un nouveau fichier donnant z et T associé au même couple (x,y) ?

Par exemple ci le fichier texte initial est :

Code :

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

1
2
3
4
5
6
7
8
 
X   Y   Z   T
1   1   7   8 
2   3   3   3   
4   6   6   4 
2   3   5  -1  
1   1   2   4
4   6   6   0

je souhaiterais obtenir le fichier qui soit ordonné par couple (X,Y) identiques :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
X_s(:,1)   Y_s(:,2)   Z_s(:,3)  T_s(:,4)  (associé au même couple (x,y)=(1,1)
   1             1           7         8 
   1             1           2         4
 
 
X_s(:,1)   Y_s(:,2)   Z_s(:,3)  T_s(:,4)   (associé au couple (x,y)=(2,3)
  2              3          3          3   
  2              3          5         -1  
 
X_s(:,1)   Y_s(:,2)   Z_s(:,3)  T_s(:,4)  (associé au couple (x,y)=(4,6)
  4              6          6          4
  4              6          6          0

Comment puis-je programmer quelque chose comme ça ? Peut-être existe t-il un outil MATLAB pour faire cela ?

Cordialement

A

[Merel]

Salut,

regarde du côté des différents tris

Code :

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

help sortrows

Ca donne un truc du genre

Code :

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

1
2
3
4
5
6
7
8
X=[1 2 4 2 1 4]';
Y=[1 3 6 3 1 6]';
Z=[7 3 6 5 2 6]';
T=[8 3 4 -1 4 0]';
 
A=[X Y Z T]
 
sortrows(A)

Après, ca n'est que de la manipulation pour lire et écrire les données.

[Corsaire_1]

Bonjour Merel,

Merci pour cette réponse ultra-rapide !


Malheureusement, cette commande que j'ai dû abandonner (justification ci-après), permet de reclasser les données du fichier source en regroupant par paquet celles correspondantes aux même couples de (x,y) mais semble ne pas être compatible avec la commande trapz...Le résultat est :

Code :

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

1
2
3
4
5
6
7
8
9
10
sortrows(A)
 
ans =
 
     1     1     2     4
     1     1     7     8
     2     3     3     3
     2     3     5    -1
     4     6     6     0
     4     6     6     4

Le problème est que ce nouveau format des données ne permet pas d'utiliser simplement la commande trapz. Le but final du programme est de calculer trapz(z,T) pour chaque couple de (x,y) identique. Ici (dans cet exemple) il s'agit d'utiliser trois fois la commande trapz :
-pour le couple (x=1, y=1) : utiliser trapz (intégrale /z) avec T=4 (en z=2) et T=8 (en z=7) (il n'y a que deux valeurs dans cet exemple simpliste...)
-pour le couple (x=2, y=3) : utiliser trapz (intégrale /z) avec T=3 (en z=3) et T=-1 (en z=5);
-pour le couple (x=4, y=6) : utiliser trapz (intégrale /z) avec T=0 (en z=6) et T=4 (en z=6)...

J'ai juste l'impression que ce classement n'est pas tout à fait compatible avec ce que je veux faire ensuite avec trapz. A moins que tu ais une autre idée derrière la tête

A

[Merel]

Hmm, je pense que cette première étape est importante pour arriver à ton résultat final. reste plus qu'à trouver le truc pour regrouper ou dissocier ta matrice résultante avant de lancer un trapz.

Regarde du côté de unique, intersect etc... Bref, tous les trucs de conditionnement pour arrivé à séparer les éléments qui t'intéressent.

[Corsaire_1]

Bonjour à tous,

Je vais reformuler mon problème un peu plus proprement.

J'ai un fichier source qui possède quatre colonnes (x,y,z,T). Je souhaiterais classer ces données afin de regrouper dans un même paquet (les une à la suite des autres) toutes les lignes qui possèdent le même (x,y). Par exemple, je souhaiterais que :

Code :

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

1
2
3
4
5
6
7
 
x y z T
1 2 3 4
2 3 4 6
1 2 6 7
4 2 3 6
2 3 6 0

devienne :

Code :

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

1
2
3
4
5
6
7
 
x y z T
1 2 3 4
1 2 6 7
2 3 4 6
2 3 6 0
4 2 3 6

La commande sortrows(A, COL) permet de classer par ordre croissant les éléments de ce fichier suivant la colonne COL. Dans le cas général, cette commande ne permet pas de résoudre mon problème puisque des lignes avec des (x,y) identiques peuvent très bien ne pas se retrouver à côté.

Je n'ai pas trouvé de façon simple pour réaliser ce tri selon les couples (x,y) (pas forcément ordonnées par ordre croissant d'ailleurs)...

Quelqu'un peut t-il me donner un coup de main ?

Merci
A

[Corsaire_1]

Merci Merel pour ta réponse...

Je viens de noter de plus que la commande "sortrows" permet de classer les données par ordre croissant ou décroissant par rapport à une colonne...mais dans le cas général "sortrows" ne regroupera pas par paquet les lignes possédant un couple (x-y) identique. Donc même la première étape que tu proposais avec cette commande ne marche pas dans le cas général...

A

[Merel]

Heu est ce que tu aurais un contre-exemple à donner ? Parce que là je ne vois pas.

Peu importe ce que tu mettras comme argument dans ton sortrows, tu auras bien tes couples dans un certain ordre.

[Merel]

Je te mets un bout de code que j'ai fait rapidement. Sauf si je suis tombé sur un cas particulier, ca a l'air de bien fonctionné. Par contre, c'est codé avec des boucles et ca n'est pas du tout optimisé. Mais ca après c'est à toi de retravailler le truc.

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
X=[1 1 2 9 1 4 2 1 4 1]';
Y=[1 1 3 5 8 6 3 1 6 8]';
Z=[7 5 3 4 2 6 5 2 6 5]';
T=[8 4 3 1 3 4 1 4 0 4]';
 
A=[X Y Z T];
 
S=sortrows(A)
 
u=1;
cp=1;
i=1;
 
while i<=length(S)
 
 
    while S(i,1)==S(i+1,1) && S(i,2)==S(i+1,2)
 
 
        i=i+1;
 
 
        if i==length(S)
 
            res=[S(cp:i,3) S(cp:i,4)]
            resultat(u)=trapz(res(:,1),res(:,2));
            return
        end
 
    end
 
    res=[S(cp:i,3) S(cp:i,4)]
    i=i+1;
 
 
    if i==length(S)
 
        res=[S(end,3) S(end,4)]
        resultat(u)=trapz(res(:,1),res(:,2));
        return
    end
 
    resultat(u)=trapz(res(:,1),res(:,2));
    u=u+1;
 
    clear res;
    cp=i;
 
end

[Corsaire_1]

Voici le résultat d'un contre-exemple...il s'agit du fichier sur lequel je travaille (trop gros pour être mis en pièce-jointe même zippé). Il y a un problème pour x = 0.490. Comme tu peux le constater, l'application de sortrows sur mon fichier donne quelque chose du type :

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
 
>>sortrows(A) =
 
   0.4990    0.0145   -0.1556    0.3159
    0.4990    0.0145   -0.1384    0.3602
    0.4990    0.0145   -0.1213    0.4192
    0.4990    0.0145   -0.1042    0.4451
    0.4990   -0.0145   -0.4879    0.2217
    0.4990   -0.0145   -0.4722    0.1942
    0.4990   -0.0145   -0.4565    0.1654
    0.4990   -0.0145   -0.4408    0.1301
    0.4990   -0.0145   -0.0592    0.5393
    0.4990   -0.0145   -0.0435    0.5749
    0.4990   -0.0145   -0.0278    0.5855
    0.4990   -0.0145   -0.0121    0.5941
    0.4990    0.0145   -0.4879    0.2217
    0.4990    0.0145   -0.4722    0.1942
    0.4990    0.0145   -0.4565    0.1654
    0.4990    0.0145   -0.4408    0.1301

les couples (0.490 , 0.0145) ne sont pas tous regroupés en un morceau...

A

[Merel]

Ben suffit de faire un tri sur la première et la deuxième colonne...

Code :

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

S=sortrows(A,[1 2])

Là tu n'auras plus de problème

[Corsaire_1]

Merci Merel pour ce petit bout de code...

Malheureusement, le fait de trier sur la première et la deuxième colonne ne corrige pas le problème ! voici ce qu'on obtient (pour la partie qui pose problème) :

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
 
>>B=sortrows(A, [1 2]);
    0.4990    0.0145   -0.3444    0.0025
    0.4990    0.0145   -0.3616    0.0127
    0.4990    0.0145   -0.3787    0.0310
    0.4990    0.0145   -0.3958    0.0513
    0.4990    0.0145   -0.3273   -0.0009
    0.4990    0.0145   -0.3101    0.0031
    0.4990    0.0145   -0.2929    0.0150
    0.4990    0.0145   -0.3359   -0.0002
    0.4990   -0.0145   -0.0121    0.5941
    0.4990   -0.0145   -0.0592    0.5393
    0.4990   -0.0145   -0.0278    0.5855
    0.4990   -0.0145   -0.0435    0.5749
    0.4990   -0.0145   -0.4879    0.2217
    0.4990   -0.0145   -0.4722    0.1942
    0.4990   -0.0145   -0.4565    0.1654
    0.4990   -0.0145   -0.4408    0.1301
    0.4990    0.0145   -0.0121    0.5941
    0.4990    0.0145   -0.0592    0.5393
    0.4990    0.0145   -0.0278    0.5855
    0.4990    0.0145   -0.0435    0.5749
    0.4990    0.0145   -0.4879    0.2217
    0.4990    0.0145   -0.4722    0.1942

A moins qu'il y ait des chiffres après la virgules différents qui n'apparaissent pas...

A

[Merel]

Dans ce cas là, je dirais en effet que tu dois avoir des chiffres après la virgule qui n'apparaissent pas.

Si tu fais

Code :

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

1
2
B(1,1)==B(9,1)
B(1,1)==B(17,1)

ce te donne quoi ?

Si les valeurs sont différentes, il faut savoir si tu veux les valeurs exactes ou les arrondis.
Si un arrondi suffit, dans ce cas, tu peux utiliser une troncature. A toi de fixer le nombre de chiffre après la virgule

Code :

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

fix(B*10^4)/10^4

[Corsaire_1]

J'obtiens 1 dans les deux cas...ces quantités sont bien strictement égales...très étrange !

A

[Merel]

remontage de post.

J'ai effectué des tests sur le fichier au complet et il n'y a pas d'erreur de classement. Le problème que tu as provient simplement de l'arrondi matlab que tu as à l'écran.

Si tu fais cela :

Code :

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

B=sortrows(A,[1 2]);

Tu as -0.4998 pour les valeurs 33, 54 et 75
et 0.4990 pour les valeurs 24763, 24791 et 24806.

Or si tu fais

Code :

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

1
2
3
B(33,1)
B(54,1)
B(75,1)

et

Code :

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

1
2
3
B(24763,1)
B(24791,1)
B(24806,1)

tu auras comme résultat (respectivement):

Code :

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

1
2
3
-0.4997741
-0.4997741
-0.49977407

et

Code :

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

1
2
3
-0.498959
-0.498959
-0.49895903

Tu as donc des valeurs qui ne sont pas égales. D'où des alternances dans ton résultat.
Le tri a donc bien été effectué. Soit tu gardes ces valeurs d'origines, soit tu passes par un arrondi de ton choix pour les remettre dans un ordre qui t'arrange.

Edit :

Avec un arrondi, tu as également un tri correct.

Code :

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

1
2
A(:,1)=round(A(:,1)*10^4)/10^4;
B=sortrows(A,[1 2]);