coder un programme n fois

**camelia136** · 25/07/2011, 11h58

bonjour,

comment faire pour coder un programme et le faire tourner une fois. Ensuite on le fait tourner n fois en considérant des coût bruité du resulat (par exemple on multiplie chaque resultat par une valeur aléatoire entre 0.9 et 1.1)

**Jean Dumoncel** · 25/07/2011, 12h24

Bonjour,

As-tu essayé de coder quelque chose? montre nous ton code, même si il est faux.

**camelia136** · 25/07/2011, 13h40

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
function [dist,path] = dijkstra(nodes,segments,start_id,finish_id)
 
 
 
if (nargin < 3) % SETUP
    % (GENERATE RANDOM EXAMPLE OF NODES AND SEGMENTS IF NOT GIVEN AS INPUTS)
    % Create a random set of nodes/vertices,and connect some of them with
    % edges/segments. Then graph the resulting map.
 
 num_nodes = 40; L = 100; max_seg_length = 30; ids = (1:num_nodes)';
 
 
valeur_init =2; 
rand('seed',valeur_init); % initialisation
rand(num_nodes,2)    % Generate a random set of number
 
rand('seed',valeur_init); % ré-initialisation
 
nodes = [ids L*rand(num_nodes,2)]; % create random nodes
h = figure; plot(nodes(:,2),nodes(:,3),'k.') % plot the nodes
 
    text(nodes(num_nodes,2),nodes(num_nodes,3),...
        [' ' num2str(ids(num_nodes))],'Color','b','FontWeight','b')
    hold on
    num_segs = 0; segments = zeros(num_nodes*(num_nodes-1)/2,3);
 
    for i = 1:num_nodes-1 % create edges between some of the nodes
        text(nodes(i,2),nodes(i,3),[' ' num2str(ids(i))],'Color','b','FontWeight','b')
        for j = i+1:num_nodes
            d = sqrt(sum((nodes(i,2:3) - nodes(j,2:3)).^2));
            if and(d < max_seg_length,rand < 0.9)
                plot([nodes(i,2) nodes(j,2)],[nodes(i,3) nodes(j,3)],'k.-')
                % add this link to the segments list
                num_segs = num_segs + 1;
                segments(num_segs,:) = [num_segs nodes(i,1) nodes(j,1)];
            end
        end
    end
    segments(num_segs+1:num_nodes*(num_nodes-1)/2,:) = [];
    axis([0 L 0 L])
 
 
    % Calculate Shortest Path Using Dijkstra's Algorithm
    % Get random starting/ending nodes,compute the shortest distance and path.
 
 
 
prompt = {'Enter starting node:','Enter ending node:'};
dlg_title = 'Get starting/ending nodes';
num_lines = 1;
def = {'',''};
answer = inputdlg(prompt,dlg_title,num_lines,def);
 
if isempty(answer)
    return
end
 
start_id = str2double(answer{1});
disp(['start id = ' num2str(start_id)]);
finish_id = str2double(answer{2});
disp(['finish id = ' num2str(finish_id)]);
 
 
 
 
 
    [distance,path] = dijkstra(nodes,segments,start_id,finish_id);
 
    disp(['distance = ' num2str(distance)]); disp(['path = [' num2str(path) ']']);
 
 
    % If a Shortest Path exists,Plot it on the Map.
 
 
    figure(h)
    for k = 2:length(path)
        m = find(nodes(:,1) == path(k-1));
        n = find(nodes(:,1) == path(k));
        plot([nodes(m,2) nodes(n,2)],[nodes(m,3) nodes(n,3)],'ro-','LineWidth',2);
    end
    title(['Shortest Distance from ' num2str(start_id) ' to ' ...
        num2str(finish_id) ' = ' num2str(distance)])
    hold off
 
