NAG Library for SMP & Multicore, Mark 23

FSW3223DCL - License Managed

Windows XP/Vista/7 32-bit, Intel Fortran

Users' Note


1. Introduction

This document is essential reading for every user of the NAG Library for SMP & Multicore implementation specified in the title. It provides implementation-specific detail that augments the information provided in the NAG Mark 23 Library Manual (which we will refer to as the Library Manual). Wherever that manual refers to the "Users' Note for your implementation", you should consult this note.

In addition, NAG recommends that before calling any Library routine you should read the following reference material (see Section 5):

(a) Essential Introduction
(b) Chapter Introduction
(c) Routine Document

The libraries supplied with this implementation have been compiled in a manner that facilitates the use of multiple threads.

1.1. Restrictions

In this implementation, the Compaq Visual Fortran calling convention is used (ifort /iface:cvf). In essence this means that parameters are accessed by reference. Character strings are passed as address/length pairs (i.e. /iface:mixed_str_len_arg, which is automatically turned on if /iface:cvf is specified).

Fortran 90/95/2003 users are advised that the compiled *.mod files (the interface blocks) have been compiled with the Intel Fortran Compiler 12.1 and are intended for use with that compiler. Users may have to compile the interface blocks themselves if they wish to use them with a different compiler.

When the DLL is used with a non-Intel compiler, please note that two input/output systems are in use: those of Intel for library routines and of course the compiler's own input/output routines for the calling program. This means that programs like the E04UDF example program cannot read the data from just one file. This is because the program reads some of the data using its input/output system. When the option setting routine tries to read the data file, the Intel input/output routines are used. The two input/output systems are completely disjoint and so in particular Intel has no knowledge of the position in the data file that the program input/output system has reached. The problem is circumvented by having two separate data files. Routines affected by this are mainly the option setting routines in chapters H02 and E04.

2. Post Release Information

Please check the following URL:

for details of any new information related to the applicability or usage of this implementation.

3. General Information

3.1. Accessing the Library

The NAG Library for SMP & Multicore has been built using the version of Intel Fortran described in the Installer's Note. To call the DLLs from a program compiled with a different version of Intel Fortran, you may need to move or rename the files libifcoremd.dll and libmmd.dll in the install_dir\bin folder, so that the correct Intel Fortran runtime DLLs are picked up. To facilitate this, the batch file hide_ifort_rtls.bat has been provided in the install_dir\bin folder. This file will rename the Intel Fortran run-time libraries libifcoremd.dll and libmmd.dll in that folder. The file expose_ifort_rtls.bat, also in that folder, is provided to convert the names back again. (Note that appropriate access permissions may need to be in place for these batch files to work.)

In this section we assume that the library has been installed in the default folder:

  c:\Program Files\NAG\FS23\fsw3223dcl
If this folder does not exist, please consult the system manager (or the person who did the installation). In some of the following subsections, this folder is referred to as install_dir.

We also assume that the default shortcut for the Library command prompt is placed in the Start Menu under:

  Start|All Programs|NAG|FS23|NAG Library for SMP and Multicore (FSW3223DCL)
                    |FSW3223DCL Command Prompt

If this shortcut does not exist, please consult the system manager (or the person who did the installation). (Other shortcuts created as part of the Library installation procedure are also assumed to be in this location.)

To ensure that the NAG DLL is accessible at runtime, the PATH environment variable must be set such that the location of the NAG DLLs, specifically the folder install_dir\bin, is on the path. The install_dir\MKL_ia32_10.3\bin folder must also be on the path, but should appear later in the path than the install_dir\bin folder, since the NAG versions of some linear algebra routines (BLAS or LAPACK) are included in FSW3223DC.dll. (See Section 4 for details.)

3.1.1. From a command window

To access this implementation from a command window some environment variables need to be set (if you chose not to allow the installation program to set them for you).

