Ecrire une formule apd programme existant

Version imprimable

Bonjour à tous,

Je suis en train de me casser la tête depuis plusieurs heures à essayer d'écrire une formule en Fortran 90.

Voici ce que je dois faire :

Citation:

Convertir le calcul du jour julien en une fonction (au sens Fortran 90) recevant jour, mois
et année comme arguments et retourant JD (réel).

Pour cela je pars d'un programme déjà conçu et qui fonctionne :
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 program ToJD implicit none integer::d,m,y real::JD,B,A d=20 m=2 y=2012 IF(m<=2) THEN y=y-1 m=m+12 ENDIF IF(y>1582) THEN A=y/100 B=2-A+(A/4) ELSE B=0 ENDIF JD=INT(365.25*(y+4716))+INT(30.6001*(m+1))+d+B-1524.5 print *,JD end program
Ma première idée (c'est la première formule que j'écris d'ailleurs) :
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 real function JD(d,m,y) implicit none integer,intent(in)::d,m,y real::B,A IF(m<=2) THEN y=y-1 m=m+12 ENDIF IF(y>1582) THEN A=y/100 B=2-A+(A/4) ELSE B=0 ENDIF JD=INT(365.25*(y+4716))+INT(30.6001*(m+1))+d+B-1524.5 end function
Cependant j'ai compris que les variables de la fonction ne peuvent être impliqués dans le "calcul" (ex. y=y-1)

Je suppose que pour l'algorithme il faut utiliser des nouvelles données mais alors je ne comprends pas bien comment ça peut affecter la fonction et ses variables ?
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 real function JD(d,m,y) implicit none integer,intent(in)::d,m,y real::B,A,o,p,q IF(p<=2) THEN q=q-1 p=p+12 ENDIF IF(q>1582) THEN A=q/100 B=2-A+(A/4) ELSE B=0 ENDIF o=d p=m q=y JD=INT(365.25*(q+4716))+INT(30.6001*(p+1))+o+B-1524.5 end function
Je sais pas du tout ce que ça vaut le dernier paragraphe ?! Il est sûrement faux :-/

Au passage est-ce vous pourriez me donner un petit programme qui utilise la fonction en question car j'ai pas encore appris ça mais c'est super utile pour savoir si la fonction fonctionne correctement

Merci d'avance !

Salut,

…j'ai commencé à écrire quelque chose et paf je découvre des trucs. J'étais persuadé qu'on n'était obligé de mettre des intent pour les fonctions mais en fait oui sinon, avec i une variable d'entrée i=i+1 met bien à jours i… c'est très pervers.
Donc il faut que tu fasses des copies de tes variables d'entrée éventuellement, ou que tu adapte par exemple ton q=q-1 (ligne 8 dernier code) tu peux le remplacer par q=y-1 car à ce moment tu code q est inconnu, pas assigné donc oui q=q-1 va se faire mais avec la valeur de q que tu trouves dans la mémoire, à savoir n'importe quoi puisque tu ne l'as pas assigné.
C'est bien je viens d'apprendre qu'on peut faire une déclaration du type
Code:

1 2 real function toto(lala)
je connaissais
Code:

1 2 3 function toto(lala) real :: toto
et
Code:

1 2 3 function toto(lala) result(titi) real :: titi ! bon la on ne parlera pas de lala
et parce que c'est tard et que je suis fatigué voici UNE solution, moche, on peut faire mieux mais voilà, c'est la solution du soir.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 !>\brief un commentaire pour bien décrire ce que fait la fonction FUNCTION lala(dd,mm,yy) IMPLICIT NONE ! input INTEGER, INTENT(in) :: dd !< day INTEGER, INTENT(in) :: mm !< month INTEGER, INTENT(in) :: yy !< year ! output REAL :: lala !< pô's friend … or not ! local variables INTEGER :: d,m,y ! copy of input variables d=dd m=mm y=yy ! ici un copié collé des lignes 11 à 25 du premier morceau de code END FUNCTION*lala
les commentaires bizarres c'est pour la documentation par doxygen…

et le lien du soir pour se détendre : http://www.nojhan.net/geekscottes

Bonne nuit ;)

Salut

Voici une implémentation en Fortran 90 :

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
 
function julien (jour, mois, annee)
 
! Convertit une date civile en temps julien
 
  implicit none
  real :: julien
  integer, intent(in) :: jour, mois, annee
  integer :: ms, an, siecle
 
  if (mois > 2) then
    ms = mois - 3
    an = annee
  else
    ms = mois + 9
    an = annee - 1
  end if
 
  siecle = an / 100
  an = an - 100 * siecle
 
  julien = int(siecle * 146097.0 / 4.0) &
         + int(an * 1461.0/ 4.0) + int((ms * 153.0 + 2.0) / 5.0) &
         + 1721119.0 + jour - 0.5
 
end function julien

