Fortran

Cet article possède un paronyme, voir Fortemps.

Fortran

* * *

Date de première version  | 1957
Paradigme | Multi-paradigme : impératif (procédural, structuré, orienté-objet), orienté tableaux, parallélisme, générique
Auteur  | John Backus
Développeur  | John Backus & IBM
Dernière version | Fortran 2023 (ISO/IEC 1539-1:2023) (le 17 novembre 2023, il y a 19 mois)
Typage  | fort, statique
Normes | ISO/IEC 1539
Influencé par  | Speedcoding
A influencé  | Algol 58, BASIC, C, DOPE, PL/I, PACT I, MUMPS, Ratfor
Implémentations  | Intel Fortran Compiler, GFortran, IBM XL Fortran, NVIDIA HPC SDK, Lahey/Fujitsu, Absoft, Cray, NAG, Arm, NEC, Silverfrost, Oracle, Flang, LFortran, etc.
Système d'exploitation | Multiplateforme
Licence | Licence MIT
Site web | fortran-lang.org
Extension de fichier | f, for et f90
modifier
Supercalculateur IBM Blue Gene/P. Simulation en Fortran de l'accrétion autour d'un trou noir (www.bhac.science). Densité à gauche et densité d'énergie magnétique à droite (zoom).

Fortran (mathematical FORmula TRANslating system) est un langage de programmation généraliste dont les domaines de prédilection sont le calcul scientifique et le calcul numérique. Il est utilisé aussi bien sur ordinateur personnel que sur les superordinateurs, où il sert d'ailleurs à tester leurs performances dans le cadre du classement TOP500 des superordinateurs les plus puissants au monde, entre autres grâce à la bibliothèque LINPACK.

Le nombre de bibliothèques scientifiques écrites en Fortran, éprouvées et améliorées pendant de longues années, et les efforts continus consacrés aux compilateurs pour exploiter au fil des décennies les nouvelles possibilités des calculateurs (vectorisation, coprocesseurs, parallélisme) ont maintenu l'usage de ce langage qui ne cesse d'évoluer.

