Discussion :

[junigoku]

Bonjour,
Je débute en Fortran et j'ai de nouveau besoin de l'aide de la communauté.
J'ai écrit un petit programme qui, dans une série de nombres, détermine ceux qui sont premiers. Ceux-ci sont alors est classés dans des tableaux lignes par lignes, une colonne après l'autre. J'arrive à écrire (write) des tableaux de taille connu, de façon séquentielle. Mais, j'ai donc 3 problèmes:
- je suis obligé de mettre une condition (instruction if) sur le remplissage du tableau afin qu'il soit écrit: tant que celui-ci n'est pas plein, il ne sera pas écrit. J'ai compensé, en demandant l'écriture du dernier tableau, plein ou pas, lorsque la série de nombre à tester est fini. Je me demande s'il n'y a pas un moyen pour éviter cela, si oui comment?
-ma deuxième préoccupation porte sur le dernier tableau. Au début et à chaque cycle, le tableau est réinitialisé à 0. De ce fait lorsque j'écris le dernier tableau, il contient des 0 dans les 'cases' non remplis. Ma question est: comment faire pour avoir juste des cases vides en lieu et place des 0?
- enfin, je souhaite pouvoir écrire chaque tableau dans un fichier (texte pour faire simple) losque celui est prêt, plein ou pas, en serie avec des noms consécutifs. C'est à dire, si pour une série de nombre je peux remplir i tableaux (xlines, ycolon) alors j'aurais 1 fichier présentant successivement les i tableaux tableaux (tab1, tab2, ..., tabi) avec des noms indicatifs (tabi).
Je sais que c'est beaucoup mais je patauge à l'intérieur sans succès depuis un certain temps déjà. Je suis prêt à apprendre et je suis preneur de toutes explications, tous conseils et autres lignes de codes qui peut me faciliter la compréhension de la tâche à accomplir. je joint le code de mon programme.
Merci d'avance

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
 
program prime_func
      implicit none
      integer, parameter :: nlinemax= 4, ncolumnmax = 4
      integer, dimension (nlinemax, ncolumnmax) :: tt
      integer:: i, j, k, ntest, mtest, ierr, a, b
      logical:: Lans, Lprimefunc
 
 
      print*,'Entrer two numbers'
      read (*,*) ntest, mtest
      do while (ntest > mtest)
      print*, 'Wrong, give the smallest before'
      read (*,*) ntest, mtest
      end do
 
      tt = 0
      j=1
 
      print*, 'the list of prime number, from', ntest, 'to', mtest
      do i = ntest, mtest
        Lans = Lprimefunc (i, ierr)
 
        if (ierr == 1) then
        else if (ierr == 0) then
            if (Lans .eqv. .true.) then
              b=(j-1)/nlinemax+1
              a=j-(b-1)*nlinemax
              tt(a,b) =i
              j=j+1
                if (j==ncolumnmax*nlinemax+1) then
                  do k = 1, nlinemax
                    write(*,*) tt (k, : )
                  enddo
                  write(*,*)
                  j=1
                  tt = 0
                end if
            end if
        end if
            if (i==mtest) then
                do k = 1, nlinemax
                    write(*,*) tt (k, : )
                enddo
            end if
      end do
      end program prime_func
 
*Lprimefunc
************************************************************************
*                                                                      *
      logical function Lprimefunc (i, ierr)
*                                                                      *
************************************************************************
* Logical prime function                                               *
************************************************************************
*                                                                      *
      implicit none
      integer :: i, idiv, idivmax, ierr
*
* initialization
*
      ierr = 0
 
      Lprimefunc = .false.
*
* condition on error flag value regading the value of the number to be
* tested, and evaluation of the primality
*
      if (i <= 0) then
          ierr = 1
        else if (i == 1) then
        else if (i == 2) then
          Lprimefunc = .true.
        else
          idivmax = int (sqrt (dble (i)))
          do idiv = 2, idivmax
            if (mod (i, idiv) == 0) return
          end do
          Lprimefunc = .true.
      end if
      return
      end

