Programme avec double précision

**feynman** · 19/02/2008, 15h26

Bonjour,
j'ai écrit ce programme qui calcule la solution d'un système triangulaire supérieur.
Le problème est que, si j'utilise double précision, je n'obtiens pas des valeurs de A ni de X (A étant la matrice et X le vecteur solution); alors où est le truc ?
Merci pour votre aide
Voilà mon programme :

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
   program trianglee
              parameter(n=3)
              double precision A(n,n),b(n),X(n)
              integer i,j
              do i=1,n
                 do j=1,n
                    if((i.lt.j).or.(i.eq.j)) then
                       A(i,j)=float(i*j)
                     else
                       A(i,j)=0.
                     end if
                   enddo
               enddo
 
              print 10,((A(i,j),j=1,n),i=1,n)
10            format('A=',3(/,1X,3(D4.1,1X)))
              do i=1,n
                 b(i)=1.
              enddo
              Call triangle(n,A,b,X)
              print 20,(X(i),i=1,n)
20            format('X=',3(D4.1,1X))
              end
 
                subroutine triangle(M,C,D,Y)
 
                integer j,i
                double precision C(M,M),D(M),Y(M),S
                Y(M)=D(M)/C(M,M)
                   do i=M-1,1,-1
                      S = 0.
                      do j=i+1,M
                          S=S+C(i,j)*Y(j)
                      enddo
                    Y(i)=(D(i)-S)/C(i,i)
                    enddo
                return
                end

**FR119492** · 19/02/2008, 16h11

Salut !

Tu es vraiment incorrigible.

Tu ignores toujours l'instruction Implicit None.
Tu nous dis que tu ne trouves pas la solution, mais tu ne nous dis pas ce que tu trouves.
Tu écris ((i.lt.j).or.(i.eq.j)) alors que (i.le.j) serait beaucoup plus simple.
Tu utilises un format D4.1 alors que tu n'as manifestement pas compris la signification du 4 et du 1.
Tu ne semble pas avoir encore compris qu'avant d'appeler à l'aide, tu devrais chercher un peu toi-même.
La méthode la plus simple pour déboguer un programme consiste à imprimer suffisamment de résultats intermédiaires.

Jean-Marc Blanc

**feynman** · 19/02/2008, 16h53

Envoyé par FR119492

Salut !

Tu es vraiment incorrigible.

Tu ignores toujours l'instruction Implicit None.
Tu nous dis que tu ne trouves pas la solution, mais tu ne nous dis pas ce que tu trouves.
Tu écris ((i.lt.j).or.(i.eq.j)) alors que (i.le.j) serait beaucoup plus simple.
Tu utilises un format D4.1 alors que tu n'as manifestement pas compris la signification du 4 et du 1.
Tu ne semble pas avoir encore compris qu'avant d'appeler à l'aide, tu devrais chercher un peu toi-même.
La méthode la plus simple pour déboguer un programme consiste à imprimer suffisamment de résultats intermédiaires.

Jean-Marc Blanc

Cher Jean Marc,
1.Oui je n utilise pas implicit none je ne vois pas son importance
2.Voila ce que je trouve :

Code :

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

1
2
3
4
5
6
7
   elarwadi@lmarech3:~$ g77 -o triangle triangle.f
elarwadi@lmarech3:~$ ./triangle
A=
 **** **** ****
 **** **** ****
 **** **** ****
X=**** **** ****

3. Si je comprends ce que le nombre 4 et le nombre 1 represente:
si tu as Dw.d alors le w c est le nombre de place desirés et le d est le nombre des nombres apres la virgules
voila

**feynman** · 19/02/2008, 17h08

Quand je met real a la place de double precision ca marche, mais quand je le remplace par double precision, je tombe dans le truc

**gregory2526** · 19/02/2008, 19h12

Il faut bien être clair sur l'intérêt du IMPLICIT NONE

Il oblige à déclarer le type de chaque variable. Sans cela, toutes les variables sont des réel, sauf celles dont la première lettre est entre I et P (il me semble)

L'un des intérêts :
Si par exemple tu te trompe dans un nom de variable (ex : tu as une variable "epsilon" et a un moment donné tu écris "epslion"), le compilateur va de mettre un message d'erreur et tu n'auras pas de problème. Si tu n'a pas utilisé implicit none, tu n'auras pas d'erreur de compilation mais une erreur à l'utilisation du programme, et tu auras plus de mail à découvrir le problème.

**TheOyoStyledMan** · 19/02/2008, 20h16

Bonjour,

je te prie de bien vouloir comprendre l'intérêt du IMPLICIT NONE. Avec moi cela fera trois personnes qui te le diront.

