Convertir Matlab en Fortran 90

Version imprimable

Bonjour,
Voilà, j'ai un problème : je dois convertir un code du Matlab en Fortran 90. Mais je n'ai jamais travaillé sur Fortran, j'ai essayé de m'adapter mais je trouve des difficultés à convertir des boucles écrites en Matlab... Voici les boucles dont je parle et merci infiniment pour votre aide...

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
while Nbrloop<cst_loop
 
i=1;
 
% Boucle de calcul aller
while i<Nbr_iteration+1
   Pp_R(i+1)=Pp_R(i)+gamma_p*(sigma_ep*N2_R(i)-sigma_ap*N1_R(i))*Pp_R(i)*deltaX-alpha_p*Pp_R(i)*deltaX;
Psplus_R(i+1)=Psplus_R(i)+gamma_s*(sigma_es*N2_R(i)-sigma_as*N1_R(i))*Psplus_R(i)*deltaX+gamma_s*N2_R(i)*sigma_es*2*nm*h*c^2*(delta_lambda_S/lambda_S^3)*deltaX-alpha_s*Psplus_R(i)*deltaX;   
R12=(sigma_ap*Pp_R(i+1)*gamma_p)/(Aco*h*vp);
R21=(sigma_ep*Pp_R(i+1)*gamma_p)/(Aco*h*vp);
W12=(sigma_as*(Psplus_R(i+1)+Psmoins_R(i+1))*gamma_s)/(Aco*h*vs);    W21=(sigma_es*(Psplus_R(i+1)+Psmoins_R(i+1))*gamma_s)/(Aco*h*vs);      N1_R(i+1)=((R21+W21+A21)*N)/(R12+W12+R21+W21+A21);
N2_R(i+1)=N-N1_R(i+1);
 
i=i+1;
 
end  %fin boucle aller
Imax=i
 
% Boucle de calcul retour
while i>1
Psmoins_R(i-1)=Psmoins_R(i)+gamma_s*(sigma_es*N2_R(i)-sigma_as*N1_R(i))*Psmoins_R(i)*deltaX+gamma_s*N2_R(i)*sigma_es*2*nm*h*c^2*(delta_lambda_S/lambda_S^3)*deltaX-alpha_s*Psmoins_R(i)*deltaX;
R12=(sigma_ap*Pp_R(i-1)*gamma_p)/(Aco*h*vp);
R21=(sigma_ep*Pp_R(i-1)*gamma_p)/(Aco*h*vp);
W12=(sigma_as*(Psplus_R(i-1)+Psmoins_R(i-1))*gamma_s)/(Aco*h*vs);    W21=(sigma_es*(Psplus_R(i-1)+Psmoins_R(i-1))*gamma_s)/(Aco*h*vs);      N1_R(i-1)=((R21+W21+A21)*N)/(R12+W12+R21+W21+A21);
N2_R(i-1)=N-N1_R(i-1);
 
i=i-1;
 
end %fin boucle retour
Nbrloop=Nbrloop+1
end %fin boucle Nombre aller retour

25/10/2007, 14h08
Sylvain Bergeron
Je ne connais rien à MatLab, alors peut-etre qu'il y a des subtilités que je ne vois pas, mais le code me semble très près de ce que tu dois écrire en Fortran :
- Les « while condition ... end » deviennent des « do while (condition) ... enddo »
- Les « % commentaires » deviennent « ! commentaires »
- Les intructions n'ont pas à être terminées par « ; » en Fortran.
Ce qui précède est valide pour Fortran 90 et +. Si tu dois utiliser le dialecte Fortran 77, alors c'est un peu moins direct. J'y vais de mémoire, qu'on me corrige au besoin :
- Il n'y a pas de while en Fortran 77. Il faut donc une structure comme suit :
Code:

1 2 3 4 5 10 if (.not. Condition) goto 20 ... instructions du while goto 10 20 continue
- Les commentaires sont des lignes commençant en colonne 1 par le caractère «C». Il n'est pas possible d'avoir un commentaire à la fin d'un instruction (comme dans instruction % commentaire ).
- Les instructions ne peuvent pas être terminées par « ; » en Fortran 77.
25/10/2007, 15h38
driss80
Citation:
Envoyé par Sylvain Bergeron

Je ne connais rien à MatLab, alors peut-etre qu'il y a des subtilités que je ne vois pas, mais le code me semble très près de ce que tu dois écrire en Fortran :