else %--------------------------------------------------------------------------
    % MAIN FUNCTION - DIJKSTRA'S ALGORITHM
 
    % initializations
    node_ids = nodes(:,1);
    [num_map_pts,cols] = size(nodes);
    table = sparse(num_map_pts,2);
    shortest_distance = Inf(num_map_pts,1);
    settled = zeros(num_map_pts,1);
    path = num2cell(NaN(num_map_pts,1));
    col = 2;
    pidx = find(start_id == node_ids);
    shortest_distance(pidx) = 0;
    table(pidx,col) = 0;
    settled(pidx) = 1;
    path(pidx) = {start_id};
    if (nargin < 4) % compute shortest path for all nodes
        while_cmd = 'sum(~settled) > 0';
    else % terminate algorithm early
        while_cmd = 'settled(zz) == 0';
        zz = find(finish_id == node_ids);
    end
    while eval(while_cmd)
        % update the table
        table(:,col-1) = table(:,col);
        table(pidx,col) = 0;
        % find neighboring nodes in the segments list
        neighbor_ids = [segments(node_ids(pidx) == segments(:,2),3);
            segments(node_ids(pidx) == segments(:,3),2)];
        % calculate the distances to the neighboring nodes and keep track of the paths
        for k = 1:length(neighbor_ids)
            cidx = find(neighbor_ids(k) == node_ids);
            if ~settled(cidx)
 
                d = sqrt(sum((nodes(pidx,2:cols) - nodes(cidx,2:cols)).^2));
 
                if (table(cidx,col-1) == 0) || ...
                        (table(cidx,col-1) > (table(pidx,col-1) + d))
                    table(cidx,col) = table(pidx,col-1) + d;
                    tmp_path = path(pidx);
                    path(cidx) = {[tmp_path{1} neighbor_ids(k)]};
                else
                    table(cidx,col) = table(cidx,col-1);
                end
            end
        end
        % find the minimum non-zero value in the table and save it
        nidx = find(table(:,col));
        ndx = find(table(nidx,col) == min(table(nidx,col)));
        if isempty(ndx)
            break
        else
            pidx = nidx(ndx(1));
            shortest_distance(pidx) = table(pidx,col);
            settled(pidx) = 1;
        end
    end
    if (nargin < 4) % return the distance and path arrays for all of the nodes
        dist = shortest_distance';
        path = path';
    else % return the distance and path for the ending node
        dist = shortest_distance(zz);
        path = path(zz);
        path = path{1};
    end
end

j'ai envie que ce programme se code plusieurs fois , en multipliant la valeur de la distance par un nombre aléatoire entre 0.9 et 1.1

**Jean Dumoncel** · 25/07/2011, 14h33

Quelle est la variable qui définie la valeur de la distance?

Sinon as-tu essayé cette fonction au moins une fois? Si oui quel est ton code pour appeler la fonction?

**camelia136** · 25/07/2011, 14h51

Envoyé par magelan

Quelle est la variable qui définie la valeur de la distance?

Sinon as-tu essayé cette fonction au moins une fois? Si oui quel est ton code pour appeler la fonction?

la fonction c'est Dijkstra

et la variable qui définit la distance est d

**sellamelie** · 25/07/2011, 16h12

ton code est pas très clair pour moi.. niveau mise en page, tu aurais pu jouer plus sur des appels de fonctions plus clairs..
sauf erreur de ma part, tu n'as qu'à rajouter un facteur random quand tu calcules d, avec par exemple:

Code :

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

1
2
3
random = (1.1+(0.9-1.1)*rand(1)) ;
%sort un nombre aléatoire entre 0.9 et 1.1
NewD=random*d ;

après pour faire l'opération plusieurs fois, rajoute juste une boucle autour de ton appel de fonction principal...

**camelia136** · 25/07/2011, 16h29

Envoyé par sellamelie

ton code est pas très clair pour moi.. niveau mise en page, tu aurais pu jouer plus sur des appels de fonctions plus clairs..
sauf erreur de ma part, tu n'as qu'à rajouter un facteur random quand tu calcules d, avec par exemple:

Code :

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

1
2
3
random = (1.1+(0.9-1.1)*rand(1)) ;
%sort un nombre aléatoire entre 0.9 et 1.1
NewD=random*d ;

après pour faire l'opération plusieurs fois, rajoute juste une boucle autour de ton appel de fonction principal...

Merci sellamelie pour ta reponse , j'ai déjà essayé ce que tu m'as dit mais ça ne marche pas