The shortcut:

  Start|All Programs|NAG|FS23|NAG Library for SMP and Multicore (FSW3223DCL)
                    |FSW3223DCL Command Prompt
may be used to start a command prompt window with the correct settings for the INCLUDE, LIB and PATH environment variables the Library and the supplied MKL.

If the shortcut is not used, you can set the environment variables by running the batch file envvars.bat for this implementation. The default location of this file is:

  c:\Program Files\NAG\FS23\fsw3223dcl\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing fsw3223dcl.

You may then compile and link to the NAG Library on the command line using one of the following commands:

  ifort /iface:cvf /MD /Qopenmp driver.f FSW3223DC_static.lib mkl_rt.lib user32.lib
where driver.f is your application program; or
  ifort /iface:cvf /MD /Qopenmp driver.f FSW3223DC.lib
if the DLL version of the library is required. Note that in the DLL case it is not necessary to explicitly link to the MKL libraries. Notice that in both cases we compile using the /iface:cvf compiler flag. This tells the compiler that we wish to use the CVF calling convention. We also use the /MD compiler flag. This tells the compiler that we wish to link to multi-threaded DLL versions of compiler run-time libraries. Both these flags are important to ensure compatibility with this implementation of the NAG Library for SMP and Multicore. If you do not use them - particularly /iface:cvf - it is likely that your programs will fail to run correctly.

The /Qopenmp flag tells the compiler to heed any OpenMP directives that may be present in your own code. It also causes the linker to link to the compiler threading library, libiomp5md.lib. For older versions of the Intel compiler, a different threading library (named libguide) was used by default. If you are using an older compiler (such as ifort 10.1) then you may need to add libiomp5md.lib explicitly to the compile line, e.g.

  ifort /iface:cvf /MD /Qopenmp driver.f FSW3223DC_static.lib mkl_rt.lib
        user32.lib libiomp5md.lib
  ifort /iface:cvf /MD /Qopenmp driver.f FSW3223DC.lib libiomp5md.lib
to avoid error messages at link or run time.

More information on calling NAG Fortran or C DLLs is available on the NAG web site at
More information specific to this product may be available from the Post Release Information page:

3.1.2. From MS Visual Studio

The instructions given here are for Visual Studio .NET 2003/2005/2008 with Intel Fortran Compiler 12.1. Other versions may vary.

To ensure that the NAG DLLs are accessible at runtime, the PATH environment variable must be set such that the location of the NAG DLLs, specifically the folder install_dir\bin, is on the path. The location of the MKL DLLs, install_dir\MKL_ia32_10.3\bin must also be on the path, but should appear after the install_dir\bin folder.

Once Visual Studio has been opened, it is possible to set up the directories for use with Intel Fortran in this and all subsequent projects which use this compiler. One way to do so is:

  1. Select the Tools pull down menu, and click on Options.

  2. In the Options window, click on Intel(R) Fortran (or Intel(R) Visual Fortran) and then choose Compilers in the left window pane. (In some versions of Visual Studio you may need to click on Show all settings to see the Intel compiler options.)

  3. In the right window pane, click on the '...' to the right of the Libraries panel.

  4. Add the path to the NAG DLL import library to the Set Directory List window. The default location is:
      c:\Program Files\NAG\FS23\fsw3223dcl\lib

  5. In this implementation, if linking to the DLL version of the NAG Library, there is no need to add the path to the MKL libraries, since the BLAS and LAPACK symbols are exported from the NAG import library (FSW3223DC.lib). However, any MKL library folders in the Libraries path must come after the path to the NAG Library, as it is important that these are not picked up before the NAG Library, as explained in Section 3.1.

  6. Click on the OK button in the Set Directory List window.

  7. In the right window pane, click on the '...' to the right of the Includes panel.

  8. Add the path to the NAG interface blocks to the Set Directory List window. The default location is:
      c:\Program Files\NAG\FS23\fsw3223dcl\nag_interface_blocks

  9. Click on the OK button in the Set Directory List window.

  10. Click on the OK button in the Options window.

