%From AE38@IBM3090.RZ.UNI-KARLSRUHE.DE Mon Jun  7 12:00:44 1993
%Received: from ibm3090.rz.uni-karlsruhe.de by armagnac.ucs.usl.edu with SMTP id AA14020
%  (5.65c/IDA-1.4.4 for <rbk5287@USL.EDU>); Mon, 7 Jun 1993 12:00:09 -0500
%Received: from DKAUNI2 by ibm3090.rz.uni-karlsruhe.de (IBM MVS SMTP V2R2.1)
%   with BSMTP id 2292; Mon, 07 Jun 93 18:59:56 MET
%Message-Id: <"93-06-07-18:58:55.23*AE38"@IBM3090.RZ.UNI-KARLSRUHE.DE>
%Date:    Mon, 07 Jun 93 18:58
%From: "Wolfgang Walter"
% <AE38@IBM3090.RZ.UNI-KARLSRUHE.DE>
%To: "R. Baker Kearfott"                  <rbk5287@usl.edu>
%Subject: F90 Overview - LaTeX source
%Status: R
%
%
%Baker,
%
%here is the LaTeX source of the transparencies for my F90 talk which
%I promised you at Argonne.  Sorry for the delay - I had to catch up
%on a few other things here.  You may have to modify \topmargin and/or
%\odd(even)sidemargin for US paper.  For your classes you can just take
%away my personal footer and everything should fit fine. However, for
%teaching you may want to stretch out the material a bit.  What I did
%is more like a rather dense compendium - a quick 1 hour overview for
%advanced Fortran programmers.
%
%I am also sending out (by snail mail) several Ph.D. theses which may
%be of interest to you, namely two on implementing elementary functions
%accurately for arbitrary floating-point systems (Braune and Kraemer)
%and one on AD (Fischer) - all of them in German.  With your command of
%the language, I'm sure that you will enjoy reading them.
%
%Well, that's it for now.  It was good to see you at Argonne.
%If you have any particular wishes/criticism regarding Fortran,
%please let me know.  The next international meeting (WG5) will be
%in Berchtesgaden, Bayern, July 5-9.
%
%With best regards,
%
%Wolfgang
%
%----------------------------------------------------------------------
%
% This is a LaTeX document.  It has to be translated with lplain.
% Author:  Wolfgang V. Walter
%          Inst. of Applied Mathematics
%          Univ. of Karlsruhe
%      D - 76128  Karlsruhe
%          Germany
%
%        ( 76128 is the new zip code after July 1st.  It is valid for
%          the whole university and only for it, so no street address
%          or POBox is required any longer. )
%
\documentstyle[12pt,fleqn]{article}

\pagestyle{empty}
\sloppy

%\setlength{\topmargin}{-14mm}
\setlength{\topmargin}{-24mm}
\setlength{\textheight}{266mm}
\setlength{\oddsidemargin}{-6mm}
\setlength{\evensidemargin}{-6mm}
\setlength{\textwidth}{186mm}

\setlength{\parindent}{0em}
%\setlength{\parskip}{5pt plus 2pt minus 1pt}
\setlength{\parskip}{1ex}

\hyphenation{Karls-ruhe}

  \newlength{\abovelength}
  \setlength{\abovelength}{2ex}
  \newcommand{\abovetable}{\vspace{\abovelength}}
  \newcommand{\abovetheorem}{\vspace{\abovelength}}

  \newlength{\belowlength}
  \setlength{\belowlength}{2ex}
  \newcommand{\belowtable}{\vspace{\belowlength}}
  \newcommand{\belowtheorem}{\vspace{\belowlength}}


  \newtheorem{thedef}{Definition}
  \newtheorem{thelem}{Lemma}
  \newtheorem{thecor}{Corollary}
  \newtheorem{thethm}{Theorem}
  \newtheorem{thepost}{Postulate}
  \newtheorem{theconj}{Conjecture}

  \newenvironment{adef}{%\abovetheorem
\begin{tabparagraph} \begin{thedef} \rm}{\end{thedef}
\end{tabparagraph}% \belowtheorem
}

  \newenvironment{alem}{%\abovetheorem
\begin{tabparagraph} \begin{thelem} \rm}{\end{thelem}
\end{tabparagraph}% \belowtheorem
}

  \newenvironment{acor}{%\abovetheorem
\begin{tabparagraph} \begin{thecor} \rm}{\end{thecor}
\end{tabparagraph}% \belowtheorem
}

  \newenvironment{athm}{%\abovetheorem
\begin{tabparagraph} \begin{thethm} \rm}{\end{thethm}
\end{tabparagraph}% \belowtheorem
}

  \newenvironment{apost}{%\abovetheorem
\begin{tabparagraph} \begin{thepost} \rm}{\end{thepost}
\end{tabparagraph}% \belowtheorem
}

  \newenvironment{aconj}{%\abovetheorem
\begin{tabparagraph} \begin{theconj} \rm}{\end{theconj}
\end{tabparagraph}% \belowtheorem
}


% \renewcommand{\thefootnote}{\fnsymbol{footnote}}

  \newenvironment{tabparagraph}{
     \begin{list}{}{\setlength{\leftmargin}{18mm}
                    \setlength{\topsep}{0pt}
                    \setlength{\itemsep}{0pt}
                    \setlength{\partopsep}{\parskip}
                   }
           \item {}            }{
     \end{list}                 }


% Haeufig verwendete Abkuerzungen
% -------------------------------

  \newcommand{\cent}      {c\hspace{-.4em}{$|$}\hspace{.2em}} %???
  \newcommand{\fractional}{fractional\ }                     % ???
  \newcommand{\infi}      {\mbox{$in${\em f}\/}}             % ???

  \newcommand{\etc}       {etc.\ }
  \newcommand{\ie}        {\mbox{i.\,e.\ }}
  \newcommand{\eg}        {\mbox{e.\,g.\ }}

  \newcommand{\Fortran}   {\mbox{Fortran}}
  \newcommand{\Ffirst}    {\mbox{FORTRAN$\:$66}}
  \newcommand{\FOLD}      {\mbox{FORTRAN$\:$77}}
  \newcommand{\Feightx}   {\mbox{Fortran$\:$8x}}
  \newcommand{\FNEW}      {\mbox{Fortran$\:$90}}
  \newcommand{\Fninety}   {\mbox{Fortran$\:$90}}
  \newcommand{\FSC}       {\mbox{FORTRAN--SC}}
  \newcommand{\FXSC}      {\mbox{FORTRAN--XSC}}
  \newcommand{\AXSC}      {\mbox{ACRITH--XSC}}
  \newcommand{\Pascal}    {\mbox{Pascal}}
  \newcommand{\PSC}       {\mbox{PASCAL--SC}}
  \newcommand{\PXSC}      {\mbox{PASCAL--XSC}}
  \newcommand{\Algol}     {\mbox{Algol}}
  \newcommand{\AlgolOLD}  {\mbox{Algol$\:$60}}
  \newcommand{\AlgolNEW}  {\mbox{Algol$\:$68}}
  \newcommand{\Ada}       {\mbox{Ada}}
  \newcommand{\CXSC}      {\mbox{C--XSC}}
