Fonction Find sur chaque ligne d'une matrice creuse

Version imprimable

31/01/2011, 17h39
Mathieu999

Fonction Find sur chaque ligne d'une matrice creuse

Bonjour,

Alors je vous explique le problème :

J'ai une matrice creuse, et je voudrais récupérer sur chaque ligne les emplacements des éléments non-nuls, pour ensuite les concaténer.
Pour l'instant j'ai fait ça avec une boucle for, sur chaque ligne de la matrice,
en utilisant find, mais c'est assez lent. J'aimerais donc pouvoir me passer
de cette boucle mais je ne vois pas comment. Une solution serait de faire
un "find" sur toute la matrice et récupérer le vecteur résultant pour le
découper ensuite, mais le nombre d'éléments à "découper" varie.

Auriez-vous une idée pour se passer de cette satanée boucle ? ;-)

Merci d'avance,

Mathieu
31/01/2011, 17h47
Caro-Line

Peut-être avec SPARSE ?

Code:

doc sparse
01/02/2011, 09h32
Buide

Essaie de remplacer le find par du "logical indexing"

En gros faire

Code:

A(find(A~=0))

c'est beaucoup plus long que de faire

Code:

A(A~=0)

.

Comme ça ça à l'air ridicule, mais la fonction find dans une boucle peut prendre un temps monstrueux.

En fait pour être plus clair voici le bout de code :
Code:

1 2 3 4 5 6 7 8 9 for i=1:size(Adj1) L=find(Adj1(i,: )); Lab=[Vlbl1(i) Vlbl1(L)]; Str=strcat(num2str(sort(Lab(: )))); NumLab=str2double(Str); LabMat1(i)=NumLab; end
Adj1 étant une matrice creuse et Vlbl un vecteur. Je ne pourrais pas utiliser
le "logical indexing" ici à la place de find, car ce dernier me retourne les
emplacements des élements ~= 0, et pas les éléments eux-mêmes.

Merci quand même pour les pistes ;-)

Je ferais comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
N = 3;
X = sparse((rand(N)>.3).*randi(10,N));
 
idx = find(X);
 
nRows = size(X,1);
nX = numel(X);
 
V = cell(1,nRows);
 
for n = 1:nRows
    idx2 = ismembc(idx,n:nRows:nX);
    if any(idx2)
        V{n} = X(idx(idx2));
    end
end

sinon je ne comprends pas bien à quoi servent les lignes suivantes de ton code :

Citation:

Envoyé par Mathieu999

Code:

1
2
3
 
        Str=strcat(num2str(sort(Lab(: ))));          
        NumLab=str2double(Str);

01/02/2011, 10h11
Mathieu999
Oula je ne comprends pas du tout ton code, Dut ;-)
Va falloir que je décortique tout ça...

Sinon pour les lignes :
Code:

1 2 Str=strcat(num2str(sort(Lab(: )))); NumLab=str2double(Str);
En fait je transforme d'abord le vecteur Lab en strings, et puis
je concatène ceux-ci. Je les retransforme ensuite en nombre pour pouvoir
les manipuler plus facilement.

Merci pour ta réponse en tout cas !
01/02/2011, 10h21
Jerome Briot
Citation:

Envoyé par Mathieu999

Oula je ne comprends pas du tout ton code, Dut ;-)

En fait j'utilise l'indexage linéaire :
- http://matlab.developpez.com/faq/?pa...exage_lineaire
- http://briot-jerome.developpez.com/m...matrices/#LIII
Sinon, ISMEMBC est un fichier MEX qui fonctionne comme la fonction ISMEMBER mais uniquement sur des vecteurs. Comme c'est un fichier MEX, le code est plus rapide qu'avec ISMEMBER (qui fait d'ailleurs appel à ISMEMBC)
01/02/2011, 10h39
Buide

Et pourquoi ne pas utiliser ceci:

Code:

full(X(X~=0))

J'utilise aussi de grande sparse matrices et généralement j'utilise cette commande.

EDIT: Pas trop grande non plus.
01/02/2011, 11h24
Jerome Briot

Citation:

Envoyé par Buide

Code:

full(X(X~=0))

Dans ce cas, je pense qu'il serait plus efficace de faire :

Code:

nonzeros(X);

Sinon pour la question initiale, Mathieu999 voulait parcourir la matrice ligne par ligne...
01/02/2011, 11h54
Buide

Citation:

Envoyé par Dut

Dans ce cas, je pense qu'il serait plus efficace de faire :

Code:

nonzeros(X);

Sinon pour la question initiale, Mathieu999 voulait parcourir la matrice ligne par ligne...

Oui, tu as raison...
Désolé d'avoir dévié du topic...
01/02/2011, 13h45
Mathieu999

Enfin si vous avez des idées pour faire ça non pas ligne par ligne
mais en une seule fois par opération matricielle je suis preneur
aussi ;-)
02/02/2011, 12h24
Jerome Briot

Quel est le problème avec la fonction NONZEROS alors ?
11/02/2011, 13h57
Mathieu999

Désolé pour la réponse tardive ;-)

en fait la fonction non-zeros donne les valeurs des emplacements
différents de 0, et moi j'ai besoin des endroits proprement dit où
les éléments sont différents de 0.

Et donc quel est le problème avec FIND ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
>> N = 3;
>> X = sparse((rand(N)>.3).*randi(10,N))
 
X =
 
   (1,1)        5
   (2,1)        5
   (3,1)        7
   (2,2)        8
   (3,2)        3
   (1,3)        7
   (2,3)        7

Code:

1
2
3
4
5
6
7
>> full(X)
 
ans =
 
     5     0     7
     5     8     7
     7     3     0

Code:

1
2
3
4
5
6
7
8
9
10
11
>> idx = find(X)
 
idx =
 
     1
     2
     3
     5
     6
     7
     8

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>> [r,c] = find(X)
 
r =
 
     1
     2
     3
     2
     3
     1
     2
 
 
c =
 
     1
     1
     1
     2
     2
     3
     3