Having done this, if an Intel Fortran project requires a library or NAG interface block during the compilation and linking process then the full path to the library and interface block do not need to be specified.

Whilst the above changes will apply to every Intel Fortran project, the following tasks need to be performed for each individual Intel Fortran project.

The library is intended to be run in fully optimised mode, so to avoid any warning messages, you might decide to set the active configuration to Release. You can do this from the Toolbar or alternatively via the Build|Configuration Manager menus. Note that if you work in Debug mode, you may receive a warning message about conflicting C run-time libraries.

There are a number of ways to add the NAG Library to the project. We describe just two; choose the one that most suits you.

If the Solution Explorer window is open then make sure that the group project (the first line) is NOT selected. From the Project menu, choose the project Properties item. (Alternatively right-click on a specific single project in the Solution Explorer and choose Properties.)

From the form, click/expand Linker in the leftmost panel and then choose Input. The right hand panel will now have an Additional Dependencies entry, and you need to type FSW3223DC.lib in this location. Alternatively, to link to the static library, add libraries FSW3223DC_static.lib and mkl_rt.lib here. Press the OK button.

You will also need to set the calling convention to "CVF". From the Properties form, click/expand Fortran and then choose External Procedures. Click on the Calling Convention entry in the right hand panel and select CVF from the drop-down list. Selecting this option will automatically change the entry for String Length Argument Passing to After Individual String Argument when you click on Apply or OK; this is the convention required by this implementation of the NAG Library.

We also recommend that you use the multithreaded DLL version of the runtime library. From the Properties form, click/expand Fortran in the leftmost panel and then choose Libraries. Click on the Runtime Library entry in the right hand panel and select Multithread DLL from the drop-down list.

For a multithreaded application, as well as selecting a multithreaded run-time library, you should set the /automatic (or /Qauto) compiler flag, to ensure that all local variables are allocated on the stack. To set this option, from the Properties form click/expand Fortran and then choose Data. Click on the Local Variable Storage entry in the right hand panel and select Local Variables AUTOMATIC from the drop-down list. Press the OK button to accept the changes and close the form.

As described earlier when compiling from the command line, you may also wish to tell the compiler to use the /Qopenmp switch. From the Properties form, click/expand Fortran in the leftmost panel and then choose Language. Click on the Process OpenMP Directives entry in the right hand panel and select Generate Parallel Code (/QopenMP) from the drop-down list.

The Properties information may also be accessed via the Toolbar. With the project selected in Solution Explorer, choose the Properties Window button on the Toolbar. In the ensuing window choose then the rightmost Property Pages icon. Select the appropriate settings as detailed in the paragraphs above.

The project should now compile and link using the appropriate choice from the Build menu.

To run a program that does not require input or output redirected from standard input or standard output, from within the Microsoft Development Environment, the program may be executed via the Debug menu (by selecting Start Without Debugging, for example).

If a data file needs to be attached to the standard input or the output of a program needs to be redirected to the standard output, we recommend that you run the executable from a command prompt window to avoid the limitations of Visual Studio.

3.1.2. Note on Module Files

The .mod module files supplied with this NAG Library implementation in the nag_interface_blocks folder were compiled with the Intel ifort compiler. Such module files are compiler-dependent and will not be suitable for use with other Fortran compilers. If you wish to use the NAG example programs, or use the interface blocks in your own programs, when using another compiler, you will first need to create your own module files. See Section 3.3 for details.

3.1.3. From other environments

The c_headers and vb_headers folders of the library installation contain header files and declaration statements to aid in calling the NAG Library from C/C++ or Visual Basic (including VB6, VB.NET and VBA) respectively.

The samples folder of the library installation contains various subfolders which may help if you wish to call the library from C, C++, Microsoft Excel, Microsoft Visual Basic or VB.NET, or the Lahey or gfortran Fortran compilers. We do not give detailed information on how to do that here, but more information may appear on the Post Release Information page:

Otherwise please contact NAG for advice.

3.2. Set the number of threads to use

Set the environment variable OMP_NUM_THREADS to the number of processors required, up to maximum available on your system, e.g. in a command window type:
where N is the number of threads required. OMP_NUM_THREADS may be re-set between each execution of the program, as desired.

In general, the maximum number of threads you are recommended to use is the number of physical cores on your SMP system.

3.3. Interface Blocks

The NAG Library for SMP & Multicore interface blocks define the type and arguments of each user callable NAG Library for SMP & Multicore routine. These are not essential to calling the NAG Library for SMP & Multicore from Fortran programs. However, they are required if the supplied examples are used. Their purpose is to allow the Fortran compiler to check that NAG Library for SMP & Multicore routines are called correctly. The interface blocks enable the compiler to check that:

(a) subroutines are called as such;
(b) functions are declared with the right type;
(c) the correct number of arguments are passed; and
(d) all arguments match in type and structure.

The NAG Library for SMP & Multicore interface block files are organised by Library chapter. They are aggregated into one module named

The modules are supplied in pre-compiled form (.mod files) and they can be accessed by specifying the -module:pathname option on each compiler invocation, where pathname (install_dir\nag_interface_blocks) is the path of the directory containing the compiled interface blocks.

If you use the Library command prompt shortcut or set the environment variables by running the batch file envvars.bat for this implementation (see Section 3.1.1), and the Intel ifort compiler, you can use any of the commands described in Section 3.1.1 to access these modules since the environment variable INCLUDE will be set.

The .mod module files were compiled with the compiler shown in Section 2.1 of the Installer's Note. Such module files are compiler-dependent.

If you wish to use NAG modules with a Fortran compiler other than the Intel compiler, you will need to recompile the interface blocks with your own compiler, as decscribed here.

Copy all the .f90 files from the nag_interface_blocks folder to a new folder of your choice, for example (if you wish to use them with the NAG compiler nagfor) nag_interface_blocks_nagfor. Then compile all the files into objects using your compiler. Because the interface blocks contain some inter-dependencies, the order of compilation is important, but the following compilation order should work (again, using the NAG compiler as an example):

  nagfor -f77 -w=x95 -c nag_precisions.f90
  nagfor -f77 -w=x95 -c nag_blas_consts.f90
  nagfor -f77 -w=x95 -c nag_a_ib.f90
  nagfor -f77 -w=x95 -c nag_blas_ib.f90
  nagfor -f77 -w=x95 -c nag_blast_ib.f90
  nagfor -f77 -w=x95 -c nag_c_ib.f90
  nagfor -f77 -w=x95 -c nag_d_ib.f90
  nagfor -f77 -w=x95 -c nag_e_ib.f90
  nagfor -f77 -w=x95 -c nag_f_ib.f90
  nagfor -f77 -w=x95 -c nag_g_ib.f90
  nagfor -f77 -w=x95 -c nag_h_ib.f90
  nagfor -f77 -w=x95 -c nag_lapack_ib.f90
  nagfor -f77 -w=x95 -c nag_m_ib.f90
  nagfor -f77 -w=x95 -c nag_p_ib.f90
  nagfor -f77 -w=x95 -c nag_s_ib.f90
  nagfor -f77 -w=x95 -c nag_x_ib.f90
  nagfor -f77 -w=x95 -c nag_long_names.f90
  nagfor -f77 -w=x95 -c nag_library.f90
(N.B. here the nagfor -f77 flag is used to generate modules with the STDCALL calling convention. The -w=x95 flag suppresses warnings about long symbol names. For other compilers, different flags may be necessary).

To use the newly compiled module files, you will need a compiler-dependent switch to tell the compiler where to find them when you are compiling programs. For example, with the NAG compiler, the command

  nagfor -f77 -w=x95 -I nag_interface_blocks_nagfor
