Discussion :

[Globoxx]

Bonjour,

Je travaille sur une simulation de colonisation. Mon algorithme crée un arbre binaire avec chaque planète colonisée.
Il fonctionne parfaitement mais est très lent. Je souhaiterais l'optimiser mais je ne sais pas comment m'y prendre...
Auriez-vous des pistes ?

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
 
 
        Vector = bsxfun(@minus,P(:,1:3),Origine);
        Normes = sqrt(sum(Vector.^2, 2));
 
        [best_ways(1),idx(1)] = min(Normes);
        Normes(idx(1)) = inf;
        [best_ways(2),idx(2)] = min(Normes);
 
        P(idx(1),4) = 1;
        P(idx(1),5) = 0;
 
        P(idx(2),4) = 2;
        P(idx(2),5) = 0;
 
        planete_visitee(1,:) = P(idx(1),:);
        planete_visitee(2,:) = P(idx(2),:);
        P(idx(1),:) = P(1,:);
        P(idx(2),:) = P(2,:);
        P(1,:) = planete_visitee(1,:);
        P(2,:) = planete_visitee(2,:);
 
        Planetes_visitees = [P(1,:);P(2,:)];
 
        if all(Planetes_visitees(1,1:3)) == all(Terre(1,1:3)) || all(Planetes_visitees(2,1:3)) == all(Terre(1,1:3))
            Terre_trouvee = true;
        end
 
 
        exposant = zeros(1,100);
        exposant(1) = 2;
 
        for i = 2:length(exposant)
        	exposant(i) = exposant(i-1)*2;
        end
 
        j = 1;
        k = 3;
        l = 1;
        while Terre_trouvee == false
 
            for i = 1:exposant(j)
                Vector = zeros(Indices(N),3);
 
                Vector(k:end,1) = P(exposant(j)+(k - exposant(j)):end,1) - P(l,1);
                Vector(k:end,2) = P(exposant(j)+(k - exposant(j)):end,2) - P(l,2);
                Vector(k:end,3) = P(exposant(j)+(k - exposant(j)):end,3) - P(l,3);
 
                Normes = sqrt(sum(Vector.^2, 2));
 
                idx(1) = find(Normes(k:end) == min(Normes(k:end)));
                idx(1) = idx(1) + (k-1);
                Normes(idx(1)) = inf;
                idx(2) = find(Normes(k:end) == min(Normes(k:end)));
                idx(2) = idx(2) + (k-1);
 
                P(idx(1),4) = k;
                P(idx(1),5) = l;
 
                P(idx(2),4) = k+1;
                P(idx(2),5) = l;
 
                planete_visitee(1,:) = P(idx(1),:);
                planete_visitee(2,:) = P(idx(2),:);
                P(idx(1),:) = P(k,:);
                P(idx(2),:) = P(k+1,:);
                P(k,:) = planete_visitee(1,:);
                P(k+1,:) = planete_visitee(2,:);
 
                Planetes_visitees = [Planetes_visitees;P(k,:);P(k+1,:)];
 
                if all(P(k,1:3)) == all(Terre(1,1:3)) || all(P(k+1,1:3)) == all(Terre(1,1:3))
                    Terre_trouvee = true;
                    break;
                end
 
                k = k+2;
                l = l+1;
            end
 
        j = j+1;
        end
 
        % Retrassage du chemin jusqu'à la Terre
 
        Chemin_terre = Terre(1,1:3);
        x = 2;
        j = Planetes_visitees(end,5);
        while j ~= 0
            Chemin_terre(x,1:3) = Planetes_visitees(j,1:3);
            j = Planetes_visitees(j,5);   
            x = x+1;
        end
        Chemin_terre(x,1:3) = Origine;
 
        % Calcul de la distance de ce chemin
 
        Vectors = zeros(size(Chemin_terre,1)-1,3);
 
        for i = 1:size(Vectors,1)
            Vectors(i,1:3) = Chemin_terre(i+1,1:3) - Chemin_terre(i,1:3);
        end
 
        Normes = sqrt(sum(Vectors.^2, 2));
        Jusqua_Terre = sum(Normes);

Merci d'avance

[shaiHulud]

Bonjour,

Tu as l'air d'avoir optimisé quelques bouts (je vois du bxsfun et des opération vectorisées), mais pas partout (certaines boucles me semblent vectorialisables). De plus, tu as l'air d'avoir dérecursifié ton parcours d'abre (while plutot qu'appels récursifs). Les seules pistes qu'il me restent sont:
- Utilise le profiler matlab pour voir quelle partie de code prends du temps.
- Essaye de passer en calcul parallèle, mais ça va pas être facile avec un while extérieur.

[Jerome Briot]

Tu as l'air d'avoir optimisé quelques bouts (je vois du bxsfun et des opération vectorisées),

Nous avons... nous avons

=> [parfor] Où puis-je l'utiliser correctement dans mon algorithme ?

Il suffit de d'appliquer encore une fois les mêmes méthodes au reste du code

[Globoxx]

Je ne pensais pas que tu te souviendrais de moi
Malgré votre aide et en relisant mon ancien post, je ne parviens pas à placer une boucle parfor. D'abord parce que je ne parviens pas à remplacer mon break. En plus certaines de mes matrices sont incompatibles... je n'arrive pas à changer cela.