Formation Fortran 90/95 basique
Prérequis: connaissance opérationnelle d'un language de programmation

Introduction

    * Historique
    * bibliographie
    * documentation

Généralités

    * Mon premier programme Fortran
    * Unités de programme
    * Syntaxe  de base

 Déclarations

    * Types de base
    * Instruction IMPLICIT NONE
    * Constantes littérales
    * Initialisation
    * Constantes symboliques
    * Durée de vie des identificateurs
    * Instruction EQUIVALENCE

 Opérateurs et expressions

    * Opérateurs arithmétiques
    * Opérateurs relationnels
    * Opérateurs logiques
    * Opérateur de concaténation
    * Opérateur d'affectation
    * Priorité des Opérateurs

 Structures de contrôle

    * Les tests
    * Les itérations

 Tableaux

    * Déclaration
    * Définitions (rang, profil, étendu)
    * Initialisation
    * Manipulation de tableaux

Types structurés

 Entrées-Sorties

    * Fichier binaire séquentiel
    * Fichier texte séquentiel
    * Fichier binaire à accès direct
    * Fichier texte à accès direct
    * Fichier interne
    * Instructions de positionnement
    * Instruction INQUIRE

 Procédures

    * Arguments, paramètres
    * Subroutines
    * Fonctions
    * Arguments de type chaîne de caractères
    * Arguments de type tableau
    * Arguments de type procédure
    * Procédures internes
    * Procédures intrinsèques

 Common

    * L'instruction COMMON
    * Common blanc
    * Common étiqueté

 Include

    * La directive INCLUDE

Le bon usage du langage

    * Recommandations  de style
    * A éviter

Conclusion : ce qu'il reste à voir
    * pointeurs, opérateurs, interfaces, visibilité