will tell the compiler to look in the new folder for module files.

3.4. Example Programs

The example results distributed were generated at Mark 23, using the software described in Section 2.2 of the Installer's Note. These example results may not be exactly reproducible if the example programs are run in a slightly different environment (for example, a different Fortran compiler, a different compiler library, or a different set of Basic Linear Algebra Subprograms (BLAS) or Linear Algebra PACKage (LAPACK) routines). The results which are most sensitive to such differences are: eigenvectors (which may differ by a scalar multiple, often -1, but sometimes complex); numbers of iterations and function evaluations; and residuals and other "small" quantities of the same order as the machine precision.

Note that the example material has been adapted, if necessary, from that published in the Library Manual, so that programs are suitable for execution with this implementation with no further changes. The distributed example programs should be used in preference to the versions in the Library Manual wherever possible.

The example programs are most easily accessed by the batch files nagsmp_example_static.bat or nagsmp_example_dll.bat which are in the folder install_dir\batch.

The batch files need the environment variable NAG_FSW3223DCL.

As mentioned in Section 3.1.1, the installation procedure provides a shortcut which starts a Command Prompt with local environment variables. The environment variables include NAG_FSW3223DCL. This shortcut is placed in the Start Menu under

  Start|All Programs|NAG|FS23|NAG Library for SMP and Multicore (FSW3223DCL)
                    |FSW3223DCL Command Prompt
If the shortcut is not used, you need to set this environment variable. It can be set by running the batch file envvars.bat for this implementation. The default location of this file is:
  c:\Program Files\NAG\FS23\fsw3223dcl\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing FSW3223DCL.

The batch script nagsmp_example_static.bat will provide you with a copy of an example program (and its data, if any), compile the program and link it with the library FSW3223DC_static.lib and the MKL. Finally, the executable program will be run.

The example program concerned, and the number of OpenMP threads to use, are specified by the arguments to nagsmp_example_static.bat, e.g.

  nagsmp_example_static e04ucf 4
will copy the example program e04ucfe.f and its data file e04ucfe.d into the current directory and process them to produce the example program results in the file e04ucfe.r.

Alternatively you could use:

  nagsmp_example_dll e04ucf 4

The difference between nagsmp_example_static.bat and nagsmp_example_dll.bat is that while nagsmp_example_static.bat links to the static version of the NAG SMP and MKL Libraries, nagsmp_example_dll.bat links to the DLL versions of the libraries.

3.5. Fortran Types and Interpretation of Bold Italicised Terms

The NAG Library and documentation use parameterized types for floating-point variables. Thus, the type
appears in documentation of all NAG Library for SMP & Multicore routines, where nag_wp is a Fortran KIND parameter. The value of nag_wp will vary between implementations, and its value can be obtained by use of the nag_library module. We refer to the type nag_wp as the NAG Library "working precision" type, because most floating-point arguments and internal variables used in the library are of this type.

In addition, a small number of routines use the type

where nag_rp stands for "reduced precision type". Another type, not currently used in the library, is
for "higher precision type" or "additional precision type".

For correct use of these types, see almost any of the example programs distributed with the Library.

For this implementation, these types have the following meanings:

      REAL (kind=nag_rp)      means REAL (i.e. single precision)
      REAL (kind=nag_wp)      means DOUBLE PRECISION
      COMPLEX (kind=nag_rp)   means COMPLEX (i.e. single precision complex)
      COMPLEX (kind=nag_wp)   means double precision complex (e.g. COMPLEX*16)

In addition, the Manual has adopted a convention of using bold italics to distinguish some terms.

One important bold italicised term is machine precision, which denotes the relative precision to which DOUBLE PRECISION floating-point numbers are stored in the computer, e.g. in an implementation with approximately 16 decimal digits of precision, machine precision has a value of approximately 1.0D-16.

