Fortran 95 Test Suite, Version 1.1


The Fortran 95 Test Suite is a suite of files containing programs for testing and evaluating Fortran 95 (ISO/IEC:1539-1997) standard-conforming compilers and processing tools. No language extensions are tested.

The programs are provided in source code format and can be used to check whether the system under test correctly processes legal (and, in the case of constraints and other prohibitions that must be reported, illegal) Fortran 95 code. Because the Fortran 95 Test Suite is provided in source form, it may form the basis of customized test capabilities.

In this document the term standard refers to ISO/IEC 1539:1997(E), the ISO standard for the Fortran programming language. This is now generally known as Fortran 95.

This document describes the entire test suite as it will be in a final version. This document also indicates which parts of the test suite are distributed with Version 1.1.

Background and General Information

The Fortran 95 Test Suite checks the syntactic and semantic analysis phases of Fortran 95 processing and compilation systems and contains substantial checks for run-time operation.

There is no enforced testing regime within the Fortran 95 Test Suite . The user is free to use these tests in any appropriate way, e.g.,

The Fortran 95 Test Suite is completely self checking in that each set of tests provides an indication as to which tests passed and which tests failed. In addition, pass/fail statistics are provided, when using TEST files (see section 7) to inform the user of the number of passes and/or failures for a given set of tests.

The tests may be used during compiler/tool development to ensure that all aspects of the language are being correctly processed, and during maintenance to ensure that changes to a system do not introduce new errors, i.e., as a means of regression testing.

All source code may be modified, extended, or enhanced by the user to incorporate additional tests specific or appropriate to their own environment.


Distribution Medium

The source for the Fortran 95 Test Suite is provided in gzipped Unix "tar" format.

Size of the Test Suite

The test suite consists of more than 400,000 lines of Fortran code. Approximately twenty-two megabytes of disk space are needed to store the test suite. (Version 1.1 consists of about 170,000 lines of code and takes about 6MB of disk space.)Execution of several of the test programs generates other tests that are then executed; in particular, the tests in the KEYWORDS directory generates and executes approximately ten million lines of test code, but the tests are deleted as they are run, so they do not require an unusually large amount of disk storage.

Extracting the files

To extract the files, "gunzip" or "gzip -d' the file, go to a directory in which the files are to be stored and execute the command

tar xf file.tar


The files are all contained in two subdirectories of the main directory U_F95_TS; the subdirectories are DOCS and TESTS. The organization of the subdirectories is described below.

Customizing the Test Suite

Some aspects of the test suite are system dependent. System dependencies are parameterized whenever possible. An environment variable U_F95_TS_SYSTEM must be set prior to running any test scripts. All known system dependencies are specified by files in the directory U_F95_TS/TESTS/$U_F95_TS_SYSTEM. Sample directories are included for several systems, including NAG and FUJ (Fujitsu).

Most dependencies related to the Fortran 95 compiler command line are specified as the values of shell variables in the file U_F95_TS/TESTS/$U_F95_TS_SYSTEM/COMPILER:

  • The name of the test system
  • The name of the compiler, e.g., "f95"
  • Names of the compiler options that specify source form, optimization, standard conformance checking, whether or not to produce an executable version, and the name of the executable file produced (if any)
  • Source file suffixes that designate source form
  • The size of the standard error files and standard output files resulting from a compilation after lines indicated in the files "err.ignore" and "std.ignore" have been removed