Les « while condition ... end » deviennent des « do while (condition) ... enddo »
Les « % commentaires » deviennent « ! commentaires »
Les intructions n'ont pas à être terminées par « ; » en Fortran.

Ce qui précède est valide pour Fortran 90 et +. Si tu dois utiliser le dialecte Fortran 77, alors c'est un peu moins direct. J'y vais de mémoire, qu'on me corrige au besoin :

Il n'y a pas de while en Fortran 77. Il faut donc une structure comme suit :

Code:

1 2 3 4 5 10 if (.not. Condition) goto 20 ... instructions du while goto 10 20 continue

Les commentaires sont des lignes commençant en colonne 1 par le caractère «C». Il n'est pas possible d'avoir un commentaire à la fin d'un instruction (comme dans instruction % commentaire ).
Les instructions ne peuvent pas être terminées par « ; » en Fortran 77.
j'ai essayé avec cela mais je n'ai pas encore de resultat; le probleme se pose au niveau des indices i, i+1..merci
25/10/2007, 15h46
Sylvain Bergeron

Citation:

Envoyé par driss80

j'ai essayé avec cela mais je n'ai pas encore de resultat; le probleme se pose au niveau des indices i, i+1..merci

Comment as-tu déclaré les tableaux et que valent les variables ou constantes cst_loop et Nbr_iteration ?

Citation:

Envoyé par Sylvain Bergeron

Comment as-tu déclaré les tableaux et que valent les variables ou constantes cst_loop et Nbr_iteration ?

j'ai essayé de rectifier mon code source et je n'ai que 3erreurs maintenant, mais le problème se pose au niveau des boucles....et merci infiniment pour votre interet....

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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
      program main 
      Implicit none
      Integer, parameter :: Nbr_iteration=200,cst_loop=4
      doubleprecision, parameter :: PsmoinsL=1.D-06,W0=30.D0,L=5.D0
!     parameter ( Tdebut=0.D0, DT=1.0d-5)
      Doubleprecision, Dimension(Nbr_iteration) :: N1_R,N2_R,X_R
      Doubleprecision, Dimension(Nbr_iteration) :: Pp_R,Psplus_R
      Doubleprecision, Dimension(Nbr_iteration) :: Psmoins_R 
      Doubleprecision, Dimension(Nbr_iteration) :: R12_R,R21_R
      Doubleprecision, Dimension(Nbr_iteration) :: W12_R,W21_R
      Doubleprecision Rco,Aco,Rfo,Acl,gamma_p
      Doubleprecision lambda_s,sigma_ap,sigma_ep,sigma_es,sigma_as
      Doubleprecision alpha_p,alpha_s,tau,delta_lambda_s,n
      Doubleprecision gamma_s,R1,R2,tau_s,h
      Doubleprecision c,vp,vs,A21,N2
      Doubleprecision v,deltaX,x,N1
      double precision resultat 
      integer i, Nbrloop
      doubleprecision :: pi=4.D0*atan(1.D0) 
      write(*,*) 'nombre d''itérations:',Nbr_iteration
 
!!!!!!!!!!!!!!!!!!!  ouverture du fichier lelongdelafibre.txt
 
      open(20,file='F:\projet_these_mghaaraz\calcul_static\
     & lelongdelafibre.txt',form='unformatted',status='unknown', 
     & iostat='ios')
      if(IOS /= 0) then
      write(*,*) 'Erreur d''ouverture du fichier lelongdelafibre.txt' !-ERREUR RENVOYEE ICI-
      end if
!     T1 = Tdebut
!      TFIN = 1000.0d0
!      Ne=(TFIN-T1)/DT
!      write(*,*)'Ne=',Ne
 
!	TOL = 1.d-3
 
!!!!!!!!!!!!!!!!!!!  déclaration des données 
 
      data sigma_ap,sigma_ep,sigma_es,sigma_as,alpha_p,alpha_s,
     &delta_lambda_s,gamma_s,R1,R2,tau_s,h,vp,N/3.D-25,5.D-26,
     &2.5D-25,1.4D-27,3.D-03,5.D-3,2.D-8,0.75,0.04,0.4,3.D-07,
     &6.62D-34,3.D+08,319.D+12/
 
      Rco=8.D-06
      Aco=pi*Rco**2
      write(*,*) 'Aco=', Aco
 
      Rfo=200.D-06     
      Acl=pi*(Rfo**2-Rco**2)
      write(*,*) 'Acl=', Acl
 
      gamma_p=Aco/Acl
      write(*,*) 'gamma_p=', gamma_p
 
      c=3.D+08
      lambda_s=1.08D-06
      vs=c/lambda_s
      write(*,*) 'vs=', vs 
 
      tau=1.D-03
      A21=1/tau
      write(*,*) 'A21=', A21
 
      n=1.45
      v=c/n
      write(*,*) 'v=', v
 
      L=5.
      deltaX=L/float(Nbr_iteration)
      write(*,*) 'deltaX=', deltaX
 
