Fortran

langage de programmation
(Redirigé depuis FORTRAN)

Fortran
Logo.

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 2018 (ISO/IEC 1539-1:2018) (le 2018 novembre 28, il y a 2 ans)
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
Site web fortran-lang.orgVoir et modifier les données sur Wikidata
Extension de fichier f, for et f90Voir et modifier les données sur Wikidata

Fortran (mathematical FORmula TRANslating system) est un langage de programmation généraliste dont le domaine de prédilection est 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, grâce à la bibliothèque LINPACK.

Supercalculateur IBM Blue Gene/P.

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 prochaine norme, pour l'instant désignée par Fortran 202x, est attendue pour 2023. Les discussions sur le contenu de la suivante, Fortran 202y, ont commencé.

Historique et versionsModifier

 
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 normalisé depuis le milieu des années 60 et est devenu une norme ISO depuis Fortran 90.

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[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 FortranModifier

  • Décembre 1953 : après avoir développé le système Speedcoding pour l'IBM 701, John Backus, ingénieur en radiophonie recruté en 1950 chez IBM, rédige une lettre à l'attention de son supérieur pour lui proposer le projet FORTRAN destiné à l'IBM 704, première machine IBM 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 : son groupe de recherche rédige un rapport intitulé Preliminary Report, Specifications for the IBM Mathematical FORmula TRANslating System, FORTRAN[2]. Il faut ensuite deux ans d'efforts à l'équipe qu'il dirige au sein d'IBM pour écrire le premier compilateur FORTRAN (25 000 lignes[3], pour l'IBM 704)[4], désigné alors par le mot translator. 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, aussi rapide que celui qu'aurait écrit un programmeur en langage machine.
  • 1957 : le compilateur FORTRAN est déployé courant avril sur tous les IBM 704. C'est une révolution car il n'est plus nécessaire d'être un expert de l'ordinateur pour écrire des programmes. Les chercheurs et les ingénieurs peuvent désormais écrire seuls 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 »[5]. FORTRAN n'a alors que des expressions arithmétiques et donc logiquement le branchement conditionnel est le « IF-arithmétique » à trois adresses : IF (A-B) 10, 20, 30 indiquait de sauter aux instructions d'étiquette 10, 20 ou 30 selon que A-B était négatif, nul ou positif.
  • 1958 : FORTRAN II[6],[7],[8] apportait les fonctions FUNCTION et les sous-programmes SUBROUTINE que l’on appelle par l’instruction CALL.
  • 1959 : FORTRAN III permettait d’y insérer du langage assembleur symbolique, mais n'est jamais sorti sous forme de produit.
  • 1962 : FORTRAN IV[9] introduit, entre autres, l'instruction « IF-logique », permettant d'écrire IF (A .GE. B) GOTO 10 (aller à 10 si A est supérieur ou égal à B). 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.
  • 1965 : la norme ECMA FORTRAN[10], située à cheval entre le « Basic FORTRAN » et le « FORTRAN USASI ».
  • 1966 : FORTRAN 66 (USASI X3.9-1966)[11] est la première version officiellement normalisée (par l'American Standards Association) de FORTRAN. Cette normalisation est nécessaire car des dialectes du langage commencent à apparaître.
  • 1977 : John Backus reçoit le Prix Turing[12] 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)[13],[14], est une évolution majeure qui apporte entre autres améliorations, la programmation structurée avec les blocs IF / THEN / ELSE / END IF. Il inclut en particulier des extensions au langage introduites par les différents compilateurs. Également en 1978, une extension du Département de la Défense des USA introduit entre autres les blocks DO WHILE / END DO[15] et l'instruction IMPLICIT NONE.

