optimisation d'un bout de code

Version imprimable

Bonjour à tous,

J'ai la tête un peu dasn le pâté, donc je fais appel à vos lumières en cas de solution simple et triviale :aie: :
Je voudrais supprimer la boucle dans le code suivant. Note importante : le vecteur index possède des répétitions, comme dans le bout de code d'exemple.

Merci++ de votre aide. :D
Code:

1 2 3 4 5 6 index = [1 2 3 2 5 2 6] ; % c'est un exemple. dans la réalité index fait jusqu'à 10000 valeurs. M = zeros(1, 10) ; % c'est un exemple. dans la réalité M est une matrice 1000 x 1000 a = 0.2 ; for k=1:numel(index) M(index(k)) = M(index(k)) + a ; end

en attendant vos lumières, j'ai écrit cette hideuse béquille :

Code:

1
2
3
4
5
6
7
8
9
function M = ajouter (M, idx, a)
% ajoute à M la valeur a pour tous les index idx (avec répétition)
idx = sort(idx(:)) ; % trie les index à traiter
while numel(idx)>0
    df = [1; diff(idx)] ; % repère les doublons
    unefois = idx(df>0) ; % sélectionne les index sans doublons
    M(unefois) = M(unefois)+a ; % ajoute a à M sur les index non doublonnés
    idx = idx(df==0) ; % supprime les éléments traités
end

qui marche comme ça par exemple :

Code:

1
2
3
4
5
6
>> M = zeros(1,10) ;
M = ajouter (M, [5 4 3 2 1 5 1 2 3 2 3 4 4 5 5 6], 1)
 
M =
 
     2     3     3     3     4     1     0     0     0     0

peut-on faire plus élégant ? et plus rapide (éviter le tri, en particulier) ?
merci :)

14/12/2010, 19h28
Jean Dumoncel
Salut,

pour éviter la boucle :
Code:

1 2 3 4 5 6 7 index = [1 3 2 2 5 2 6] ; M = zeros(1, 10) ; a = 0.2 ; [B,I,J] = unique(index); h = hist(J,length(B)); MM(B) = M(B)+a.*h;
Par contre je vois pas comment tu pourrais éviter le tri (ici c'est la fonction unique qui s'en charge).
14/12/2010, 19h49
ol9245
Citation:
Envoyé par magelan

Salut,

pour éviter la boucle :

Code:

1 2 3 4 5 6 7 index = [1 3 2 2 5 2 6] ; M = zeros(1, 10) ; a = 0.2 ; [B,I,J] = unique(index); h = hist(J,length(B)); MM(B) = M(B)+a.*h;

Par contre je vois pas comment tu pourrais éviter le tri (ici c'est la fonction unique qui s'en charge).
Bonne pioche. Ton code est plus de 10 fois plus rapide que le mien sur mes données :ccool::D

Je laisse le fil ouvert quelques heures au cas ou ... :P
14/12/2010, 21h12
Jerome Briot
N'arrivant pas bien à comprendre avec exactitude la forme des données de ton problème, voici quelques petites suggestions...
Code:

1 2 3 index = [1 2 3 2 5 2 6] ; a = 0.2 ; M = histc(index,1:10)*a;
ou
Code:

1 2 3 4 5 index = [1 2 3 2 5 2 6] ; M = zeros(1,10); a = 0.2 ; v = 1:max(index); M(v) = histc(index,v)*a;
ou encore
Code:

1 2 3 index = [1 2 3 2 5 2 6] ; a = 0.2 ; M = histc(index,1:max(index))*a;
Pour bien comprendre, la variable index contient les indices linéaires de certains éléments de la matrice M (1000x1000), c'est ça ?
15/12/2010, 09h46
tubaas
salut
une proposition différente mais moins efficace :cry: (en même temps c'est normal qu'une fonction comme HISTC soit plus optimisée...)
Code:

1 2 3 4 5 function M=toto(index,a) M=a*arrayfun(@(x)countInd(x,index),1:10); function y=countInd(x,index) y=sum(index==x);
j'ai essayé différentes façons de compter mais les temps d'exécution restent similaires sur ton petit exemple

Merci++ à tous pour vos propositions.
Ces 4 fonctions se tiennent dans un mouchoir sur un vrai jeu de données (entre 12.88 secondes et 13.5 secondes).
Je vais garder la fonction ajouter1 qui a le mérite de pourvoir être écrite en une ligne au fil du code.

Grace à votre (notre ?) communauté, avoir des problèmes de développement deviendrait presque un plaisir tant les réponses sont rapides, nombreuses, instructives, et, surtout vraiment très belles, (pour ceux qui sont sensibles à ce genre de beauté cela va de soi).

Pour mon retour à la programmation pour quelques semaines, après d'autres activités diverses et variées, c'est que du bonheur !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 function ajouter4(index, a) [B,I,J] = unique(index); h = hist(J,1:length(B)); M(B) = M(B)+(a.*h(:)); end function ajouter1(index, a) M = M + (histc(index',1:numel(M)) .* a).' ; end function ajouter2(index, a) x = 1:max(index) ; U = histc(index,x) .* a ; M(x) = M(x) + U(:); end function ajouter3(index, a) b = unique(index); U = histc(index,b) ; M(b) = M(b) + a .* U(:); end

15/12/2010, 14h15
Uren

Au temps pour moi, j'ai lu le second post et pas le premier :D

et encore plus rapide

et encore plus rapide :

Code:

1
2
3
4
function ajouter(index, a)
    ix = 1:max(index) ;        
    M(ix) = M(ix) + accumarray(index, repmat(a,size(index))) ;
end