Formation Fortran 90/95 avancé
Prérequis: connaissance de Fortran 77

  Introduction : historique, évolution, documentation, ...

    * 1.1 - Historique
    * 1.2 - Compatibilité norme 77/90
    * 1.3 - Apports de Fortran 90
    * 1.4 - Aspects obsolètes
    * 1.5 - Évolution : nouveautés Fortran 95
    * 1.6 - Comparaisons avec d'autres langages
    * 1.8 - Bibliographie
    * 1.9 - Documentation

 2 Généralités : syntaxe, typage, mise en oeuvre, ...

    * 2.1 - Structure d'un programme
    * 2.2 - Éléments syntaxiques
          o 2.2.1 - Les identificateurs
          o 2.2.2 - Le "format libre"
          o 2.2.3 - Les commentaires
          o 2.2.4 - Le "format fixe"
          o 2.2.5 - Les déclarations
          o 2.2.6 - Typage et précision des nombres : paramètre KIND
    * 2.3 - Compilation, édition des liens, exécution

 3 Types dérivés (structures de données)

    * 3.1 - Définition et déclaration de structures
    * 3.2 - Initialisation (constructeur de structure)
    * 3.3 - Symbole % d'accès à un champ
    * 3.4 - Types dérivés et procédures
    * 3.5 - Types dérivés et entrées/sorties
    * 3.6 - Conclusion et rappels

 4 Programmation structurée

    * 4.1 - Introduction
    * 4.2 - Boucles DO
    * 4.3 - Construction SELECT-CASE

 5 Extensions tableaux

    * 5.1 - Définitions (rang, profil, étendue,...)
    * 5.2 - Manipulations de tableaux (conformance, constructeur, section, taille,...)
    * 5.3 - Tableau en argument d'une procédure (taille et profil implicites)
    * 5.4 - Section de tableau non contiguë en argument d'une procédure
    * 5.5 - Fonctions intrinsèques tableaux
          o 5.5.1 - Interrogation (maxloc, lbound, shape,...)
          o 5.5.2 - Réduction (all, any, count, product,...
          o 5.5.3 - Multiplication (matmul, dot_product,...)
          o 5.5.4 - Construction/transformation (reshape, cshift, pack, merge, transpose,...)
    * 5.6 - Instruction et bloc WHERE
    * 5.7 - Expressions d'initialisation

 6 Gestion mémoire

    * 6.1 - Tableaux automatiques
    * 6.2 - Tableaux dynamiques (ALLOCATABLE , profil différé)

 7 Pointeurs

    * 7.1 - Définition, états d'un pointeur
    * 7.2 - Déclaration d'un pointeur
    * 7.3 - Symbole =>
    * 7.4 - Symbole = appliqué aux pointeurs
    * 7.5 - Allocation dynamique de mémoire
    * 7.6 - Fonction NULL() et instruction NULLIFY
    * 7.7 - Fonction intrinsèque ASSOCIATED
    * 7.8 - Situations à éviter
    * 7.9 - Déclaration de ``tableaux de pointeurs''
    * 7.10 - Passage en argument de procédure
    * 7.11 - Pointeurs et COMMON
    * 7.12 - Exemple de liste chaînée

 8 Interface de procédures et modules

    * 8.1 - Interface ``implicite'' : définition
    * 8.2 - Interface ``implicite'' : exemple
    * 8.3 - Arguments : attributs INTENT et OPTIONAL
    * 8.4 - Passage d'arguments par mot-clé
    * 8.5 - Interface ``explicite'' : procédure interne (CONTAINS)
    * 8.6 - Interface ``explicite'' : 5 cas possibles
    * 8.7 - Interface ``explicite'' : bloc interface
    * 8.8 - Interface ``explicite'' : ses apports
    * 8.9 - Interface ``explicite'' : module avec bloc interface (USE)
    * 8.10 - Interface ``explicite'' : module avec procédure
    * 8.11 - Cas d'interface ``explicite'' obligatoire
    * 8.12 - Argument de type procédural et bloc interface

 9 Interface générique

    * 9.1 - Introduction
    * 9.2 - Exemple avec "module procedure"
    * 9.3 - Exemple : contrôle de procédure F77

 10 Surcharge d'opérateurs

    * 10.1 - Introduction
    * 10.2 - Interface operator
    * 10.3 - Interface assignment

 11 Contrôle de visibilité, encapsulation et gestion de zones dynamiques

    * 11.1 - Introduction
    * 11.2 - Instruction PRIVATE et PUBLIC
    * 11.3 - Attribut PRIVATE et PUBLIC
    * 11.4 - Type dérivé ``semi-privé''
    * 11.5 - Exemple complet avec gestion des zones dynamiques inaccessibles en retour de fonction
    * 11.6 - Paramètre ONLY de l'instruction USE

 12 Procédures récursives

    * 12.1 - Procédures récursives : clause RESULT
    * 12.2 - Procédures récursives : exemple

 13 Nouveautés sur les E./S.

    * 13.1 - OPEN (status, position, action, delim,...)
    * 13.2 - INQUIRE (recl, action, iolength, delim,...)
    * 13.3 - Entrées-sorties sur les fichiers texte (advance='no')
    * 13.4 - Instruction NAMELIST
    * 13.5 - Spécification de format minimum

 14 Quelques nouvelles fonctions intrinsèques

    * 14.1 - Conversions entiers/caractères (char, ichar,...)
    * 14.2 - Comparaison de chaînes (lge, lgt, lle, llt)
    * 14.3 - Manipulations de chaînes (adjustl, index, scan,...)
    * 14.4 - Transformations de chaînes( transfer)
    * 14.5 - Précision et codage numérique (tiny, huge, epsilon, nearest, spacing,...)
    * 14.6 - Temps, nombres aléatoires (cpu_time, date_and_time, random_number,...)
    * 14.7 - Opérations sur les bits ( iand, ior, ishft, ibits,...)

15 Le bon usage du langage

    * 15.1 - Recommandations  de style
    * 15.2 - programmation fonctionnelle versus orientée objet

16 Les outils - la pratique

    * 16.1 - Environnements de développement
    * 16.2 - Compilateurs
    * 16.3 - Optimisation - profiling
    * 16.4 - Bibliothèques pour le calcul scientifique
    * 16.5 - Cohabitation avec les autres langages: appels, traducteurs
    * 16.6 - Stratégie de tests
    * 16.7 - Projet et cycle de développement
    * 16.8 - Interfaces Homme-Machine

17 Mini-projet
    * 17.1 - Création d'une petite bibliothèque réutilisable,
    * 17.2 - ou bien création d'un petit logiciel à partir de bibliothèques existantes
    * Thème à choisir avec un chef de projet