Fortran va bénéficier des expressions conditionnelles

Fortran, le langage de programmation pensé pour le calcul scientifique, va bénéficier des expressions conditionnelles.
La syntaxe a été présentée aux développeurs

Fortran (mathematical FORmula TRANslating system) est un langage de programmation dont le domaine de prédilection est le calcul scientifique et le calcul numérique. Pensé dans les années 50 pour le calcul scientifique, il continue cependant à être largement utilisé dans le domaine de la recherche scientifique pour le calcul intensif. D'ailleurs, 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.

Contrairement à des langages plus évolués, le déroulement des opérations individuelles en machine reste relativement contrôlable dans le langage, ce qui permet d'écrire des codes relativement efficaces en termes de calcul. 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 contribué à maintenir l'usage de ce langage.

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 (Fortran 2008), et le calcul parallèle de façon native (Coarray Fortran 2008/2018), en plus des interfaces OpenMP, OpenACC et de la bibliothèque Message Passing Interface.

Pièce jointe 601161
Exemple de code écrit en Fortran

Les développeurs vont pouvoir profiter des expressions conditionnelles. Comme l'a noté Malcolm Cohen, diverses fonctionnalités avaient été proposées pour les fonctionnalités «*conditionnelles et*» avec l'intention d'être livrées dans Fortran 2008. Cependant, faute du manque de consensus quant à savoir s'il s'agissait de fonctions ou d'opérateurs, cela n'a pas été le cas. C'est dans ce contexte qu'en 2018 a été proposée une autre approche qui a fait l'objet de discussions au sein de la communauté.

Cette fois-ci, le consensus semble avoir été trouvé et la syntaxe des expressions conditionnelles a été présentée aux développeurs. La proposition a été approuvée, mais la norme finale sera votée et il faudra du temps pour qu'elle apparaisse dans les compilateurs.

Voici un exemple de syntaxe (expression conditionnelle avec elseif-chaining)*:

Code:

( cond ? expr : cond2 ? expr2 : expr3 )

Forme recommandée pour les arguments conditionnels avec option*:

Code:

( cond ? arg : cond2 ? arg2 : arg3 )

Où le jeton spécial .NIL. signifie qu'il n'y a pas d'argument (cela n'entre pas en conflit avec les opérateurs utilisateur, car ce jeton spécial est toujours suivi de deux-points ou de parenthèses droites, et cela ne peut pas arriver pour les opérateurs).

Forme précédente pour l'argument conditionnel avec option*:

Code:

( cond ? arg : cond2 ? arg2 ) ! else absent arg

Concernant la syntaxe formelle, il est indiqué :

Un <conditional-expr> est un primaire (<primary>).
Un <conditional-arg> est un argument actuel (<actual-arg>).

Dans les descriptions de syntaxe ci-dessous, les parties séparées sont sur des lignes séparées uniquement pour faciliter la lecture – dans la norme, ils seraient soit sur une longue ou plusieurs lignes jointes avec les marqueurs de continuation.
Code:

1 2 3 4 5 6 7 8 9 10 <conditional-expr> ::= ( <scalar-logical-expr> ? <then-expr> : <scalar-logical-expr> ? <elseif-expr> ]... : <else-expr> ) <conditional-arg> ::= ( <scalar-logical-expr> ? <consequent-arg> : <scalar-logical-expr> ? <consequent-arg> ]... : <consequent-arg> ) <consequent-arg> ::= <actual-arg> | .NIL.
Contraintes et autres exigences :

Contrainte*: chaque <expr> dans une <conditional-expr> doit avoir le même type déclaré, les mêmes types de paramètres et rang.
Contrainte*: dans un <conditional-arg>, chaque <expr> ou <variable> qui est un <consequent-arg> doit avoir le même type déclaré, les mêmes types de paramètres et rang.
Contrainte*: au moins un élément <consequent-arg> d'un élément <conditional-arg> ne doit pas être .NIL..
Contrainte : un <consequent-arg> ne doit pas être .NIL. à moins que le correspondant argument factice ne soit facultatif.
Contrainte*: dans un <conditional-arg> qui correspond à un INTENT(OUT) ou INTENT(INOUT) factice, chaque <consequent-arg> doit être un <variable>.
Contrainte : Si l'argument fictif correspondant est allouable, un pointeur ou un tableau, les attributs de chaque <consequent-arg> doivent satisfaire aux exigences de cet argument factice.

Cela permet d'éliminer la possibilité d'une erreur de non-concordance d'arguments au runtime en fonction des résultats des <scalar-logical-expr>. Le libellé permet à un argument conséquent d'être un pointeur, allouable, ou d'avoir un corank indépendamment des autres arguments conséquents, mais pas indépendamment de l’
argument factice.
Contrainte : Dans une référence à une procédure générique, chaque <consequent-arg> dans un <conditional-arg> doit avoir le même corank, et si un <expr> dans un <conditional-arg> a l'allouable ou le pointeur attribut, chaque <expr> doit avoir cet attribut.