Salut,

Merci de ta réponse :) Malheureusement mon problème n'est pas résolu :(

Voici donc la fonction (A et B n'étaient pas défini dans la fonction mais je pense j'ai résolu ce problème)
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 FUNCTION JD(dd,mm,yy) IMPLICIT NONE INTEGER, INTENT(in) :: dd INTEGER, INTENT(in) :: mm INTEGER, INTENT(in) :: yy REAL :: JD INTEGER :: d,m,y,A,B d=dd m=mm y=yy IF(m<=2) THEN y=y-1 m=m+12 ENDIF IF(y>1582) THEN A=y/100 B=2-A+(A/4) ELSE B=0 ENDIF JD=INT(365.25*(y+4716))+INT(30.6001*(m+1))+d+B-1524.5 END FUNCTION
Pour tester si ça marchait j'ai voulu faire une fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 program testconvertto implicit none integer :: dd,mm,yy integer :: JD dd = 20 mm = 2 yy = 2012 print *, JD(dd,mm,yy) end program
Et lorsque je "fortranise" le tout (la commande est-elle correct lorsqu'il y a 2 fichiers ? )

Citation:

gfortran fichierformule.f90 fichierprogramme.f90

Et quand j'exécute le programme j'obtiens : 1242949286 au lieu de 2455977.5 :-/

D'où provient cette satanée erreur ? ^^

Merci

Edit : Merci de ta réponse Grame, je ne l'avais pas vu quand j'ai posté, par contre je suis obligé de repartir de mon programme de conversion qui fonctionne ^^

07/03/2012, 15h54
Grame
Bonjour

Citation:

Et lorsque je "fortranise" le tout (la commande est-elle correct lorsqu'il y a 2 fichiers ? )

oui

Citation:

Et quand j'exécute le programme j'obtiens : 1242949286 au lieu de 2455977.5 :-/

D'où provient cette satanée erreur ? ^^

Je ne vois pas d'erreur dans ton code. C'est l'algorithme qui est faux.
Avec l'implémentation que je t'ai donnée, on obtient bien 2455977.5
Code:

1 2 3 4 ~/codes/f95/utils> ./a.out Temps julien : 2455977.5 Date : 20 2 2012
07/03/2012, 17h53
RondoudouBooleen
Citation:
Envoyé par Grame

C'est l'algorithme qui est faux.
Avec l'implémentation que je t'ai donnée, on obtient bien 2455977.5

Code:

1 2 3 4 ~/codes/f95/utils> ./a.out Temps julien : 2455977.5 Date : 20 2 2012
Non non mon algorithme n'est pas faux puisque j'obtiens 2455977.5 en l'utilisant dans mon programme (le 1er code cité) :(

Est-ce que ça se peut que ça soit Fortran qui déconne ? Un ami m'a dit qu'il avait lu qu'il y a parfois des erreurs avec les fonctions

Merci
07/03/2012, 21h35
Grame
Bonsoir

Citation:

Non non mon algorithme n'est pas faux puisque j'obtiens 2455977.5 en l'utilisant dans mon programme (le 1er code cité) :(

ok

Citation:

Est-ce que ça se peut que ça soit Fortran qui déconne ? Un ami m'a dit qu'il avait lu qu'il y a parfois des erreurs avec les fonctions

Change d'amis ;)
Je n'ai jamais vu que Fortran déconnait, les programmeurs (dont moi), si.

Sérieusement, en regardant de près, l'erreur saute aux yeux.
Ta fonction est déclarée REAL
Code:

1 2 REAL :: JD
alors que dans le programme appelant, elle est déclarée INTEGER
Code:

1 2 integer :: JD
Déclare la en REAL, est ton résultat sera juste.

Bonne soirée
07/03/2012, 22h25
RondoudouBooleen

Ah, comme quoi c'est des fois beaucoup plus facile (et flagrant) qu'on le pense ^^

Un grand merci :)

Sinon je compte quand même le garder comme ami :p A mon avis il devait faire référence à ça http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html

Bonjour,

Je me permets de reposer une nouvelle question ici, ce n'est plus un problème de fonction mais de subroutine, je vous laisse voir le problème par vous même :

Code:

1
2
3
4
5
6
7
8
9
 gfortran FromJDdriver.f90 TestFromJD.f90
 ./a.out
 -2147483648
           2
    -5884201
 ./a.out
          19
           2
        2012

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
 gfortran FromJDdriver.f90 TestFromJD.f90 -o test
./test
         -70
           5
        2012
 ./test
     -250506
           1
        2698
 ./test
          18
           2
        2012
 ./test
          19
           2
        2012
 ./test
          19
           2
        2012
 ./test
          19
           2
        2012
 ./test
          19
           2
        2012
./test
          19
           2
        2012
./test
 -2147483648
           2
    -5884201
 ./test
 -2147483648
           2
    -5884201
 ./test
   194798096
           1
     -531315
gfortran FromJDdriver.f90 TestFromJD.f90 -o test
 ./test
 -2147483648
           2
    -5884201
 ./test
          19
           2
        2012

Bon je sais que j'en ai mis beaucoup mais c'est pour le côté scientifique on multiplie les expériences ^^

Donc en gros j'obtiens la bonne réponse mais de manière assez ... aléatoire, comme vous pouvez le voir j'ai essayé de changer de nom, de supprimer le fichier compilé etc ... Y'a une raison à ça ?

Merci;)