Fortran moderneModifier

  • 1991 : Fortran 90 (ISO/IEC 1539:1991, puis ANSI X3.198-1992)[16] 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, les types dérivés, l'instruction IMPLICIT NONE pour rendre obligatoire la déclaration des variables, les structures de contrôle SELECT CASE, 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[17].
  • 1994 : ISO/IEC 1539-2:1994, qui définit des chaînes de caractères de longueur variable[18]. Cette norme a été révisée en 2000[19].
  • 1997 : Fortran 95 (ISO/CEI 1539-1:1997)[20] : 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.
  • 1999 : ISO/IEC 1539-3:1999, qui définit des directives de compilation conditionnelle. Cette norme a été révisée en 2011[21].
  • 2004 : Fortran 2003 (ISO/CEI 1539-1:2004)[22] est une révision majeure qui supporte la programmation orientée objet[23]. 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)[24], 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.
  • 2018 : Fortran 2018 (ISO/CEI 1539-1:2018)[25], considérée comme une révision mineure, introduit en particulier :
    • ISO/IEC TS 29113:2012 Interopérabilité ultérieure de Fortran avec C
    • ISO/IEC TS 18508:2015 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 Systèmes de microprocesseurs — Arithmétique flottante
  • 2021 : le planning pour la version suivante, informellement dénommée Fortran 202x, a démarré en juin 2017[26]. Le document de travail du comité est disponible[27]. La publication de la norme est prévue pour octobre 2023.

Gouvernance et communautéModifier

GouvernanceModifier

Fortran fait partie des langages normalisés depuis 1965 et est devenu une norme ISO depuis Fortran 90. La norme Fortran est gérée par le groupe de travail ISO/IEC JTC1/SC22/WG5[28], 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)[29] 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[30],[31].

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[32] 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 202X, comme par exemple l'amélioration de la programmation générique, les expressions conditionnelles, des valeurs par défaut pour les arguments optionnels, etc.

CommunautéModifier

Depuis juillet 1982, le bulletin mensuel FORTRAN Forum[33] est publié par le SIGPLan (Special Interest Group in Programming Languages) de l'ACM (Association for Computing Machinery) trois fois par an.

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

Un groupe Fortran Programmers est créé sur LinkedIn en juillet 2008.

Le site Fortran Wiki est créé en octobre 2008. Il est édité par les utilisateurs du langage et propose de nombreuses ressources.

Début 2020, une nouvelle communauté d'utilisateurs fortran-lang.org est créée[36] 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[37], 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. La communauté édite une lettre mensuelle[38] 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 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[39].

Les efforts déployés par cette communauté expliquent en grande partie le retour en avril 2021 de Fortran à la 20e place du top 20 de l'index TIOBE puis à la 14e place en juillet 2021 et la 13e en août 2021[40].

L'International Fortran Conference (FortranCon) 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 prochaine édition est prévue pour 2023, un rythme d'environ dix-huit mois ayant été choisi.

Code source : format et syntaxeModifier

Ancien format fixeModifier

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 :

  • le code commence à partir de la 7e colonne et ne doit pas dépasser la 72e ;
  • 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 ;
  • 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 espaces n'ont pas de signification entre la 7e et la 72e colonnes. Ainsi, la boucle DO 10 I=1,5 peut aussi s'écrire DO10I=1,5[41]. Le 10 représente ici le label obligatoire de fin de boucle. L'extension MIL-STD-1753 du département de la Défense américain a introduit le END DO en FORTRAN 77 (à la place d'une instruction ou de CONTINUE) mais le label restait obligatoire[42].

Les extensions de fichiers les plus courantes pour le format fixe sont .f et .for, mais ce n'est qu'une convention et rien n'empêche de les utiliser avec le format libre.