j'ai envie en fait que quand le code me trouve le trajet le moins court et le visualise dans un graphe qu'il me multiplie cette distance trouvée par un coefficient de 0.9 à 1.1 pour que quand je relance le programme une autre fois il prend en compte cette variation

je vais essayer de changer les noms pour que ça soit plus clairs

**sellamelie** · 25/07/2011, 16h42

donc tu veux qu'il te multiplie par un facteur la distance totale?
et apres qu'il utilise cette valeur pour faire quoi?

**camelia136** · 25/07/2011, 16h54

Envoyé par sellamelie

donc tu veux qu'il te multiplie par un facteur la distance totale?
et apres qu'il utilise cette valeur pour faire quoi?

oui j'ai envie qu'il multiplie la distance des différents segments qui mène du noeud de départ vers le noeud d'arrivée par un coefficient aleatoire de 0.9 à 1 pour que je relance le programme une autre fois et qu'il me calcule un autre chemin et il me trouve une solution alternative

**sellamelie** · 25/07/2011, 16h59

ah donc en fait tu ne veux pas qu'il modifie la distance finale, mais la distance entre chacun des noeuds, et qu'il recalcule un nouveau chemin avec ces nouveaux paramètres si je comprends bien?

**camelia136** · 25/07/2011, 17h05

Envoyé par sellamelie

ah donc en fait tu ne veux pas qu'il modifie la distance finale, mais la distance entre chacun des noeuds, et qu'il recalcule un nouveau chemin avec ces nouveaux paramètres si je comprends bien?

Tout à fait

il me calcule la plus courte distance entre A et B puis il me recalcule un nouveau chemin entre A et B avec ces nouveaux paramètres

**sellamelie** · 25/07/2011, 17h08

dans ce cas, il faudra initialiser les nodes en dehors de la boucle, et à chaque fin d'itération multiplier chacun de ses composants par le random qu'on a créé tout à l'heure. je ne saisis pas trop ou est ce que tu bloques?

**camelia136** · 25/07/2011, 17h16

Envoyé par sellamelie

dans ce cas, il faudra initialiser les nodes en dehors de la boucle, et à chaque fin d'itération multiplier chacun de ses composants par le random qu'on a créé tout à l'heure. je ne saisis pas trop ou est ce que tu bloques?

c'est que je suis débutante en Matlab et en programmation j'ai repris un code déjà fait que j'ai modifié et adapté à ce que je veux donc j'ai un peu du mal

je vais essayer de faire ce que tu m'as dit

merci

**camelia136** · 25/07/2011, 17h47

quand j'initialise le nodes et je compile le graphe ne me donne plus aucun résultats

**sellamelie** · 25/07/2011, 17h52

c'est à dire? tu as quoi comme message d'erreur?

tu dois probablement initialiser les nodes au mauvais endroit, du coup quand tu lances la fonction, il ne trouve pas ta matrice je suppose...

**camelia136** · 25/07/2011, 17h54

Envoyé par sellamelie

c'est à dire? tu as quoi comme message d'erreur?

tu dois probablement initialiser les nodes au mauvais endroit, du coup quand tu lances la fonction, il ne trouve pas ta matrice je suppose...

il y'a aucun message d'erreur ça se compile j'ai le graphe avec les noeuds et les segments mais ça ne calcule rien ,

**camelia136** · 26/07/2011, 10h01

Envoyé par sellamelie

dans ce cas, il faudra initialiser les nodes en dehors de la boucle, et à chaque fin d'itération multiplier chacun de ses composants par le random qu'on a créé tout à l'heure. je ne saisis pas trop ou est ce que tu bloques?

Bonjour Sellamelie

en fait quesque tu veux dire par multiplier chacun des composants de la boucle ?

**sellamelie** · 26/07/2011, 10h15

