\chapter{Fortran} \label{chap:Fortran} \index{Fortran}

Fortran (\textsc{FORmula TRANslator}) est, avec le Cobol\index{Cobol},
un des premiers langages évolués. Il a été conçu après la seconde
guerre mondiale, en 1954, par
John Warner Backus, ingénieur en radiophonie chez IBM\index{IBM},

%	========================================

\section{F77}

Dernière version à exiger le format '80 colonnes' des cartes perforées,
cette version est aussi (aux yeux de vieux dinos) la plus pure,
à cause d'instructions comme le \textsl{computed goto} ou le
mythique \textsl{comefrom}\footnote{Keyword: Datamatic}.
Nom officiel : \texttt{ANSI X3.9-1978}.

%	============****************===============

% https://linuxfr.org/users/vmagnin/journaux/taptempo-fortran

\section{Gfortan} \index{gfortran}

Puis ce langage du passé a subi une évolution lente vers quelque
chose de bien plus moderne : le Fortran 90.
Les dinos vont devoir s'adapter.
Et songer à utiliser un \texttt{gfortran} moderne,
un élément de la Gnu Compiler Collection\index{gcc}.

Comme pour tous les langages de programmation,
il est obligatoire d'avoir l'exemple canonique, donc le voilà.
Il faut l'enregister dans un fichier nommé \texttt{hello.f90}
pour que le compilateur puisse admettre que c'est écrit
en \textsl{free form format}.

\begin{verbatim}
$ cat hello.f90
program hello
    implicit none
    print *, "hello world"
end
$ gfortran -Wall hello.f90 -o hello && ./hello
 hello world
$
\end{verbatim}

% --------------------------------------------------------
%
% https://fortranwiki.org/fortran/show/Command-line+arguments
%
\section{Args \& Env}

Un fort beau programme, mais il est un peu fermé au monde extérieur.
Quand on lance un programme, il peut recevoir des instructions
par (mais pas que) deux canaux : les arguments de la ligne de commande
et les variables d'environnement.

\begin{verbatim}
program rum_me
  implicit none
  integer               :: nbarg, foo
  character(len=32)     :: arg

  nbarg = IARGC()
  if (nbarg .GT. 0) then
    do foo=1, nbarg
       call GETARG(foo, arg)
       print *, foo,"   ",  arg
    enddo
  endif
end
\end{verbatim}

Si un des arguments doir être vu comme une valeur numérique,
il faut la convertir avant usage. Exemple pour un nombre
flottant~:

\begin{verbatim}
  character(len=89)             :: arg
  real                          :: cx
  call getarg(2, string)
  read (string, *) cx
\end{verbatim}

% --------------------------------------------------------

\section{Tableaux}

Rank, Size, \textsc{allocatable}, toussa\dots

Amies du C, soyez d'entrée prévenues, en Fortran, l'indice
par défaut du premier élément d'un tableau est \textbf{1},
mais cette valeur peut être modifiée à la déclaration
du tableau.

% --------------------------------------------------------

\section{Fichiers}

Pour qui vient du C et de la philosophie Unix, la gestion
des fichiers en Fortran est assez déroutante%
\footnote{Par contre, pour un dino des \textsl{big irons}\dots}.
Il semble qu'il y ait deux concepts orthogonaux :

\begin{itemize}
\item Direct access \textit{vs.} Sequential access
\item Formtated \textit{vs.} Unformated
\end{itemize}

\textit{Open, Read, Write, Inquire, toussa\dots}

\subsection{Sequentiel texte}

XXX\index{XXX}

\subsection{Indexé} \index{index}

XXX\index{XXX}

% --------------------------------------------------------

\section{Modules}

Une notion essentielle, à mon avis, pour écrire des programmes
au-delà de 104 lignes. Oui, j'avoue, j'ai bien changé depuis
l'époque où je confectionnait des procédures \textsl{monobloc}
de 1337 lignes, avec une bonne centaine de \texttt{GOTO} dedans.

Il serait bon de voir un exemple du monde réel. Ou juste un
exemple basique. Mais avec des explications. Parce que ce n'est pas
vraiment évident. Mais c'est un concept balaize.

% --------------------------------------------------------
\section{Random et Aléa}

La dernière ligne va vous étonner.

\begin{verbatim}
    integer, dimension(3) :: tarray
    integer               :: t3
    real                  :: dummy
    call itime(tarray)
    t3 = 3600*tarray(1) + 60*tarray(2) + tarray(3)
    write(0, '(A,3I3,A,I6)') "sranding: ", tarray, " --> ", t3
    call srand(t3)
    ! after initializing the random generator engine,
    ! you MUST use it for initializing the initializer
    dummy = rand()
\end{verbatim}

% --------------------------------------------------------
% new Thu 24 Nov 2022 02:27:05 AM CET

\section{Options de gfortran} \index{gfortran}

Comme d'habitude avec gcc\footnote{The Gnu Compiler Collection}, les
options sont innombrables. J'ai essayé d'en dégager les plus importantes,
mais ce ne sont probablement pas les seules.

% --------------------------------------------------------
% new 29 decembre 2022

\section{Nombres complexes}

Partie imaginaire : \texttt{ipart = aimag(cmplx)}.

% --------------------------------------------------------

\section{Images}

La bibliothèque \textbf{Plplot} semble être un bon choix pour commencer,
mais il existe bien d'autres options.
Par exemple \textbf{g2} (page \pageref{g2}) semble être utilisable
avec les vieux F77, et possiblement avec un Fortran moderne, il faut juste
un peu de \textsc{rtfm}.

Nous allons donc commencer par Plplot, pour envisager ensuite les alternatives.

% --------------------------------------------------------

\subsection{Plplot} \index{plplot} \label{ploplt}

Commençons directement par un EMC\footnote{Exemple Minimal Compilable}
qui ne va pas faire grand chose, à part initialiser la machinerie
interne de Plplot qui est assez avancée.
Il y a beaucoup de paramètres réglables, mais aussi des fonctions
qui gèrent pour vous les valeurs « par défaut ».
Voyez cette exemple comme un \textsl{boilerplate} simple
ou un \textsc{HelloWorld}~:

\begin{verbatim}
program dessine
  use plplot
  implicit none
  call plinit ()
  call plenv(-2.1, 2.1, -2.1, 2.1, 0, 0)
  call plend
end program
\end{verbatim}

Il ne se passe pas grand chose, sauf la proposition de choisir
le type de sortie.
Dans la version que j'ai (XXX\index{XXX}), on a le choix entre
X-Window, PostScript mono ou couleur, Xfig, Null, UserMemory et SVG.
C'est intriguant de ne pas avoir au moins \textbf{un} format
pixmap\index{pixmap}.

Laissons cette question en suspens, et commençons à dessiner.
D'accord, mais dessiner quoi ?

% --------------------------------------------------------

\section{Questions}

\index{XXX}

\begin{itemize}
\item Comment déclarer une variable statique dans une procédure ?
\item Pourquoi ne pas parler de DISLIN ?
\item Est-il possible de causer à \texttt{libsndfile} ?
\item Comment caler une chaine à gauche avec un \textsc{format} ?
\end{itemize}

%	========================================