!!!!!!!!!!!!!!!!!!!  conditions initiales
 
      N=3.D+19
      N2_R(1)=0.24*N
      N1_R(1)=0.76*N   ! N1(0)=N-N2(0)
      Pp_R(1)=W0
      Psplus_R(1)=0.D+0
      X_R(1)=0.D+0
      R12_R(1)=0.
      R21_R(1)=0.
      W12_R(1)=0.
      W21_R(1)=0.
 
      write(*,*) 'Pp_R(1)=', Pp_R(1)
      write(*,*) 'Psplus_R(1)=', Psplus_R(1)
      write(*,*) 'N2_R(1)/N=', N2_R(1)/N
      write(*,*) 'N1_R(1)/N=', N1_R(1)/N
      write(*,*) 'X_R(1)=', X_R(1)
      write(*,*) 'R12_R(1)=', R12_R(1)
      write(*,*) 'R21_R(1)=', R21_R(1)
      write(*,*) 'W12_R(1)=', W12_R(1)
      write(*,*) 'W21_R(1)=', W21_R(1)
 
!!!!!!!!!!!!!!!!!!!  initialisation des tableaux
 
      subroutine initialisation_1(N1_R, N2_R, X_R, Pp_R, Psplus_R,
     & Psmoins_R,R12_R,R21_R,W12_R,W21_R)
      implicit none
      doubleprecision N1_R(200),N2_R(200),X_R(200),Pp_R(200),
     &Psplus_R(200),Psmoins_R(200),R12_R(200),R21_R(200),
     &W12_R(200),W21_R(200)
      integer i
      Do i=1, 180
         N1_R(i)=0.
         N2_R(i)=0.
         X_R(i)=0.
         Pp_R(i)=0.
         Psplus_R(i)=0.
         Psmoins_R(i)=0.
         R12_R(i)=0.
         R21_R(i)=0.
         W12_R(i)=0.
         W21_R(i)=0.
      enddo
      end subroutine initialisation_1        
 
!!!!!!!!!!!!!!!!!!!  initialisation Ps- et X
 
      subroutine initialisation_2(Psmoins_R,X_R,PsmoinsL,x,deltaX)  
      double precision Psmoins_R(200),X_R(200)
      double precision PsmoinsL,x,deltaX
      integer i
      PsmoinsL=1.d-06 
      x=0.
      do while (i.lt.Nbr_iteration+1)
         do i=180, 1, -1
         Psmoins_R=PsmoinsL
         x=x+deltaX
         X_R=x
         enddo
      enddo
      end subroutine initialisation_2
 
 
 