The file U_F95_TS/TESTS/$U_F95_TS_SYSTEM/compiler.FRE is a Fortran 95 module containing parameters that describe the kind numbers, the default input and output units, and the end-of-file and end-of-record signals returned by the IOSTAT= specifier for the system being tested. This file is used to generate tests that execute code for all possible kinds. U_F95_TS/TESTS/$U_F95_TS_SYSTEM also contains the following files:

  • err.ignore: Lines in the standard error file containing these characters will be removed prior to determining if a compilation error occurred.
  • std.ignore: Lines in the standard output file containing these characters will be removed prior to determining if a compilation error occurred.
  • err.signal: If the standard error file contains lines with these characters, it will be assumed that a compilation error occurred.
  • gen.signal: If the standard output file or the standard error file contains lines with these characters, it will be assumed that a compilation error occurred. This is used by the tests for invalid programs in the directory U_F95_TS/TESTS/INVALID/GEN.
  • obs.signal: If the standard output file or the standard error file contains lines with these characters, it will be assumed that the compiler has detected an obsolescent feature. This is used by the tests for deprecated features in the directory U_F95_TS/TESTS/INVALID/DEPREC.
  • del.signal: If the standard output file or the standard error file contains lines with these characters, it will be assumed that the compiler has detected a deleted feature. This is used by the tests for deleted features in the directory U_F95_TS/TESTS/INVALID/DELETED.
  • syn.signal: If the standard output file or the standard error file contains lines with these characters, it will be assumed that a syntax error has been detected. This is used by the tests for invalid programs in the directory U_F95_TS/TESTS/INVALID/CONSTRAINTS.

To attempt to determine if a compilation error has occurred, the value returned by executing the compile command is tested and the presence of a core file is tested. Also, it is determined whether an executable file has been generated in the appropriate cases.

Although the intention has been to parameterize all system dependencies using the files described above, there may still be some system dependencies in the tests.


The directory DOCS contains three versions of this document:

Features of Version 1.1

Test Files

All tests are contained in the subdirectory U_F95_TS/TESTS.

Fortran 95 tests written using free source form have the suffix ".FRE"; those using fixed source form have the suffix ".FIX". The TEST scripts change these suffixes to the appropriate one designated in the file COMPILER.

Files with the suffix ".inc" are include files.

Files with the suffix ".inp" or ".in?" are data input files.

Files with the suffix ".out" are output files produced by executing a test and may be removed at any time.


The organization of the "TESTS" subdirectory will be as follows (phase I files are denoted by *):



























Some of these directories have additional subdirectories corresponding to chapters of a book, sections of the Fortran standard, etc.

Test Types

Files may be categorized as containing programs dealing with one of the following:

Failure Tests

Failure tests are not supposed to compile properly or run. They test that invalid syntax or semantics are detected correctly.

Executable Semantic Tests

These tests exist to check the semantic phases of a compiler or processing tool. All of these tests programs are executable, since it is often only possible to check that a language statement/construct has been interpreted according to the semantic rules of the language at run-time.

Most semantic tests are checked and a PASS/FAIL report is generated. Some of these programs produce output files that can be viewed to ensure that the correct results are obtained. In some cases these can be compared with existing result files to check that the system under test produces the expected output.

Script Files

In the directory U_F95_TS/TESTS, in each of its subdirectories, and in each subdirectory of the directory INVALID there is a script file named "TEST" that may be used to invoke tests in that directory or its subdirectories. These are Unix Bourne shell scripts, but may be modified to run under a different shell or different operating system.

When the user runs tests using a TEST script file, a file named "TEST.out" is created. This file contains the results of running a particular set of tests and should be examined after each run.

When any of the TEST programs are run with no argument, all tests in that directory and its subdirectories are run, producing a TEST.out file in that directory and all subdirectories containing a TEST command file. The one exception is that execution of TEST in the directory U_F95_TS does not run the TEST script in the subdirectory KEYWORDS because of the long time that it takes to run those tests. The KEYWORDS tests must be run explicitly by executing TEST in the directory U_F95_TS with the argument KEYWORDS or executing the TEST script in the directory U_F95_TS/KEYWORDS.

Execution of all the tests in one directory can take from a few mintues to a small number of hours on a typical RISC workstation. Executing the TESTS in directory KEYWORDS may take several days.

TEST may take arguments as follows:

cd GUIDE # Change directory to the Programmer's Guide tests

TEST # Test all programs in the Guide

TEST C04 # Test all programs in Chapter 4 of the Guide