[Sylvain Bergeron]

je suis obligé de mettre une condition (instruction if) sur le remplissage du tableau afin qu'il soit écrit: tant que celui-ci n'est pas plein, il ne sera pas écrit. J'ai compensé, en demandant l'écriture du dernier tableau, plein ou pas, lorsque la série de nombre à tester est fini. Je me demande s'il n'y a pas un moyen pour éviter cela, si oui comment?

Je ne crois pas qu'il y ait d'alternative à ce que tu fais. Tu pourrais améliorer un peu je pense en faisant partir j à 0 et non à 1 de sorte qu'il te donnerait à tout moment le nombre d'éléments dans le tableau. Tu devrais donc l'incrémenter avant de calculer où placer le prochain élément. Au lieu de tester si j est devenu trop grand, tu pourrais alors tester si b > nlinemax, imprimer, vider, réduire b à 1, et placer i dans le tableau :

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
 
j = j + 1
b = (j-1)/nlinemax+1
a=j-(b-1)*nlinemax
if (b > nlinemax) then
   do k = 1, nlinemax
      write(*,*) tt (k, : )
   enddo
   write(*,*)
   j = 1
   tt = 0
   b = 1
   a = 1
end if
tt(a,b) =i

Ça me semble plus naturel, mais c'est vraiment une question de style.

Au début et à chaque cycle, le tableau est réinitialisé à 0. De ce fait lorsque j'écris le dernier tableau, il contient des 0 dans les 'cases' non remplis. Ma question est: comment faire pour avoir juste des cases vides en lieu et place des 0?

Tu pourrais transformer le tableau en tableau de caractères pour que les cellules vides contiennent des blancs et non des 0, mais ce serait lourd pour rien. La solution consiste plutôt à calculer la position du dernier élément et à imprimer le tableau partiel :

Code :

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

1
2
3
4
5
6
7
 
b = (j-1)/nlinemax+1
a=j-(b-1)*nlinemax
do k = 1, b - 1
      write(*,*) tt (k, : )
enddo
write(*,*) tt (b, 1:a )

Petit commentaire éditorial : Le test de tableau partiel (if (i==mtest) then) ne devrait pas être dans la boucle. Il devrait être sortie de la boucle et là, tu testes s'il y a quelque chose dedans (si j > 0 ou > 1 selon que j part à 0 ou à 1).

je souhaite pouvoir écrire chaque tableau dans un fichier (texte pour faire simple) lorsque celui est prêt, plein ou pas, en serie avec des noms consécutifs. C'est à dire, si pour une série de nombre je peux remplir i tableaux (xlines, ycolon) alors j'aurais 1 fichier présentant successivement les i tableaux tableaux (tab1, tab2, ..., tabi) avec des noms indicatifs (tabi)

Tu dois introduire un compteur de tableau NbTableau qui part à 1 et que tu incrémentes à chaque fois que tu vides. Quand tu imprimes, tu commence par un write(*,*) "tab",NbTableau.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
program prime_func
      implicit none
      ...
      logical:: Lans, Lprimefunc
      ...
         Lans = Lprimefunc (i, ierr)
         ...
            if (Lans .eqv. .true.) then
              ...

Dernier commentaire de style.

Lans est logique et contient déjà vrai ou faux. Tu n'as donc pas à tester si Lans est équivant à vrai, tu n'as qu'à faire if (Lans) then. Évidemment que cette syntaxe n'est pas très intuitive, mais c'est surtout parce que le nom de ta variable ne l'est pas. Si tu l'appelais EstPremier, ça donnerait :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
program prime_func
      implicit none
      ...
      logical:: EstPremier, Lprimefunc
      ...
         EstPremier = Lprimefunc (i, ierr)
         ...
            if (EstPremier) then
              ...

[junigoku]

Merci