Merci gregory2526 pour ton explication.

PS: on ne te dit pas cela pour t'embêter, mais sincèrement, mon boulot consiste en partie à corriger ces genres d'erreurs et c'est la première chose que l'on regarde (et qui nous permet de "juger" le code auquel on a à faire). Mettre un IMPLICIT NONE permet premièrement à la personne qui programme d'être plus claire et sûre sur ce qu'elle veut faire et deuxièmement à une personne qui relit de mieux comprendre le code.

**FR119492** · 19/02/2008, 23h30

Bonjour !

Peut-être qu'à trois ce sera suffisant pour le Implicit None. On a rarement vu une telle unanimité sur ce forum.

Pour Gregory2625: en fait, c'est de i à n.

Pour Feynman: Alors, ce n'est pas le 4.1, mais le D que tu n'as pas compris.

Jean-Marc Blanc

**feynman** · 20/02/2008, 12h35

Pour Jean Marc,
La lettre D c est pour indiquer qu on travail avec double precision
quand meme j arrive pas a voire pourquoi j obtient pas des résultats (comme j ai indiqué la haut) en utilisant double precision

**feynman** · 20/02/2008, 12h46

Je penses que le truc est ici :

Code :

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

    A(i,j)=float(i*j )

Alors comment transformer le integer en double precision?
pour le real c est connu, on fait real(i*j)
merci

**FR119492** · 20/02/2008, 22h33

Salut !

La lettre D c'est pour indiquer qu'on travaille avec double precision

Essaie de remplacer ton D4.1 par un D15.3 et tu comprendras.

Le D n'a rien à voir avec la précision avec laquelle on travaille, c'est-à-dire le nombre d'octets des variables stockées en mémoire et traitées par le processeur. Il indique qu'on affiche en notation scientifique avec 3 chiffres pour l'exposant.

Jean-Marc Blanc

**feynman** · 21/02/2008, 08h13

Ok merci Jean Marc

**Ladgalen** · 21/02/2008, 14h32

Pour contrarier les gens sur le IMPLICIT NONE

mon prof de fortran nous avait traumatisé avec ça. Pour elle c'était la première chose à écrire.

Je comprend toute les règles de sécurité que vous avez mentionnée. Mais quand j'écris des programmes
implicit double precision (a-h,o-z) est vraiment agréable car on a pas à déclarer les entiers des boucles par exemple. Et d'autre part les tableau on doit forcément les déclarer ce qui limite les erreurs.

Pour ce qui est de la lisibilité le fait que tous les entiers commence par des lettres de i à n ça évite de se poser des questions ou de chercher dans la liste des déclarations. J'ai vu des programmes avec des déclarations de 20 lignes ... c'est lourd surtout pour déclarer une variable temporaire dont on ne se sert que ponctuellement.

Je pense que du point de vue de la robustesse d'un programme c'est vrai que le implicit none a un interet. Mais du point de vue pratique quand comme moi on écrit toute la journée des programmes entre 20 et 200 lignes qui sont en fait des sortes de scripts plus que des programmes, le implicit est quand même avantageux ?

Non ? Jean Marie ? Gregory ? Qu'elle est votre vision de la chose ? il faut faire du code propre point barre ?

Moi j'ai appris le F90 et je suis tomber dans un labo où les gens qui programment utilisent le F77 et je me suis laisser un peu influencer par la dangereuse souplesse du F77 tout en gardant les notations pratiques du F90 (le == >= et les additions vectorielles ...). D'autant plus que la personne avec qui je travaille est un inconditionnel du implicit real*8 et du common !

**FR119492** · 21/02/2008, 15h55

Salut Ladgalen !

C'est vrai que si

tu es suffisamment expérimenté;
tes programmes sont petits;

le Implicite None n'est pas absolument indispensable. Mais pense à l'ingénieur électricien qui veut calculer le courant dans une résistance de 500 ohms soumise à une tension de 20 volts:

Code :

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

1
2
3
      R=500.
      U=20.
      I=U/R

Personne n'est obligé d'avoir de bonnes habitudes, mais ça évite bien des ennuis.
Il y a quelques années, je donnais un cours de programmation et j'avais, dans un premier temps, fait écrire par mes étudiants un petit programme à me remettre sur disquette. La leçon suivante, j'ai redistribué ces disquettes, chaque étudiant recevant celle d'un camarade, et je leur ai demandé d'apporter certaines modifications au programme. Ah!, si tu les avais entendu pester contre ceux qui n'avaient pas suivi des règles strictes de programmation!

Jean-Marc Blanc

PS. Le listing du plus gros programme que j'ai écrit faisait environ 500 pages.

**Ladgalen** · 21/02/2008, 16h28