!!!!!!!!!!!!!!!!!!!  boucles de calcul statique
   10 if(.not. Nbrloop.lt.cst_loop) go to 20
      do while (i.lt.Nbr_iteration+1) 
         call initialisation_1
         Do i=2, 180
         Pp_R=Pp_R+gamma_p*(sigma_ep*N2_R-sigma_ap*N1_R)*
     &   Pp_R*deltaX-alpha_p*Pp_R*deltaX
         Psplus_R=Psplus_R+gamma_s*(sigma_es*N2_R-sigma_as*N1_R)*
     &   Psplus_R*deltaX+gamma_s*N2_R*sigma_es*2*int(n)*h*c*c*
     &   (delta_lambda_S/lambda_S**3)*deltaX-alpha_s*Psplus_R*deltaX
         R12_R=(sigma_ap*Pp_R*gamma_p)/(Aco*h*vp)
         R21_R=(sigma_ep*Pp_R*gamma_p)/(Aco*h*vp)
         W12_R=(sigma_as*(Psplus_R+Psmoins_R)*gamma_s)/(Aco*h*vs)
         W21_R=(sigma_es*(Psplus_R+Psmoins_R)*gamma_s)/(Aco*h*vs)
         N1_R=((R21_R+W21_R+A21)*N)/(R12_R+W12_R+R21_R+W21_R+A21)
         N2_R=N-N1_R
         write(20,*) 'Pp_R=', Pp_R
         write(20,*) 'Psplus=', Psplus_R 
         write(20,*) 'N2_R/N=', N2_R/N
         enddo
      enddo
      do while (i.gt.1)
         call initialisation_2
         do i=180, 2, -1
         Psmoins_R=Psmoins_R+gamma_s*(sigma_es*N2_R-sigma_as*N1_R)*
     &   Psmoins_R*deltaX+gamma_s*N2_R*sigma_es*2*int(n)*h*c*c*
     &   (delta_lambda_S/lambda_S**3)*deltaX-alpha_s*Psmoins_R*deltaX
         R12_R=(sigma_ap*Pp_R*gamma_p)/(Aco*h*vp)
         R21_R=(sigma_ep*Pp_R*gamma_p)/(Aco*h*vp)
         W12=(sigma_as*(Psplus_R+Psmoins_R)*gamma_s)/(Aco*h*vs)
         W21_R=(sigma_es*(Psplus_R+Psmoins_R)*gamma_s)/(Aco*h*vs)
         N1_R=((R21_R+W21_R+A21)*N)/(R12_R+W12_R+R21_R+W21_R+A21)
         N2_R=N-N1_R
         enddo
         write(20,*) "Psmoins_R=", Psmoins_R
      enddo
      go to 10
   20 continue  
 
!!!!!!!!!!!!!!!!!!!  test condition initiale entre Ps+ et Ps- en 0
      R1=R1*100.
      write(*,*) 'donnez R1'
      read(*,*) R1
      write(*,*) 'R1=', R1
      resultat=Psplus_R/Psmoins_R
      resultat=resultat*100.
      write(20,*) 'donnez resultat'
      read(20,*) resultat
      write(10,*) 'resultat=', resultat
      if (resultat.ge.R1-0.005.and.resultat.le.R1+0.005) then
      write(*,*) 'la valeur initiale de Ps- "OK"'
      else
      write(*,*) 'la valeur initiale de Ps- "pas OK"'
      endif 
      close(20)
      end program main

25/10/2007, 17h06
FR119492

Salut !

Cleve Moler, un des coauteurs de la bibliothèque LinPack, écrite en Fortran, et par la suite "inventeur" de MatLab, a écrit: "La vie est bien trop courte pour la passer à écrire des boucles". C'est ce qui explique la difficulté qu'il y a à traduire en Fortran un programme MatLab "bien écrit": MatLab travaille sur des tableaux entiers alors qu'en Fortran, les opérations s'effectuent séparément sur chaque composante des tableaux, à l'intérieur de boucles souvent imbriquées. Il en résulte qu'un programme MatLab est beaucoup plus dense, ou, en sens inverse, que sa traduction en Fortran comportera un beaucoup plus grand nombre de lignes. En traduisant littéralement d'un langage dans l'autre, tu obtiendras un très mauvais code. A ta place, je récrirais complètement le programme. Mais évidemment, ça fait 43 ans que je fais du Fortran, ce qui change tout!

Bonne chance quand même.
Jean-Marc Blanc
25/10/2007, 17h10
driss80

Citation:

Envoyé par FR119492

Salut !

Cleve Moler, un des coauteurs de la bibliothèque LinPack, écrite en Fortran, et par la suite "inventeur" de MatLab, a écrit: "La vie est bien trop courte pour la passer à écrire des boucles". C'est ce qui explique la difficulté qu'il y a à traduire en Fortran un programme MatLab "bien écrit": MatLab travaille sur des tableaux entiers alors qu'en Fortran, les opérations s'effectuent séparément sur chaque composante des tableaux, à l'intérieur de boucles souvent imbriquées. Il en résulte qu'un programme MatLab est beaucoup plus dense, ou, en sens inverse, que sa traduction en Fortran comportera un beaucoup plus grand nombre de lignes. En traduisant littéralement d'un langage dans l'autre, tu obtiendras un très mauvais code. A ta place, je récrirais complètement le programme. Mais évidemment, ça fait 43 ans que je fais du Fortran, ce qui change tout!

Bonne chance quand même.
Jean-Marc Blanc

merci quand même c'est gentil de votre part...
25/10/2007, 22h53
Jerome Briot