Cela conserve la résolution générique au moment de la compilation.

Par exemple :
Code:

1 2 y = ( i>=1 .And. i<=Size(a) ? a(i) : -Huge(y) ) x = ( Out_Of_Range(y,x) ? Ieee_Value(Ieee_Quiet_NaN,x) : y )
Tout ceci découle directement du cahier des charges.

L'évaluation d'un <conditional-expr> ou <conditional-arg> sélectionne un <expr> ou un <consequent-arg> en évaluant chaque <scalar-logical-expr> à son tour jusqu'à ce que l'un d'eux soit vrai, ou qu'il n'y en ait plus. Si tous les <scalar-logical-expr> sont évalués à false, le dernier <expr> ou <consequent-arg> est sélectionné.
Le type déclaré, les paramètres de type et le rang d'un <conditional-arg> ou <conditional-expr> sont ceux des <expr> ou <actual-arg> qu'il contient.
La valeur d'une <conditional-expr> est la valeur de l'<expr> sélectionnée.
Si l'évaluation d'un <conditional-arg> sélectionne .NIL., il n'y a pas d'argument effectif associé à l'argument factice. Sinon, l'<expr> ou la <variable> sélectionnée est l'argument effectif.
Toutes les exigences statiques d'un argument factice sur des arguments effectifs s'appliquent à tout <consequent-arg>, par exemple si les objets co-indexés sont interdits en tant qu'argument réel, ils sont également interdits en tant qu'argument conséquent.

Si la forme précédente est choisie à la place de la forme recommandée :
Code:

1 2 3 <conditional-arg> ::= ( <scalar-logical-expr> ? <consequent-arg> : <expr-logique-scalaire> ? <argument-consequent> ]... : <consequent-arg> ] )
Contrainte*: si l'argument factice correspondant n'est pas facultatif, le dernier facultatif ": <consequent-arg>" doit apparaître.

L'évaluation d'une <conditional-expr> ou <conditional-arg> sélectionne une <expr> ou une <variable> en évaluant chaque <scalar-logical-expr> à son tour jusqu'à ce que l'une d'entre elles soit vraie, ou qu'il n'y en ait plus. Si toutes les <scalar-logical-expr> ont la valeur false et que la dernière <expr> ou <variable> est immédiatement précédée de deux points, cette <expr> ou <variable> est sélectionnée.

Si l'évaluation d'un argument <conditional-arg> ne sélectionne aucune <expr> ou <variable>, aucun argument effectif n'est associé à l'argument factice. Sinon, l'<expr> ou la <variable> sélectionnée est l'argument effectif.

Bien qu'elles n'aient pas été intégrées au langage, les expressions conditionnelles ont été utilisées pour la première fois en Fortran en 1957 par John McCarthy*: « J'ai inventé des expressions conditionnelles en relation avec un ensemble de routines de mouvements légaux d'échecs que j'ai écrites en FORTRAN pour l'IBM 704 au MIT en 1957-58. Ce programme n'utilisait pas de traitement de liste. L'instruction IF fournie dans FORTRAN 1 et FORTRAN 2 était maladroite à utiliser, et il était naturel d'inventer une fonction XIF(M,N1,N2) dont la valeur était N1 ou N2 selon que l'expression M était nulle ou non. La fonction raccourcissait de nombreux programmes et les rendait plus faciles à comprendre, mais il devait être utilisé avec parcimonie, car les trois arguments devaient être évalués avant que XIF ne soit entré, puisque XIF était appelé comme une fonction FORTRAN ordinaire, bien qu'écrite en langage machine. Cela a conduit à l'invention de la véritable expression conditionnelle qui n'évalue qu'un seul des N1 et N2 selon que M est vrai ou faux et à un désir d'un langage de programmation qui permettrait son utilisation. »

Sources : Fortran (1, 2), John McCarthy

Et vous ?

:fleche: Avez-vous déjà utilisé Fortran ? Qu'en pensez-vous ?
:fleche: Que pensez-vous de l'ajout des expressions conditionnelles dans le langage ?

Voir aussi :

:fleche: Le langage Julia serait-il plus rapide que Fortran et plus propre que NumPy ? Oui, selon Martin Maas, un développeur
:fleche: ogpf propose une interface orientée objet pour réaliser des graphiques depuis Fortran, la bibliothèque est maintenant disponible via fpm
:fleche: Sortie de gtk-fortran 4.0 pour la réalisation d'interfaces graphiques en Fortran moderne, la nouvelle version donne accès aux nouveautés de GTK 4
:fleche: Index TIOBE : Objective-C perd de sa popularité et quitte le top 20 des langages de programmation alors que l'on assiste à un regain de croissance pour le langage Fortran
:fleche: FPM, un gestionnaire de paquets officiel pour Fortran qui gère aussi la compilation des programmes