% \newcommand{\CPP}       {\mbox{C$++$}}
  \newcommand{\CPP}       {\mbox{C\raisebox{0.3ex}{\footnotesize $++$}}}
  \newcommand{\ModII}     {\mbox{Modula--2}}
  \newcommand{\ModIII}    {\mbox{Modula--3}}
  \newcommand{\COBOL}     {\mbox{COBOL}}
  \newcommand{\PLI}       {\mbox{PL/I}}
  \newcommand{\IEEEbin}   {\mbox{IEEE$\:$754}}
  \newcommand{\IEEEarb}   {\mbox{IEEE$\:$854}}
  \newcommand{\LIA}       {\mbox{LIA}}
  \newcommand{\LIAI}      {\mbox{LIA--1}}

  \newcommand{\INT}       {\mbox{\tt INTEGER}}
  \newcommand{\REAL}      {\mbox{\tt REAL}}
  \newcommand{\DREAL}     {\mbox{\tt DOUBLE REAL}}
  \newcommand{\COMPLEX}   {\mbox{\tt COMPLEX}}
  \newcommand{\DCOMPLEX}  {\mbox{\tt DOUBLE COMPLEX}}
  \newcommand{\IVAL}      {\mbox{\tt INTERVAL}}
  \newcommand{\DIVAL}     {\mbox{\tt DOUBLE INTERVAL}}
  \newcommand{\CIVAL}     {\mbox{\tt COMPLEX INTERVAL}}
  \newcommand{\DCIVAL}    {\mbox{\tt DOUBLE COMPLEX INTERVAL}}
  \newcommand{\CXIVAL}    {\mbox{\tt COMPLEX\_INTERVAL}}


  \newcommand{\zz}        {\hspace{3em}}

  \newcommand{\RR}        {\mbox{\bf R}}
  \newcommand{\ulp}       {\mbox{ulp}}
  \newcommand{\circirc}   {\mbox{$\:\circ\;\!\!\!\!\!\!\bigcirc$}}


% Selbst definierte Befehle
% =========================

% Environment fuer Saetze
% -----------------------

  \newtheorem{Satz}{Satz}

% Quadratsymbole fuer +,-,*,/,Integral,Kringel und Punkt
% ------------------------------------------------------

  \newcommand{\quadr}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){}}
     \end{picture}}

  \newcommand{\qplus}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ + $}}
     \end{picture}}

  \newcommand{\qminus}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ - $}}
     \end{picture}}

  \newcommand{\qmul}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ * $}}
     \end{picture}}

  \newcommand{\qdiv}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ / $}}
     \end{picture}}

  \newcommand{\qint}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ \int $}}
     \end{picture}}

  \newcommand{\qcirc}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ \circ $}}
     \end{picture}}

  \newcommand{\qdot}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,8)
       \put(2,0){\framebox(6,6){\scriptsize $ \;\! \cdot $}}
     \end{picture}}

% Rautesymbole fuer +,-,*,/,Integral,Kringel und Punkt
% ----------------------------------------------------

  \newcommand{\raute}{\diamondsuit}

  \newcommand{\rplus}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(2.5,1.5){\scriptsize $ + $}
     \end{picture}}

  \newcommand{\rminus}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(2.5,1.5){\scriptsize $ - $}
     \end{picture}}

  \newcommand{\rmul}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(3.5,1.5){\scriptsize $ * $}
     \end{picture}}

  \newcommand{\rdiv}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(3.5,1.5){\scriptsize $ / $}
     \end{picture}}

  \newcommand{\rcirc}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(3.5,1.5){\scriptsize $ \circ $}
     \end{picture}}

  \newcommand{\rint}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(2,0.1){$ \int $}
     \end{picture}}

  \newcommand{\rdot}
    {\setlength{\unitlength}{1pt}
     \begin{picture}(10,12)
       \put(1,0){$\diamondsuit$}
       \put(2.5,1.5){\scriptsize $\;\cdot$}
     \end{picture}}


% Doppelgestrichene Buchstaben fuer mathematische Mengenausdruecke
% ----------------------------------------------------------------

% Doppelt gestrichenes C fuer Indizes
  \def\iC{{\em \kern.24em
           \vrule width.04em height1.0ex depth-.05ex
           \kern-.30em C}}

% Doppelt gestrichenes C
  \def\C{{\em \kern.24em
          \vrule width.05em height1.3ex depth-.05ex
          \kern-.38em C}}

% Doppelt gestrichenes P fuer Indizes
  \def\iP{{\em I \kern-.25em P}}

% Doppelt gestrichenes P
  \def\P{{\em I \kern-.35em P}}

% Doppelt gestrichenes R fuer Indizes
  \def\iR{{\em I \kern-.25em R}}
%
% Doppelt gestrichenes R
%  \def\R{{\em I \kern-.35em R}}

% Doppelt gestrichenes N fuer Indizes
  \def\iN{{\em I \kern-.25em N}}

% Doppelt gestrichenes N
  \def\N{{\em I \kern-.35em N}}

% Fette Buchstaben im Mathe-Font
% ------------------------------

  \def\bm#1{\mbox{\boldmath $#1$}}

% FORTRAN-SC-Operatoren mit .XX.
% ------------------------------

  \def\fop#1{$.\mbox{#1}.$}

% Abkuerzungen fuer haeufig verwendete Befehle
% --------------------------------------------

  \newcommand{\wtilde}{\widetilde}
  \newcommand{\what}{\widehat}

% Kommandos fuer 'ungleich mit i.a. darueber', 'Teilmenge/ungleich',
% 'Teilmenge/Kringel' und 'gleich mit Fragezeichen darueber'
% ---------------------------------------------------------------------

  \newcommand{\ianeq}
    {\stackrel{\mbox{$\;$\scriptsize\ia}}{\neq}}
  \newcommand{\subneq}
    {\mbox{\raisebox{-0.5ex}{$\;\stackrel{\subset}{\neq}\:$}}}
  \newcommand{\subcirc}
    {\stackrel{\circ}{\subset}}
  \newcommand{\trs}
    {\rule[-1.5ex]{0em}{4.5ex}}
  \newcommand{\eques}
    {\mbox{\raisebox{-0.5ex}{$\;\stackrel{\mbox{?}}{=}\:$}}}
  \newcommand{\subkns}
    {\mbox{\raisebox{-0.5ex}{$\;\stackrel{\textstyle \subcirc}
                             {\mbox{\scriptsize k $\neq$ s}}\:$}}}


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

 \renewenvironment{abstract}{% \bigskip %%% ???
% \begin{center}
% {\small \bf Abstract}
% \end{center}
 \begin{minipage}{\textwidth}
 \setlength{\parindent}{1.5em}
 \small
% \vspace{-2ex}
 \mbox{} \\}{\end{minipage}  % \bigskip %%% ???
 }

\newcounter{myequationcount}