Parmi les fonctionnalités ajoutées ces dernières décennies, on citera le calcul sur les tableaux (qui peuvent comporter jusqu'à quinze dimensions), la programmation modulaire, la programmation générique (Fortran 90), le calcul haute performance (Fortran 95), la programmation orientée objet et l'interopérabilité avec les bibliothèques du langage C (Fortran 2003), la programmation concurrente et le calcul parallèle à l'aide des cotableaux (Fortran 2008), des équipes, des évènements et des sous-routines collectives (Fortran 2018), en plus des interfaces OpenMP, OpenACC et de la bibliothèque Message Passing Interface. La norme actuelle est Fortran 2023, publiée le 17 novembre 2023. Les discussions ont commencé sur le contenu de la future norme Fortran 2028.

## Historique et versions

[modifier | modifier le code]

Influences de Fortran, Algol et Cobol

Projet lancé en 1954 et aboutissant à une première version en 1957, Fortran est le premier langage de programmation de haut niveau, suivi notamment par Lisp (1958), Algol (1958) et COBOL (1959). Il est le premier langage à être normalisé[1],[2], au milieu des années 60, et est devenu une norme ISO en 1980. Un astéroïde a été nommé 9548 Fortran (1985 CN) en son honneur[3].

Le nom du langage est généralement écrit en majuscules (FORTRAN) pour désigner les versions du langage antérieures à la norme Fortran 90[note 1] car à l'époque les lettres minuscules ne font pas partie du jeu de caractères du langage. Par contre, il est toujours écrit avec une majuscule à partir de Fortran 90. Enfin, depuis environ 2010 les titres des livres en anglais utilisent souvent l'expression modern Fortran (Fortran moderne) pour distinguer la forme actuelle du langage de ses formes historiques.

### Période classique du Fortran

[modifier | modifier le code]

* 1953 : John Backus, jeune ingénieur titulaire d'une maîtrise de mathématiques recruté en 1950 chez IBM, développe pour l'IBM 701 le système Speedcoding, un interpréteur qui facilite la programmation en particulier pour le calcul en virgule flottante. En décembre, il rédige une lettre à l'attention de son supérieur Cuthbert Hurd (en)[4] pour lui proposer le projet FORTRAN destiné à l'IBM 704. L'objectif est d'accélérer considérablement le développement et le débogage des programmes, jusqu'alors écrits en langage machine, afin de réduire leur coût d'exploitation, qui pour moitié provient des salaires des informaticiens et pour moitié des machines. Backus insiste pour que l'IBM 704 devienne la première machine commerciale dont le processeur supporte directement les nombres en virgule flottante.
* John Backus (1924-2007), inventeur du FORTRAN, lauréat du prix Turing en 1977.1954 : le groupe de recherche de Backus, le « Programming Research Group » basé à New York, rédige un rapport intitulé Preliminary Report, Specifications for the IBM Mathematical FORmula TRANslating System, FORTRAN[5], daté du 10 novembre 1954. Il faut encore deux ans d'efforts pour terminer le premier compilateur FORTRAN (25 000 lignes[6])[note 2], désigné alors par le mot anglais translator (traducteur). Dès le départ, ce compilateur est conçu pour fournir un code très optimisé, en particulier pour le calcul sur les tableaux et le traitement des boucles imbriquées, quasiment aussi rapide que celui qu'aurait écrit un programmeur en langage machine (objectif alors accueilli avec scepticisme par les clients d'IBM). D'après Backus lui-même[4], le développement du langage ne peut pas être séparé de la conception du compilateur et c'est même sur le compilateur que porte l'essentiel de l'effort initial. Le langage est défini au fur et à mesure, avec comme guide principal la simplicité de la syntaxe.
* 1957 : le compilateur FORTRAN est déployé courant avril sur tous les IBM 704, sur bande magnétique[4], avec son manuel intitulé Preliminary Operator's Manual[7]. Fin 1957, un manuel plus complet, le Programmer's Primer[8] rédigé par Grace E. Mitchell, est édité. FORTRAN est un succès et une révolution car il n'est plus nécessaire d'être un expert de l'ordinateur pour écrire et déboguer des programmes. Mary Tsingou, physicienne et mathématicienne au Los Alamos National Laboratory et qui travailla avec Fermi, Pasta et Ulam, dira ainsi : « Quand le Fortran est arrivé, c'était presque comme le paradis »[9]. D'après la revue Nature (2021), ce compilateur fait partie des dix codes informatiques ayant le plus marqué la science[10]. L'instruction `GO TO` permet de sauter à une ligne numérotée par une étiquette. Le `IF` de cette première version est arithmétique : `IF (A-B) 10, 20, 30` permet de sauter aux instructions d'étiquettes 10, 20 ou 30 selon que l'expression A-B est négative, nulle ou positive.
* 1958 : FORTRAN II[4],[11],[12] apporte les fonctions `FUNCTION` et les sous-programmes `SUBROUTINE` que l’on appelle par l’instruction `CALL`, ce qui permet aux programmeurs de se répartir plus facilement le travail. L'instruction `COMMON` permet à plusieurs sous-programmes de partager des données communes. Le nouveau compilateur est également plus rapide que le compilateur Fortran I : il permet en particulier de découper un long programme en plusieurs parties pouvant être compilées indépendamment.
* 1959 : FORTRAN III n'est déployé que sur une vingtaine de machines. Il est possible d'insérer des routines en langage assembleur symbolique dans le code mais cette fonctionnalité sera abandonnée car elle compromettrait la portabilité des programmes écrits en FORTRAN. Le groupe de Backus n'est plus chargé du développement du FORTRAN, activité transférée à l'Applied Programming Department. Backus préconise le développement de deux compilateurs[4] : un compilateur rapide pour la phase de débogage et un compilateur optimiseur pour le programme final. Mais l'idée n'est pas suivie.
* 1960 : FORTRAN devient l'un des premiers langages multi-plateforme, des compilateurs devenant disponibles[13] sur quelques machines d'autres constructeurs qu'IBM.
* 1962 : FORTRAN IV[14] introduit les nombres réels double précision, les complexes et les booléens, ainsi que les opérateurs `.AND.`, `.OR.` et `.NOT.`. Le `IF` logique permet d'écrire par exemple `IF (A .GE. B) GOTO 10` (aller à 10 si A est supérieur ou égal à B). Le type des variables peut désormais être déclaré explicitement. Il est nécessaire de modifier les programmes écrits en FORTRAN II : le traducteur automatique SIFT (SHARE Internal FORTRAN Translator)[15] est mis à disposition. Cette même année, chaque compilateur apportant ses extensions et variantes, un comité des normes FORTRAN est formé afin de normaliser le langage pour qu'il soit portable d'une machine à l'autre.
* 1962 : le processus de normalisation du langage est lancé avec le comité ASA X3.4.3[2]. Des brouillons sont publiés en 1964 dans Communications of the ACM.
* 1965 : ECMA-9 FORTRAN[16] est la première norme FORTRAN, publiée en avril 1965 par l'ECMA (European Computer Manufacturers Association) dans le cadre d'une collaboration avec l'ANSI (American National Standards Institute). Il s'agit en fait d'une version du langage intermédiaire[1] entre les deux niveaux du langage définis dans la norme FORTRAN 66.
* 1966 : FORTRAN 66 (ANSI X3.9-1966)[17] est la norme développée par l'ANSI, essentiellement basée sur FORTRAN IV. Elle définit en fait deux niveaux du langage : le FORTRAN proprement dit et une version simplifiée, le Basic FORTRAN. Le langage FORTRAN est le premier langage de programmation à avoir été normalisé.
* 1972 : l'ISO publie l'ISO Recommendation for Fortran (R1539), constituée des deux niveaux du langage définis dans FORTRAN 66 et du niveau intermédiaire défini par l'ECMA FORTRAN. Mais il ne s'agit que d'une recommandation.
* 1977 : John Backus reçoit le Prix Turing[18] pour « ses contributions profondes, influentes et durables à la conception de systèmes de programmation pratiques de haut niveau, notamment par ses travaux sur le FORTRAN, et pour ses publications pionnières sur les procédures formelles pour la spécification des langages de programmation. »
* 1978 : FORTRAN 77 (ANSI X3.9-1978)[19],[20] est une évolution majeure. Comme pour FORTRAN 66, la norme définit deux niveaux du langage : le FORTRAN complet, ou full language, et une version simplifiée, ou subset language. Cette norme inclut en particulier des extensions au langage introduites par les différents compilateurs depuis FORTRAN 66. Elle apporte, entre autres améliorations, la programmation structurée avec les blocs `IF / THEN / ELSE / END IF`, le type de données `CHARACTER` en remplacement des constantes d'Hollerith (en) (qui sont supprimées de la norme), les fonctions `LGE`, `LGT`, `LLE`, `LLT` pour la comparaison des chaînes de caractères, l'attribut `PARAMETER` pour déclarer des constantes, l'attribut `SAVE` pour la persistance des variables locales, etc. Fin 1978, l'extension MIL-STD-1753[21] du département de la Défense américain introduit entre autres le `END DO` en FORTRAN 77 (bien que le label final reste obligatoire), les blocks `DO WHILE / END DO`, l'instruction `INCLUDE`, l'instruction `IMPLICIT NONE` et des fonctions pour manipuler les bits des entiers.
* 1980 : le texte de la norme ANSI X3.9-1978 est adopté par l'ISO et devient la norme ISO 1539-1980[2].

### Fortran moderne

[modifier | modifier le code]

* 1991 : Fortran 90 (ISO/IEC 1539:1991, puis ANSI X3.198-1992)[22] est une version majeure ayant pour objectif de mettre Fortran au niveau des autres langages modernes. La norme apporte en particulier les modules, la récursivité, les arguments optionnels et nommés, la surcharge des opérateurs, une syntaxe pour le calcul sur les tableaux, l'allocation dynamique des tableaux grâce à l'attribut `ALLOCATABLE`, les types dérivés, l'attribut `POINTER`[note 3], l'instruction `IMPLICIT NONE` pour rendre obligatoire la déclaration des variables, les structures de contrôle `SELECT CASE`, les procédures `SYSTEM_CLOCK` et `DATE_AND_TIME` pour accéder à l'horloge du système, etc. Les restrictions concernant la mise en forme des programmes (colonnes 1 à 72) disparaissent : l'écriture se fait en format libre. Afin de rester compatible avec les nombreux codes industriels écrits en FORTRAN (Nastran, bibliothèques NAG et IMSL, etc.), Fortran 90 est conçu de telle façon que FORTRAN 77 en constitue un sous-ensemble.
* 1992 : IEEE 1003.9-1992, volet FORTRAN 77 de la norme POSIX[23].
* 1994 : ISO/IEC 1539-2:1994, qui définit des chaînes de caractères de longueur variable[24]. Cette norme a été révisée en 2000[25].
* 1997 : Fortran 95 (ISO/CEI 1539-1:1997)[26] : quoique mise à jour mineure, cette norme introduit en particulier les instructions `FORALL` et `WHERE` pour le calcul vectoriel, les procédures `PURE` et `ELEMENTAL` et rend obsolescentes certaines fonctionnalités telles que les boucles à compteur réel ou l'instruction `PAUSE`. La procédure `CPU_TIME` permet de mesurer le temps processeur utilisé par un segment de programme.
* 1999 : ISO/IEC 1539-3:1999, qui définit des directives de compilation conditionnelle. Cette norme a été révisée en 2011[27].
* 2004 : Fortran 2003 (ISO/CEI 1539-1:2004)[28] est une révision majeure qui supporte la programmation orientée objet. L'interface avec le langage C est assurée par le module interne ISO_C_BINDING et les mots-clés `BIND` et `VALUE`, qui permettent à un programme Fortran d'accéder facilement aux bibliothèques disponibles en C. Les pointeurs de procédure permettent de choisir lors de l'exécution une procédure à exécuter. Les types dérivés sont améliorés, ainsi que les entrées/sorties. On peut désormais gérer les exceptions en calcul flottant de la norme IEEE 754. La norme apporte également la gestion des caractères ISO 10646, base de l'Unicode. L'intégration avec le système d'exploitation est améliorée avec l'introduction des instructions `get_command_argument`, `get_command`, et `command_argument_count`.
* 2010 : Fortran 2008 (ISO/CEI 1539-1:2010)[29],[30], initialement pensée comme une révision mineure, introduit finalement les co-tableaux (co-arrays) comme paradigme de programmation parallèle. Les traitements sur ces co-tableaux sont effectués par des images (instances parallèles d'un programme Fortran). Cette norme introduit également les boucles `DO CONCURRENT` pour la parallélisation des itérations sans interdépendance. Les modules peuvent désormais comporter des sous-modules. Et les structures `BLOCK...END BLOCK` permettent de déclarer des variables à portée limitée n'importe où à l'intérieur d'une routine. La modularité est améliorée par l'introduction des `SUBMODULE`. De nouvelles procédures intrinsèques sont introduites pour la gestion des bits. De nouvelles constantes sont ajoutées au module `ISO_FORTRAN_ENV`, en particulier les `KIND` des types d'entiers `INT8`, `INT16`, `INT32`, `INT64` et de réels `REAL32`, `REAL64`, `REAL128`.
* 2018 : Fortran 2018 (ISO/CEI 1539-1:2018)[31], considérée comme une révision mineure, introduit en particulier :
* ISO/IEC TS 29113:2012[32] Interopérabilité ultérieure de Fortran avec C
* ISO/IEC TS 18508:2015[33] Caractéristiques parallèles supplémentaires en Fortran : les images peuvent désormais être regroupées en équipes (teams) travaillant sur des tâches différentes. Avec les événements (events), une image peut poster un évènement à destination d'autres images, ou attendre de recevoir un évènement. Les sous-routines collectives (collective subroutines) permettent d'effectuer des tâches simples sur les résultats d'un ensemble d'images, par exemple calculer la somme des valeurs d'une variable dans les différentes images.
* ISO/IEC/IEEE 60559:2011[34] Systèmes de microprocesseurs — Arithmétique flottante
* 2023 : la norme Fortran 2023 (ISO/IEC 1539-1:2023), initialement dénommée Fortran 202x, a été publiée le 17 novembre 2023, après six ans de travail. Le document de référence du comité est disponible[35]. Il s'agit d'une version dite mineure qui apporte de nombreuses améliorations à diverses parties du langage, mais pas de nouveau paradigme de programmation. Par exemple, la longueur maximale des lignes de programme passe de 132 à 10000 caractères, et les expressions conditionnelles, reprenant la syntaxe du C, font leur apparition[36]. De nouvelles fonctions facilitent le passage des chaînes de caractères entre C et Fortran. Les boucles `DO CONCURRENT` peuvent gérer la réduction des variables. Les fonctions `SIMPLE` sont des fonctions `PURE` n'accédant à aucune donnée extérieure (à part leurs arguments).
* La future norme Fortran 2028 devrait en particulier apporter[37] des templates pour la programmation générique, la gestion des tâches asynchrones, un pré-processeur Fortran, la possibilité de définir les KIND utilisés par défaut dans un programme, etc.

## Gouvernance et communauté

[modifier | modifier le code]

### Gouvernance

[modifier | modifier le code]

Fortran fait partie des langages normalisés depuis 1965 et est devenu une norme ISO en 1980[1]. La norme Fortran est actuellement gérée par le groupe de travail ISO/IEC JTC1/SC22/WG5[38], généralement simplement appelé WG5 (pour Working Group 5), qui charge le comité Fortran US INCITS PL22.3 (généralement appelé J3, en référence à son ancien nom ANSI X3J3)[39] de développer le langage. Le WG5 est composé d'experts chargés de faire des recommandations pour faire évoluer le langage. Le J3 est composé de fabricants de matériel, d'éditeurs de compilateurs, d'utilisateurs issus aussi bien de l'industrie que du monde académique.

Chaque révision de la norme peut ajouter de nouveaux paradigmes ou fonctionnalités, éventuellement déjà implémentées par les compilateurs sous forme d'extensions au langage, clarifier des points restés ambigus, mais aussi rendre obsolescentes d'anciennes fonctionnalités. En effet, depuis Fortran 90, les normes comportent systématiquement en annexes une liste des fonctionnalités supprimées et une liste des fonctionnalités obsolètes et donc susceptibles d'être supprimées dans une prochaine révision de la norme. Les compilateurs continuent néanmoins généralement de supporter ces fonctionnalités pour assurer la pérennité des codes déjà développés. Enfin, il s'écoule généralement plusieurs années entre la publication d'une nouvelle norme et la prise en charge intégrale de ses nouvelles fonctionnalités dans les compilateurs[40],[41].

En 1995, le WG5 met en place des rapports techniques de type 2 pour travailler sur des fonctionnalités importantes qui n'auront pas le temps d'être intégrées à la norme en cours de rédaction, mais en constitueront une extension qui pourra être intégrée dans la norme suivante.

En 2019, un dépôt GitHub[42] est créé afin que tous les utilisateurs du langage puissent proposer facilement au comité J3 des évolutions pour les normes futures. Il sert actuellement à proposer des nouveautés pour la norme Fortran 202Y qui succédera à Fortran 2023, comme l'amélioration de la programmation générique, des valeurs par défaut pour les arguments optionnels, etc.

### Communauté

[modifier | modifier le code]

En 1955, IBM crée le groupe d'utilisateurs SHARE afin que ses clients puissent échanger entre eux. John Backus y fait des présentations régulières durant le développement du premier compilateur FORTRAN[43]. En avril 1957, des ingénieurs de Westinghouse y rapportent la compilation du premier programme FORTRAN en dehors d'IBM. Alors que le langage se diffuse, un sous-groupe SHARE y est consacré : le FORTRAN Standard Commitee.

En 1970, la British Computer Society crée le Fortran Specialist Group[44], toujours en activité en 2023, afin de promouvoir le langage, participer à ses évolutions et organiser des échanges entre utilisateurs.

Créé en juillet 1982, le bulletin mensuel FORTRAN Forum[45] a été publié par le SIGPLan (Special Interest Group in Programming Languages) de l'ACM (Association for Computing Machinery) trois fois par an, jusqu'en avril 2020.

Le 29 novembre 1983, un groupe de discussion `net.lang.f77` est créé sur Usenet. Le 7 novembre 1986, il est renommé `comp.lang.fortran` et est toujours l'un des principaux canaux de communication de la communauté Fortran.

La liste de diffusion comp-fortran-90[46] est consacrée aux questions concernant le Fortran à partir de la norme Fortran 90. On peut en consulter les archives jusque 1997, mais l'activité y est désormais très réduite avec seulement six messages postés en 2020.

Début 2020, une nouvelle communauté d'utilisateurs fortran-lang.org est créée[47],[48] afin de fédérer les efforts dans l'écosystème Fortran, sur le modèle de langages plus jeunes. En s'appuyant sur GitHub[49], elle développe en particulier une bibliothèque standard Fortran (stdlib) similaire à celle du C, un gestionnaire de paquets Fortran (fpm) faisant également office de système de compilation, le compilateur interactif LFortran, ainsi que des tutoriels pour apprendre le Fortran moderne. Certaines pages sont traduites en français. La communauté édite une lettre mensuelle résumant ses activités en cours et diffuse des informations sur Twitter. Une visioconférence mensuelle permet à ses membres de discuter des projets à mener. Son forum Fortran Discourse[50] est devenu un lieu central de discussion pour la communauté Fortran. Les projets de la communauté ont reçu l'aide de cinq étudiants lors du Google Summer of Code 2021 (GSoC 2021)[51], et de même pour le GSoC 2022.

L'International Fortran Conference (FortranCon)[52] est créée en 2020. Initialement prévue à Zurich début juillet 2020, elle a lieu en visioconférence à cause de la pandémie de Covid-19. La seconde édition, FortranCon 2021, a également lieu en visioconférence les 23 et 24 septembre 2021. Les vidéos des conférences sont disponibles sur la chaîne YouTube FortranCon. La troisième édition, FortranCon 2025, a lieu les 4 et 5 novembre 2025 sur Zoom.

En avril 2021, Fortran commence à refaire des apparitions dans le top 20 de l'indice TIOBE[53]. En 2024, il a passé les huit derniers mois dans le top 10.

## Applications

[modifier | modifier le code]

Écoulement autour d'un cylindre calculé à l'aide d'un code Fortran avec OpenCL (Université de Bristol).

Fortran est toujours l'un des langages les plus utilisés pour le calcul intensif, que ce soit pour l'astronomie, la modélisation climatique, la modélisation chimique, la modélisation en économie, la mécanique des fluides numérique, la physique numérique, l'analyse de données, la modélisation hydrologique, l'algèbre linéaire numérique et les bibliothèques numériques (LAPACK, IMSL et NAG), l'optimisation, la simulation de satellites, l'ingénierie des structures et les prévisions météorologiques. Les calculs peuvent aussi bien être réalisés sur des ordinateurs de bureau que sur des supercalculateurs.

Température de surface et vitesse des courants océaniques, calculées avec le code Fortran NEMO (Nucleus for European Modelling of the Ocean,) au Barcelona Supercomputing Center (2020).

De nombreux tests de performance (benchmarks) destinés à évaluer les performances des nouveaux microprocesseurs sont écrits en Fortran.

Contrairement aux idées reçues[54], les logiciels internes des sondes Voyager 1 et Voyager 2 de la NASA n'ont pas été écrits en FORTRAN mais en langage machine[55], contrairement à une partie des logiciels au sol.

De nombreux artistes ont utilisé FORTRAN : Iannis Xenakis, Vera Molnár, Pierre Barbaud, etc.

## Code source : format et syntaxe

[modifier | modifier le code]

### Ancien format fixe

[modifier | modifier le code]

Code source en FORTRAN 77 (format fixe) avec sortie du compilateur (ordinateur : CDC 175 de l'université technique de Rhénanie-Westphalie à Aix-la-Chapelle).

Avant la norme Fortran 90, le FORTRAN, créé à l'époque des cartes perforées (en particulier avec le système FMS), utilise une mise en page adaptée à ces supports :

* la colonne 1 peut contenir la lettre C indiquant un commentaire. Le caractère * est aussi accepté ;
* les colonnes 1 à 5 peuvent contenir une étiquette numérique (facultative) de l'instruction, dont la valeur peut être limitée à 32 767 ou 9 999 suivant le compilateur ;
* la colonne 6 indique une suite de l'instruction précédente ;
* le code commence à partir de la 7e colonne et ne doit pas dépasser la 72e. Les espaces n'ont pas de signification dans ces colonnes : une boucle `DO 10 I=1,5` peut aussi s'écrire `DO10I=1,5`[note 4] (le `10` est ici l'étiquette obligatoire de fin de boucle) ;
* les colonnes 73 à 80 servent à l'identification et la numérotation des cartes perforées (souvent les trois initiales du projet, du chef de projet ou du programmeur, suivies de numéros de cinq chiffres attribués de dix en dix pour permettre des insertions de dernière minute).

Les extensions de fichiers les plus courantes pour le format fixe sont `.f` et `.for`, mais ce n'est qu'une convention adoptée par la plupart des compilateurs. Rien n'empêche de les utiliser avec le format libre à condition d'en avertir le compilateur à l'aide de l'option adéquate.

### Fortran moderne

[modifier | modifier le code]

Depuis la norme Fortran 90, le code source est écrit suivant un format dit libre : il n'y a plus de colonne particulière, les lignes font au maximum 132 caractères (mais elles peuvent être continuées à l'aide du caractère `&`), les commentaires sont introduits par un point d'exclamation (éventuellement disposé à la suite d'une instruction Fortran). L'extension de nom de fichier la plus courante est alors `.f90`[note 5], même si le programme utilise des fonctionnalités de normes plus récentes telles que Fortran 2018.

program degrad
! =================================================
! Imprime une table de conversion degrés -> radians
! avec 32 chiffres significatifs (réels 128 bits)
! =================================================
use, intrinsic :: iso_fortran_env, only: wp=>real128

implicit none
! Déclaration des variables
integer  :: deg
real(wp) :: radians(0:90)
! Déclaration des constantes
real(wp), parameter :: pi = 4.0_wp * atan(1.0_wp)
real(wp), parameter :: coeff = (2.0_wp * pi) / 360.0_wp
character(*), parameter :: ligne_horizontale = "(49('-'))"

! Remplissage du tableau :
radians = [ (coeff * deg, deg=0,90) ]

! En-tête de la table
write (*, ligne_horizontale)
write (*, "('| Degrés |', 15(' '), 'Radians', 16(' '), '|')")
write (*, ligne_horizontale)
! Affichage formaté
do deg = 0, 90
write (*, "('|   ', I2,'   |  ', F34.32,'  |')") deg, radians(deg)
end do
! Fin de la table
write (*, ligne_horizontale)
end program degrad

Notes :

* ce programme est écrit en Fortran moderne[56]. Il nécessite un compilateur implémentant les bases de la norme Fortran 2008 ;
* l'instruction `use` permet d'importer le module intrinsèque `iso_fortran_env` qui définit des constantes, en particulier pour les types de réels disponibles (`real32, real64, real128`). Ici seule est importée la constante `real128` qui sera désignée par l'alias `wp` (working precision). Les nombres réels apparaissant dans le programme sont suffixés par cet alias afin de définir leur type. Il suffirait ainsi de remplacer `real128` par `real64` ou `real32` pour modifier de façon cohérente la précision numérique utilisée dans l'ensemble du programme, pour autant que le compilateur prenne en charge la précision correspondante ;
* l'instruction `implicit none`, introduite dans la norme Fortran 90, rend la déclaration des variables obligatoire. Historiquement, celle-ci est en effet facultative : les variables dont le nom commence par une des lettres I, J, K, L, M ou N sont par défaut de type `integer`, les autres de type `real`. Ce mécanisme est désormais fortement déconseillé et l'instruction `implicit none` doit donc être systématiquement utilisée ;
* la déclaration se fait en début de routine. Le type de données et les noms de variables sont séparés par `::`. On utilise les entiers par défaut pour `deg`. La numérotation des tableaux commence par défaut à 1 en Fortran mais ici on la fait commencer à 0 pour le tableau `radians(0:90)`. Les constantes, qui peuvent être calculées, sont spécifiées par l'attribut `parameter`. Les chaînes de caractères sont de longueur fixe, mais ici l'étoile indique que la longueur de la chaîne doit être définie en fonction de la longueur de son contenu ;
* le contenu du tableau `radians()` est calculé à l'aide d'un constructeur, avec `deg` pour variable de boucle variant de 0 à 90. Le Fortran permettant de calculer directement sur des tableaux, on aurait pu écrire également `radians = coeff * [ (deg, deg=0,90) ]` ;
* l'instruction `write` se réfère à une unité d'entrée-sortie (`*` désigne le terminal) et une spécification de format. Ce format est ici stocké dans la chaîne `ligne_horizontale` et décrit qu'il faudra afficher 49 tirets. On aurait également pu utiliser une déclaration `format` située sur une autre ligne et précédée d'un label numérique ;
* l'instruction `do deg = 0, 90` indique de répéter en boucle les instructions qui suivent (jusqu'au `end do`) pour toutes les valeurs de `deg` de 0 à 90 par pas de 1 ;
* le `write` à l'intérieur de la boucle permet d'écrire sur le terminal les valeurs des variables `deg` et `radians(deg)` en utilisant deux caractères pour `deg` (qui est un entier) et 34 caractères dont 32 après la virgule pour `radians(deg)` qui est un réel.

## Compilateurs

[modifier | modifier le code]

De nombreux compilateurs commerciaux ou libres sont disponibles.

### Compilateurs actuels

[modifier | modifier le code]

#### Compilateurs libres

[modifier | modifier le code]

Avant sa version 4.0, le compilateur libre GCC incluait le compilateur g77[57] pour le FORTRAN 77, qui a été remplacé en 2005[58],[59] par le compilateur GFortran[60], issu d'un fork de G95 réalisé en 2003. En décembre 2022, GFortran prend en charge quasiment intégralement Fortran 2003[61] et Fortran 2008[62] et environ 40 % de Fortran 2018[63]. Contrairement aux compilateurs Intel et Cray, il ne gère pas encore de façon native la programmation parallèle avec les co-tableaux mais nécessite l'installation de la bibliothèque OpenCoarrays[64].

Omni Compiler[65] est un méta-compilateur C et Fortran destiné à transformer du code contenant des directives XcalableMP et OpenACC en code parallèle natif.

#### Compilateurs propriétaires

[modifier | modifier le code]

On trouve de nombreux compilateurs commerciaux : Portland Group (en)[66] (filiale de NVidia), NAG, etc. La plupart des fabricants de stations de travail ou d'ordinateurs destinés au calcul intensif proposent également un compilateur Fortran : Intel[67], IBM[68], Oracle (à la suite du rachat de Sun Microsystems[69]), HPE Cray[70] (Cray a été racheté par HP en 2019), etc.

Certains de ces compilateurs commerciaux ont des versions gratuites pour une utilisation non commerciale : c'est le cas d'Oracle[71], Portland Group[72]. On peut télécharger le compilateur BiSheng[73] que Huawei a développé pour sa plateforme Kunpeng : pour le Fortran, il utilise Flang en frontal.

Quant aux compilateurs Intel[74], ils sont depuis janvier 2021 gratuits pour tous les développeurs : le nouveau compilateur ifx[75], basé sur LLVM, implémente depuis sa version 2023.0.0 l'intégralité de la norme Fortran 2018 et offre désormais les mêmes fonctionnalités que le compilateur classique ifort, qu'il remplacera progressivement[76]. Le compilateur Intel Visual Fortran est l'héritier de DEC Visual Fortran, devenu Compaq Visual Fortran puis HP Visual Fortran.

#### Compilateurs en cours de développement

[modifier | modifier le code]

De nouveaux compilateurs Fortran basés sur LLVM sont en développement : LFortran[77] qui vise à permettre de tester du code de façon interactive et Flang[78].

#### Compilateurs en ligne

[modifier | modifier le code]

Le Fortran fait partie des langages proposés par certains compilateurs en ligne, tels que codingground[79], OnlineGDB[80], JDOODLE[81], godbolt Compiler Explorer[82] et le Fortran Playground[83] de la communauté Fortran-lang. Certains proposent le choix entre plusieurs compilateurs Fortran ou plusieurs versions d'un compilateur, ou permettent d'analyser le code avec un débogueur et de voir le langage machine généré. Ces outils permettent donc d'apprendre le langage sans installer de compilateur sur sa machine, ils permettent également de collaborer en ligne sur un projet.

### Compilateurs non maintenus

[modifier | modifier le code]

* Lahey[84] : arrêté le 31 décembre 2022 (Lahey Computer Systems Inc. a fermé ses portes).
* Absoft[85] : arrêté le 31 décembre 2022 (Absoft Corporation a fermé ses portes après 42 ans d'activité).
* PathScale (en) : arrêté en 2013.
* G95 : compilateur libre développé entre 2000 et janvier 2013.
* Open64 (en) est un compilateur Fortran 95 libre arrêté en 2011.
* Compilateur FORTRAN 77 libre Open Watcom : arrêté en 2010.
* HP.
* Unisys.
* Certains fabricants ont disparu[86], tels que CDC ou DEC.

## Outils de développement

[modifier | modifier le code]

### Éditeurs et environnements de développement intégrés

[modifier | modifier le code]

La plupart des éditeurs de texte offrent une coloration syntaxique pour le Fortran : Emacs, Notepad++, Sublime Text, Vim, Neovim, Visual Studio Code... Parmi les environnements de développement intégrés, il existe une version de Code::Blocks destinée au développement en Fortran. Il existe également une version d'Eclipse destinée au Fortran, nommée Photran[87], mais dont la dernière version date de 2015. Sous Windows, le compilateur Intel Fortran est intégré à Visual Studio[88].

### Gestionnaire de paquets et systèmes de construction

[modifier | modifier le code]

Les systèmes de construction de projet tels que CMake et Meson gèrent généralement le Fortran. L'utilitaire makedepf90[89] permet de générer des fichiers Make pour un projet Fortran.

Fonctionnalités du gestionnaire de paquets Fortran fpm.

Mais Fortran dispose depuis fin 2020 du gestionnaire de paquets fpm (Fortran Package Manager)[90], qui fait office également de système de construction de projet. Il est inspiré par l'outil Cargo du langage Rust. Il permet en particulier de gérer les dépendances, qu'il peut télécharger automatiquement depuis GitHub. Et il est lui-même écrit essentiellement en Fortran et dispose d'un mécanisme de greffon permettant d'étendre ses fonctionnalités. La version 0.12 est sortie en mai 2025.

### Vérification et analyse de code

[modifier | modifier le code]

fpt[91] est un outil d'analyse de code Fortran. On peut également citer CamFort[92], un projet universitaire libre, ftncheck[93], qui est limité au FORTRAN 77 et qui n'est plus développé depuis 2005. findent[94] est un indenteur de code source qui peut également transformer l'ancien format fixe du Fortran en format libre.

Plusieurs analyseurs de type lint sont disponibles : Flint[95] et fortran-linter[96], logiciels libres écrits en Python, et FortranLint[97], produit commercial.

Lizard[98] est un analyseur de complexité cyclomatique qui prend en charge une vingtaine de langages, dont le Fortran.

### Débogage et profilage

[modifier | modifier le code]

Pour le débogage, on peut par exemple utiliser les débogueurs GNU gdb[99] ou idb (Intel Debugger). Pour le profilage sous système de type UNIX, on peut utiliser gprof et Valgrind. La couverture de code peut être évaluée avec Gcov (en).

### Préprocesseurs

[modifier | modifier le code]

Fypp[100] est un préprocesseur Python qui peut être utilisé avec n'importe quel langage, tout en étant avant tout destiné au langage Fortran. Il utilise la syntaxe du Python.

### Tests unitaires

[modifier | modifier le code]

PFUnit (en) est un framework de tests unitaires, libre et initialement développé par la NASA[101]. Le framework test-drive[102] est utilisé dans les projets fpm et stdlib, et il prend en charge Meson, CMake et fpm. On peut également citer vegetables[103] et FRUIT[104].

### Générateurs de documentation

[modifier | modifier le code]

Parmi les générateurs de documentation gérant le Fortran, on peut citer Doxygen, FORD[105] et ROBODoc[106].

### Outils spécifiques pour Windows

[modifier | modifier le code]

Quickstart Fortran[107] permet d'installer facilement sous Microsoft Windows, sans nécessiter les droits d’administration, les outils essentiels pour développer en Fortran : GCC-GFortran, Fortran Package Manager, Git for Windows, OpenBLAS (BLAS/LAPACK), GNU make. Il peut également faciliter l'installation d'Intel OneAPI et de la librairie stdlib en cours de développement.

## Bibliothèques

[modifier | modifier le code]

### Bibliothèques de calcul scientifique

[modifier | modifier le code]

De nombreuses bibliothèques de calcul ont été développées en Fortran. Certaines sont développées, utilisées, testées et donc déboguées depuis des décennies, ce qui leur assure une très grande fiabilité.

* LAPACK[108] (Linear Algebra Package) est une bibliothèque consacrée comme son nom l'indique à l'algèbre linéaire numérique.
* Basic Linear Algebra Subprograms (BLAS) est un ensemble de fonctions standardisées réalisant des opérations de base de l'algèbre linéaire. Il fait partie des dix codes informatiques ayant le plus marqué la science, d'après la revue Nature[10].
* LINPACK est une bibliothèque de fonctions pour l'algèbre linéaire, et notamment la résolution numérique de systèmes d'équations linéaires.
* Physics Analysis Workstation (PAW).
* International Mathematics and Statistics Library (IMSL) est une bibliothèque logicielle d'objets utilisables pour le développement informatique d'applications d'analyse numérique.
* NAG Fortran Library propose plus de 1700 routines mathématiques et statistiques.
* SLATEC[109] est une bibliothèque dans le domaine public proposant 1400 fonctions mathématiques, initialement développée en Fortran 77. Le code source a été adapté en Fortran moderne avec une version 4.2 datée de 2019[110].
* ...

### Bibliothèques graphiques

[modifier | modifier le code]

Les normes Fortran n'incluant pas d'instructions graphiques ou d'instructions pour construire des interfaces graphiques, la visualisation peut se faire après exécution avec des outils externes tels que ParaView, ou en appelant des outils de tracé tels que Gnuplot via l'instruction `EXECUTE_COMMAND_LINE()`, ou enfin à l'aide de bibliothèques :

* DISLIN[111], créé par le Max Planck Institute for Solar System Research, permet de tracer des données et de réaliser des interfaces graphiques. Multiplate-formes (UNIX, Linux, FreeBSD, OpenVMS, Windows et MS-DOS). Fonctionne avec de nombreux compilateurs, ainsi que d'autres langages que le Fortran. Téléchargeable gratuitement depuis la version 11.3 de mars 2020.
* GINO[112] permet de tracer des données et de réaliser des interfaces graphiques. Logiciel commercial pour Windows et Linux.
* GrWin Graphics Library[113] : logiciel libre pour Windows.
* gtk-fortran[114] est une bibliothèque sous licence libre GPL 3 permettant de créer des interfaces graphiques GTK en Fortran, grâce aux fonctionnalités d'interopérabilité Fortran / C introduites depuis la norme Fortran 2003. Multi-plateforme (Linux, Windows, macOS, FreeBSD, Raspberry Pi...). Supporte GTK 4, la bibliothèque généraliste GLib et la bibliothèque PLplot. Peut être utilisée comme dépendance fpm.
* JAPI (Java Application Programming Interface)[115] : interface Java/Fortran permettant de créer une interface graphique complète pour les programmes Fortran. Multiplate-formes (Windows, Linux, Solaris). Fonctionne avec de nombreux compilateurs (entre autres gfortran, Compaq Visual Fortran…). Logiciel libre sous licence LGPL.
* MATFOR[116] : construction d'interfaces graphiques et bibliothèques numériques et graphiques pour Fortran et d'autres langages. Logiciel commercial pour Windows et Linux.
* ogpf[117] permet d'accéder facilement à gnuplot depuis un programme Fortran, grâce à l'utilisation de la programmation orientée objet. Il peut être utilisé comme paquet fpm.
* PLplot (en)[118] : bibliothèque permettant de dessiner des graphiques scientifiques. Multilangage et multiplate-formes (Linux, OpenSolaris, Unix, MS-DOS, Windows, Mac OS X). Logiciel libre sous licence LGPL.
* Quickwin[119] : bibliothèque graphique fournie avec le Compaq Visual Fortran (désormais Intel Visual Fortran). Ne fonctionne que sous Windows.
* Winteracter[120] : construction d'interfaces graphiques et d'outils de visualisation. Logiciel commercial pour Windows, Linux et MacOS X.

Début 2021, les bibliothèques suivantes ne sont plus maintenues depuis au moins 10 ans :

* f90gl : interface du Fortran 90 avec OpenGL, GLU et GLUT. Multiplate-formes. Fonctionne avec de nombreux compilateurs. Licence : domaine public.
* Ftcl : interface Fortran-Tcl/TK. gratuit, open-source.
* g2 graphical library : pour Linux, AIX, Digital Unix, SunOS, IRIX, OpenVMS, Windows. Logiciel libre sous licence LGPL.
* PGPLOT (en) : bibliothèque de routines graphiques, interactive, gratuite, multiplate-forme, gère beaucoup de périphériques de sortie.
* pilib (Platform Independent Library for Fortran) : interface Fortran 90-95 / GTK. Développement arrêté. Logiciel libre.
* PSPLOT : générer des dessins en PostScript.
* SansGUI : interface commerciale pour Windows et Compaq Visual Fortran.
* Xeffort : bibliothèque graphique pour Visual Fortran. Logiciel libre pour Windows.

## Interopérabilité avec les autres langages

[modifier | modifier le code]

Depuis Fortran 2003, l'interopérabilité du Fortran avec le langage C est normalisée. Le module intrinsèque ISO_C_BINDING définit des constantes de types telle que `c_int` ou `c_double`, des procédures et constantes permettant en particulier de gérer l'interopérabilité des pointeurs C et Fortran, ainsi que des constantes pour les caractères telles que `c_null_char` pour gérer l'échange des chaînes de caractères. Cette partie du langage a reçu des améliorations avec la norme Fortran 2018.

Cette interopérabilité normalisée facilite d'une part l'appel des innombrables bibliothèques écrites en C, et d'autre part l'utilisation par d'autres langages de bibliothèques écrites en Fortran. Julia sait ainsi appeler des fonctions Fortran de manière native avec la function `ccall()`. Python peut utiliser des bibliothèques Fortran grâce à F2PY[121] (Fortran to Python interface generator), qui fait partie de NumPy.

## Autres langages pour le calcul scientifique

[modifier | modifier le code]

Le Fortran côtoie désormais de nombreux autres langages et logiciels pour le calcul scientifique, en particulier :

* C et C++[note 6],
* des langages interprétés tels que Python grâce à des bibliothèques telles que NumPy et SciPy, dont certaines parties sont d'ailleurs écrites en Fortran,
* Julia,
* R (langage), axé statistiques et analyse de données,
* des logiciels tels que Scilab, MATLAB ou GNU Octave. Scilab et MATLAB incorporent d'ailleurs les bibliothèques BLAS et LAPACK, développées en Fortran[122],[123]. MATLAB était à l'origine un programme en Fortran, distribué aux universités et aux centres de recherche[124].

Par ailleurs, d'autres langages ont été développés dans les années 2000 pour faciliter la programmation parallèle sur les superordinateurs, avant la parution de la norme Fortran 2008. On peut citer X10, développé par IBM depuis 2004, et Chapel, développé par Cray depuis 2009. Un autre langage, Fortress, apparu en 2006 et développé par Sun Microsystems, a été abandonné en 2012. Ces trois langages font partie du projet High Productivity Computing Systems (en) de la DARPA.

## Notes et références

[modifier | modifier le code]

### Notes

[modifier | modifier le code]

1. ↑ On notera toutefois que dans le premier manuel de Fortran (1956), le nom est écrit avec un F en capitale d'imprimerie et les autres lettres en petites capitales d'imprimerie.
2. ↑ Interrogé à ce sujet, John Backus expliqua dans un entretien, qu'il ne pouvait en être autrement, bien qu'en 1990 tout binôme d'étudiants en informatique puisse en écrire un en quelques mois : « Nous n'avions pas les concepts. Nous n'avions pas davantage les outils ». Il explique dans le même entretien[réf. souhaitée] que ce qui avait donné le plus de travail à l'équipe était la génération d'un code indexant de façon pas trop inefficace les tableaux.
3. ↑ Le concept de pointeur en Fortran est beaucoup plus restrictif qu'en C. Un pointeur ne pointe pas vers une adresse mais vers une cible possédant l'attribut `TARGET`, et il possède un type et un rang.
4. ↑ Attention, écrire `DO 10 I=1.5` sans espace (`DO10I=1.5`) affecterait la valeur 1.5 à la variable `DO10I`.
5. ↑ Les extensions avec un F majuscule, telles que `.F90` sont généralement interprétées par les compilateurs comme indiquant la nécessité d'utiliser avant compilation un préprocesseur Fortran.
6. ↑ Par exemple la GSL écrite en C, et Blitz++ ou IML++, en C++.

### Références

[modifier | modifier le code]

1. ↑ a b et c (en) D. T. Muxworthy, A REVIEW OF PROGRAM PORTABILITY AND FORTRAN CONVENTIONS, août 1976, 61 p. (lire en ligne)
2. ↑ a b et c (en) Martin N. Greenfield, History of FORTRAN standardization, ACM Press, 1982, 817 p. (ISBN 978-0-88283-035-3, DOI 10.1145/1500774.1500877, lire en ligne)
3. ↑ « Small-Body Database Lookup », sur ssd.jpl.nasa.gov (consulté le 8 septembre 2024)
4. ↑ a b c d et e (en) John Backus, « The history of FORTRAN I, II, and III », ACM SIGPLAN Notices, vol. 13, no 8,‎ août 1978, p. 165-180 (DOI 10.1145/960118.808380, lire en ligne).
5. ↑ Preliminary Report, Specifications for the IBM Mathematical FORmula TRANslating System, FORTRAN [PDF].
6. ↑ « John Backus », sur IBM Archives (consulté le 10 novembre 2014).
7. ↑ « Anonymous. The FORTRAN Automatic Coding System for the IBM 704 EDPM : Preliminary Operator's Manual. April 8, 1957. — Software Preservation Group », sur www.softwarepreservation.org (consulté le 28 septembre 2021)
8. ↑ « 704 Fortran Programmer's Primer — Software Preservation Group », sur www.softwarepreservation.org (consulté le 28 septembre 2021)
9. ↑ (en) « “We thank Miss Mary Tsingou” », sur www.lanl.gov (consulté le 24 septembre 2021)
10. ↑ a et b (en) Jeffrey M. Perkel, « Ten computer codes that transformed science », Nature, vol. 589, no 7842,‎ 20 janvier 2021, p. 344–348 (DOI 10.1038/d41586-021-00075-2, lire en ligne, consulté le 3 mars 2023)
11. ↑ (en) Irving N. Rabinowitz, « Report on the algorithmic language FORTRAN II », Communications of the ACM, vol. 5, no 6,‎ juin 1962, p. 327-337 (DOI 10.1145/367766.368151).
12. ↑ FORTRAN II Reference Manual for the IBM 704 (1958)
13. ↑ « List of FORTRAN Implementations », sur fortran.bcs.org (consulté le 30 septembre 2021)
14. ↑ Description of /360 WATFOR - A FORTRAN IV Compiler
15. ↑ « Computer Resurrection Issue 41 », sur www.computerconservationsociety.org (consulté le 5 octobre 2021)
16. ↑ [PDF] Standard ECMA FORTRAN.
17. ↑ [PDF] Norme FORTRAN 66.
18. ↑ John Backus A.M. Turing Award (1977).
19. ↑ [PDF] Norme FORTRAN 77.
20. ↑ (en) Frank Engel, Jr., « Draft proposed ANS FORTRAN BSR X3.9 X3J3/76 », ACM SIGPLAN Notices, vol. 11, no 3,‎ mars 1976, p. 1-212 (DOI 10.1145/956013.1070892).
21. ↑ [PDF] MIL-STD-1753, Military Standard: FORTRAN, DOD Supplement to American National Standard X3.9-1978.
22. ↑ [PDF] Standard Fortran 90.
23. ↑ IEEE 1003.9-1992 - POSIX(R) FORTRAN 77 Language Interfaces - Part 1: Binding for System Application Program Interface (API).
24. ↑ ISO/IEC 1539-2:1994 -- Information technology -- Programming languages -- FORTRAN -- Part 2: Varying length character strings.
25. ↑ ISO/IEC 1539-2:2000 -- Information technology -- Programming languages -- Fortran -- Part 2: Varying length character strings.
26. ↑ [PDF] Standard Fortran 95.
27. ↑ ISO/IEC 1539-3:1999 -- Information technology -- Programming languages -- Fortran -- Part 3: Conditional compilation.
28. ↑ [PDF] Standard Fortran 2003.
29. ↑ [PDF] Standard Fortran 2008.
30. ↑ (en) John Reid, « The New Features of Fortran 2008 », WG5,‎ 13 mars 2014 (lire en ligne [PDF])
31. ↑ [PDF] Standard Fortran 2018.
32. ↑ 14:00-17:00, « ISO/IEC TS 29113:2012 », sur ISO (consulté le 28 septembre 2021)
33. ↑ 14:00-17:00, « ISO/IEC TS 18508:2015 », sur ISO (consulté le 28 septembre 2021)
34. ↑ 14:00-17:00, « ISO/IEC/IEEE 60559:2011 », sur ISO (consulté le 28 septembre 2021)
35. ↑ WD 1539-1 J3/24-007 (Fortran 2023 Interpretation Document), 18 décembre 2023
36. ↑ (en) John Reid, « The New Features of Fortran 2023 », WG5,‎ 13 mars 2023 (lire en ligne [PDF])
37. ↑ WG5, « WORK ITEMS FROM THE HYBRID WG5 MEETING HELD ON JUNE 27 TO 28, 2024 IN BERKELEY, CA, USA », sur wg5-fortran.org, 30 juin 2024 (consulté le 17 décembre 2024)
38. ↑ Groupe de travail ISO/IEC JTC1/SC22/WG5
39. ↑ Comité Fortran US J3
40. ↑ Compiler Support for the Fortran 2003 Standard.
41. ↑ Compiler Support for the Fortran 2008 Standard.
42. ↑ (en) « GitHub - j3-fortran/fortran_proposals: Proposals for the Fortran Standard Committee », sur GitHub (consulté le 17 septembre 2021)
43. ↑ (en) Mark Jones Lorenzo, The History of the Fortran Programming Language - Abstracting Away the Machine, Philadelphie, SE Books, 2019 (ISBN 978-1-082-39594-9)
44. ↑ (en) « BCS Fortran Specialist Group Home page », sur fortran.bcs.org (consulté le 28 février 2023)
45. ↑ (en) « SIGPLAN-FORTRAN Home », sur dl.acm.org (consulté le 17 septembre 2021)
46. ↑ « JISCMail - COMP-FORTRAN-90 List at WWW.JISCMAIL.AC.UK », sur www.jiscmail.ac.uk (consulté le 28 septembre 2021)
47. ↑ (en) Laurence Kedward et al., « The State of Fortran », Computing in Science & Engineering,‎ 16 mars 2022, p. 63-72 (ISSN 1521-9615 et 1558-366X, DOI 10.1109/MCSE.2022.3159862 , arXiv 2203.15110v2, HAL hal-03624071, lire en ligne , consulté le 30 mars 2022)
48. ↑ Vincent Magnin, José Alves, Antoine Arnoud, Arjen Markus et Michele Esposito Marzino, « Fortran... et puis quoi encore ? » [PDF], sur www.societe-informatique-de-france.fr, Bulletin 1024, novembre 2023 (DOI 10.48556/sif.1024.22.143, consulté le 10 novembre 2023), p. 143-161
49. ↑ (en) « The Fortran Programming Language », sur GitHub (consulté le 16 septembre 2021)
50. ↑ (en) « Fortran Discourse », sur Fortran Discourse (consulté le 28 septembre 2021)
51. ↑ (en) « Google Summer of Code, Fortran-lang projects », sur summerofcode.withgoogle.com (consulté le 25 septembre 2021)
52. ↑ « FortranCon 2021 », sur Theory & Computation Events (Indico) (consulté le 28 septembre 2021)
53. ↑ « Indice TIOBE des langages les plus populaires »
54. ↑ (en-US) Adam Mann, « Interstellar 8-Track: How Voyager's Vintage Tech Keeps Running », Wired,‎ 25 septembre 2013 (ISSN 1059-1028, lire en ligne, consulté le 9 mars 2023)
55. ↑ « Voyager Spacecraft and Fortran 5 » (consulté le 23 mai 2024)
56. ↑ (en) Metcalf, Michael; Reid, John; Cohen, Malcolm, Modern Fortran Explained: Incorporating Fortran 2018, Oxford Univ. Press, novembre 2018 (ISBN 978-0198811886)
57. ↑ Copie de l'ancien site de g77 sur le site de l'USGS.
58. ↑ GCC 4.0 Release Series - Changes, New Features, and Fixes.
59. ↑ Code source de GCC 4.0.0.
60. ↑ GCC Wiki - GFortran.
61. ↑ gfortran - Fortran 2003 status.
62. ↑ gfortran - Fortran 2008 status.
63. ↑ gfortran - Fortran 2018 status.
64. ↑ (en) « OpenCoarrays », sur OpenCoarrays (consulté le 12 avril 2021)
65. ↑ Omni Compiler.
66. ↑ Portland Group Fortran.
67. ↑ Intel Fortran Compilers.
68. ↑ IBM - Fortran Compilers family.
69. ↑ Oracle Solaris Studio.
70. ↑ CrayDoc - Customer Documentation
71. ↑ Téléchargement de Oracle Solaris Studio.
72. ↑ PGI Community Edition, pour Linux et macOS.
73. ↑ « Introduction to Bisheng Compiler_Kunpeng DevKit_Kunpeng Compiler_User Guide (BiSheng Compiler) _HUAWEI CLOUD », sur support.huaweicloud.com (consulté le 28 septembre 2021)
74. ↑ Compiltateurs Intel gratuits pour tous les développeurs.
75. ↑ Intel Fortran Compiler ifx
76. ↑ (en) « The Next Chapter for the Intel® Fortran Compiler », sur community.intel.com, 16 décembre 2022 (consulté le 21 décembre 2022)
77. ↑ LFortran
78. ↑ Flang
79. ↑ Compilateur en ligne codingground.
80. ↑ Compilateur en ligne OnlineGDB.
81. ↑ Compilateur en ligne JDOODLE.
82. ↑ Compilateur en ligne godbolt Compiler Explorer.
83. ↑ « Playground », sur play.fortran-lang.org (consulté le 24 décembre 2022)
84. ↑ Lahey Fortran.
85. ↑ Absoft Fortran.
86. ↑ Bitsavers - documentation d'ordinateurs anciens.
87. ↑ (en) Jeffrey Overbey, « Photran - An Integrated Development Environment and Refactoring Tool for Fortran | The Eclipse Foundation », sur www.eclipse.org (consulté le 11 avril 2021)
88. ↑ Intel Compilers Compatibility with Microsoft Visual Studio and Xcode
89. ↑ « Utilitaire makedepf90 »
90. ↑ Fortran Package Manager fpm.
91. ↑ www.simconglobal.com, « WinFPT and fpt - Fortran Engineering - Summary », sur simconglobal.com (consulté le 11 avril 2021)
92. ↑ CamFort
93. ↑ fthcneck
94. ↑ « findent, indenteur de code source Fortran. »
95. ↑ Aimad Er-Raiy, Antoine Dauptain, Quentin Douasbin, flinter: Flinter, a fortran code linter (lire en ligne)
96. ↑ Corentin Cadiou, fortran-linter: A linter for Fortran files (lire en ligne)
97. ↑ « Cleanscape FortranLint Fortran source code analysis tool », sur stellar.cleanscape.net (consulté le 11 octobre 2021)
98. ↑ Terry Yin, Lizard, 9 octobre 2021 (lire en ligne)
99. ↑ « GDB: The GNU Project Debugger », sur www.gnu.org (consulté le 22 septembre 2021)
100. ↑ « Fypp documentation — Fypp 3.1 documentation », sur fypp.readthedocs.io (consulté le 17 septembre 2021)
101. ↑ Verification of Fortran Codes
102. ↑ Framework de tests unitaires test-drive.
103. ↑ Framework de tests unitaires vegetables.
104. ↑ Framework de tests unitaires FRUIT.
105. ↑ Fortran-FOSS-Programmers/ford, Fortran F/OSS Programmers Group, 12 avril 2021 (lire en ligne)
106. ↑ « ROBODoc », sur rfsber.home.xs4all.nl (consulté le 18 avril 2021)
107. ↑ Laurence Kedward, Quickstart Fortran on Windows, 22 novembre 2021 (lire en ligne)
108. ↑ « LAPACK — Linear Algebra PACKage », sur netlib.org (consulté le 1er novembre 2021).
109. ↑ « slatec », sur www.netlib.org (consulté le 18 octobre 2021)
110. ↑ مهدي شينون (Mehdi Chinoune), MehdiChinoune/SLATEC,‎ 18 octobre 2021 (lire en ligne)
111. ↑ DISLIN
112. ↑ GINO
113. ↑ GrWin Graphics Library
114. ↑ gtk-fortran
115. ↑ JAPI (Java Application Programming Interface)
116. ↑ MATFOR
117. ↑ « ogpf, interface gnuplot en Fortran orienté objet »
118. ↑ PLplot
119. ↑ Quickwin
120. ↑ Winteracter
121. ↑ « F2PY Users Guide and Reference Manual — NumPy v1.21 Manual », sur numpy.org (consulté le 21 septembre 2021)
122. ↑ MATLAB Incorporates LAPACK.
123. ↑ Dev Community in Scilab.
124. ↑ Code source de la première version de MATLAB.

## Voir aussi

[modifier | modifier le code]

Sur les autres projets Wikimedia :

* Fortran, sur le Wiktionnaire

### Bibliographie

[modifier | modifier le code]

* Ed Akin, Object-Oriented Programming via Fortran 90/95, Cambridge University Press, 13 janvier 2003, 1re éd. (ISBN 978-0-521-52408-7 et 978-0-511-53011-1, lire en ligne)
* Walter S. Brainerd, Guide to Fortran 2003 Programming, London, Springer London, 2009 (ISBN 978-1-84882-543-7, lire en ligne)
* Ian Chivers et Jane Sleightholme, Introduction to Programming with Fortran, Cham, Springer International Publishing, 2018 (ISBN 978-3-319-75502-1, lire en ligne)
* Norman S. Clerman et Walter Spector, Modern Fortran: Style and Usage, Cambridge, Cambridge University Press, 2011 (ISBN 978-1-139-02768-7, lire en ligne)
* Milan Curcic, Modern Fortran: Building efficient parallel applications, Manning Publications, 24 novembre 2020, 1st edition éd. (ISBN 978-1-61729-528-7)
* Claude Delannoy, Programmer en fortran - Fortran 90 et ses évolutions - fortran 95, 2003 et 2008, Librairie Eyrolles, février 2015 (ISBN 978-2-212-14020-0, lire en ligne)
* Richard J. Hanson et Tim Hopkins, Numerical Computing with Modern Fortran, Philadelphia, PA, Society for Industrial and Applied Mathematics, janvier 2013 (ISBN 978-1-61197-312-9, lire en ligne)
* Michael Metcalf, John Reid, Malcolm Cohen et Reinhold Bader, Modern Fortran Explained: Incorporating Fortran 2023, Oxford University Press (ISBN 978-0-19-887657-1, OCLC 2023946356, lire en ligne)
* Robert W. Numrich, Parallel Programming with Co-arrays, First edition. | Boca Raton, FL : CRC Press/Taylor & Francis, Chapman and Hall/CRC, 6 septembre 2018, 1re éd. (ISBN 978-0-429-43718-2, lire en ligne)

### Articles connexes

[modifier | modifier le code]

* Fortran 90
* Fortran 95
* Netlib est un site qui offre une collection de bibliothèques de fonctions pour le calcul numérique.

### Autres liens externes

[modifier | modifier le code]

Notices d'autorité :

* BnF (données)
* LCCN
* GND
* Espagne
* Israël
* Tchéquie

* Cours de Fortran de l'IDRIS (CNRS).
* Fortran sur le Wiki ubuntu-fr : cette page décrit l'installation et l'utilisation des outils Fortran sur une distribution Linux Ubuntu.
* (en) Blog Dr. Fortran de Steve Lionel, responsable depuis 2018 du Working Group WG5 pour l'élaboration des normes Fortran.
* (en) Comparaison de différents compilateurs Fortran.

v · m

Langages de programmation

Concurrents |

* Ada
* Erlang
* Go
* Modula-2

Déclaratifs |

* Clips
* Prolog
* Mercury

Fonctionnels |

* Clojure
* Common Lisp
* Erlang
* F#
* Gallina
* Haskell
* Lisp
* ML
* OCaml
* Opa
* Scheme
* Standard ML

Impératifs |

* Algol
* APL
* Assembleur
* Basic
* BCPL
* C
* Cobol
* DOPE
* Forth
* Fortran
* Julia
* Limbo
* Lua
* Modula-2
* MUMPS
* Natural
* NQC
* NXC
* OPL
* Pascal
* Perl
* PL/I
* RPG
* PowerShell
* Rust
* Tcl
* WLangage

Orientés objet |

* ActionScript
* AppleScript
* C++
* C#
* CoffeeScript
* D
* Delphi
* Eiffel
* Groovy
* Haxe
* Java
* JavaScript
* Lisaac
* Logo
* Objective-C
* PHP
* Python
* Ruby
* Scala
* Scratch
* Simula
* Smalltalk
* Swift
* Kotlin
* Visual Basic

* Liste de langages de programmation

* Portail de la programmation informatique

*[7e]: Septième
*[72e]: Soixante-douzième (septante-deuxième)
*[réf.]: référence
*[(en)]: Langue : anglais
*[p.]: pages
*[vol.]: volume
*[no]: numéro
*[[PDF]]: Document au format Portable Document Format (PDF) d'Adobe
*[et al.]: et alii (et d’autres)
*[(en-US)]: Langue : anglais américain
*[1er]: premier
*[1re]: première
*[éd.]: édition
*[v]: Voir ce modèle.
*[m]: Modifier ce modèle. Merci de prévisualiser avant de sauvegarder.