[Débutant] conversion code MATLAB en pseudocode

conversion code MATLAB en pseudocode

Bonjour,

Je ne connais pas matlab, le code dont je dispose concerne une application basée sur les Algo. génétiques.
J'ai besoin d'aide, convertir quelques lignes de code matlab en pseudo-code pour que je puisse mieux comprendre et le réécrire dans un autre langage.

Bonjour,

Doit-on deviner quel est ce code par télépathie? :mrgreen:

Conversion code matlab en pseudo-code

Bonjour,
J'avais seulement posé la question, voila le code matlab que je dois réécrire dans un autre langage.
je me chargerai de convertir les fonction de matlab et les autres.
Expliciter ce code par une écriture en pCode me faciliterait beaucoup la compréhension pour la conversion.

Code:

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
151
152
 
GHA=[];
Dec=[];
H0=[];
 
% Données 
H0(1)=(15+19.3/60)*pi/180;
H0(2)=(77+34.9/60)*pi/180;
GHA(1)=(131+24.8/60)*pi/180;
GHA(2)=(3+14.2/60)*pi/180;
Dec(1)=(45+58.4/60)*pi/180;
Dec(2)=(49+25.7/60)*pi/180;
 
% Résultat a trouver
Ljuste=(41+39.1/60)*pi/180;
Lamjuste=(17+7.3/60)*pi/180;
 
% Parametres initiaux 
tol=2*pi/180;             % limite des perturbations
pc=0.5;                    % seuil du croisement
pm=0.05;                  % seuil de la mutation
pr=1*pi/180;             % limite mutation
Lini=42*pi/180;          % lng initiale
Lamini=18*pi/180;       % lat initiale
N=50;                       % nombre d'individus
epsilon=1e-4;             % critère d’arrêt
randnum=2*rand(N,1)-1; % vecteur de N nombre aléatoire entre -1 et 1  (la fonction rand renvoie un réel entre 0 et 1)
 
%création de N individus de manière stochastique 
L=Lini+tol*randnum;
Lam=Lamini+tol*randnum;
 
L0=L;
Lam0=Lam;
 
% Matrices qui contiendront le Hc et de la norme entre Hc et H0.
 
RMSE=zeros(length(L),1);
Hc=zeros(length(L),length(H0));
 
%Calcul de Hc pour chaque individu.
for k=1:length(H0)
    for j=1:length(L)
       Hc(j,k)=asin(sin(L(j))*sin(Dec(k))+cos(L(j))*cos(Dec(k))*cos(GHA(k)-Lam(j)));
    end
end
 
%Calcul de la norme.
 
for j=1:length(L)
    for k=1:length(H0)
        RMSE(j)=RMSE(j)+(Hc(j,k)-H0(k))^2/length(H0);
    end
end
 
RMSE=sqrt(RMSE);
minRMSE=min(RMSE);            % critère d’arrêt 
 
g=0;
while (g<=10000 && minRMSE>=epsilon)
    %la selection consiste a choisir n individus de la génération en
    % donnant la meilleure probabilité a celui qui a la distance
    % minimale RMSE