Je n'ai pas bien compris pourquoi tu voulais reécrire ton code de MATLAB vers Fortran ?

Souhaites-tu t'affranchir complètement de MATLAB ou seulement interfacer tes codes MATLAB avec d'autres programmes Fortran (ou l'inverse) ?

Citation:

Envoyé par FR119492

Cleve Moler, un des coauteurs de la bibliothèque LinPack, écrite en Fortran, et par la suite "inventeur" de MatLab, a écrit: "La vie est bien trop courte pour la passer à écrire des boucles".

Amen :mouarf:
26/10/2007, 11h07
driss80

Citation:

Envoyé par Dut

Je n'ai pas bien compris pourquoi tu voulais reécrire ton code de MATLAB vers Fortran ?

Souhaites-tu t'affranchir complètement de MATLAB ou seulement interfacer tes codes MATLAB avec d'autres programmes Fortran (ou l'inverse) ?

Amen :mouarf:

enfin je prepare une these et on m'a demande de convertir mon code du mat. vers for. pour deux choses gagner sur le temps et sur la precision!!!...
29/10/2007, 09h48
gregory2526

Bonjour,

pour la précision, je ne suis pas sûr que tu y gagnerai.

Par contre, il me semble que tu peux compiler un script matlab en c directement avec matlab (si je ne me trompe... Mais je ne l'ai jamais fait...)

peut-être cela serait-il plus facile de cette manière ?
29/10/2007, 18h32
FR119492

Salut !

Citation:

Envoyé par Dut

Je n'ai pas bien compris pourquoi tu voulais reécrire ton code de MATLAB vers Fortran ?

Sans vouloir déclencher une polémique, je dirais ceci: il y a des cas très particulier où un programme Fortran (ou C) peut présenter des avantages significatifs par rapport à MatLab, que ce soit en terme de vitesse d'exécution ou en terme de place en mémoire, à condition de suffisamment bien connaitre le Fortran. A titre d'exemple, je citerais le cas de la résolution de systèmes linéaires où la matrice est symétrique, positive définie et tridiagonale par blocs.

La question pour toi est de savoir ce qui est le plus précieux: si c'est ton temps, reste à MatLab; si c'est le temps de ton processeur, passe au Fortran.

Bonne chance.
Jean-Marc Blanc
29/10/2007, 19h03
Jerome Briot

Citation:

Envoyé par FR119492

Sans vouloir déclencher une polémique

Il n'y a pas à polémiquer ici.

MATLAB repose sur des bibliothèques/codes Fortran/C/C++/Java/Perl (en gros). Et ce, même si il possède son propre langage...

Citation:

Envoyé par Loren Shure

You are correct that much of MATLAB is not written in Java. Primarily Java is used for the user interface, and occasionally some other tidbits, I think like using the serial port sometimes. The parser, interpreter, etc. — main guts, are in C and C++, linked with libraries that are sometimes Fortran for some of the math, though some of that is via vendor libraries and we might not know what language they are in — but most likely not Java.
–Loren

Les fichiers MEX C/C++ et Fortran existe depuis de nombreuses années sous MATLAB. Même si il est vrai que les différences de vitesse de calcul ne sont plus si significatives (avec le JIT et les techniques de vectorisation), on peut estimer que les langages bas niveau seront ~toujours~ plus rapide que MATLAB.

Au niveau de la gestion de mémoire, il ne fait aucun doute que la gestion de block de mémoire contigüe par MATLAB est un frein à la résolution de problème de grandes dimensions

Citation:

La question pour toi est de savoir ce qui est le plus précieux: si c'est ton temps, reste à MatLab; si c'est le temps de ton processeur, passe au Fortran.

Plus généralement :

Citation:

Si tu es en phase de développement d'algorithme, reste sur MATLAB, si tu cherches à produire du code final, autonome et efficace, envisage de passer au langage bas niveau si ton code MATLAB optimisé ne te suffit pas

Je ne sais pas si je me suis bien fait comprendre, mais en gros, sans C ou Fortran, pas de MATLAB. Par contre, pour la rapidité de prise en main et de développement, MATLAB a l'avantage. (fallait bien que je finisse en disant que MATLAB est meilleur :mouarf:)
30/10/2007, 20h15
FR119492

Citation:

Envoyé par Dut

fallait bien que je finisse en disant que MATLAB est meilleur

De toute manière, on sait que le meilleur langage est celui dont on a l'habitude!

Jean-Marc Blanc