The precise value of machine precision is given by the routine X02AJF. Other routines in Chapter X02 return the values of other implementation-dependent constants, such as the overflow threshold, or the largest representable integer. Refer to the X02 Chapter Introduction for more details.

The bold italicised term block size is used only in Chapters F07 and F08. It denotes the block size used by block algorithms in these chapters. You only need to be aware of its value when it affects the amount of workspace to be supplied – see the parameters WORK and LWORK of the relevant routine documents and the Chapter Introduction.

3.6. Explicit Output from NAG Routines

Certain routines produce explicit error messages and advisory messages via output units which have default values that can be reset by using X04AAF for error messages and X04ABF for advisory messages. (The default values are given in Section 4.) These routines are potentially not thread safe and in general output is not recommended in a multithreaded environment.

4. Routine-specific Information

Any further information which applies to one or more routines in this implementation is listed below, chapter by chapter.
  1. C06

    In this implementation calls to the Intel Discrete Fourier Transforms Interface (DFTI) routines, from the supplied MKL library, are made whenever possible in the following NAG routines:
    C06PAF  C06PCF  C06PFF  C06PJF  C06PKF  C06PPF  C06PQF  C06PRF  C06PSF
    C06PUF  C06PXF  C06RAF  C06RBF  C06RCF  C06RDF
    The Intel DFTI routines allocate their own workspace internally, so no changes are needed to the size of workspace array WORK passed to the NAG C06 routines listed above from that specified in their respective library documents.

  2. F06, F07, F08 and F16

    Many LAPACK routines have a "workspace query" mechanism which allows a caller to interrogate the routine to determine how much workspace to supply. Note that LAPACK routines from the Intel MKL library may require a different amount of workspace than the equivalent NAG versions of these routines. Care should be taken when using the workspace query mechanism.

    In this implementation calls to BLAS and LAPACK routines are implemented by calls to MKL, except for the following routines:


    The following NAG named routines are wrappers to call LAPACK routines from MKL:

  3. G02

    The value of ACC, the machine-dependent constant mentioned in several documents in the chapter, is 1.0D-13.

  4. P01

    On hard failure, P01ABF writes the error message to the error message unit specified by X04AAF and then stops.

  5. S07 - S21

    Functions in these Chapters will give error messages if called with illegal or unsafe arguments.

    The constants referred to in the Library Manual have the following values in this implementation:

    S07AAF  F_1 = 1.0E+13
            F_2 = 1.0E-14
    S10AAF  E_1 = 1.8715E+1
    S10ABF  E_1 = 7.080E+2
    S10ACF  E_1 = 7.080E+2
    S13AAF  x_hi = 7.083E+2
    S13ACF  x_hi = 1.0E+16
    S13ADF  x_hi = 1.0E+17
    S14AAF  IFAIL = 1 if X > 1.70E+2
            IFAIL = 2 if X < -1.70E+2
            IFAIL = 3 if abs(X) < 2.23E-308
    S14ABF  IFAIL = 2 if X > x_big = 2.55E+305
    S15ADF  x_hi = 2.65E+1
    S15AEF  x_hi = 2.65E+1
    S15AFF  underflow trap was necessary
    S15AGF  IFAIL = 1 if X >= 2.53E+307
            IFAIL = 2 if 4.74E+7 <= X < 2.53E+307
            IFAIL = 3 if X < -2.66E+1
    S17ACF  IFAIL = 1 if X > 1.0E+16
    S17ADF  IFAIL = 1 if X > 1.0E+16
            IFAIL = 3 if 0 < X <= 2.23E-308
    S17AEF  IFAIL = 1 if abs(X) > 1.0E+16
    S17AFF  IFAIL = 1 if abs(X) > 1.0E+16
    S17AGF  IFAIL = 1 if X > 1.038E+2
            IFAIL = 2 if X < -5.7E+10
    S17AHF  IFAIL = 1 if X > 1.041E+2
            IFAIL = 2 if X < -5.7E+10
    S17AJF  IFAIL = 1 if X > 1.041E+2
            IFAIL = 2 if X < -1.9E+9
    S17AKF  IFAIL = 1 if X > 1.041E+2
            IFAIL = 2 if X < -1.9E+9
    S17DCF  IFAIL = 2 if abs(Z) < 3.92223E-305
            IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4
            IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9
    S17DEF  IFAIL = 2 if Im(Z) > 7.00921E+2
            IFAIL = 3 if abs(Z) or FNU+N-1 > 3.27679E+4
            IFAIL = 4 if abs(Z) or FNU+N-1 > 1.07374E+9
    S17DGF  IFAIL = 3 if abs(Z) > 1.02399E+3
            IFAIL = 4 if abs(Z) > 1.04857E+6
    S17DHF  IFAIL = 3 if abs(Z) > 1.02399E+3
            IFAIL = 4 if abs(Z) > 1.04857E+6
    S17DLF  IFAIL = 2 if abs(Z) < 3.92223E-305
            IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4
            IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9
    S18ADF  IFAIL = 2 if 0 < X <= 2.23E-308
    S18AEF  IFAIL = 1 if abs(X) > 7.116E+2
    S18AFF  IFAIL = 1 if abs(X) > 7.116E+2
    S18DCF  IFAIL = 2 if abs(Z) < 3.92223E-305
            IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4
            IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9
    S18DEF  IFAIL = 2 if Re(Z) > 7.00921E+2
            IFAIL = 3 if abs(Z) or FNU+N-1 > 3.27679E+4
            IFAIL = 4 if abs(Z) or FNU+N-1 > 1.07374E+9
    S19AAF  IFAIL = 1 if abs(X) >= 5.04818E+1
    S19ABF  IFAIL = 1 if abs(X) >= 5.04818E+1
    S19ACF  IFAIL = 1 if X > 9.9726E+2
    S19ADF  IFAIL = 1 if X > 9.9726E+2
    S21BCF  IFAIL = 3 if an argument < 1.583E-205
            IFAIL = 4 if an argument >= 3.765E+202
    S21BDF  IFAIL = 3 if an argument < 2.813E-103
            IFAIL = 4 if an argument >= 1.407E+102

  6. X01

    The values of the mathematical constants are:
    X01AAF (pi) = 3.1415926535897932
    X01ABF (gamma) = 0.5772156649015328

  7. X02

    The values of the machine constants are:

    The basic parameters of the model

    X02BHF   = 2
    X02BJF   = 53
    X02BKF   = -1021
    X02BLF   = 1024
    X02DJF   = .TRUE.

    Derived parameters of the floating-point arithmetic

    X02AJF   = 1.11022302462516E-16
    X02AKF   = 2.22507385850721E-308
    X02ALF   = 1.79769313486231E+308
    X02AMF   = 2.22507385850721E-308
    X02ANF   = 2.22507385850721E-308

    Parameters of other aspects of the computing environment

    X02AHF   = 1.42724769270596E+45
    X02BBF   = 2147483647
    X02BEF   = 15
    X02DAF   = .TRUE.

  8. X03

    X03AAW and X03AAX are internal routines which are exported from this NAG Fortran Library implementation as they may be useful when calling the DLLs from environments such as Excel (as explained below).

    The routine X03AAW changes the floating-point control word such that it sets the working precision to double precision (53-bit mantissa) and sets the rounding mode to nearest. X03AAW takes a single INTEGER argument, which is used to store the floating-point control word value on input and return it to the calling program, so this routine is also used to retrieve the original (i.e. on entry) value of the control word.

    The routine X03AAX sets the floating-point control word to the value specified in its single INTEGER argument. It is typically used to restore the floating-point control word to its original value after a call to X03AAW, but may, of course, be used to set a different value.

    The Library is designed to operate in double precision (53-bit) mode, not the extended precision mode also possible on the chip. A normal Intel Fortran program will operate, by default, in this mode, but other environments may re-set the floating-point control word so that the chip operates in extended precision mode. Excel is one such environment. To obtain consistent behaviour the user may wish to use X03AAW directly before entering any other Library routine in order to restore the mode of operation to double precision.

    A corollary of the behaviour of these two routines is that they may also be used as a "get and set" pair, with X03AAW used to get the value of the floating-point control word on entry, and X03AAX used to set a new value (or restore the original value), but note the "side-effect" of calling X03AAW, namely that this will set the control word as described above.

  9. X04

    The default output units for error and advisory messages for those routines which can produce explicit output are both Fortran Unit 6.