10/03/2012, 17h11
Matthieu Brucher

Une variable mal initialisée quelque part ?
12/03/2012, 08h03
Ehouarn
Bonjour,

Dans la lignée de ce qu'a déjà dit Grame plus haut, si il y a un problème, c'est dans 99,99999% des cas parce qu'il y a des erreurs dans le programme.

Donc le réflexe à avoir est de compiler avec toutes les options du compilateur permettant d'identifier ces bourdes.
Par exemple avec gfortran, je ne peux que te recommander de compiler avec au minimum les options suivantes:
Code:

1 2 -O2 -Wall -fbounds-check -ffpe-trap=invalid,zero,overflow
Et de bien lire les retours du compilateur lors de la compilation (et de l'exécution).

Bonne continuation.
12/03/2012, 19h19
RondoudouBooleen
Merci de vos réponses :)

J'en profite pour poser une dernière petite question (car pour faire ma nouvelle série d'exo j'avais besoin de faire celui-ci mais je le savais pas ^^ )

Citation:

Ecrire un programme Fortran 90 MinMax qui affche le minimum et le maximum d'un tableau T de N nombres entiers.

J'ai écrit un fonction Minmax(a,b,minimum,maximum) qui donne le min et le max de {a,b} mais je ne sais pas comment l'adapter au cas d'un tableau ?!
Code:

1 2 3 4 5 6 7 8 9 subroutine minmax(a,b,minimum,maximum) implicit none real,intent(in) :: a,b real,intent(out) :: minimum,maximum minimum=min (a,b) maximum=max (a,b) end subroutine
J'ai eu la "mauvaise idée" de penser que ça marcherait d'adapter en (y'a pas tout juste l'idée) :
Code:

1 2 3 4 5 6 implicit none real,intent(in),DIMENSION(:) :: Tableau real,intent(out) :: minimum,maximum minimum=min (Tableau) maximum=max (Tableau)
Mais ça me compte Tableau comme une donnée et donc min & max ne sont pas utilisables :-/

Merci d'avance

(edit 22h35 : j'ai ajouté les bouts de codes de mes fonctions)
13/03/2012, 08h07
Ehouarn

Bonjour,

Quelques pistes pour t'aider:
- Il existe en Fortran 90 les fonctions intrinsèques maxval() et minval() qui prennent un tableau en argument et renvoient le max ou le min.
- Autre possibilité: parcourir les N éléments du tableau en utilisant min() et max() pour comparer l'élément courant avec le maximum/minimum rencontré jusque là.

Bon courage.

PS: Tu devrais plutôt ouvrir un nouveau fil lorsque tu changes de sujet.

Bonsoir,

Merci de ta réponse ;)

Pour max/minval j'avais trouvé sur internet mais je pense pas qu'on est censé les utilisées puisqu'on l'a pas vu en cours (enfin il faut utiliser plein de trucs qu'on voit pas (ou mal) en cours mais bon ^^

J'ai tenté une autre approche et ça a l'air de fonctionner :)
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 program MinMax implicit none real, dimension(999)::t real :: maximum,minimum integer :: x call random_number(t) maximum=t(1) minimum=t(1) do, x=2,999 if(t(x).ge.maximum) then maximum=t(x) endif if(t(x).le.minimum) then minimum=t(x) endif enddo print *, maximum,minimum end program

Bonsoir

Citation:

J'ai tenté une autre approche et ça a l'air de fonctionner

Oui, ca me semble correct.
Juste 3 petites remarques :

- je ne suis pas sûr que ce soit une très bonne idée de choisir x comme nom de variable entière. Ca peut à un moment donné créer une erreur par inadvertance.
Habituellement les variables entières (et surtout les variables de boucles) sont plutôt i,j,k

- autant prendre tout de suite l'habitude des écritures réactualisées par la norme Fortran 95 :
.ge. s'écrit >=
.le. <=
.gt. >
.lt. <

- tu peux tester dans la même boucle min et max.

Ton programme devient alors :
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 program MinMax implicit none real, dimension(999)::t real :: maximum,minimum integer :: i call random_number(t) maximum=t(1) minimum=t(1) do i=2,999 if(t(i) >= maximum) then maximum=t(i) elseif (t(i) <= minimum) then minimum=t(i) endif enddo print *, maximum,minimum end program