sel_s=sum(1./RMSE);               % création du critère de sélection (comme on cherche un minimum j'ai choisi 1/RMSE qui sera maximal au  %minumum
 
sel_m=[];
sel_m(1)=(1/RMSE(1))/sel_s;       % afin de pouvoir appliquer la sélection je crée un intervalle [0,1] dont la taille de i eme segment représente 
                                              % la proba. de l'individu i
for j=2:N
    sel_m(j)=(1/RMSE(j))/sel_s+sel_m(j-1);
end
 
 
 
[L_s,Lam_s,indice] = selection(L,Lam,floor(N),sel_m);             % sélection de N individu 
[L_new,Lam_new] = croisement(L_s,Lam_s,floor(N),pc);         % croisement entre Les N/2 paires qui ont été sélectionnées
[L_mu,Lam_mu] = mutation(L,Lam,N,pm,pr);                         % mutation de quelques individus 
L_old=L;
Lam_old=Lam;
 
% regroupement de tous les individus (génération courante, les
% mutants et ceux issus du croisements), leur nombre est supérieur
% à N
 
L=zeros(length(L_new)+length(L_mu)+length(L_s)+length(L_old),1);
Lam=zeros(length(L_new)+length(L_mu)+length(L_s)+length(L_old),1);
L(1:length(L_new))=L_new;
L(length(L_new)+1:length(L_new)+length(L_mu))=L_mu;
L(length(L_new)+length(L_mu)+1:length(L_new)+length(L_mu)+length(L_s))=L_s;
L(length(L_new)+length(L_mu)+length(L_s)+1:length(L_new)+length(L_mu)+length(L_s)+length(L_old))=L_old;
 
 
 
Lam(1:length(L_new))=Lam_new;
Lam(length(L_new)+1:length(L_new)+length(L_mu))=Lam_mu;
Lam(length(L_new)+length(L_mu)+1:length(L_new)+length(L_mu)+length(L_s))=Lam_s;
Lam(length(L_new)+length(L_mu)+length(L_s)+1:length(L_new)+length(L_mu)+length(L_s)+length(L_old))=Lam_old;
 
 
%recalcul du critère de sélection pour la nouvelle famille.
 
RMSE=zeros(length(L),1);
Hc=zeros(length(L),length(H0));
 
for k=1:length(H0)
    for j=1:length(L)
       Hc(j,k)=asin(sin(L(j))*sin(Dec(k))+cos(L(j))*cos(Dec(k))*cos(GHA(k)-Lam(j)));
    end
end
for j=1:length(L)
    for k=1:length(H0)
        RMSE(j)=RMSE(j)+(Hc(j,k)-H0(k))^2/length(H0);
    end
end
 
RMSE=sqrt(RMSE);
sel_s=sum(1./RMSE);
sel_m=[];
sel_m(1)=(1/RMSE(1))/sel_s;
for j=2:length(L)
    sel_m(j)=(1/RMSE(j))/sel_s+sel_m(j-1);
end
 
%Comme le nombre est supérieur a N, on le réduit avec la sélection
[L,Lam,indice] = selection(L,Lam,N,sel_m);
 
%On calcul le critère d’arrêt pour la nouvelle génération, s'il n'est
%pas atteint on refait l'opération.
 
RMSE=zeros(length(L),1);
Hc=zeros(length(L),length(H0));
 
for k=1:length(H0)
    for j=1:length(L)
       Hc(j,k)=asin(sin(L(j))*sin(Dec(k))+cos(L(j))*cos(Dec(k))*cos(GHA(k)-Lam(j)));
    end
end
 
 
for j=1:length(L)
    for k=1:length(H0)
        RMSE(j)=RMSE(j)+(Hc(j,k)-H0(k))^2/length(H0);
    end
end
RMSE=sqrt(RMSE);
 
%S'il est atteint, la solution est l’individu qui atteint le minimum
 
[minRMSE,p]=min(RMSE);
 
g=g+1
end

Bonjour,

je pense qu'il y a peu de chance que quelqu'un te fasse la conversion de tout le code. Je suppose que tu comprends certaines lignes, ce serait plus efficace pour toi si tu nous disais quelles lignes te posent des problèmes.

Conversion code matlab en pseudo-code

Bonjour,

RMSE dans matlab est un vecteur colonne.
Hc est une matrice contenant Length(L) et length(H0).
je dois donc déclarer RMSE(i) et Hc(i,j) en variable tableau bouclée sur N=50.
De même pour L qui lui aussi doit être un L(), les données DEC ,GHA et H0 doivent aussi être des tableaux, DEC(1), GH(1), ....H0(2).
je dois donc déclarer tab(): L_old, L_s, Lam_old, Lam, indice, randnum.
Code:

1 2 3 RMSE=zeros(length(L),1); Hc=zeros(length(L),length(H0));
Pouvez vous m’éclairer un peu plus ?

Si tu n'as pas accès au logiciel, je sais que ça ne va pas être évident, mais tu peux avoir accès à la documentation en ligne de caque fonction, il suffit de taper matlab + le nom de la fonction dans un moteur de recherche (par exemple "matlab length).

La fonction length renvoie la longueur de la plus grande dimension d'un tableau. La fonction zéros créé un tableau rempli de 0.

Donc RMSE=zeros(length(L),1); créé un tableau de une colonne et dont le nombre de ligne est length(L) (=50).
Hc=zeros(length(L),length(H0)); créé un tableau de length(L) lignes et length(H0) (=2) colonnes.

Conversion code matlab en pseudo-code

Ok, Magellan je commence a voir peu plus clair.
merci.

Conversion code matlab en pseudo-code

Bonjour,

%création de N individus de manière stochastique
L=Lini+tol*randnum;
Lam=Lamini+tol*randnum;

L et Lam sont des variables tableau.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 For i=1 to N L(i) = Lini+tol*(2*rnd-1) Lam(i) = Lamini+tol*(2*rnd-1) Next Tout comme les données: NbObs = 2 For i=1 to NbObs H0(i)= H0(i)*Trigo.Rad GHA(i)= GHA(i)*Trigo.Rad Dec(i)= Dec(i)*Trigo.rad Next
Est ce la bonne voie ?

Oui, cela a l'air correct.