5. Documentation

The Library Manual is available as part of the installation or via download from the NAG website. The most up-to-date version of the documentation is accessible via the NAG website at

The Library Manual is supplied in the following formats:

The following main index files have been provided for these formats:

Use your web browser to navigate from here. For convenience, a master index file containing links to the above files has been provided at

Advice on viewing and navigating the formats available can be found in the Online Documentation document.

In addition the following are provided:

Please see the Intel web site for further information about MKL (

6. Support from NAG

(a) Contact with NAG

Queries concerning this document or the implementation generally should be directed to NAG at one of the addresses given in the Appendix. Users subscribing to the support service are encouraged to contact one of the NAG Response Centres (see below).

(b) NAG Response Centres

The NAG Response Centres are available for general enquiries from all users and also for technical queries from sites with an annually licensed product or support service.

The Response Centres are open during office hours, but contact is possible by fax, email and phone (answering machine) at all times.

When contacting a Response Centre, it helps us deal with your enquiry quickly if you can quote your NAG site reference or account number and NAG product code (in this case FSW3223DCL).

(c) NAG Websites

The NAG websites provide information about implementation availability, descriptions of products, downloadable software, product documentation and technical reports. The NAG websites can be accessed at the following URLs:,, or

(d) NAG Electronic Newsletter

If you would like to be kept up to date with news from NAG then please register to receive our free electronic newsletter, which will alert you to announcements about new products or product/service enhancements, technical tips, customer stories and NAG's event diary. You can register via one of our websites, or by contacting us at

(e) Product Registration

To ensure that you receive information on updates and other relevant announcements, please register this product with us. For NAG Library products this may be accomplished by filling in the online registration form at

7. User Feedback

Many factors influence the way that NAG's products and services evolve, and your ideas are invaluable in helping us to ensure that we meet your needs. If you would like to contribute to this process, we would be delighted to receive your comments. Please contact any of the NAG Response Centres (shown below).

Appendix - Contact Addresses

Wilkinson House
Jordan Hill Road
OXFORD  OX2 8DR                         NAG Ltd Response Centre
United Kingdom                          email:

Tel: +44 (0)1865 511245                 Tel: +44 (0)1865 311744
Fax: +44 (0)1865 310139                 Fax: +44 (0)1865 310139

801 Warrenville Road
Suite 185
Lisle, IL  60532-4332                   NAG Inc Response Center
USA                                     email:

Tel: +1 630 971 2337                    Tel: +1 630 971 2337
Fax: +1 630 971 2706                    Fax: +1 630 971 2706

Nihon NAG KK
Hatchobori Frontier Building 2F
Tokyo 104-0032                          Nihon NAG Response Centre
Japan                                   email:

Tel: +81 3 5542 6311                    Tel: +81 3 5542 6311
Fax: +81 3 5542 6312                    Fax: +81 3 5542 6312

NAG Taiwan Branch Office
5F.-5, No.36, Sec.3
Minsheng E. Rd.
Taipei City 10480                       NAG Taiwan Response Centre
Taiwan                                  email:

Tel: +886 2 25093288                    Tel: +886 2 25093288
Fax: +886 2 25091798                    Fax: +886 2 25091798