Fortran moderneModifier

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

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[43], 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 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[44]. 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 = deg * (/ (coeff, 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.

CompilateursModifier

De nombreux compilateurs commerciaux ou libres sont disponibles.

Compilateurs actuelsModifier

Compilateurs libresModifier

Avant sa version 4.0, le compilateur libre GCC incluait le compilateur g77[45] pour le FORTRAN 77, qui a été remplacé en 2005[46],[47] par le compilateur GFortran[48], lui-même issu d'un fork réalisé en 2003 de G95, autre compilateur libre développé entre 2000 et janvier 2013. En septembre 2019, GFortran prend en charge quasiment intégralement Fortran 2003[49], presque tout Fortran 2008[50] et environ 20 % de Fortran 2018[51]. 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[52].

Omni Compiler[53] 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étairesModifier

On trouve de nombreux compilateurs commerciaux, parmi lesquels : Lahey[54], Absoft[55], Portland Group (en)[56] (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 de Fortran : Intel[57], IBM[58], Oracle (à la suite du rachat de Sun Microsystems[59]), HPE Cray[60] (Cray a été racheté par HP en 2019), etc. Le compilateur Intel Visual Fortran est l'héritier de DEC Visual Fortran, devenu Compaq Visual Fortran puis HP Visual Fortran.

Certains de ces compilateurs commerciaux ont des versions gratuites pour une utilisation non commerciale : c'est le cas d'Oracle[61], Portland Group[62].

Quant aux compilateurs Intel[63], ils sont depuis janvier 2021 gratuits pour tous les développeurs.

Compilateurs en cours de développementModifier

Début 2021, de nouveaux compilateurs Fortran basés sur LLVM sont en développement : LFortran [64] qui vise à permettre de tester du code de façon interactive, Flang[65] et Intel Fortran Compiler ifx[66] (actuellement en version Beta), destiné à terme à remplacer ifort.

Compilateurs en ligneModifier

Le Fortran fait partie des langages proposés par certains compilateurs en ligne, tels que codingground[67], OnlineGDB[68], JDOODLE[69] et godbolt Compiler Explorer[70]. 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 maintenusModifier

Outils de développementModifier

Éditeurs et environnements de développement intégrésModifier

La plupart des éditeurs de texte offrent une coloration syntaxique pour le Fortran : Atom, 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[74] dédiée au développement en Fortran. Il existe également une version d'Eclipse dédiée au Fortran, nommée Photran[75], mais dont la dernière version date de 2015. Sous Windows, le compilateur Intel Fortran est intégré à Visual Studio[76].

Gestionnaire de paquets et systèmes de constructionModifier

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

Mais Fortran dispose depuis fin 2020 du gestionnaire de paquets fpm (Fortran Package Manager)[78], 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 en Fortran.

Vérification et analyse de codeModifier

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

DébogueursModifier

On peut par exemple utiliser le débogueur GNU gdb[83] ou le débogueur idb (Intel Debugger)[84].

PréprocesseursModifier

Fypp[85] 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 unitairesModifier

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

Générateurs de documentationModifier

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

BibliothèquesModifier

Bibliothèques de calcul scientifiqueModifier

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é.

Bibliothèques graphiquesModifier

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[93] : bibliothèque graphique créée par le Max Planck Institute for Solar System Research. Multiplate-formes (UNIX, Linux, FreeBSD, OpenVMS, Windows et MS-DOS). Fonctionne avec de nombreux compilateurs, ainsi que d'autres langages que le Fortran. Gratuit pour un usage non-commercial.
  • GINO[94] : construction d'interfaces graphiques et d'outils de visualisation. Logiciel commercial pour Windows et Linux.
  • GrWin Graphics Library[95] : logiciel libre pour Windows.
  • gtk-fortran[96] permet de créer des interfaces graphiques GTK en Fortran, grâce au module ISO_C_BINDING introduit par la norme Fortran 2003. Multi-plateforme (Linux, Windows, macOS, FreeBSD, Raspberry Pi...). Licence GPL 3. Supporte aussi bien GTK 3 que GTK 4, ainsi que la GLib et PLplot.
  • JAPI (Java Application Programming Interface)[97] : 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[98] : construction d'interfaces graphiques et bibliothèques numériques et graphiques pour Fortran et d'autres langages. Logiciel commercial pour Windows et Linux.
  • ogpf[99] 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)[100] : 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[101] : bibliothèque graphique fournie avec le Compaq Visual Fortran (désormais Intel Visual Fortran). Ne fonctionne que sous Windows.
  • Winteracter[102] : 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 langagesModifier

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[103] (Fortran to Python interface generator), qui fait partie de NumPy.

Autres langages pour le calcul scientifiqueModifier

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

  • C et C++[104],
  • 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[105],[106]. MATLAB était à l'origine un programme en Fortran, distribué aux universités et aux centres de recherche[107].

Par ailleurs, des langages de programmation ont été développés dans les années 2000 pour faciliter la programmation parallèle sur les superordinateurs, un domaine où Fortran est très utilisé. 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érencesModifier

  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. Preliminary Report, Specifications for the IBM Mathematical FORmula TRANslating System, FORTRAN [PDF].
  3. « John Backus », sur IBM Archives (consulté le ).
  4. 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.
  5. (en) « “We thank Miss Mary Tsingou” », sur www.lanl.gov (consulté le )
  6. (en) John Backus, « The history of FORTRAN I, II, and III », ACM SIGPLAN Notices, vol. 13, no 8,‎ , p. 165-180 (DOI 10.1145/960118.808380, lire en ligne).
  7. (en) Irving N. Rabinowitz, « Report on the algorithmic language FORTRAN II », Communications of the ACM, vol. 5, no 6,‎ , p. 327-337 (DOI 10.1145/367766.368151).
  8. FORTRAN II Reference Manual for the IBM 704 (1958)
  9. Description of /360 WATFOR - A FORTRAN IV Compiler
  10. [PDF] Standard ECMA FORTRAN.
  11. [PDF] Norme FORTRAN 66.
  12. John Backus A.M. Turing Award (1977).
  13. [PDF] Norme FORTRAN 77.
  14. (en) Frank Engel, Jr., « Draft proposed ANS FORTRAN BSR X3.9 X3J3/76 », ACM SIGPLAN Notices, vol. 11, no 3,‎ , p. 1-212 (DOI 10.1145/956013.1070892).
  15. [PDF] MIL-STD-1753, Military Standard: FORTRAN, DOD Supplement to American National Standard X3.9-1978.
  16. [PDF] Standard Fortran 90.
  17. IEEE 1003.9-1992 - POSIX(R) FORTRAN 77 Language Interfaces - Part 1: Binding for System Application Program Interface (API).
  18. ISO/IEC 1539-2:1994 -- Information technology -- Programming languages -- FORTRAN -- Part 2: Varying length character strings.
  19. ISO/IEC 1539-2:2000 -- Information technology -- Programming languages -- Fortran -- Part 2: Varying length character strings.
  20. [PDF] Standard Fortran 95.
  21. ISO/IEC 1539-3:1999 -- Information technology -- Programming languages -- Fortran -- Part 3: Conditional compilation.
  22. [PDF] Standard Fortran 2003.
  23. initiée par Simula 67 et popularisée par C++ et Java.
  24. [PDF] Standard Fortran 2008.
  25. [PDF] Standard Fortran 2018.
  26. Fortran 202x - Development Schedule.
  27. WD 1539-1 J3/21-007r1 (Fortran 202x Working Draft), 21 mai 2021
  28. Groupe de travail ISO/IEC JTC1/SC22/WG5
  29. Comité Fortran US J3
  30. Compiler Support for the Fortran 2003 Standard.
  31. Compiler Support for the Fortran 2008 Standard.
  32. (en) « GitHub - j3-fortran/fortran_proposals: Proposals for the Fortran Standard Committee », sur GitHub (consulté le )
  33. (en) « SIGPLAN-FORTRAN Home », sur dl.acm.org (consulté le )
  34. « Annonce de la création du groupe de discussion net.lang.f77 », sur groups.google.com (consulté le )
  35. « comp.lang.fortran - Google Groupes », sur groups.google.com (consulté le )
  36. Milan Curcic, Ondřej Čertík, Brad Richardson et Sebastian Ehlert, « Toward Modern Fortran Tooling and a Thriving Developer Community », arXiv:2109.07382 [cs],‎ (lire en ligne, consulté le )
  37. (en) « The Fortran Programming Language », sur GitHub (consulté le )
  38. « News - Fortran Programming Language », sur fortran-lang.org (consulté le )
  39. (en) « Google Summer of Code, Fortran-lang projects », sur summerofcode.withgoogle.com (consulté le )
  40. « index | TIOBE - The Software Quality Company », sur www.tiobe.com (consulté le )
  41. Attention, écrire DO 10 I=1.5 sans espace (DO10I=1.5) affecterait la valeur 1.5 à la variable DO10I.
  42. MIL-STD-1753.
  43. 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.
  44. (en) Metcalf, Michael; Reid, John; Cohen, Malcolm, Modern Fortran Explained: Incorporating Fortran 2018, Oxford Univ. Press, (ISBN 978-0198811886)
  45. Copie de l'ancien site de g77 sur le site de l'USGS.
  46. GCC 4.0 Release Series - Changes, New Features, and Fixes.
  47. Code source de GCC 4.0.0.
  48. GCC Wiki - GFortran.
  49. gfortran - Fortran 2003 status.
  50. gfortran - Fortran 2008 status.
  51. gfortran - Fortran 2018 status.
  52. (en) « OpenCoarrays », sur OpenCoarrays (consulté le )
  53. Omni Compiler.
  54. Lahey Fortran.
  55. Absoft Fortran.
  56. Portland Group Fortran.
  57. Intel Fortran Compilers.
  58. IBM - Fortran Compilers family.
  59. Oracle Solaris Studio.
  60. CrayDoc - Customer Documentation0
  61. Téléchargement de Oracle Solaris Studio.
  62. PGI Community Edition, pour Linux et macOS.
  63. Compiltateurs Intel gratuits pour tous les développeurs .
  64. LFortran
  65. Flang
  66. Intel Fortran Compiler ifx
  67. Compilateur en ligne codingground.
  68. Compilateur en ligne OnlineGDB.
  69. Compilateur en ligne JDOODLE.
  70. Compilateur en ligne godbolt Compiler Explorer.
  71. Open Watcom.
  72. PathScale EKOPath.
  73. Bitsavers - documentation d'ordinateurs anciens.
  74. (en) darmar, « Code::Blocks IDE for Fortran », sur CBFortran, (consulté le )
  75. (en) Jeffrey Overbey, « Photran - An Integrated Development Environment and Refactoring Tool for Fortran | The Eclipse Foundation », sur www.eclipse.org (consulté le )
  76. Intel Compilers Compatibility with Microsoft Visual Studio and Xcode
  77. « Utilitaire makedepf90 »
  78. Fortran Package Manager fpm.
  79. www.simconglobal.com, « WinFPT and ftp - Fortran Engineering - Summary », sur simconglobal.com (consulté le )
  80. CamFort
  81. fthcneck
  82. « findent, indenteur de code source Fortran. »
  83. « GDB: The GNU Project Debugger », sur www.gnu.org (consulté le )
  84. (en) « Intel Debugger », dans Wikipedia, (lire en ligne)
  85. « Fypp documentation — Fypp 3.1 documentation », sur fypp.readthedocs.io (consulté le )
  86. Verification of Fortran Codes
  87. Framework de tests unitaires test-drive.
  88. Framework de tests unitaires vegetables.
  89. Framework de tests unitaires FRUIT.
  90. Fortran-FOSS-Programmers/ford, Fortran F/OSS Programmers Group, (lire en ligne)
  91. « ROBODoc », sur rfsber.home.xs4all.nl (consulté le )
  92. http://www.netlib.org/lapack/.
  93. DISLIN
  94. GINO
  95. GrWin Graphics Library
  96. gtk-fortran
  97. JAPI (Java Application Programming Interface)
  98. MATFOR
  99. « ogpf, interface gnuplot en Fortran orienté objet »
  100. PLplot
  101. Quickwin
  102. Winteracter
  103. « F2PY Users Guide and Reference Manual — NumPy v1.21 Manual », sur numpy.org (consulté le )
  104. Par exemple la GSL écrite en C, et Blitz++ ou IML++, en C++.
  105. MATLAB Incorporates LAPACK.
  106. Dev Community in Scilab.
  107. Code source de la première version de MATLAB.

Voir aussiModifier

Sur les autres projets Wikimedia :

BibliographieModifier

Articles connexesModifier

Autres liens externesModifier