TEST C05/words.FRE C05/pal1.FRE # Test two programs in Chapter 5

TEST C0[4-6]/*.FIX # Test all fixed source programs in Chapters 4-6

Tests Provided

The following sections provide a general description of the tests in each of the main subdirectories. The sections marked with an asterisk (*) are contained in phase I; the others will be provided in a later version.


Each type and kind of array is passed to and from a subroutine and to a function. Various methods of passing the arrays are tested, such as assumed shape and assumed size. Passing to module procedures, internal procedures, and external procedures is tested.


A version of Mike Metcalf's program that converts from fixed source form to free source form is tested. A fixed form version of the program is executed on itself, producing a free source form version. This version is then used also to convert the fixed source form version. The two results are compared. The sed script is needed to correct one bug in this version of the conversion program.


This subdirectory contains semantic tests for all the programs in the book, Programmer's Guide to Fortran 95, Brainerd, Adams, and Goldberg, 1998. There is a subdirectory for each chapter of the book.


This subdirectory contains semantic tests for all the programs in the book, The Fortran 95 Handbook, Adams, Brainerd, Martin, Smith, and Wagener, 1997.


INVALID contains examples of code that must be detected as invalid or obsolescent.


The subdirectory CONSTRAINTS tests that the compiler detects and reports all violations of the constraints in ISO1539. There is a subdirectory for each section of the standard. The names of the files indicate the syntax rule to which the constraints are applicable.

In the directory U_F95_TS/INVALID/CONSTRAINTS there is a number of test programs that may fail when run with a particular Fortran 95 compiler or processing tool. These are listed below:

  • The tests pertaining to syntax rule R1228 have been modified to reflect clarifications adopted by ISO. The clarification indicates that arrays may occur in some contexts in statement functions, but an array argument to any function reference must be an array name, and the result must be scalar. Also any functions appearing in the definition of the statement function must not require an explicit interface or be a transformational intrinsic; and the result must be scalar.
  • The file r537p5e2.FRE contains a test to check that a data-stmt-object is not made accessible via host association. This may be difficult to test on some systems because the data-stmt-object may be declared implicitly. This means that the object is a different one from that used in the host program and will not cause an error.


The subdirectory DEPREC tests that each deprecated (or obsolescent) feature is detected by the compiler. The names of the files reflect the feature that is deprecated.

Each file is a complete program containing a simple example of one of the obsolescent features. Although they will compile and run, they do not provide extensive run-time checks.

When compiled, each file should cause one or more messages from the compiler indicating the obsolescent feature..


The subdirectory DELETE tests that each deleted feature is detected by the compiler. The names of the files reflect the feature that is deleted.

Each file is a complete program containing a simple example of one of the deleted features. Although they will compile and run, they do not provide extensive run-time checks.

When compiled, each file should cause one or more messages from the compiler indicating the deleted feature.


The subdirectory GEN contains other tests of nonstandard features that must be detected by a compiler.

  • datatrans.FRE combines and checks all the data transfer keyword constraints in a single program.
  • hexdigits.FRE checks that only hexadecimal digits are allowed in a DATA statement if the boz-literal-constant begins with "Z".
  • include_1.FRE, include_2.FRE, include_3.FRE, and include_4.FRE check restrictions on the use of the INCLUDE capability.
  • statalloc1.FRE checks that pointer targets cannot be allocated within the ALLOCATE statement in which they appear.
  • statalloc2.FRE checks that allocatable arrays cannot be allocated within the ALLOCATE statement in which they appear.


These extensive input/output tests are executed for each type and kind. The tests are generated from templates by scripts.


This subdirectory contains tests for all the programs in the Fortran 95 standard, ISO/IEC 1539 : 1997 Information Technology--Programming Languages--Fortran. Statements have been added to produce complete programs, but most are compiled and not executed. There is a subdirectory for each section of the standard.


This set of tests checks each keyword in Fortran 95 to ensure that it may be used in any allowed context. For example, it checks that PRINT may be used as variable name. When the test are executed, each keyword is substituted into several different program templates, creating programs that uses the keyword in a various contexts. There are more than 400 keywords and approximately 25,000 of code are generated and executed for each keyword. Thus, more than 10 million lines of code are executed when KEYWORDS/TEST is executed. This will probably take days on many machines.


The subdirectories under SEMANTICS provide run-time checks of all of the major features of the Fortran 95 programming language.


The subdirectory ARRAYS contains array-processing tests; the name of the test file indicates the sort of tests executed: for example, the file ash2dext.FRE tests passing arrays to an external procedures with two-dimensional assumed-shape dummy arguments. Files with names beginning with "sa" test sequence association. These tests are similar to those in the directory U_F95_TS/ARRAYS, except the tests are made only for default kinds. However, arguments of many types are made in each procedure call.


The subdirectory AUTOMATIC tests the use of automatic variables.


The subdirectory INTRINSICS exercises all of the intrinsic procedures. The tests are not all independent--many of the array tests, for instance, assume that ANY and ALL work (though if they fail, the tests will fail).


The subdirectory MISC contains miscellaneous tests.

  • casetest.FRE checks CASE and SELECT.
  • eqveqop.FRE checks equivalence of .EQ. and ==.
  • if_else.FRE checks IF, ELSEIF, ELSE, and ENDIF.
  • test_hanoi.FRE checks recursion. This program solves the classic "Towers of Hanoi" problem.
  • test01_f77.FIX and test01_f95.FRE determine the slope of a line between two points, basic numeric operations, and file handling.
  • test02_f77.FIX and test02_f95.FRE determine the roots of a third degree equation of the form ax3 + bx2 + cx + d between −100 and +100. The method of bisection is used to determine the value of the roots. It uses basic numeric operations and file handling.
  • test03_f77.FIX and test03_f95.FRE determine the value of a polynomial of degree 4.
  • test04_f77.FIX and test04_f95.FRE determine the transpose of a five by five matrix. The f77 version uses a subroutine; the f95 version uses the intrinsic TRANSPOSE.
  • test05_f77.FIX and test05_f95.FRE add two matrices. The f77 version uses a subroutine; the f95 version uses array addition.
  • test06_f77.FIX and test06_f95.FRE compute the multiplication of two matrices. The f77 version uses a subroutine; the f95 version uses the intrinsic MATMUL.
  • test07_f77.FIX and test07_f95.FRE solve a set of linear equations. The coefficients of the variables are read from an input file.
  • test08_f77.FIX and test08_f95.FRE count the occurrence of letters in a block of text. They use character handling.
  • test09_f77.FIX and test09_f95.FRE search for a character string within a block of text.
  • test10_f77.FIX and test10_f95.FRE create and update an inventory of compact disks. They use direct access and sequential files.
  • test11_f77.FIX and test11_f95.FRE solve a wordsearch puzzle.


The subdirectory POINTERS contains tests that check the pointer facilities.


SPOT contains collection of small "spot" tests for specific constructs and language features.

  • ai.FRE is a list-directed output test.
  • aj.FRE tests generic with same name as specific.
  • an.FRE tests that ENDDO/CONTINUE act the same with respect to control transfers.
  • at.FRE tests scalar default integer MODULO at execution time.
  • ax.FRE tests scalar integer pointer functions.
  • bc.FRE checks optional arguments (missing at runtime.
  • bg.FRE tests formatted sequential output to standard output, advancing and nonadvancing.
  • bh.FRE tests nonadvancing output to standard output (prompting).
  • br.FRE tests argument association of single-dimension fixed length character arrays to an internal procedure.
  • bs.FRE checks initialization of small binary/octal/hexadecimal constants, ISHFTC, and hexadecimal output.
  • bu.FRE checks ALLOCATE, LBOUND, and UBOUND.
  • bv.FRE checks simple binary/octal/hexadecimal initialization.
  • bw.FRE is a miscellany of bit operations.
  • by.FRE tests ASIN of an array.
  • bz.FRE checks arithmetic IF.
  • cc.FRE checks IABS.
  • ci.FRE tests nonadvancing input.
  • cm.FRE checks ALLOCATE and DEALLOCATE (with STAT=).
  • cn.FRE checks derived type (with scalar components) initialization and output.
  • co.FRE checks derived type (with fixed-size array components) initialization and output.
  • cp.FRE checks derived type (with nested scalar components) initialization and output.
  • ct.FRE is a simple SIZE and UBOUND test for assumed-shape arrays.
  • cu.FRE tests UBOUND of fixed-bound array (compile time UBOUND).
  • cv.FRE is a list-directed READ and formatted WRITE test of array-sections in i/o-implied-DO.
  • da.FRE tests comparison of COMPLEX and REAL arrays.
  • dc.FRE tests BOZ constants.
  • de.FRE tests COMPLEX*REAL (fixed-size contiguous) vectors.
  • df.FRE tests COMPLEX*REAL (fixed-size contiguous) vectors.
  • dn.FRE tests COMPLEX array initialization.
  • do.FRE tests CHARACTER initialization in DATA.
  • dq.FRE tests reading a floating-point number from an internal file using a character string format.
  • ds.FRE is a list-directed output test of character spacing when character items are derived type components.
  • du.FRE tests that negative zero is printed properly.
  • dv.FRE tests passing array sections to f77 style dummies.
  • dy.FRE tests real array initialization by a scalar.
  • ed.FRE tests assignment of scalar to derived type fixed size array component.
  • ee.FRE tests assignment to fixed size array component of a dummy argument.
  • ef.FRE tests a simple character*(*) function.
  • el.FRE tests simple variable-length character functions.
  • em.FRE tests simple variable-length character functions.
  • en.FRE tests list directed input.
  • ep.FRE tests INTERFACE blocks to variable-length character functions.
  • er.FRE tests overloading intrinsic function names.
  • et.FRE tests simple pointer array components.
  • eu.FRE tests nonadvancing input using EOR=, SIZE= and END=.
  • fa.FRE tests array constructors.
  • fb.FRE tests a recursive function.
  • fc.FRE tests an array assignment.
  • fd.FRE test an array assignment involving equivalence.
  • fe.FRE tests multiplication of objects of type matrix.
  • ff.FRE tests a pointer in a common block.
  • fg.FRE tests the intrinsic MATMUL in a WHERE block.
  • fh.FRE tests a recursive subroutine that reverses the values in a vector.
  • fi.FRE tests an internal read.
  • fj.FRE amd fk.FIX test a simple PRINT statement.
  • fk.FRE tests an equivalenced target.
  • fl.FRE tests a module and interface.
  • fm.FRE tests a character array constructor.
  • fn.FRE tests passing a pointer to a subroutine.
  • fo.FIX tests the use of keywords as variables.
  • fp.FRE and fp.FIX test some edit descriptors.
  • fq.FRE and fq.FIX test strings with embedded single and double quotes.
  • fs.FRE and fs.FIX test control constructs.
  • ft.FRE and ft.FIX test program units, interface blocks, and the WHERE construct.
  • fu.FRE and fu.FIX test BOZ constants and the Hollerith edit descriptor.
  • fv.FRE tests a dynamic defined matrix type using pointers.
  • fw.FRE tests a recursive function involving pointers.
  • fx.FRE tests producing a "graph" representing densities; it involves several mathematical intrinsic functions and internal functions.
  • fy.FRE computes some statistics involving rainfall data using array intrinsics.
  • fz.FRE tests repeated dynmaic allocation of a defined type vector involving pointers.
  • ga.FRE tests passing of arrays.
  • gb.FRE tests namelist input.
  • gc.FIX tests passing of expressions.
  • gd.FRE tests a simple structure.
  • ge.FRE tests allocation and deallocation of a pointer variable.
  • gf.FRE tests a structure whose component is a pointer array.
  • gg.FRE tests the minloc intrinsic function.
  • gh.FRE tests a module for computing with Roman numerals.
  • gi.FRE tests sequence types.
  • gj.FRE tests a linked list.
  • gk.FRE tests passing through two levels of subroutine calls.
  • gl.FRE tests a program that prints a copy of itself.
  • gm.FRE tests a program that puts approprriate suffixes on numbers.
  • gn.FRE tests an internal write to an array section.
  • go.FRE tests a recursive funtion with an alternate return.
  • gp.FIX tests a very long arithmetic statement.
  • gq.FRE tests a zero-sized parameter array.hd.
  • gh.FRE tests a module for comuting with Roman numerals.
  • ha.FRE tests the components of a structure.
  • hb.FRE tests common and equivalence.
  • hc.FRE tests nonadvancing input/output.
  • hd.FRE tests the f90split program.
  • he.FRE tests implied-DOs in an array constructor.
  • hf.FRE checks the size of an array triplet with negative stride.
  • hg.FRE is a cube root solver.
  • hh.FRE tests a tree sort.
  • hi.FRE checks the max of an array parameter.
  • hj.FRE tests reading an array section with namelist input.
  • hk.FRE checks some type complex calculations
  • hl.FRE checks the CASE construct with characters.
  • hm.FRE checks the reshape intrinsic and equivalence.
  • hn.FRE solves equations using allocatable arrays, structures, and pointers.
  • ho.FRE checks the DATA statement.
  • hp.FRE checks the RESHAPE intrinsic and an array constructor to form the identity matrix.
  • hq.FRE checks the parentheses in an expression are honored.
  • hr.FRE checks passing subroutines as arguments.
  • hs.FRE runs two sorts and checks the results.
  • ja.FRE runs Loren Meissners skeleton linear equation solver.
  • jb.FRE checks vector subscripts.
  • jc.FRE converts integers to strings.
  • jd.FRE tests a couple of shell sorts.
  • je.FRE checks the MOD function and array constructors.
  • jf.FRE tests the ASSOCIATED intrinsic function.
  • jg.FRE is Jean Vezina's implementation of a generic linked list.
  • jh.FRE tests vector subscripts.



The subdirectory GEN contains general syntax checks that exercise the compiler's lexical and syntactic phases; for example, there are checks that all optional keywords for intrinsic functions are allowed.

  • chkkinds.FRE checks typed constants and kind numbers. The test file is generated when the test is executed to incorporate tests for the kind numbers specified in U_F95_TS/TESTS/$U_F95_TS_SYSTEM/compiler.FRE.
  • datatran.FRE tests all the legal combinations of keyword specifiers for data transfer statements, syntax rules R909 to R912.
  • inctst.FRE tests a simple and nested include file. This test uses files file*.inc for actual inclusion of data.
  • key13all.FRE tests for optional keywords in intrinsic function references.
  • optblkin.FRE tests optional blanks in keywords (e.g., END IF).
  • optblkot.FRE tests the absence of optional blanks in keywords (e.g. ENDIF).
  • specnam?.FRE checks that all of the specific names can be declared as intrinsic and of the specified types (Section 13.12 of the standard) and checks to see that all of the specific names can be used as actual arguments.


The subdirectory MIN contains some minimal programs (for example, the minimal program consisting of only an END statement) and minimal subprograms..


The subdirectory RULES contains tests for every syntax rule in the Fortran 95 programming language; the name of the file indicates the rule numbers in the standard that are tested--for example, the file 512t518.FRE contains tests for R512 through R518, 213.FRE tests R213 only, and 201a208.FRE tests rules R201 and R208.


This subdirectory contains semantic tests for all the programs in the book, Fortran Top 95--Ninety-Five Key Features of Fortran 95 by Adams, Brainerd, Martin, and Smith, 1998.


The subdirectory UTILITIES contain programs that might be of general use. It contains the following files:

  • elefunt.FIX, a fixed format source file containing a version of the ELEFUNT elementary function test program. This program is based on the ELEFUNT package described in Software Manual for the Elementary Functions, W.J. Cody and W. Waite, Prentice Hall, Englewood Cliffs, 1980. ISBN 0-13-822064-6. The user may need to modify the logical function "lround" if the target machine does not round the results of operations on real numbers to the nearest machine number. The program requires the data file "elefunt.d" to be connected to standard input (e.g. elefunt < elefunt.d), this file contains user modifiable switches to control which tests are run. The output from running this utility is delivered in "elefunt.out".
  • elefunt.d, the data file for use with "elefunt.f"
  • elefunt.r, a sample ELEFUNT output file
  • fixedtst.FIX, a fixed format program which tests the fixed source form extensions listed in Section 3.3.2 of the standard. This file is also used as input to the translation utility described below.
  •, an include file for use with "fixedtst.FIX"
  • kindlist.FRE works out what integer and real kind numbers are in use and prints a summary to "kindlist.out". It uses SELECTED_INT_KIND and SELECTED_REAL_KIND.
  • translat.FRE, a small program that can be used to translate Fortran 77 fixed source form programs to Fortran 95 free source form. When executed, it uses the file fixedtst.FIX as input and produces fixedtst.out as output. It can be modified to make other changes (e.g. REAL*8 to REAL(KIND=1)).

Services from The Fortran Company


Please contact The Fortran Company at the following address by telephone, fax, postal mail, or electronic mail if you have any questions or problems related to the Fortran 95 Test Suite .

The Fortran Company
6025 N. Wilmot Road Tucson, Arizona 85750 USA
+1-877-355-6640 (voice & fax)

Other Test Suites

The Fortran Company markets the EVT (Expression Validation Tests), produced by Imagine1 and the SHAPE array processing test suite of Spackman & Hendrickson.

The Fortran Company develops and markets a "Lite" version of the test suite, suitable for compiler evaluation by end users. This suite includes benchmarks for performance evaluation as well as conformance testing.

For information about these test suites, contact The Fortran Company the address given above.


The Fortran Company provides Fortran 95 training both at a customer's site and in Tucson.

For information about this training service, contact The Fortran Company at the address given above or visit the web site:

Compilers and Books

The Fortran Company sells a variety of Fortran compilers, tools, and books. Visit the web site:

Services from NAG


It may be possible for your local advisory service or NAG Site Contact to resolve queries concerning this document or the software in general. However, please do contact NAG, at one of the supplied addresses, if you have any difficulties.

Technical queries should be addressed to the Technical Support Desk, which may also be contacted by electronic mail:

excluding North America:



North America:


Other Products

NAG is continually striving to bring the best in mathematical, statistical and graphical software to its users. It caters for the package user, the software developer and the Fortran, Ada, C, Pascal or Algol 68 enthusiast. To find out more about the growing range of facilities available please contact NAG and ask for a free information pack.

NAG Users Association

NAGUA is the NAG Users Association, and membership is open to all users of NAG products and services. As a member of NAGUA your organization would receive the newsletter "NAGUA News" three times a year, would receive discounts at the annual conference, and those sites with access to electronic mail would be able to participate in NAGMAG, our electronic mail digest. For an information pack and membership application form, contact the NAGUA Co-ordinator at the supplied address.


Wilkinson House
Jordan Hill Road
United Kingdom
Tel: +44 865 511245
Fax: +44 865 310139

User Response Centre
Tel: +44 865 311744
Fax: +44 865 311755


NAG Inc.
1400 Opus Place, Suite 200
Downers Grove IL 60515-5702 USA
Tel: +1-708 971 2337
Fax: +1 708 971 2706


200 Schleissheimerstrasse 5
W-8046 Garching bei Munchen
Tel: +49 89 3207395
Fax: +49 89 3207396


NAGUA Co-ordinator
NAG Users Association
PO Box 426
United Kingdom
Tel: +44 865 311102