\newenvironment{myequation}[3]{
  \refstepcounter{myequationcount}
  \begin{tabular*}{\textwidth}{@{}llrr@{}}
    \hspace*{\leftmargini}
    \makebox[64mm][l]{$ #1 $}        &   %%% 61mm
    \makebox[50mm][l]{ #2 }          &   %%% 49mm
    \hfill \makebox[40mm][r]{\sl #3} &   %%% 38mm
%%%    (\themyequationcount)
\\
  }{\end{tabular*}
  }


% \newcommand{\Exa}   {{\abovetable\large\sc Example:}\\[1ex]}
% \newcommand{\Exas}  {{\abovetable\large\sc Examples:}\\[1ex]}
  \newcommand{\Exa}   {{\sc Example:} \\ }
  \newcommand{\Exas}  {{\sc Examples:} \\ }
  \newcommand{\Examp} {\vspace{1ex} {\Large\bf Example:} \vspace{-1ex}}
  \newcommand{\Examps}{\vspace{1ex} {\Large\bf Examples:} \vspace{-1ex}}


  \newcommand{\maintit}[1]{\vspace{6ex} % only if not at top of page
                                        \begin{center}
                                          {\huge\bf #1} \\[4ex]
                                        \end{center} }

  \newcommand{\subtit}[1]{\vspace{4ex} % only if not at top of page
                                        \begin{center}
                                          {\huge\bf #1} \\[4ex]
                                        \end{center} }

  \newcommand{\subsubtit}[1]{\vspace{3ex} % only if not at top of page
                              {\Large\bf #1:} \\[1ex]
                            }

  \newcommand{\bottomofpage}
  { \vfill
    {\normalsize\bf
      {\Large\bf $\Box$}   Wolfgang V. Walter
      {\large\bf \raisebox{0.5ex}{$\bigtriangledown$}}
                        Inst.\ of Applied Mathematics
      {\large\bf $\bigtriangleup$}
                        Univ.\ of Karlsruhe
      {\Large\bf $\Diamond$}   \hfill   {\Large\bf \thepage}
    }
    \newpage
  }

  \newcommand{\bottomoflastpage}
  { \vfill
    {\normalsize\bf
      {\Large\bf $\Box$}   Wolfgang V. Walter
      {\large\bf \raisebox{0.5ex}{$\bigtriangledown$}}
                        Inst.\ of Applied Mathematics
      {\large\bf $\bigtriangleup$}
                        Univ.\ of Karlsruhe
      {\Large\bf $\Diamond$}   \hfill   {\Large\bf \thepage}
    }
  }


\begin{document}

{\flushleft   %%% BEGIN \flushleft %%%


\Large\sf


\begin{center}
  {\huge\bf \FNEW} \\[3ex]
  {\LARGE\bf An Overview of the New \Fortran\ Language} \\[10ex]
  {\large\bf Wolfgang V. Walter \\[1.2ex]
             Institute of Applied Mathematics \\[0.8ex]
             University of Karlsruhe} \\[15ex]
\end{center}

\begin{itemize}
%
  \item
History of \Fortran\
%
  \item
Available Implementations of \FNEW\
%
  \item
Overview of New Language Features
%
  \item
Sample Programs and Modules
%
%  \item
%Numerical Problems and Shortcomings
%
  \item
Summary
%
  \item
\FNEW\ Literature
%
\end{itemize}



\newpage

\maintit{History of \Fortran}

\begin{itemize}
%
  \item
\Ffirst\ (ANSI/ISO 1966): first programming language standard
%
  \item
\FOLD\ (ANSI/ISO 1978): modest revision of \Ffirst\
%
  \item
further development as ``\Feightx'': major revision necessary
%
  \item
technical work: ANSI/X3J3, supervision: ISO/IEC JTC1/SC22/WG5
%
  \item
many difficulties, changing world, increasing demands
%
  \item
``Super-\Fortran\ \`{a} la Ada'' or ``Small is beautiful''?
%
%  \item
%{\sl \FSC\ developed and implemented since 1984}
%
%  \item
%{\sl IBM Product ACRITH (High Accuracy Arithmetic Subroutine
%Library) released in 1984/85/86}
  \item
First Public Review in 1987: complexity too great?
%
  \item
X3J3 deadlock
% between avant-gardists and traditionalists
%
%  \item
%deadlock
resolved at ISO/WG5 meeting in Paris in Sept.\ 1988
%
  \item
Second Public Review in 1989: largely favorable
%
  \item
technical content of standard finalized in 1990 ~$\Rightarrow$ ``\FNEW''
%
%  \item
%{\sl \FSC\ released as IBM Product \AXSC: High Accuracy
%Arithmetic -- Extended Scientific Computation in 1990}
%
  \item
Third Public Review in 1990: mostly a formality
%
  \item
single world-wide \Fortran\ standard?
ANSI standard = ISO standard?
%
  \item
International Standard: ``\FNEW'', ISO/IEC 1539\,:\,1991
(Aug.\ 1991)
%
%  \item
%{\sl \FXSC\ (a \FNEW\ module library for accurate and
%reliable scientific computation) developed since Oct.\ 1991}
%
  \item
American Standard: ``Extended Fortran'', ANSI X3.198-1992
identical to international standard,
but \FOLD\ (ANSI X3.9-1978) remains in effect simultaneously
(only in USA)
%
  \item
European Standard: ``\FNEW'', EN~21539\,:\,1992\, and all other
national standards identical to international standard (1992/93)
%
  \item
next standard planned for 1996: clarifications and corrections only (?)
%
\end{itemize}



\bottomofpage

\maintit{Available Implementations of \FNEW}

\begin{itemize}
%
  \item
Numerical Algorithms Group Ltd.: NAGWare -- f90 Compiler \\
{\sl first full implementation of \FNEW} \\
{\sl generates C code for workstations and mainframes}
%
  \item
Salford Software Ltd./NAG Ltd.: NAGWare -- FTN90 Compiler \\
{\sl generates native code for IBM PCs and compatibles} \\
{\sl (available from h.o.\ Computer, K\"oln in Germany)}
%
  \item
ParaSoft Corp.: \FNEW\ Translator pf90 \\
{\sl translates \FNEW\ to \FOLD} \\
{\sl available for vector processors, mainframes, workstations, PCs}
%
  \item
Pacific-Sierra Research Corp.: VAST-90 \\
{\sl translates \FNEW\ to \FOLD\ --- and vice versa} \\
{\sl available for some workstations}
%
  \item
Edinburgh Portable Compilers Ltd.: EPC Fortran-90 Compiler \\
{\sl generates native code for
Intel 80x86, Sun SPARC, Motorola 68K and 88K, and IBM RS/6000} \\
{\sl available for certain workstations and PCs (?)}
%
  \item
MasPar: exclusive use of \FNEW\ for parallel programming (?)
%
  \item
Convex, Cray, DEC, IBM, Lahey, SGI, Sun, and others appear committed
to provide full implementations of \FNEW\ with native code generation
in 1993 or 1994 (?)
%
  \item
many existing \FOLD\ compilers offer some \FNEW\ features,
in particular array and syntax extensions
%
\end{itemize}



\bottomofpage

\maintit{Overview of \FNEW}
%
%\subtit{General}

\begin{itemize}
%
  \item
\FNEW\ is a superset of \FOLD\
%
  \item
all \FOLD\ programs are valid \FNEW\ programs and
should compile and run as expected
%
  \item
complete modernization of \Fortran\
(subject to strict compatibility with \FOLD)
%
  \item
major additions, extensions and improvements in all areas
%
  \item
powerful new features and concepts:
    \begin{itemize}
      \item   free source form
      \item   improved, block-structured syntax
      \item   array processing
      \item   assumed-shape arrays
      \item   allocatable arrays
      \item   dynamic storage
      \item   pointers
      \item   optional arguments
      \item   recursion
      \item   modules
      \item   derived types (user-defined data structures)
      \item   user-defined operators and assignment
      \item   explicit and generic interfaces
      \item   procedure, operator and assignment overloading
    \end{itemize}
%
\end{itemize}



\bottomofpage

\subtit{Lexical Enhancements}

\begin{itemize}
%
  \item
long names with up to 31 characters
%
  \item
underscore ``\verb\_\'' allowed in names
%
  \item
new syntax for relational operators:~
\verb\<\, \verb\<=\, \verb\==\, \verb\>=\, \verb\>\, \verb\/=\
%
  \item
in-line comments introduced by ``\verb\!\'' (extend to end of line)
%
  \item
multiple statements on one line separated by ``\verb\;\''
(optional at end of line)
%
  \item
\verb\"\ and \verb\'\ may be used interchangeably to delimit
character constants
%
  \item
statements may be continued on up to 39 continuation lines
%
  \item
free source form:
%
  \begin{itemize}
    \item
      no special columns for comments, labels, continuation lines
    \item
      up to 132 characters per line
    \item
      blanks significant, lexical tokens must be contiguous
    \item
      continuation line announced by ``\verb\&\'' at end of preceding
      line
    \item
      continuation position may be indicated by ``\verb\&\'' on
      continuation line
  \end{itemize}
%
\end{itemize}

\Examps\
%
\begin{verbatim}
   CHARACTER (LEN=60) ::  this_name_is_31_characters_long
   REAL ::  x, y, z

   x = 3.5 ;  y = 4.5 ;  z = 5.5 ; ! end-of-line comment
   IF ( x < y .AND. z > y .OR.   & ! initial line
        x == z .AND. y /= 0.0 )  & ! 1st continuation line
     z = x + y + z                 ! 2nd continuation line

   this_name_is_31_characters_long = "This sentence is &
     &more than 31 characters long, isn't it?"
\end{verbatim}



\bottomofpage

\subtit{Block-Structured Syntax}

\begin{itemize}
%
  \item
\verb\PROGRAM  My_First_Fortran_90_Program\ \\
\verb\  WRITE (*,*) "This is my first Fortran 90 program."\ \\
\verb\END PROGRAM  My_First_Fortran_90_Program\
\vspace{2ex}
%
  \item
\verb\RECURSIVE  FUNCTION  factorial (n)  RESULT (res)\ \\
\verb\  INTEGER  n, res\ \\
\verb\  res = 1\ \\
\verb\  IF ( n > 1 )  res = n * factorial(n-1)\ \\
\verb\END FUNCTION  factorial\
\vspace{2ex}
%
  \item
\verb\SUBROUTINE  swap_structures (left, right)\ \\
\verb\  TYPE(structure) ::  left, right, temp\ \\
\verb\  temp = left ;  left = right ;  right = temp ;\ \\
\verb\END SUBROUTINE  swap_structures\
\vspace{2ex}
%
  \item
\verb\MODULE  INTERVAL_ARITHMETIC\ \\
\verb\ ! type and operator definitions, other declarations\ \\
\verb\CONTAINS\ \\
\verb\ ! module procedures\ \\
\verb\END MODULE  INTERVAL_ARITHMETIC\
\vspace{2ex}
%
  \item
\verb\TYPE  INTERVAL\ \\
\verb\  REAL ::  inf, sup\ \\
\verb\END TYPE  INTERVAL\
\vspace{2ex}
%
  \item
\verb\INTERFACE\ \\
\verb\  RECURSIVE  FUNCTION  factorial (n)  RESULT (res)\ \\
\verb\    INTEGER  n, res\ \\
\verb\  END FUNCTION  factorial\ \\
\verb\END INTERFACE\
\vspace{2ex}
%
\end{itemize}



\bottomofpage

\subtit{Control Structures}

\begin{itemize}
%
  \item
\verb\indexed_loop:  DO i = 1, 19, 2\ \\
\verb\                 x(i+1) = x(i) - x(i-1)\ \\
\verb\               END DO indexed_loop\ \\
\vspace{3ex}
%
  \item
\verb\infinite_loop: DO        ! is this an infinite loop?\ \\
\verb\                 x = COS(x)\ \\
\verb\                 IF ( x > 0.5 )  EXIT infinite_loop\ \\
\verb\               END DO infinite_loop\ \\
\vspace{3ex}
%
  \item
\verb\general_loop:  DO m = 6, 0, -1\ \\
\verb\                 IF (MOD(m,3) == 0) CYCLE general_loop\ \\
\verb\                 WRITE (*,*)  m   ! output: 5, 4, 2, 1\ \\
\verb\               END DO general_loop\ \\
\vspace{3ex}
%
  \item
\verb\while_loop:    DO WHILE ( x > 0.001 )  ! redundant !\ \\
\verb\                 x = SIN(x)            ! feature   !\ \\
\verb\                 WRITE (*,*)  x\ \\
\verb\               END DO while_loop\ \\
\vspace{3ex}
%
  \item
\verb\pseudo_while_loop:   &   ! functionally equivalent !\ \\
\verb\&              DO        ! to while_loop above     !\ \\
\verb\                 IF ( x <= 0.001 )  EXIT\ \\
\verb\                 x = SIN(x)\ \\
\verb\                 WRITE (*,*)  x\ \\
\verb\               END DO pseudo_while_loop\ \\
\vspace{3ex}
%
\end{itemize}



\bottomofpage

\subtit{~}

\begin{itemize}
%
  \item
\verb\masked_array_assignment:                   &\ \\
\verb\&         WHERE ( matrix1 > 0 )\ \\
\verb\            matrix2 = LOG(matrix1)\ \\
\verb\          ELSEWHERE\ \\
\verb\            matrix2 = -1000\ \\
\verb\          END WHERE masked_array_assignment\ \\
\vspace{3ex}
%
  \item
\verb\choice:   SELECT ( number )\ \\
\verb\            CASE (  :0 )  choice\ \\
\verb\              number = 0\ \\
\verb\            CASE ( 1:5 )  choice\ \\
\verb\             ! do not change 1, 2, 3, 4, 5\ \\
\verb\            CASE ( 7, 9 ) choice\ \\
\verb\              number = number - 1\ \\
\verb\            CASE DEFAULT  choice ! CASE ( 6, 8, 10: )\ \\
\verb\              number = 2 * number\ \\
\verb\          END SELECT choice\ \\
\vspace{3ex}
%
  \item
\verb\block_if: IF ( number<=0 ) THEN  ! functionally equiv.\ \\
\verb\              number = 0         ! to construct above \ \\
\verb\            ELSEIF ( 1<=number .AND. number<=5 ) THEN\ \\
\verb\             ! do not change 1, 2, 3, 4, 5\ \\
\verb\            ELSEIF ( number==7 .OR. number==9 ) THEN\ \\
\verb\              number = number - 1\ \\
\verb\            ELSE\ \\
\verb\              number = 2 * number\ \\
\verb\          END IF block_if\ \\
\vspace{3ex}
%
\end{itemize}



\bottomofpage

\subtit{Intrinsic Types}

\begin{itemize}
%
  \item
as in \FOLD: \INT, \REAL, \COMPLEX, \verb\LOGICAL\, \verb\CHARACTER\
%
  \item
all intrinsic types are now parametrized by a \verb\KIND\ type
parameter to select a specific representation method
(\eg single, double, extended)
%
\end{itemize}

\Examps\
%
\begin{verbatim}
 INTEGER, PARAMETER:: DOUBLE=KIND(0D0), bit=1, Deutsch=49

 INTEGER(KIND=2)                  ! may be 2 byte INTEGER
 INTEGER(SELECTED_INT_KIND(9))    ! min. 9 decimal digits
 REAL(KIND=KIND(0.0))             ! REAL
 REAL(KIND=DOUBLE)                ! DOUBLE PRECISION
 REAL(SELECTED_REAL_KIND(24,300)) ! min. 24 dec. digits,
                                  ! exponent range +/-300
                                  ! same for COMPLEX:
 COMPLEX(KIND(0.0))                  ! COMPLEX
 COMPLEX(DOUBLE)                     ! DOUBLE COMPLEX
 COMPLEX(SELECTED_REAL_KIND(24,300)) ! same as for REAL
 LOGICAL(KIND(.FALSE.))           ! default LOGICAL
 LOGICAL(bit)                     ! could be BIT type
 CHARACTER(KIND("A"))             ! default character set
 CHARACTER(Deutsch)               ! German character set \end{verbatim}
%
\vspace{1ex}
\verb\    -12345_2                   ! INTEGER(2) constant\ \\
\verb\    1.23456789012E+3_DOUBLE    ! REAL(DOUBLE) constant\ \\
\verb\    (-1.333333333333_DOUBLE,4) ! COMPLEX(DOUBLE) constant\ \\
\verb\    .TRUE._bit                 ! LOGICAL(bit) constant\ \\
\verb\    Deutsch_"\%
eine l\"angst f\"allige, h\"ochst begr\"u{\ss}enswerte \"Anderung%
\verb\"\ \\
\verb\                            ! CHARACTER(Deutsch) constant\ \\



\bottomofpage

\subtit{Derived Types}

\begin{itemize}
%
  \item
user-defined data structures with components of arbitrary types
%
  \item
recursive type definition allowed if component is a pointer
%
  \item
structure constructor uses derived type name as ``constructor function''
%
  \item
component selection introduced by ``\%'' (``.'' in Pascal-like
languages)
%
  \item
assignment predefined for derived types, but may be redefined
%
\end{itemize}

\Examps\
%
\begin{verbatim}
   TYPE  INTERVAL  ! derived types cannot be parametrized
     REAL  INF, SUP
   END TYPE  INTERVAL

   TYPE  DOUBLE_INTERVAL    ! thus a new type is required
     REAL (DOUBLE)  INF, SUP
   END TYPE  DOUBLE_INTERVAL

   TYPE  list_of_names
     CHARACTER (LEN=30) ::  name
     TYPE (list_of_names), POINTER ::  next
   END TYPE  list_of_names

   TYPE (INTERVAL)  X, Y, Z
   TYPE (DOUBLE_INTERVAL)  DI
   TYPE (list_of_names)  list
    . . .
     ! structure constructor for INTERVAL object:
   Z = INTERVAL( MIN(X%INF, Y%INF), MAX(X%SUP, Y%SUP) )
    . . .
   list % next % name = 'Tom Smith'
\end{verbatim}



\bottomofpage

\subtit{Pointers}

\begin{itemize}
%
  \item
\verb\POINTER\ is an attribute, not a special type
%
  \item
pointers are strongly typed
%
  \item
pointers are complete data object descriptors, not simply addresses
%
  \item
pointer objects may have any type and any rank and shape
%
%  \item
%initial status of pointers is {\bf undefined} (no automatic
%initialization)
%
  \item
\verb\ASSOCIATED\ tests whether a pointer is associated with a target
%
  \item
one may \verb\NULLIFY\, \verb\ALLOCATE\, and \verb\DEALLOCATE\ pointers
%
  \item
pointers are automatically dereferenced in most contexts
%
  \item
context uniquely determines whether pointer or referenced object is used
%
  \item
pointer assignment is denoted by \verb\=>\
%
  \item
any pointer target must have \verb\TARGET\ or \verb\POINTER\ attribute
%
  \item
{\bf Problem:} pointers are {\bf initially undefined}, \ie not NULL
%
\end{itemize}

\Examp\
%
\begin{verbatim}
   TYPE  tree
     INTEGER ::  value
     TYPE (tree), POINTER ::  left, right
   END TYPE  tree

   TYPE (tree), POINTER ::  root, temp
    . . .
   ALLOCATE ( root )
   root%value = 3
   NULLIFY ( root % left, root % right )
   temp = root       ! ordinary assignment (copies object)
   root%left => temp ! pointer assignment (copies pointer)
\end{verbatim}



\bottomofpage

\subtit{Arrays}

\begin{itemize}
%
  \item
element type and rank (number of dimensions) always fixed
%
  \item
assumed-shape arrays (dummy arguments with unspecified index bounds)
%
  \item
automatic arrays (shape defined upon entry into a procedure)
%
  \item
deferred-shape (dynamic) arrays:
\verb\ALLOCATABLE\ or \verb\POINTER\ attribute
%
  \item
one may \verb\ALLOCATE\ and \verb\DEALLOCATE\ deferred-shape arrays
at any time
%
  \item
deferred-shape arrays may be allocated with any shape (but fixed rank)
%
  \item
\verb\ALLOCATABLE\ arrays must not be dummy arguments, function
results, or structure components
%
  \item
an array \verb\POINTER\ may be used wherever a pointer is allowed
%
  \item
array constructors (one-dimensional): \verb\(/ list_of_values /)\,
\eg \\
\verb\   (/ 1, 3, 5, 7, 9 /)\, same as \verb\(/ 2*i-1, i=1,5 /)\
%
  \item
array sections (subarrays) via subscript triplets and vector subscripts
%
  \item
subscript triplet: \verb\(first:last:stride)\, \eg \\
\verb\   V(0:9:3)\, \verb\V(9:0:-3)\, \verb\V(6: :3)\,
\verb\M(2:4,2:4)\, \verb\M(i, : )\
%
  \item
vector subscript: \verb\( index_vector )\, \eg \\
\verb\   V( (/0,3,6,9/) )\, \verb\V( (/2,4,2/) )\,
\verb\M(2:4, (/2,4,2/))\
%
  \item
zero-sized arrays allowed, \eg \\
\verb\   V(1:0)\, \verb\M(2:4,4:2)\, \verb\M(3,1:5:-2)\
%
  \item
array assignment requires left-hand side array of appropriate shape
%
  \item
{\bf Problem: no automatic allocation} of left-hand side dynamic
array during assignment
%
\end{itemize}



\bottomofpage

\Examps\
%
\begin{itemize}
%
  \item
in \FNEW, the multiplication of two non-square matrices is very
cumbersome if the result matrix redefines one of the operands:
%
    \begin{verbatim}
   REAL, DIMENSION(:,:), ALLOCATABLE ::  A, B, T
    . . .
   ALLOCATE ( A(m,n), B(n,k) )
   READ (*,*)  A, B
    . . .
  ! now compute B = A * B !
   ALLOCATE ( T(SIZE(A, 1), SIZE(B, 2)) )
   T = MATMUL(A, B)
   DEALLOCATE (B)
   ALLOCATE ( B(SIZE(T, 1), SIZE(T, 2)) )
   B = T
   DEALLOCATE (T)    \end{verbatim}
%
\vspace{1ex}
%
  \item
in \AXSC, this is very simple (implicit memory management):
%
    \begin{verbatim}
      DYNAMIC / REAL(:,:) /  A, B
       . . .
***   B is automatically freed and reallocated:
      B = A * B    \end{verbatim}
%
\vspace{1ex}
%
  \item
in \FNEW, a function result (array) of unknown size must be a pointer:
%
    \begin{verbatim}
   FUNCTION  read_vector ( )
     REAL, DIMENSION(:), POINTER ::  read_vector
     INTEGER  dim
     READ (*,*)  dim
     ALLOCATE ( read_vector(dim) )
     READ (*,*)  read_vector
   END FUNCTION  read_vector    \end{verbatim}
%
\end{itemize}



\bottomofpage

{\large

\begin{verbatim}
   PROGRAM  GAUSS   ! with allocatable arrays !

   ! Copyright (c) 1993 by Wolfgang V. Walter, Univ. Karlsruhe.
   ! May be copied and used as long as this notice is retained.

   ! Gauss elimination to solve a system of linear equations.
   ! The square system matrix A, the right-hand side vector b,
   ! and the solution vector x are ALLOCATABLE arrays.
   ! Array sections are used to access (parts of) rows of A
   ! and parts of the solution vector x.

     INTEGER           ::  i, j, n
     REAL              ::  factor
     REAL, ALLOCATABLE ::  A(:,:), b(:), x(:)

     WRITE (*,*)  ' Please enter dimension n : '
     READ  (*,*)  n
     ALLOCATE ( A(n,n), b(n), x(n) )
     WRITE (*,*)  ' Please enter linear system row by row: '
     READ  (*,*)  ( A(i,:), b(i), i = 1, n )

     DO j = 1, n           ! reduction to upper triangular form
       DO i = j+1, n
         factor = A(i,j) / A(j,j)
         A(i,j+1: ) = A(i,j+1: ) - factor * A(j,j+1: )
         b(i) = b(i) - factor * b(j)
       END DO
     END DO

     x(n) = b(n) / A(n,n)  ! backsolving
     DO j = n-1, 1, -1
       x(j) = (b(j)-DOT_PRODUCT(A(j,j+1: ), x(j+1: ))) / A(j,j)
     END DO
     WRITE (*,*)  ' Solution vector x : ', x
   END PROGRAM  GAUSS   \end{verbatim}

}


\bottomofpage

{\large

\begin{verbatim}
   PROGRAM  GAUSS   ! with array pointers as aliases !

   ! Copyright (c) 1993 by Wolfgang V. Walter, Univ. Karlsruhe.
   ! May be copied and used as long as this notice is retained.

   ! Gauss elimination to solve a system of linear equations.
   ! The system is stored in an (n x n+1) ALLOCATABLE array LS
   ! whose last column is the right-hand side of the system.
   ! The square system matrix A and the right-hand side vector
   ! b are pointers to array sections of LS (aliases).

     INTEGER                                   ::  i, j, n
     REAL                                      ::  factor
     REAL, DIMENSION(:,:), ALLOCATABLE, TARGET ::  LS
     REAL, DIMENSION(:)  , ALLOCATABLE         ::  x
     REAL, DIMENSION(:,:), POINTER             ::  A
     REAL, DIMENSION(:)  , POINTER             ::  b

     WRITE (*,*)  ' Please enter dimension n : '
     READ  (*,*)  n
     ALLOCATE ( LS(n,n+1), x(n) )
     WRITE (*,*)  ' Please enter linear system row by row: '
     READ  (*,*)  ( LS(i, : ), i = 1, n )  ! read full rows
                                           ! (A and b simult.)
     A => LS(1:n,1:n)      ! alias for system matrix
     b => LS(1:n,n+1)      ! alias for right-hand side

     DO j = 1, n           ! reduction to upper triangular form
       DO i = j+1, n
         factor = A(i,j) / A(j,j)
         LS(i,j+1: ) = LS(i,j+1: ) - factor * LS(j,j+1: )
       END DO              ! treat complete equation (A and b)
     END DO

     x(n) = b(n) / A(n,n)  ! backsolving
     DO j = n-1, 1, -1
       x(j) = (b(j)-DOT_PRODUCT(A(j,j+1: ), x(j+1: ))) / A(j,j)
     END DO
     WRITE (*,*)  ' Solution vector x : ', x
   END PROGRAM  GAUSS   \end{verbatim}

}



\bottomofpage

\subtit{Modules and Interface Blocks}

\begin{itemize}
%
  \item
\verb\MODULE\ encapsulates abstract data types
(data type plus operations)
%
  \item
\verb\MODULE\ encapsulates shared data (replaces \verb\COMMON\ blocks)
%
  \item
\verb\MODULE\ encapsulates procedures and interfaces (``library'')
%
  \item
\verb\PUBLIC\ and \verb\PRIVATE\ control exportation to other modules
(visibility)
%
  \item
\verb\USE\ controls importation from other modules
%
  \item
module procedures allowed at end of module, separated by \verb\CONTAINS\
%
  \item
local (nested) procedures allowed in external and module procedures and
in main programs
%
  \item
local procedures at end of host procedure, separated by \verb\CONTAINS\
%
  \item
nesting of procedures one level deep only (!)
%
  \item
\verb\INTERFACE\ blocks define specific and generic interfaces
%
  \item
a specific interface defines the interface of an \verb\EXTERNAL\
procedure
%
  \item
a generic interface defines a generic procedure name,
an \verb\OPERATOR\, or an \verb\ASSIGNMENT\
%
  \item
overloading of intrinsic operators and procedures possible for new
types
%
%  \item
%redefinition of intrinsic operators and procedures prohibited for
%old types
%
  \item
user may define new operator names (no digits allowed), \eg \\
\verb\   .MUL.\, \verb\.my_operator.\, \verb\.Inverse.\
%
  \item
unlimited overloading as long as interface is unique
%
\end{itemize}



\bottomofpage

{\large

\begin{verbatim}
   MODULE  REAL_INTERVALS
   ! Copyright (c) 1992 by Wolfgang V. Walter, Univ. Karlsruhe.   !
   ! May be copied and used as long as this notice is retained.   !

   ! This module defines interval arithmetic with 2 ulp accuracy. !
   ! For the module to function properly, it is crucial that the  !
   ! real intrinsic operators  +, -, *, /  be accurate to 1 ulp.  !

     USE ERRORS   ! Import error handling routines.  A subroutine !
                  ! ERROR(CHARACTER*(*)) is assumed to exist.     !

     PRIVATE  ! Everything that is not declared PUBLIC is PRIVATE !

     PUBLIC:: INTERVAL, IVAL, INF, SUP,                           &
    &         OPERATOR(+), OPERATOR(-), OPERATOR(*), OPERATOR(/), &
    &         OPERATOR(.IS.), OPERATOR(.CH.), OPERATOR(.SB.),     &
    &         OPERATOR(.SP.), OPERATOR(.DJ.), OPERATOR(.IN.)

     TYPE INTERVAL
       PRIVATE      ! (internal structure) components are PRIVATE !
       REAL INF, SUP
     END TYPE INTERVAL

     INTERFACE IVAL
       MODULE PROCEDURE IVAL
     END INTERFACE

     INTERFACE INF
       MODULE PROCEDURE INF
     END INTERFACE

     INTERFACE SUP
       MODULE PROCEDURE SUP
     END INTERFACE

     INTERFACE OPERATOR  ( + )
       MODULE PROCEDURE POS, ADD
     END INTERFACE

\end{verbatim}

\bottomofpage

\begin{verbatim}
     INTERFACE OPERATOR  ( - )
       MODULE PROCEDURE NEG, SUB
     END INTERFACE

     INTERFACE OPERATOR  ( * )
       MODULE PROCEDURE MUL
     END INTERFACE

     INTERFACE OPERATOR  ( / )
       MODULE PROCEDURE DIV
     END INTERFACE

     INTERFACE OPERATOR  ( .IS. )
       MODULE PROCEDURE INTERSECTION
     END INTERFACE

     INTERFACE OPERATOR  ( .CH. )
       MODULE PROCEDURE CONVEX_HULL
     END INTERFACE

     INTERFACE OPERATOR  ( .SB. )
       MODULE PROCEDURE SUBSET
     END INTERFACE

     INTERFACE OPERATOR  ( .SP. )
       MODULE PROCEDURE SUPERSET
     END INTERFACE

     INTERFACE OPERATOR  ( .DJ. )
       MODULE PROCEDURE DISJOINT
     END INTERFACE

     INTERFACE OPERATOR  ( .IN. )
       MODULE PROCEDURE IN
     END INTERFACE


   CONTAINS


\end{verbatim}

\bottomofpage

\begin{verbatim}
     TYPE (INTERVAL) FUNCTION IVAL (L, R)
       REAL           ::  L
       REAL, OPTIONAL ::  R
       IVAL%INF = L
       IF ( PRESENT(R) ) THEN
         IVAL%SUP = R
       ELSE
         IVAL%SUP = L                        ! point interval
       END IF
     END FUNCTION IVAL

     REAL FUNCTION INF (INTVAL)
       TYPE (INTERVAL) INTVAL
       INF = INTVAL%INF
     END FUNCTION INF

     REAL FUNCTION SUP (INTVAL)
       TYPE (INTERVAL) INTVAL
       SUP = INTVAL%SUP
     END FUNCTION SUP

     FUNCTION POS (INTVAL)                   ! unary +
       TYPE (INTERVAL) INTVAL, POS
       POS = INTVAL
     END FUNCTION POS

     FUNCTION NEG (INTVAL)                   ! unary -
       TYPE (INTERVAL) INTVAL, NEG
       NEG%INF = -INTVAL%SUP
       NEG%SUP = -INTVAL%INF
     END FUNCTION NEG

     FUNCTION ADD (L, R)
       TYPE (INTERVAL) L, R, ADD
       ADD%INF = NEAREST(L%INF+R%INF, -1.0)  ! approximation - 1ulp
       ADD%SUP = NEAREST(L%SUP+R%SUP, +1.0)  ! approximation + 1ulp
     END FUNCTION ADD

\end{verbatim}

\bottomofpage

\begin{verbatim}
     FUNCTION SUB (L, R)
       TYPE (INTERVAL) L, R, SUB
       SUB%INF = NEAREST(L%INF-R%SUP, -1.0)  ! approximation - 1ulp
       SUB%SUP = NEAREST(L%SUP-R%INF, +1.0)  ! approximation + 1ulp
     END FUNCTION SUB

     FUNCTION MUL (L, R)
       TYPE (INTERVAL) L, R, MUL
       REAL  II, IS, SI, SS
       II = L%INF * R%INF ;   IS = L%INF * R%SUP
       SI = L%SUP * R%INF ;   SS = L%SUP * R%SUP
       MUL%INF = NEAREST( MIN(II,IS,SI,SS), -1.0 )
       MUL%SUP = NEAREST( MAX(II,IS,SI,SS), +1.0 )
     END FUNCTION MUL

     FUNCTION DIV (L, R)
       TYPE (INTERVAL) L, R, DIV
       REAL  II, IS, SI, SS
       IF ( 0.0 .IN. R )                                     &
      &  CALL ERROR('Division by interval containing zero')
       II = L%INF / R%INF ;   IS = L%INF / R%SUP
       SI = L%SUP / R%INF ;   SS = L%SUP / R%SUP
       DIV%INF = NEAREST( MIN(II,IS,SI,SS), -1.0 )
       DIV%SUP = NEAREST( MAX(II,IS,SI,SS), +1.0 )
     END FUNCTION DIV

     FUNCTION INTERSECTION (L, R)
       TYPE (INTERVAL) L, R, INTERSECTION
       IF ( .NOT. (L .DJ. R) ) THEN
         INTERSECTION%INF = MAX(L%INF, R%INF)
         INTERSECTION%SUP = MIN(L%SUP, R%SUP)
       ELSE
         CALL ERROR('Intersection of disjoint intervals')
       END IF
     END FUNCTION INTERSECTION

\end{verbatim}

\bottomofpage

\begin{verbatim}
     FUNCTION CONVEX_HULL (L, R)
       TYPE (INTERVAL) L, R, CONVEX_HULL
       CONVEX_HULL%INF = MIN(L%INF, R%INF)
       CONVEX_HULL%SUP = MAX(L%SUP, R%SUP)
     END FUNCTION CONVEX_HULL

     LOGICAL FUNCTION SUBSET (L, R)
       TYPE (INTERVAL) L, R
       SUBSET = L%INF >= R%INF .AND. L%SUP <= R%SUP
     END FUNCTION SUBSET

     LOGICAL FUNCTION SUPERSET (L, R)
       TYPE (INTERVAL) L, R
       SUPERSET = L%INF <= R%INF .AND. L%SUP >= R%SUP
     END FUNCTION SUPERSET

     LOGICAL FUNCTION DISJOINT (L, R)
       TYPE (INTERVAL) L, R
       DISJOINT = L%SUP < R%INF .OR. L%INF > R%SUP
     END FUNCTION DISJOINT

     LOGICAL FUNCTION IN (POINT, INTVAL)
       REAL POINT
       TYPE (INTERVAL) INTVAL
       IN = POINT >= INTVAL%INF .AND. POINT <= INTVAL%SUP
     END FUNCTION IN

   END MODULE  REAL_INTERVALS
\end{verbatim}

}



\bottomofpage

\subtit{Other Features}

\begin{itemize}
%
  \item
\verb\RECURSIVE\ functions and subroutines
%
  \item
\verb\RESULT\ variable for function result
%
  \item
\verb\INTENT(IN)\, \verb\INTENT(OUT)\, \verb\INTENT(INOUT)\ arguments
%
  \item
\verb\OPTIONAL\ arguments
%
  \item
\verb\PRESENT\ inquiry function to test for presence of optional
arguments
%
  \item
argument keywords (dummy argument names for argument identification)
%
  \item
non-advancing I/O to read/write partial records (\verb\ADVANCE='NO'\)
%
  \item
\verb\NAMELIST\ I/O to read/write data with variable names
%
  \item
most \FOLD\ intrinsic functions are now elemental,
\ie applicable to arrays (no loops required)
%
  \item
many new intrinsic functions for numeric manipulation and inquiry,
array construction, reduction, reshaping, manipulation, inquiry, \ldots
%
  \item
bit intrinsics for \verb\INTEGER\ (MIL-STD-1753)
%
  \item
intrinsic subroutines for random numbers, bit copying, date and time
%
  \item
binary, octal, and hexadecimal constants and I/O for \verb\INTEGER\
%
  \item
\verb\INCLUDE\ line to include source text (not a statement)
%
  \item
language evolution: obsolescent features (which were already redundant
in \FOLD) are likely candidates for deletion from future standards,
namely:
arithmetic IF,
non-integer DO loop control,
shared DO loop termination,
DO termination on statements other than END DO or CONTINUE,
branching to END IF from outside the IF block,
alternate return,
PAUSE,
ASSIGN, assigned GO TO and assigned FORMAT specifiers,
H edit descriptor (Hollerith constants)
%
\end{itemize}



\bottomofpage

\maintit{Summary}

\begin{itemize}
%
  \item
\FNEW\ is probably the most powerful, versatile, and efficient
internationally standardized programming language for
numerical programming
%
  \item
new language features of \FNEW\ greatly improve readability,
maintainability, and portability of \Fortran\ programs
%
  \item
however, computational results are still often unreliable and
incompatible when using various compilers, code optimization and
vectorization strategies, and hardware platforms
%
  \item
\FNEW\ standard fails to specify the mathematical behavior and
accuracy of the arithmetic operators and mathematical functions
%
  \item
\FNEW\ still does not provide any access to the IEEE operations
with directed roundings toward $-\infty$ and $+\infty$,
\eg via the operators: \\
\verb\   +<\, \verb\+>\, \verb\-<\, \verb\->\,
\verb\*<\, \verb\*>\, \verb\/<\, \verb\/>\
%
  \item
\FNEW\ still lacks any kind of exception handling
%
  \item
many full implementations of \FNEW\ to be expected in 1993 and 1994
%
  \item
High Performance Fortran Forum (HPFF): concerted effort of parallel
computer vendors and parallelization experts since Jan.\ 1992:
%
  \begin{itemize}
    \item
      High Performance Fortran (HPF) is a \FNEW\ extension for
      (massively) parallel programming
    \item
      intended for a variety of architectures: MIMD and SIMD,
      distributed and shared memory, vector processors, \ldots
    \item
      uses directives only (\FNEW\ comments beginning with
      ``\verb\!HPF$\'')
    \item
      related to Vienna~Fortran and Fortran-D
    \item
      final document published in May 1993
  \end{itemize}
%
\end{itemize}



}   %%% END \flushleft %%%



\bottomofpage

\maintit{\FNEW\ Literature}

\vspace{1ex}

{\large\rm
\begin{enumerate}
%
  \item
ISO: {\em Information technology -- Programming languages -- Fortran. }
International standard ISO/IEC 1539\,:\,1991\,(E),
ISO Publ.\ Dept., Case postale 56, CH-1211 Gen\`eve 20, Switzerland,
1991.
%
  \item
ANSI: {\em American National Standard Programming Language
Extended Fortran. }
ANSI X3.198-1992, 1992.
%
  \item
DIN: {\em Informationstechnik Programmiersprachen: Fortran. }
DIN EN 21539\,: %%% allow line break here !!!
1992, Beuth-Verlag, Berlin, 1993.
%
  \item
ISO: {\em Varying Length Character Strings in Fortran. }
Draft int.\ std.\ ISO/IEC CD 1539-1 (collateral std.\ to
ISO/IEC 1539\,:\,1991\,(E)), 1992.
%
  \item
Adams, J. C.; Brainerd, W. S.; Martin, J. T.; Smith, B. T.;
Wagener, J. L.:
{\em Fortran~90 Handbook; Complete ANSI/ISO Reference. }
Intertext Publ., McGraw-Hill, New York, 1992.
%
  \item
Brainerd, W. S.; Goldberg, Ch.\ H.; Adams, J. C.:
{\em Programmer's Guide to Fortran~90. }
Intertext Publ., McGraw-Hill, New York, 1990.
%
  \item
Metcalf, M.; Reid, J.: {\em Fortran~90 Explained. }
Oxford Univ.\ Press, 1990.
%
  \item
Morgan, J. S.; Schonfelder, J. L.:
{\em An Introduction to Programming in Fortran~90. }
Blackwells, Oxford, to be published in 1993.
%
  \item
Aberti: {\em Fortran~90; Initiation \`a partir du FORTRAN~77. }
S. I. editions, 2, rue du Fossan, F-06500 Menton, France, 1992.
%
  \item
Gehrke, W.: {\em Fortran~90 Referenz-Handbuch. }
Hanser, 1991.
%
  \item
Heisterkamp, M.: {\em Fortran~90; Eine informelle Einf\"uhrung. }
B.I. Wis\-sen\-schafts\-ver\-lag, Mannheim, 1991.
%
  \item
RRZN: {\em Fortran~90 Sprachumfang; Ein Nachschlagewerk. }
Regionales Rechenzentrum f\"ur Niedersachsen, SPR.F90~1,
Univ. Hannover, 1992.
%
  \item
Walter, W. V.: {\em Fortran~90: Was bringt der neue
Fortran--Standard f\"ur das numerische Programmieren?}~
In: Jahr\-buch \"Uber\-blicke Mathematik 1991, 151--175, Vieweg,
Braunschweig, 1991.
%
\end{enumerate}
}   %%% end \large\rm



\end{document}

