diviser une matrice selon une colonne avec matlab.

A = [1,4,2,5,10
     2,4,5,6,2
     2,1,5,6,10
     2,3,5,4,2]

Et j'ai envie de le diviser en deux de la matrice par la dernière colonne
A ->B et C

B =  [1,4,2,5,10
      2,1,5,6,10]
C = [2,4,5,6,2
     2,3,5,4,2]

Aussi, cette méthode pourrait être appliquée à une grande matrice, à l'instar de la matrice 100*22 en fonction de la dernière valeur de la colonne dans 9 groupes par matlab.

Pouvez-vous expliquer plus en détail ce que vous essayez d'atteindre?

OriginalL'auteur Fan Phill | 2013-08-29

Utilisation logique d'indexation

B=A(A(:,end)==10,:);
C=A(A(:,end)==2,:);

retourne

>> B
B =
     1     4     2     5    10
     2     1     5     6    10

>> C
C =
     2     4     5     6     2
     2     3     5     4     2

EDIT: En réponse à Dan commentaire ici est l'extension pour le cas général

e = unique(A(:,end));
B = cell(size(e));
for k = 1:numel(e)
    B{k} = A(A(:,end)==e(k),:);
end

ou de façon plus compacte

B=arrayfun(@(x) A(A(:,end)==x,:), unique(A(:,end)), 'UniformOutput', false);

donc pour

A =
     1     4     2     5    10
     2     4     5     6     2
     2     1     5     6    10
     2     3     5     4     2
     0     3     1     4     9
     1     3     4     5     1
     1     0     4     5     9
     1     2     4     3     1

vous obtenez les matrices dans les éléments de matrice de cellules de B

>> B{1}
ans =
     1     3     4     5     1
     1     2     4     3     1

>> B{2}
ans =
     2     4     5     6     2
     2     3     5     4     2

>> B{3}
ans =
     0     3     1     4     9
     1     0     4     5     9

>> B{4}
ans =
     1     4     2     5    10
     2     1     5     6    10

Ce sera fastidieux quand il y a 9 groupes
Il a juste besoin d'une boucle for à généraliser. Je l'ai ajouté à la réponse.
C'est mieux donne le résultat identique à la mienne, mais dans ce cas, la méthode de boucle semble plus rapide que la vectorisé approche! +1

OriginalL'auteur Mohsen Nosratinia

Ici est une approche générale qui fonctionne sur n'importe quel nombre de chiffres de la dernière colonne sur toute la taille de la matrice:

A = [1,4,2,5,10
     2,4,5,6,2
     1,1,1,1,1
     2,1,5,6,10
     2,3,5,4,2
     0,0,0,0,2];

Premier tri par la dernière colonne (beaucoup de façons de le faire, je ne sais pas si c'est le meilleur ou pas)

[~, order] = sort(A(:,end));
As = A(order,:);

Puis créer un vecteur de combien de lignes de le même nombre de figurer dans ce dernier col (c'est à dire le nombre de lignes par groupe)

rowDist = diff(find([1; diff(As(:, end)); 1]));

Remarque que pour mon exemple, des données rowDist sera égal à [1 3 2] comme il y a 1 1, 3 2s et 2 10s.
Maintenant utiliser mat2cell de diviser par ces regroupements de ligne:

Ac = mat2cell(As, rowDist);

Si vous le voulez vraiment, vous pouvez maintenant le diviser en différentes matrices (mais je doute que vous devez)

Ac{:}

résultats dans

ans =

   1   1   1   1   1

ans =

   0   0   0   0   2
   2   3   5   4   2
   2   4   5   6   2

ans =

    1    4    2    5   10
    2    1    5    6   10

Mais je pense que vous trouverez Ac plus utile

EDIT:

De nombreuses solutions pourrait ainsi faire une comparaison du temps:

A = [...
     1     4     2     5    10
2     4     5     6     2
2     1     5     6    10
2     3     5     4     2
0     3     1     4     9
1     3     4     5     3
1     0     4     5     9
1     2     4     3     1];
A = repmat(A, 1000, 1);
tic
for l = 1:100
[~, y] = sort(A(:,end));
As = A(y,:);
rowDist = diff(find([1; diff(As(:, end)); 1]));
Ac = mat2cell(As, rowDist);
end
toc
tic
for l = 1:100
D=arrayfun(@(x) A(A(:,end)==x,:), unique(A(:,end)), 'UniformOutput', false);
end
toc
tic
for l = 1:100
for k = 1:numel(e)
B{k} = A(A(:,end)==e(k),:);
end
end
toc
tic
for l = 1:100
Bb = sort(A(:,end)); 
[~,b] = histc(A(:,end), Bb([diff(Bb)>0;true]));
C = accumarray(b, (1:size(A,1))', [], @(r) {A(r,:)} );
end
toc

entraîné

Elapsed time is 0.053452 seconds.
Elapsed time is 0.17017 seconds.
Elapsed time is 0.004081 seconds.
Elapsed time is 0.22069 seconds.

Donc de même pour une grande matrice de la méthode de boucle est toujours le plus rapide.

OriginalL'auteur Dan

Utilisation accumarray en combinaison avec histc:

% Example data (from Mohsen Nosratinia)
A = [...
     1     4     2     5    10
2     4     5     6     2
2     1     5     6    10
2     3     5     4     2
0     3     1     4     9
1     3     4     5     1
1     0     4     5     9
1     2     4     3     1];
% Get the proper indices to the specific rows
B = sort(A(:,end)); 
[~,b] = histc(A(:,end), B([diff(B)>0;true]));
% Collect all specific rows in their specific groups
C = accumarray(b, (1:size(A,1))', [], @(r) {A(r,:)} );

Résultats:

>> C{:}
ans =
1     3     4     5     1
1     2     4     3     1
ans =
2     3     5     4     2
2     4     5     6     2
ans =
0     3     1     4     9
1     0     4     5     9
ans =
2     1     5     6    10
1     4     2     5    10

Noter que

B = sort(A(:,end)); 
[~,b] = histc(A(:,end), B([diff(B)>0;true]));

peut aussi être écrite

[~,b] = histc(A(:,end), unique(A(:,end)));

mais unique n'est pas intégré et est donc susceptible d'être plus lent, surtout quand elle est utilisée dans une boucle.

Note également que l'ordre des lignes a changé w.r.t. l'ordre qu'ils avaient dans la matrice d'origine. Si l'ordre des questions, vous aurez à le jeter dans une autre sort:

C = accumarray(b, (1:size(A,1))', [], @(r) {A(sort(r),:)} );

OriginalL'auteur Rody Oldenhuis

Vous devez vous connecter pour publier un commentaire.