si j'ai bien compris ce que tu cherches à faire, tu cherches à recalculer à chaque itération de ta boucle un nouevau chemin optimal sur des noeuds qui varient très peu. dans ce cas, il faut modifier les coordonnées de tes noeuds en les multipliant par ton facteur random. mais si tu multiplies TOUS les noeuds par le random, finalement, le chemin optimal n'aura plus la même distance mais passera toujours par les mêmes noeuds!
donc pour avoir des chemins qui puissent être différents, il faudrait multiplier les coordonnées de chacun des noeuds par un nouveau random, afin de vraiment rendre leur coordonnées aléatoires...
je pense que si tu n'as aucun résultats calculé, tu dois avoir un soucis dans la modification que tu as faites.
pourrais tu poster ton nouveau code, en expliquant quel fonction tu lances et comment?

**camelia136** · 26/07/2011, 11h13

Envoyé par sellamelie

si j'ai bien compris ce que tu cherches à faire, tu cherches à recalculer à chaque itération de ta boucle un nouevau chemin optimal sur des noeuds qui varient très peu. dans ce cas, il faut modifier les coordonnées de tes noeuds en les multipliant par ton facteur random. mais si tu multiplies TOUS les noeuds par le random, finalement, le chemin optimal n'aura plus la même distance mais passera toujours par les mêmes noeuds!
donc pour avoir des chemins qui puissent être différents, il faudrait multiplier les coordonnées de chacun des noeuds par un nouveau random, afin de vraiment rendre leur coordonnées aléatoires...
je pense que si tu n'as aucun résultats calculé, tu dois avoir un soucis dans la modification que tu as faites.
pourrais tu poster ton nouveau code, en expliquant quel fonction tu lances et comment?

je lance la fonction dijkstra

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
% MAIN FUNCTION - DIJKSTRA'S ALGORITHM
 
    % initializations
    node_ids = nodes(:,1);
    [num_map_pts,cols] = size(nodes);
    table = sparse(num_map_pts,2);
    shortest_distance = Inf(num_map_pts,1);
    settled = zeros(num_map_pts,1);
    path = num2cell(NaN(num_map_pts,1));
    col = 2;
    pidx = find(start_id == node_ids);
    shortest_distance(pidx) = 0;
    table(pidx,col) = 0;
    settled(pidx) = 1;
    path(pidx) = {start_id};
    nodes=zeros(40,3); :: initialisation des noeuds
 
    if (nargin < 4) % compute shortest path for all nodes
        while_cmd = 'sum(~settled) > 0';
    else % terminate algorithm early
        while_cmd = 'settled(zz) == 0';
        zz = find(finish_id == node_ids);
    end
    while eval(while_cmd)
        % update the table
        table(:,col-1) = table(:,col);
        table(pidx,col) = 0;
        % find neighboring nodes in the segments list
        neighbor_ids = [segments(node_ids(pidx) == segments(:,2),3);
            segments(node_ids(pidx) == segments(:,3),2)];
        % calculate the distances to the neighboring nodes and keep track of the paths
        for k = 1:length(neighbor_ids)
            cidx = find(neighbor_ids(k) == node_ids);
            if ~settled(cidx)
 
                d = sqrt(sum((nodes(pidx,2:cols) - nodes(cidx,2:cols)).^2));
 
 
                if (table(cidx,col-1) == 0) || ...
                        (table(cidx,col-1) > (table(pidx,col-1) + d))
                    table(cidx,col) = table(pidx,col-1) + d;
                    tmp_path = path(pidx);
                    path(cidx) = {[tmp_path{1} neighbor_ids(k)]};
                else
                    table(cidx,col) = table(cidx,col-1);
                end
            end
        end
 
 
        random = (1.1+(1-1.1)*rand(1)) nombre aléatoire entre 1 et 1.1
 
        Newd=random*d ;

**Jean Dumoncel** · 26/07/2011, 11h29

Oui, mais ce qu'on veut savoir c'est comment tu lances la fonction dijkstra. Là, tu as juste recopié une partie de la fonction

Normalement, tu sauvegardes ton fichier dijkstra.m dans un répertoire, tu crées un nouveau script dans ce répertoire, et dans ce script, tu définis tes variables et tu appelles la fonction dijkstra.

Que fais-tu exactement? Obtiens-tu des messages d'erreurs? si oui, lesquels?

coder un programme n fois [Débutant]

MATLAB

Discussions similaires

Partager

Partager