Suffisamment expérimentés je ne pense pas que ce soit mon cas, on l'est jamais assez. Mais par contre il est vrai que je n'écris que de petits programmes.

**Sylvain Bergeron** · 21/02/2008, 17h49

Pourquoi toujours mettre implicite none ?

Parce que dès que le programme gagne en importance, c'est le chemin le plus facile d'arriver à la réponse. Il y a plein d'exemple pour illustrer les erreurs possibles qui font perdre du temps (beaucoup plus que le temps « perdu » à déclarer les variables).

En général, le problème que j'ai observé avec les implicites, ce n'est pas que le type n'est pas bon, c'est que je change le nom de la variable entre les parties du programmes dès que le programme ne s'affiche pas en entier dans 1 écran (n, nb, nbr, ... sans compter les fautes de frappe : Objet, Ovbjet, ...). Et là ton programme fait une division par zéro, un underflow, retourne la mauvaise réponse, et tu passe du temps à lire, relire, rerelire, pour finalement mettre des prints partout, pour finalement découvrir qu'à la ligne 123, tu utilises NbCollonne et non NbColonne.

**gregory2526** · 22/02/2008, 11h24

a mon avis le implicit none est toujours utile, quelle que soit la taille du programme.

Dans le cas d'un tout petit programme, l'ajout d'une ligne pour le implicit none et de quelques lignes pour la déclaration des quelques variables ne coutent pas grand chose, et permet d'éviter les fautes de frappes (très courantes quand on tape un peu vite, et très difficile à repérer). Cela permet de plus de donner des noms de variables plus explicites pour un domaine particulier (ex électrique de FR119492)

Dans le cas d'un gros programme:
j'ai eu a travailler sur un code de 8000 lignes, en fortran 77.
Il n'était pas programmé par des francophones ou des anglophones.

Ils avaient utilisé une déclaration implicite

==> je débutait en fortran a l'époque. j'ai mis du temps à comprendre qu'ils utilisaient une déclaration implicite, et il a fallu que je cherches comment cela fonctionnait. A chaque fois que je voyais une nouvelle variable, il fallait que je réfléchisse pour savoir si elle faisaient partie des entiers ou non (et oui, il faut quand même un certain temps pour que ça devienne naturel)

On voit ici que l'implicit none est utile lorsque le programme est susceptible d'être modifié ou relu par quelqu'un d'autre
==> dans certains cas, le type était précisé. Cela ne facilite pas le débuggage, car du coup il faut systématiquement vérifier que pour la variable qui pose problème, le type n'a pas été déclaré quelque part.

Pour conclure, dans le cas d'un gros programme, IMPLICIT NONE
Dans le cas d'un programme sur lequel travaillent plusieurs personnes, IMPLICIT NONE
Dans le cas d'un petit programme utilisé par soi-même, ça ne coute pas grand chose de plus, et on ne sait jamais ce que peut devenir un code. S'il est porté un jour a être distribué, l'implicit none facilitera la vie des autres programmeurs

Ensuite, chacun ses préférences, si tu maitrise la programmation de cette manière, c'est à toi de voir

**feynman** · 22/02/2008, 13h49

Envoyé par FR119492

Salut !

Essaie de remplacer ton D4.1 par un D15.3 et tu comprendras.

Le D n'a rien à voir avec la précision avec laquelle on travaille, c'est-à-dire le nombre d'octets des variables stockées en mémoire et traitées par le processeur. Il indique qu'on affiche en notation scientifique avec 3 chiffres pour l'exposant.

Jean-Marc Blanc

Je ne suis pas totalement d accord avec toi Jean Marc!
quand meme j ai lu dans un livre que : "D = indicatews double precision format "

**FR119492** · 22/02/2008, 14h06

Salut !

Tu confonds deux choses:

Le format sous lequel les nombres sont stockés en mémoire et traités par le processeur, en principe selon la norme ISO/IEEE/ANSI 754. Pour des nombres réels, ce peut être sur 32 bits (Real*4) ou 64 bits (Real*8). C'est déterminé par la déclaration des variables correspondantes.
Le format de lecture-écriture, qui, pour des valeurs réelles, peut être F si tu veux les écrire en virgule fixe, E si tu veux les écrire en notation scientifique avec un exposant à 2 chiffres décimaux et D pour la notation scientifique avec un exposant à 3 chiffres. Le format D est nécessaire lorsque la valeur absolue de l'exposant excède 99, ce qui ne peut se produire qu'avec des nombres stockés en mémoire avec 64 bits, c'est-à-dire en double précision.

Jean-Marc Blanc

Programme avec double précision

Fortran

Discussions similaires

Partager

Partager