Fortran 90

        Voici un survol très rapide du langage utilisé dans les programmes de mon stage : le Fortran 90.  Ce n'est pas une introduction à la programmation en Fortran 90, mais plutôt une aide pour le vocabulaire utile.  Il est très important de noter pour la lecture et l'écriture que chaque ligne de code correspond à une ligne d'exécution.

        Déclarations
            - de variables
                type :: première_variable, deuxième_variable... (ex.: REAL :: i,j)
            - nombres complexes
               complexe :: nom_variable
            - de constantes
               type,PARAMETER, :: nom = valeur (ex.: INTEGER,PARAMETER :: n=1)
            - de vecteurs
               type,DIMENSION(longueur) :: nom (ex.: REAL,DIMENSION(2) :: duo)
            - de tableaux
               type,DIMENSION(#rangées, #colonnes) :: nom (ex.: INTEGER,DIMENSION(2:4) :: matrice)

        Assignation
            - variables
                variable = valeur
            - nombres complexes
               nombre_complexe = (partie_réelle,partie_imaginaire)
            - vecteurs
               nom_vecteur = (/valeurs/)
               nom_vecteur(position) = valeur
            - tableaux
               nom_tableau = (/a₁₁, a₁₂, ... /)
               nom_tableau(position_colonne,position_rangée) = valeur

        Opérateurs
            - arithmétiques
                .nom_opérateur. ou signe (ex.: .EQ. ou ==, .NE. ou /=, .LE. ou <=, .GT. ou >, etc.)
            - logiques
                .nom_opérateur. (ex.: .AND. , .OR. , etc.)

        Fonctions
            - logarithme naturel : LOG(x)
            - logarithme en base a : LOGA(x)
            - arrondir : NINT(x)
            - sinus : SIN(x)
            - modulo a de b : MOD(a,b) ; ex.: MOD(13,7) = 6
            - arcsinus : ASIN(x)
            - conjugué complexe : CONJG(x)
            - ...

        Opération de base
            - Lecture
                READ(a,b) première_variable, deuxième_variable, ...
                    Un chiffre à la place du a indique l'unité de lecture et un chiffre à la place du b indique le format de lecture.
                    Un astérisque (*) à la place de a et/ou de b indique que l'unité et/ou le format sera lu(e)(s) selon le modèle standard.
            - Écriture
                WRITE(a,b) 'Texte a afficher', première_variable, deuxième_variable, 'Autre texte'
                    Un chiffre à la place du a indique l'unité d'écriture et un chiffre à la place du b indique le format d'écriture.
                    Un astérisque (*) à la place de a et/ou de b indique que l'unité et/ou le format sera écrit(e)(s) selon le modèle standard.
                    Il est très important de ne pas mettre d'apostrophe dans le texte à afficher, car ils indiquent la fin du texte à afficher.
           - Non implicit
                IMPLICIT NONE
                    Pour avoir un message d'erreur si l'exécution du programme avorte, on doit insérer cette ligne.
            - Condition
                IF(condition1) THEN
                   exécution1
                ELSE IF(condition2) THEN
                   exécution2
                ELSE
                   exécution par défaut
                ENDIF
            - Il est aussi possible, pour une seule condition et une seule exécution pour cette condition, de faire (une seule ligne sans endif) :
                IF(condition) exécution
            - Cas à plusieurs options
                SELECT CASE (variable)
                CASE(première_option)
                   exécution
                CASE(deuxième_option)
                   exécution
                END SELECT
            - Boucles
                DO variable = valeur_de_départ, valeur_de_fin, incrément
                   exécution
                END DO
                    S'il n'y a pas de valeur pour l'incrément, il est par défaut de un (1).
                    Le changement de valeur de la variable se fait lors du retour au début.
            - Varia
                CYCLE
                    Lors d'une boucle, pour retourner immédiatement un début de celle-ci sans faire le reste de l'exécution.
                EXIT
                    Lors d'une boucle, pour sortir immédiatement de celle-ci, sans rien faire du reste de l'exécution et des incréments suivants.

        Sous-routines
            - Déclaration
                SUBROUTINE NOM_SOUS-ROUTINE(variables entrantes et sortantes)
                   exécution
                END SUBROUTINE NOM_SOUS-ROUTINE
            - Appel
                CALL NOM_SOUS-ROUTINE(variables entrantes et sortantes)
            - Variables entrantes (déclarations)
                type, INTENT(IN) :: noms_variables_entrantes
            - Variables sortantes (déclarations)
                type, INTENT(OUT) :: noms_variables_sortantes
            - Variables entrantes et sortantes
               type, INTENT(INOUT) :: noms_variables
                    On ne peut changer une variable seulement entrante, in faut donc la faire entrer et sortir.
            - Pour que des valeurs ne soient pas changer entre l'exécution des sous-routines, il faut utiliser :
               type, SAVE :: variable1, variables2 ...
                    ou
                SAVE
                    L'utilisation de la commande SAVE seule rend son exécution sur l'ensemble des variables de cette sous-routine.

        Modules
            - Déclarations
                MODUL NOM_MODULE
                   exécution
                END MODULE NOM_MODULE
            - Appel
                USE NOM_MODULE
            - Appel restreint
                USE NOM_MODULE, ONLY :: variable1, variable2 ...
                    L'appel de module doit se faire avant l'ensemble des déclarations

        Fonctions
            - Déclarations
               FUNCTION NOM_FONCTION(variables_utilisées)
                   exécution
                END FUNCTION NOM_FONCTION
            - Appel
                NOM_FONCTION(variables_utilisées)
            - Déclarations dans la sous-routine ou le programme où utilisée
               type :: NOM_FONCTION

        Vecteurs de différents types
            - Définition
                TYPE :: nom_du_type
                    type1 :: nom_sous-variables
                   type2 :: nom_sous-variables
                    ...
                END TYPE nom_du_type
            - Déclarations
                nom_du_type :: variable1, variable2 ...
            - Sélection d'une composante
               nom_variables%nom_sous-variables