Fortran vers Java

Version imprimable

Fortran vers Java

Bonjour,

j'ai ouvert un poste précédement sur une potentiel fuite mémoire coté Fortran.

Depuis on ma demandé de réécrire le code Fortran en Java...sauf que je n'y connais rien en Fortran, est ce que si je met une des fonctions à traduire ici, quelqu un pourrai me donner un coup de main pour comprendre la structure du truc et la passer en JAVA?
paramètre/valeur de retour etc...?

j'ai une fonction très petite qui ressemble à cela déjà:
ce que je saisi pas trop c'est la ligne SEVAL1=Y(I)+DX*B(I)
elle rappel récursivement la function? pour le reste si je comprends bien ce ne sont que des récupérations de valeur dans des tableaux et des additions/multiplication entre eux?
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 REAL FUNCTION SEVAL1 (N,U,X,Y,B) INTEGER N REAL U,X(*),Y(*),B(*) C.............................................................................. C C EVALUATION DE LA DROITE EN UN POINT U DE L'INTERVALLE [X(1),X(N)] C C SEVAL=Y(I)+B(I)*(U-X(I)) C C AVEC X(I) < U < X(I+1) C C.............................................................................. INTEGER I,J,K REAL DX I=1 IF (U.LE.X(I+1)) GO TO 30 C C RECHERCHE DE L'INTERVALLE A CONSIDERER C J=N+1 20 K=(I+J)/2 IF (U.LT.X(K)) J=K IF (U.GE.X(K)) I=K IF (J.GT.I+1 ) GO TO 20 C C EVALUATION DE LA DROITE C 30 DX=U-X(I) SEVAL1=Y(I)+DX*B(I) RETURN END
merci beaucoup!

Bonjour,

La fonction SEVAL1 retourne la valeur en U d'une fonction affine par morceaux, définie sur un intervalle [x(1),x(n)]. L'algorithme présuppose que x(1) <= u <= x(n) et comporte 2 parties :
1) la recherche par dichotomie de l'intervalle auquel appartient l'abscisse u : x(i) <= u < x(i+1) avec 1 <= i <= n (ligne 17 à 26 de votre code)
2) l'évaluation de la fonction en u (ligne 30 - 31)

Il n'y a donc pas d'appel récursif de la fonction SEVAL1.

Je vous propose ci-dessous une implantation de cette fonction en Fortran90, dont la syntaxe est plus proche que celle du Fortran 77 en espérant qu'elle vous aidera pour votre transposition :
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 real function SEVAL1(N,U,X,Y,B) integer, intent(in) :: N ! Taille des vecteurs passés en argument real, dimension(:), intent(in) :: & ! Vecteurs X, & ! Abscisses Y, & ! Ordonnées à l'origine B ! Coefficients directeur real, intent(in) :: u ! Abscisse où l'on souhaite évaluée la fonction !.............................................................................. ! ! EVALUATION DE LA DROITE EN UN POINT U DE L'INTERVALLE [X(1),X(N)] ! ! SEVAL=Y(I)+B(I)*(U-X(I)) ! ! AVEC X(I) < U < X(I+1) ! !.............................................................................. ! VARIABLES LOCALES integer :: i,j,k real :: dx ! ! RECHERCHE PAR DICHOTOMIE DE L'INTERVALLE A CONSIDERER ! I = 1 if (x(i+1) < u) then ! u n'est pas dans le premier intervalle [x(1),x(2)] J = N+1; K = (I+J)/2 do while (J > I+1) if (u < x(k)) then j = k else i = k end if end do end if ! ! EVALUATION DE LA DROITE EN U (x(i) <= U < x(i+1) ! DX = U-X(I) SEVAL1 = Y(I) + DX*B(I) end function SEVAL1

merci beaucoup pour votre réponse, effectivement le code semble beaucoup plus claire comme cela :) je vais surement faire de meme pour les autres subroutines que j'ai.

et donc cette ligne
Code:

1 2 SEVAL1 = Y(I) + DX*B(I)
finalement serait le moyen de déclarer la valeur de retour de la fonction si j'ai bien compris.

en tout cas merci, je viens de migrer une fonction quasi similaire mais qui a 2 paramètres en plus:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 I = 1 IF (I.GE.N) I=1 IF (U.LT.X(I) ) GO TO 10 IF (U.LE.X(I+1)) GO TO 30 C C RECHERCHE DE L'INTERVALLE A CONSIDERER C 10 I=1 J=N+1 20 K=(I+J)/2 IF (U.LT.X(K)) J=K IF (U.GE.X(K)) I=K IF (J.GT.I+1 ) GO TO 20
j'ai donc fait:
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 real function SEVAL2 (N,U,X,Y,B,C,D) integer, intent(in) :: N ! Taille des vecteurs passés en argument real, dimension(:), intent(in) :: & ! Vecteurs X, & ! Abscisses Y, & ! Ordonnées à l'origine B, & ! Coefficients directeur C, & D real, intent(in) :: u ! Abscisse où l'on souhaite évaluée la fonction integer :: i,j,k real :: dx I = 1 if (I >= N) then I=1 end if IF (U < X(I) ) then I=1 J=N+1 END IF if (x(i+1) < u) then ! u n'est pas dans le premier intervalle [x(1),x(2)] I=1; J=N+1; K=(I+J)/2; do while (J > I+1) if (u < x(k)) then j = k else i = k end if end do end if DX=U-X(I) SEVAL2=Y(I)+DX*(B(I)+DX*(C(I)+DX*D(I))) end function SEVAL2
je ne suis pas sur de la partie avant la boucle si vous pouvez me la valider et je ne comprends pas bien :
Code:

1 2 3 I = 1 IF (I.GE.N) I=1
vu que I est déja egal à 1, pourquoi le remettre à 1 si I >= N ?

merci encore!

16/04/2014, 10h12
LittleOwl
Bonjour,

1)

Citation:

Code:

SEVAL1 = Y(I) + DX*B(I)

finalement serait le moyen de déclarer la valeur de retour de la fonction si j'ai bien compris.

Oui. La fonction SEVAL1 retourne un flottant (type REAL) dont la valeur de retour est la valeur de la fonction affine par morceaux en U. L'indice I repère l'intervalle auquel appartient U (x(i) <= U < x(i+1) avec 1 <= i < N). La valeur de I a été déterminée par dichotomie.

2) Vous trouverez ci-dessous la façon dont je "transcrirais" en F90 le fragment de code qui vous intéresse, sous réserve que j'ai bien compris la façon dont fonctionne le code F77 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... if ( U <= X(2) ) then I = 1 else I=1; J=N+1 do while (J > I+1) K = (I+J)/2 if (u < x(k)) then j = k else i = k end if end do end if ...
3)
Citation:
Code:

1 2 I = 1 IF (I.GE.N) I=1

vu que I est déja egal à 1, pourquoi le remettre à 1 si I >= N ?
Je suis d'accord avec vous. Je pense que cette instruction ne sert à rien. C'est la raison pour laquelle je n'en ai pas tenu compte dans la transcription que je vous propose.

4) ligne 2 :

Code:

IF (U.LT.X(I) ) GO TO 10

L'instruction GOTO 10 permet de se brancher sur l'instruction reperée par l'étiquette 10 si la condition (U < X(1) car I = 1) est vérifiée. Toutes les instructions qui sont situées après l'étiquette 10 sont également exécutées, y compris la recherche par dichotomie, ce qui n'est pas le cas dans votre transcription.Néanmoins, Comme U < x(1), elle doit retourner I = 1, ce qui ne change rien. Il semble donc que le concepteur de la fonction ait souhaité prolonger la fonction affine de l'intervalle [x(1),x(2)] au domaine U < x(1). C'est la raison pour laquelle je pense que le seul test U <= x(2) est suffisant.

5) J'ai commis une erreur dans le code de la recherche par dichotomie de mon premier code. Cette erreur se retrouve dans le bloc que vous avez repris dans la fonction SEVAL2. L'instruction

Code:

K=(I+J)/2

doit se trouver dans le corps de la boucle WHILE. (cf ci-dessus)

6) en conclusion, je ne sais pas si la fonction F77 SEVAL2 a été testée mais personnellement je vérifierais qu'elle a bien le comportement souhaitée lorsque l'abscisse est en dehors du domaine de définition [x(1),x(N)] soit pour U < x(1) et U > x(N). Il semblerait que le concepteur ait choisi de prolonger la fonction mais c'est à vérifier. Enfin, comme vous pouvez le constater, je ne suis pas sur que la transcription dans un autre langage soit la solution adaptée, surtout si votre code est long, car c'est une tâche qui nécessite d'interpréter le code F77 pour retrouver sa sémantique et ensuite de le transcrire dans un autre langage. Le risque d'erreur est élevée alors que le code d'origine est censé avoir été testé et validé. Je pense qu'il serait intéressant pour vous de prendre conseil auprès d'une personne expérimentée qui a déjà eu à faire à ce genre de problème afin qu'elle puisse vous conseiller la solution la plus adaptée.

Bon courage.
16/04/2014, 10h52
palex

bonjour

merci pour cette réponse clair et précise :)

1/ en effet dans un premier temps, de mon coté je pensais réaliser des tests unitaire Java avec des jeux de données différents afin de passer dans tout les cas possible de chaque fonction/subroutine. Afin de m'en assurer je vais rajouter des write(*,*) pour etre sur que mon jeu de données test bien là où je veux aller afin de ne pas oublier un seul chemin du code Fortran. Mes tests dans un premier temps ferons donc appel à du code JNI qui appelera le code Fortran.

suite à cela je vais récupérer des tableaux de résultats que je vais conserver comme résultats de référence.

2/ensuite je pensais commencer la transcription en JAVA, chose interessante pour nous car au moindre probleme sur l'application aujourd hui il est tres difficile pour nous de dire d'ou vien le probleme.
durant cette seconde phase j'ai demander l'expertise d'une personne connaissant le Fortran afin d'etre bien sur de ce que je retranscrit, en plus de vos réponse qui vont beaucoup aider.

3/enfin une fois la transcription coté java terminé, je repasserai les tests unitaire afin de vérifier que les résultats calculé corresponde toujours au données de référence.

si déjà nous arrivons à cela alors nous aurons déjà bien avance. Mais on me demandais de chiffrer le temps à passer pour cette migration, d'ou mes questions sur le forum afin de mieux comprendre ce que je chiffre

meric encore