Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Initiation au Fortran et exemple d'inversion d'une matrice
(Article écrit par Xavier Leclercq et extrait d'Amiga News - novembre 1992)
|
|
Avant de crier au scandale en déclarant quelque chose du style "le Fortran c'est vieux et dépassé !",
laissez-moi quelques lignes de répit pour défendre la cause de ce langage. Car, première chose,
le Fortran est un langage de programmation...
Je vais aborder le sujet en pensant au débutant qui "débarque" sur l'Amiga et décide de se lancer, corps
et âme, dans la joie de la programmation. Il peut alors se tourner vers un langage qui est directement
disponible et qui est livré, manuel en main, avec n'importe quel ordinateur, c'est-à-dire le BASIC.
En l'occurrence, il s'agit d'une version "améliorée" d'un BASIC qui a fait la fortune de son programmateur,
Bill Gates (qui pèse plus de 7 milliards de dollars à 36 ans !) et qui est le fondateur de Microsoft...
Je ne suis pas spécialement un fan de ce genre de langage, mais il est clair qu'en programmation, le plus
difficile est de définir ses besoins plutôt que de choisir par défaut tel ou tel langage. En clair et
sans décodeur, le BASIC est donc un outil comme un autre avec lequel il est possible de réaliser du très bon travail.
Le problème est tout autre. Mis à part la mauvaise réputation du BASIC (programmation sauvage, code spaggetti)
le débutant, qui est livré à lui-même, tentera de bricoler en collant une suite d'instructions, bout à bout,
pour obtenir le programme de ses rêves. Et, en termes d'apprentissage, le résultat approchera plutôt du cauchemar.
En effet, le manuel livré avec votre AmigaBasic est un manuel de référence, mais n'est pas du tout un manuel d'initiation,
d'où le problème... Et les mauvaises habitudes verront le jour : on ne pense pas à déclarer les variables ni à les initialiser
ni à commenter le programme et j'en passe. Pourquoi ? Tout simplement, parce que BASIC est, on ne peut plus
permissif, et donc un très mauvais langage d'initiation à la programmation sans un bon encadrement.
Les autres choix
La possibilité du BASIC mise dans la "trashcan", il nous reste... le C ? Non, car le C (avec l'assembleur) est
un langage à l'approche trop technique pour le débutant. L'assembleur, qui est de loin le langage le plus simple
(normal puisqu'il est présent dans n'importe quel autre), est rarement abordable pour le débutant car sa compréhension
passe par une vision globale du fonctionnement de la structure d'un ordinateur. Le Pascal, quant à lui,
est assez similaire du Fortran (très proche, en fait) mais quand même un peu plus complexe.
Le Fortran est pour ainsi dire le bas de l'échelle : si vous parvenez à gravir l'échelon de sa compréhension,
vous pourrez vous envoler plus tard vers des sommets (restons modestes : l'ignorant n'est-il pas
celui qui déclare connaître tout ?). Je vais donc faire les présentations.
Il existe actuellement à ma connaissance deux compilateurs Fortran-77 sur Amiga :
l'Absoft Fortran F77 Compiler et le BC-Fortran77 Compiler. Ce dernier est présent
sur Fish 470, dans le domaine public.
Il existe néanmoins une grande différence entre le BCF et l'AbSoft : le prix et les performances.
Si le premier est gratuit, le second coûte plus de 2000 FF et est un outil professionnel...
L'AbSoft permet même d'obtenir un code exécutable optimisé pour un 68020 ou 60830 et sans
doute bientôt (si ce n'est déjà fait) pour 68040.
Un langage d'initiation
Le Fortran est un bon langage d'initiation, car il est simple (beaucoup plus simple que le BASIC)
et demande de la rigueur dans la conception de ses codes sources. Par exemple, plus question de ne
pas déclarer les variables que l'on utilise dans son programme. Le BASIC utilise un interpréteur, ce
qui signifie qu'une boucle écrite en assembleur pêchera les instructions (qui se nomment Token
sous leurs formes codifiées) et les interprètera, au fur et à mesure de leur apparition dans le
code source. Si vous demandez dix fois l'exécution de votre programme par l'instruction "RUN",
l'interpréteur traduira en langage machine et exécutera le tout par dix fois.
Il ne garde pas de traces d'une exécution précédente, il doit tout retraduire à chaque demande
d'exécution (les puristes ne m'en voudront pas j'espère, d'expliquer ainsi les choses). Le Fortran,
comme le C par exemple, est disponible sous forme d'un compilateur. Celui-ci n'est pas une bête de travail,
car si vous devez exécuter le programme dix fois, le compilateur ne traduira votre source qu'une
seule et unique fois. En réalité, l'Amiga interprète plus qu'il ne compile, parce qu'il existe au plus
bas niveau de traduction le microprocesseur qui lui aussi est un interpréteur traduisant les suites de
macro-instructions machines, en une séquence micro-programmée du niveau de l'électronique.
Le compilateur est donc une interface entre ce que vous exigez et les instructions machine qui en
résultent. La manière dont le compilateur traduira le code source, répond en Fortran à des normes
très précises. L'autre avantage énorme de ce langage est donc la portabilité. Sous ce vocable
barbare se cache le fait qu'un même listing Fortran pourra être tapé sur un PC, Amiga ou un mini-ordinateur
sans problèmes : il suffit de ne pas s'éloigner de la norme (il existe également une norme en C par exemple).
Le BCF et l'Absoft sont issus de la norme F77 (qui n'est pas la dernière mais qui est la plus utilisée).
Pour être un peu plus pragmatique, je signale quand même que le compilateur BCF est très gourmand en
mémoire (la documentation indique qu'il nous faut 1 Mo de mémoire mais je suis d'avis que la barre
doit être placée plus haut : 2 Mo me semblent un minimum...).
Entrons donc dans le vif du sujet.
A l'installation, BCF (compilateur) et BCL (éditeur de liens) doivent être copiés dans le répertoire
SYS:C. De plus, les fichiers BCRTSY et MATHLIB doivent être copiés dans le SYS:S.
Déclaration des variables
Un programme Fortran débute toujours par des déclarations de variables et se termine par une
déclaration de fin (END). Chaque ligne de code est divisée en quatre zones. La première zone
de la colonne 1 à 5 contient si nécessaire un numéro d'instruction. La deuxième zone est la colonne
6 qui contient un caractère pour indiquer une ligne de continuation. La troisième zone va de la colonne 7 à 72
et contient les instructions Fortran. Enfin, la dernière zone (73 à ...) sert à insérer des
commentaires ou à numéroter de très longs programmes. Un "C" en première ligne signifie une ligne
de commentaire. Exemple :
"INTEGER" signifie entier, "REAL" réel, les variables qui suivent seront déclarées soit en "REAL"
soit en entier de manière explicite. Il existe également des déclarations implicites. Par exemple
toutes les variables dont le nom débute par I, J, K, L, M ou N sont des entiers par défaut. Un
nom de variable débutant par une autre lettre de l'alphabet sera en "REAL",
par défaut (donc sans déclaration explicite "NBOUCLE" est un entier et "BOUCLE" est un réel).
"CHARACTER" déclare des variables de type alphabétique et "DOUBLE"
des réels en double précision. L'exemple ne marchera pas avec l'AbSoft car "Write (*,*)"
signifie l'écriture à l'écran mais "*" n'est pas un canal de sortie de la norme F77.
Pour que l'exemple fonctionne dans la norme, il vous faut d'abord ouvrir un fichier (ou
retrouver dans la documentation, le canal de sortie affectée par le compilateur).
Le fichier est fermé automatiquement mais vous pouvez également exiger sa fermeture (CLOSE (1)).
Le "1" est le canal de sortie de ce fichier et l'instruction "FORMAT"
est une instruction qui formate la sortie selon vos désirs et doit toujours être précédé d'un
numéro de ligne référencé par l'instruction "WRITE" (canal de sortie, numéro de ligne du "FORMAT").
...ce qui donne comme résultat : ABCDEFGHIJ 26 3.14 --> il y a un espace entre "J" et "26"
car le format est prévu pour la sortie d'un entier à trois positions et deux espaces entre le "6"
et le "3" car le format de sortie est prévu pour un réel couvrant six positions et "3.14"
(point de la virgule compris) ne prend que quatre positions.
Mais là où le Fortran bat tous les autres, c'est bien dans les calculs de matrices. Il est capable
de créer des boucles implicites très rapides.
Pour lire une matrice (elle est placée dans un fichier) on utilisera par exemple, le programme suivant :
La règle suivante est importante : lorsque le format de sortie est exploré (316),
il y a passage à la ligne suivante. Le fichier d'entrée "MATRICE.DAT" est le suivant :
- 416 9
513 8
8 4 5
4 2 4
3 8-4
6 7-7
4 6 3
...et celui de sortie (1> type MATRICE.RES) donne :
MATRICE A
- 4 16 9
5 13 8
8 4 5
Mais puisqu'un exemple vaut mieux que de grands discours, je vous propose un exemple de programme
qui peut-être compilé avec BCF et qui manipule déjà pas mal de concepts : il s'agit d'inverser une
matrice.
|