NAG Fortran Library, Mark 21

FLDLL214ML License Managed

Windows XP/Vista DLL, Intel Visual Fortran (/MD)

Users' Note



Contents


1. Introduction

This document is essential reading for every user of the NAG Fortran Library implementation specified in the title. It provides implementation-specific detail that augments the information provided in the NAG Mark 21 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 6):

(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. If you intend to use the NAG library within a multithreaded application please refer to the document on Thread Safety in the Library Manual (see Section 6).

2. Availability of Routines

All routines listed in the chapter contents documents of the Library Manual are available in this implementation. Please consult Mark 21 News (see Section 6) for a list of new routines and for a list of routines scheduled for withdrawal at future Marks. Your suggestions for new algorithms for future releases of the Library are welcomed (see Section 8).

3. Restrictions

As with the Mark 20 NAG Fortran Library DLLs, 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 users are advised that the compiled *.mod files (the interface blocks) have been compiled with the Intel Fortran Compiler 9.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 DLLs are 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. This implementation contains modified example programs for the affected routines, to circumvent the problem.

4. General Information

4.1. Accessing the Library

In this section we assume that the Library has been installed in the default folder:
  c:\Program Files\NAG\FL21\fldll214ml
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|FL21|

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 DLLs are accessible at runtime, the install dir\bin folder must be on the path. If the MKL version of the DLL is to be used, the install dir\MKL_ia32_9.1\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 a few BLAS/LAPACK routines are included in FLDLL214M_mkl.dll to avoid problems with the vendor versions. (See Section 5 for details.)

To check the accessibility of the NAG DLLs, run the program NAG_Fortran_DLL_info.exe which is available from the Start Menu shortcut

  NAG Fortran Library DLLs. Check Accessibility
See Section 4.2 for details of this utility.

See Section 4.1.1.1 below for information on setting environment variables from a command prompt. The PATH, LIB and INCLUDE environment variables may already have been set globally as part of the installation or this may be done via the Control Panel. (On Windows XP, from Control Panel select System | Advanced | Environment Variables; on Vista from Control Panel select System and Maintenance (if not using Classic View), then System | Advanced System Settings | Environment Variables... .) Either the user or the system variables may be edited, although Administrator privileges will be required to edit the system ones. Edit the PATH environment variable to include

  c:\Program Files\NAG\FL21\fldll214ml\batch;
  c:\Program Files\NAG\FL21\fldll214ml\bin;
  c:\Program Files\NAG\FL21\fldll214ml\MKL_ia32_9.1\bin;
  existing path
add or edit the LIB environment variable to include
  c:\Program Files\NAG\FL21\fldll214ml\lib;
  c:\Program Files\NAG\FL21\fldll214ml\MKL_ia32_9.1\lib;
  any existing library path
add or edit the INCLUDE environment variable to include
  c:\Program Files\NAG\FL21\fldll214ml\nag_interface_blocks;
  any existing include path
substituting the correct folder where the NAG Fortran DLLs are installed if necessary.

In this DLL implementation, for convenience, the MKL symbols are exported directly from the NAG import library FLDLL214M_mkl.lib, so it is not necessary to specify the MKL interface libraries libguide40.lib and mkl_s_dll.lib as well. However, if the MKL interface libraries are specified, it is important that the NAG import library preceeds them, i.e. the order should be

  FLDLL214M_mkl.lib libguide40.lib mkl_s_dll.lib
because certain parts of the MKL should not be used (see Section 5).

Information on calling the NAG Fortran DLLs from various different environments is given below. More information on calling NAG Fortran or C DLLs is available on the NAG web site at

  http://www.nag.co.uk/numeric/Num_DLLhelp.asp

4.1.1. Calling the DLLs from Intel Fortran

The NAG Fortran DLLs have been built using Intel Fortran 9.1. To call the DLLs from a program compiled with Intel Fortran 10 or later, you may need to move or rename the file libmmd.dll in the install dir\bin folder, so that the correct Intel Fortran runtime DLL is picked up.

4.1.1.1. From a command window

To access this implementation from a command window some environment variables need to be set (if this has not been done globally - see above).

The shortcut:

  Start|All Programs|NAG|FL21|NAG Fortran Library DLLs
      (FLDLL214ML). Command Prompt

may be used to start a command prompt window with the correct settings for the INCLUDE, LIB and PATH environment variables for 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\FL21\fldll214ml\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll214ml.

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

  ifort /iface:cvf /libs:dll driver.f FLDLL214M_mkl.lib
  ifort /iface:cvf /libs:dll driver.f FLDLL214M_nag.lib
where driver.f is your application program.

The first command will use the library without the NAG version of the BLAS/LAPACK procedures (FLDLL214M_mkl.lib) with the MKL libraries mkl_s_dll.lib and libguide40.lib and their associated DLLs.

The second command will use the library with the NAG version of the BLAS/LAPACK procedures (FLDLL214M_nag.lib) and its corresponding DLL.

If your program uses multiple threads, you should also compile with the /threads and /automatic options:

  ifort /iface:cvf /threads /automatic /libs:dll driver.f FLDLL214M_mkl.lib
  ifort /iface:cvf /threads /automatic /libs:dll driver.f FLDLL214M_nag.lib

Please note that the Intel Visual Fortran compiler environment variables must be set in the command window. For more details refer to the documentation for the compiler.

4.1.1.2. From MS Visual Studio .NET

The instructions given here are for Visual Studio .NET 2003 / 2005 with Intel Fortran Compiler 9.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 Fortran DLLs, specifically the folder install dir\bin, is on the path. If the MKL version of the DLL is required, the location of the MKL DLLs, install dir\MKL_ia32_9.1\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 folders 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, move the mouse over Options and click on it.
  2. In the Options window, move the mouse over the left window pane to Intel(R) Fortran and click on it. (In Visual Studio 2005, click on the "+" beside Intel(R) Fortran to expand the category and then click on Compilers.)
  3. Move the mouse to the right window pane and click on the '...' to the right of the Libraries panel.
  4. Add the path to the NAG Library import library to the Set Directory List window. The default location is:
    "c:\Program Files\NAG\FL21\fldll214ml\lib"
  5. In this implementation, there is no need to add the path to the MKL interface libraries, since the BLAS and LAPACK symbols are exported from both NAG import libraries (FLDLL214M_nag.lib and FLDLL214M_mkl.lib). (Note that this behaviour is different from NAG static library implementations.) 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 4.1.
  6. Click on the OK button in the Set Directory List window.
  7. Move the mouse to the right window pane and 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\FL21\fldll214ml\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.
From now, if an Intel Fortran project requires a library or NAG interface block then the library and interface block do not need the full path to be specified.

The interface block is simply accessed by inserting a USE statement as described in greater detail in Section 4.6.

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 designed 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. If you work in Debug mode, you may receive a warning message about conflicting C runtime libraries. This is usually harmless.

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 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 Linker in the leftmost panel (in Visual Studio 2005 click the "+" to the side of it to expand the category) and then choose Input. The right hand panel will now have an Additional Dependencies entry, and you need to type FLDLL214M_mkl.lib in this location to use the FLDLL214M_mkl.lib library and MKL. If you wish to use the self-contained NAG Library then you need to add FLDLL214M_nag.lib instead.

You will also need to set the calling convention to "CVF". From the Properties form, click Fortran (in VS2005 click the "+" next to Fortran to expand it) 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. To select this option, from the Properties form, click Fortran 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 mulithreaded application, as well as selecting a multithreaded runtime 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 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.

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. As in the paragraphs above, from the form click 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 the names of the relevant libraries in this location. Under the Fortran section, click on External Procedures and select CVF for the calling convention, and click on Libraries and select the Multithread DLL runtime library, as described above. For a multithreaded application, click on Data under the Fortran section and select Local Variables AUTOMATIC for the Local Variable Storage value, as described above. Press the OK button.

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 recent versions of Visual Studio .NET.

4.1.2. Calling the DLLs from Compaq Visual Fortran

Assuming that the folder containing the libraries has been added to the LIB environment variable, you may compile and link to the NAG Fortran Library on the command line in the following manner:

  f90 driver.f FLDLL214M_mkl.lib
or
  f90 driver.f FLDLL214M_nag.lib
where driver.f is your application program.

4.1.3. Calling the DLLs from the NAG Fortran Compiler (NAGWare f95)

Commands such as the following may be used to call the NAG DLLs from the NAG Fortran Compiler (NAGWare f95):
  f95 -f77 -w=obs -o driver.exe driver.f "install dir\lib\FLDLL214M_mkl.lib"
or
  f95 -f77 -w=obs -o driver.exe driver.f "install dir\lib\FLDLL214M_nag.lib"
where driver.f is your application program and driver.exe is the executable produced.

The full pathname of the FLDLL214M_mkl.lib or FLDLL214M_nag.lib file must be specified and must be enclosed within quotes if it contains spaces.

4.1.4. Calling the DLLs from Absoft Pro Fortran

A modified version of the example program D02CJFE.F is provided to illustrate the use of the NAG DLLs with Absoft F77 and F95 Version 9.0. This file (absoft.f) can be found in the folder
  install dir\samples\absoft_fortran_example

There are four issues to consider when using the NAG library with Absoft Pro Fortran:

  1. All real arguments and functions are DOUBLE PRECISION.
  2. All library and call back procedures must be declared STDCALL (see lines marked "CHANGE1" in absoft.f).
  3. CHARACTER arguments to the NAG library procedures must be passed using the CVF protocol. This protocol passes the length of the CHARACTER argument as an integer value immediately after the CHARACTER argument itself. The Absoft Pro Fortran compilers pass CHARACTER arguments as integer values after the formal argument list.

    To force the protocol, use the sequence VAL(LOC(...)). The LOC(...) function takes the address of its argument. The VAL(...) function passes its argument by value. Then use VAL(...) immediately after this sequence to pass the length of the argument.

    In the accompanying code the formal argument RELABS (actual argument 'Default') in all the calls to the routine D02CJF in the example program D02CJFE.F is replaced by two arguments:
    VAL(LOC(RELABS)), VAL(7)
    (see lines marked "CHANGE2"), where RELABS is declared and assigned the value 'Default' in the lines marked "NEW".
  4. Subroutine arguments to a routine need to be specified in the same file as the calling routine. (This is true of all non-stdcall compilers.)

Assuming that the folder containing the libraries has been added to the LIB environment variable, you may compile and link to the NAG Fortran Library on the command line using one of the following commands:

  f77 driver.for FLDLL214M_mkl.lib
  f77 driver.for FLDLL214M_nag.lib
  f95 driver.f FLDLL214M_mkl.lib
  f95 driver.f FLDLL214M_nag.lib
where driver.for or driver.f is your application program.

At Version 10.1 of the compiler the program will not link correctly. This is because of the two auxiliary routines passed as arguments, D02CJX and D02CJW. The symbols exported from the NAG library are not compatible with the symbols expected by the Absoft linker at 10.1. Absoft have indicated that future releases of the compiler will be able to link to the NAG libraries. Even with this restriction, the majority of NAG routines will compile and link with the Absoft 10.1 compiler.

4.1.5. Calling the DLLs from Salford FTN95

You will need SLINK version 1.26 or higher and FTN95 version 1.23 or higher.

No source file changes are necessary to call the DLLs from FTN95. However, since FTN95 uses a variant of the cdecl calling convention, the compiler has to be told that the routines in the DLLs are to be called using the CVF calling convention. This can be accomplished using the /IMPORT_LIB command line switch as follows:

  ftn95 driver.f /import_lib "install dir\bin\FLDLL214M_mkl.dll" /link
or
  ftn95 driver.f /import_lib "install dir\bin\FLDLL214M_nag.dll" /link
The full pathname of install dir should be specified to the DLLs and should be enclosed within quotes if it contains spaces. The effect of this is to assume that all exported names in the DLL are CVF STDCALL and that any use of them should use the CVF STDCALL calling convention. External names passed via the argument list to a routine in a NAG DLL are automatically adjusted for whether or not they occur in the same source.

It is also possible to compile and link using commands such as

  ftn95 /f_stdcall driver.f
  slink driver.obj "install dir\bin\FLDLL214M_nag.dll"
As with compilation, the full path to the DLLs should be specified here, within quotes if the pathname contains spaces. It is worth emphasising that the linker should link directly against the DLLs, not the *.lib files.

Plato3 is the Integrated Development Environment (IDE) that is provided with the more recent versions of FTN95. To use Plato3 for a project involving a NAG routine:

  1. From the File menu choose 'New Project'.
  2. Select 'Fortran Application' and set a name for the project and location.
  3. In the Project Explorer window, right-click on the source files and enter the files comprising the project. For example you might choose the NAG example program C05NBFE.F.
  4. Right-click on the 'References' in the Project Explorer window and enter the name of the NAG DLL you wish to use e.g. FLDLL214M_nag.dll.
  5. If your compiler is older than version 5.2 then make sure that the project does NOT use the 'Checkmate' option; prior to version 5.2 FTN95 did not work correctly with the 'Checkmate' option and the NAG STDCALL DLL. Choose for example 'Release Win32' from the drop down menu on the toolbar.
  6. Ensure that the STDCALL option is used. To specify the /F_STDCALL option go to Project | Properties | Compiler Options | Miscellaneous. There is an "Extra compiler options" property that you can set to "/F_STDCALL". Alternatively you may right-click on the NAG DLL in the Project Explorer pane, under 'References', and then under 'Properties' set the checkbox to indicate STDCALL.
  7. Unfortunately Plato3 doesn't currently support redirection of standard input/output. You can avoid this by explicitly opening the files within the main program. For example to send the results to a file c:\test.res insert the statement
            open(6,file='c:\test.res') 
    
    in the main program before any write statements to channel 6.

4.1.6. Calling the DLLs from PGI Fortran

Assuming that the LIB and PATH environment variables have been set up appropriately for your installation of the NAG Library, the command for linking to the Mark 21 DLLs using pgf90 is:

  pgf90 driver.f FLDLL214M_nag.lib -o driver.exe
(for the self-contained variant of the Library), or
  pgf90 driver.f FLDLL214M_mkl.lib -o driver.exe
(for the MKL-based variant of the Library).

This has been tested using version 7.1-6 of the PGI pgf90 compiler.

4.1.7. Calling the DLLs from Lahey/Fujitsu Fortran

A modified version of the example program D02CJFE.F is provided to illustrate the use of the NAG DLLs with Lahey/Fujitsu Fortran. This file (lahey.f) can be found in the folder
  install dir\samples\lahey_fortran_example
The advice given here has been tested using Lahey Fortran version 7.1.
  1. Code changes

    There are a few simple changes that must be made to a standard Fortran program to allow the NAG DLLs to be used by Lahey Fortran:

    1. For each NAG routine called directly insert a DLL_IMPORT statement in the calling program or subprogram e.g.
            DLL_IMPORT D02CJF
      
    2. For each NAG routine passed as an argument to a routine in the DLL insert a DLL_IMPORT statement in the calling program or subprogram e.g.
            DLL_IMPORT D02CJW
      
    3. For each user-supplied subroutine or function used as an argument to a routine in the DLL insert a DLL_IMPORT statement in the calling program or subprogram e.g.
            DLL_IMPORT OUT
      
      and in the user-supplied subroutine or function insert a DLL_EXPORT statement i.e.
            DLL_EXPORT OUT
      
      should be inserted in subroutine OUT.

      Remember to declare all these subroutines and functions as EXTERNAL and also to declare the type of any functions used. The names of imported functions are case sensitive; this means that NAG names must be in upper case.

      The second family of changes concern the treatment of character arguments which must be adjusted to suit the convention used by the NAG DLLs. Character arguments must be stripped of the hidden length argument that Lahey places at the end of all the arguments; this is accomplished by passing the value of the address of the argument as follows: VAL(POINTER(char_arg)). Then, to conform to the NAG DLL standard, the length argument needs to be added immediately following the character argument. Both arguments are passed by value. Here is an example:

            CALL D02CJF (X, XEND2, N, Y, FCN, TOL, VAL(POINTER('Default')),
           + VAL(LEN('Default')), OUT, G, W, IFAIL)
      
  2. Compilation and Linking

    Use the compiler switch "-ml bc" to compile all routines in the program. The Lahey compiler uses this switch to specify that the stdcall calling convention be used. The import library file for the DLL should be in a location specified in the LIB environment variable. Alternatively, the programmer can specify the location using the -LIBPATH linker option. Specifying the location of the library on the compiler line is a third possibility i.e.

          lf95 d02cjfe.f "install dir\lib\FLDLL214M_mkl.lib" -ml bc
    
    or
          lf95 d02cjfe.f "install dir\lib\FLDLL214M_nag.lib" -ml bc
    
  3. Execution

    As ever, make sure that the DLLs are on the PATH.

4.1.8. Calling the DLLs from GNU g77

Commands such as the following may be used for calling the NAG Fortran Library Mark 21 DLLs from g77 (Cygwin and MinGW versions), where driver.f is your application program and driver.exe is the executable produced.

Note that the commands shown below should be issued on a single line; they are shown split over two lines here to avoid truncation if this note is printed.

Using g77 from a Windows Command Prompt:

  g77 -fno-underscoring -fcase-upper -mrtd driver.f
  "install dir\lib\FLDLL214M_mkl.lib" -o driver.exe
or
  g77 -fno-underscoring -fcase-upper -mrtd driver.f
  "install dir\lib\FLDLL214M_nag.lib" -o driver.exe
Using g77 from a Cygwin xterm:
  g77 -fno-underscoring -fcase-upper -mrtd driver.f
  "install dir/lib/FLDLL214M_mkl.lib" -o driver.exe
or
  g77 -fno-underscoring -fcase-upper -mrtd driver.f
  "install dir/lib/FLDLL214M_nag.lib" -o driver.exe

Character strings arguments demand special attention. Immediately after the character string argument, pass by value the length of the string. For example:

         DEV = G01FAF(TAIL,%VAL(1),P,IFAIL)

In the example program D02CJFE.F, you need to replace the formal argument RELABS (actual argument 'Default') in all the calls to the routine D02CJF by:

         'Default',%VAL(7)

If the argument is a character array, pass the length of each array element.

This information is valid for both Cygwin and MinGW versions of g77 and has been tested with the versions of g77 that report "gcc version 3.3.3 (cygwin special)" and "gcc version 3.4.5 (mingw special)".

Modified versions of the example programs D02CJFE.F and G01FAFE.F are provided to illustrate the use of the NAG DLLs with g77. These files can be found in the folder

  install dir\samples\g77_examples

4.1.9. Calling the DLLs from Microsoft Visual C++ / Visual Studio .NET 2003 and Above

If you have Microsoft Visual Studio .NET 2003 or above then, with care, the NAG Fortran DLLs may be used from within a C or C++ environment. To assist the user make the mapping between Fortran and C types, a set of C header files and a set of C++ header files are provided. It is recommended that users wishing to use a Fortran DLL routine either copy and paste the relevant section of the appropriate file into their C or C++ applications or simply include the relevant header file with their application.

Examples of the use of the DLLs from C and C++ are given in the install dir\samples\c_examples and install dir\samples\cpp_examples folders. (Note that if the e04ccfcppclass.sln file is loaded into Visual Studio 2005 or later, the Conversion Wizard will update the files in the project/solution as necessary.)

A document, techdoc.html, giving more detailed advice on calling the DLLs from C is available in install dir\headers. There is also a shortcut to this document on the Start Menu under

  Start|All Programs|NAG|FL21|NAG Fortran Library DLLs
      (FLDLL214ML). C & C++ Header Files Information
by default.

Key information:

Assuming that the folder containing the libraries has been added to the LIB environment variable, you may compile and link your C application program to the NAG Fortran Library on the command line in the following manner:
  cl driver.c FLDLL214M_mkl.lib
or
  cl driver.c FLDLL214M_nag.lib
where driver.c is your application program. This assumes that the folder containing the header files has been added to the INCLUDE environment variable. If not, you could use:
  cl driver.c FLDLL214M_mkl.lib /I"install dir\headers"
or
  cl driver.c FLDLL214M_nag.lib /I"install dir\headers"

The following instuctions apply to Visual Studio .NET 2003 and Visual Studio 2005. Later versions may vary.

If you are working under the Visual Studio IDE, set the following values to enable linking to work. Under the project's Properties, select Configuration Properties | Linker | Input and add FLDLL214M_nag.lib or FLDLL214M_mkl.lib to the Additional Dependencies field. If the LIB environment variable has not been set elsewhere, select Configuration Properties | Linker | General and add install dir\lib to the Additional Library Directories field.

4.1.10. Calling the DLLs from Intel C/C++

The header files and discussion in Calling the DLLs from Microsoft Visual C++ apply equally to Intel C.

Assuming that the folder containing the libraries has been added to the LIB environment variable, you may compile and link your C application program to the NAG Fortran Library on the command line in the following manner:

  icl driver.c FLDLL214M_mkl.lib /I"install dir\headers"
or
  icl driver.c FLDLL214M_nag.lib /I"install dir\headers"
where driver.c is your application program.

4.1.11. Calling the DLLs from Borland C/C++

The discussion in Calling the DLLs from Microsoft Visual C++ applies equally to Borland. Borland import libraries are not supplied but may easily be constructed from the DLLs as follows:
  impdef name.def "install dir\bin\name.dll"
  implib name.lib name.def
where name denotes the name of the NAG DLL i.e. FLDLL214M_mkl or FLDLL214M_nag. The first statement constructs a module definition file, name.def, and the second takes this module definition file and constructs an import library, name.lib. Do not be alarmed by warning messages from IMPLIB. These arise from the number of alternative symbols exported from the DLL in order to provide convenient alternatives for different users.

Assuming that the folder containing the import libraries has been added to the LIB environment variable, you may compile and link your C application program to the NAG Fortran Library on the command line in the following manner:

  bcc32 -I"install dir\headers" driver.c name.lib
where driver.c is your application program.

Alternatively you may add the location of the NAG header files to the configuration file bcc32.cfg. For more details please see the compiler documentation. If you have amended the configuration file then you may simply type:

  bcc32 driver.c name.lib

4.1.12. Calling the DLLs from GNU gcc / g++

The header files and discussion in Calling the DLLs from Microsoft Visual C++ apply equally to gcc / g++.

Commands such as the following may be used to call the NAG Fortran Library DLLs from gcc or g++, where driver.c or driver.cpp is your application program and driver.exe is the executable produced.

Note that each command should be issued on a single line; the commands are shown split over two lines here to avoid truncation if this note is printed.

Using gcc to compile a C program from a Windows Command Prompt:

  gcc -I "install dir\include" driver.c "install dir\lib\FLDLL214M_mkl.lib"
  -o driver.exe
or
  gcc -I "install dir\include" driver.c "install dir\lib\FLDLL214M_nag.lib"
  -o driver.exe

Using gcc to compile a C program from a Cygwin xterm:

  gcc -I "install dir/include" driver.c "install dir/lib/FLDLL214M_mkl.lib"
  -o driver.exe
or
  gcc -I "install dir/include" driver.c "install dir/lib/FLDLL214M_nag.lib"
  -o driver.exe

Using g++ to compile a C++ program from a Windows Command Prompt:

  g++ -I "install dir\include" driver.cpp "install dir\lib\FLDLL214M_mkl.lib"
  -o driver.exe
or
  g++ -I "install dir\include" driver.cpp "install dir\lib\FLDLL214M_nag.lib"
  -o driver.exe

Using g++ to compile a C++ program from a Cygwin xterm:

  g++ -I "install dir/include" driver.cpp "install dir/lib/FLDLL214M_mkl.lib"
  -o driver.exe
or
  g++ -I "install dir/include" driver.cpp "install dir/lib/FLDLL214M_mkl.lib"
  -o driver.exe

This information is valid for both Cygwin and MinGW versions of gcc / g++ and has been tested with the versions that report "gcc version 3.3.3 (cygwin special)" and "gcc version 3.4.5 (mingw special)".

4.1.13. Calling the DLLs from Microsoft Visual Basic for Applications / Excel

The Fortran DLLs are ideally suited for use within an Excel spreadsheet. The routines may be called from Visual Basic for Applications (VBA) code. (Note that VBA and Visual Basic 6 (VB 6) have many similarities, and the same NAG Declare statements are used for both.)

Examples of use of the DLLs from within Excel are given in the install dir\samples\excel_examples folder. The folder install dir\samples\excel_examples\linear_algebra contains the file xls_demo.txt. This file gives some hints about using NAG DLLs from within Excel spreadsheets. See also the VB 6 examples for further illustrations of calling the NAG DLLs from VB 6 / VBA.

Key information:

4.1.14. Calling the DLLs from Microsoft Visual Basic 6

Visual Basic 6 (VB 6) and Visual Basic for Applications (VBA) have many similarities, so much of the VBA specific information above applies directly to VB 6. Note especially the remarks about array conventions and string handling.

Examples of use of the DLLs from Visual Basic 6 are given in the install dir\samples\vb6_examples folder. See also the VBA code within the Excel examples for further illustrations of calling the NAG DLLs from VB 6 / VBA.

Key information:

4.1.15. Calling the DLLs from Microsoft Visual Basic .NET

Many of the library routines are callable from Visual Basic .NET (VB.NET). Examples of use of the DLLs from VB.NET are given in the install dir\samples\vb.net_examples folder. (These examples were created using Visual Studio .NET 2003; if loaded into Visual Studio 2005 or later, the solution and project files will be converted by the Visual Studio Conversion Wizard.)

Key information:

4.1.16. Calling the DLLs from C#

For information on calling the NAG Fortran Library DLLs from C# see http://www.nag.co.uk/numeric/csharpinfo.asp.

4.1.17. Calling the DLLs from Delphi

The Fortran DLLs may be called from Delphi programs.

Examples of use of the DLLs from Delphi are given in the install dir\samples\delphi_examples folder. These have been tested with Delphi 2006 for Microsoft Win32. The file readme.txt in the install dir\samples\delphi_examples\e04ucf\console folder indicates how to use the DLLs from Delphi in a console window.

Key information:

4.1.18. Calling the DLLs from Java

For information on calling the NAG C Library and Fortran Library DLLs from Java see http://www.nag.co.uk/doc/TechRep/html/Tr1_04/Tr1_04.html.

4.1.19. Calling the DLLs from Python

For information on calling the NAG Fortran Library DLLs from Python using F2PY see the PDF file http://www.nag.co.uk/doc/TechRep/pdf/TR1_08.pdf.

4.1.20. The NAG Library edition of Simfit

The NAG Library edition of Simfit uses the DLL implementation of the NAG Fortran Library as its source of algorithms. For more information about the NAG Library edition of Simfit see http://www.nag.co.uk/educationuk/simfit.asp.

4.2. Accessibility Check

The diagnostic program NAG_Fortran_DLL_info.exe, which by default is located in C:\Program Files\NAG\FL21\fldll214ml\diagnostics, may be used to check whether the DLLs FLDLL214M_nag.dll and FLDLL214M_mkl.dll are accessible from the current environment. If this program is started from Windows Explorer or from the
  Start|All Programs|NAG|FL21|NAG Fortran Library DLLs
      (FLDLL214ML). Check Accessibility
shortcut on the Start Menu, the DLLs will be found if the global PATH environment variable has been set to include their location. If it is run from a Command Prompt window, then the environment local to that window will prevail. (See Section 4.1 for more information on environment variables.)

For each of the DLLs that it loads successfully, NAG_Fortran_DLL_info.exe will print the location of the DLL, and the implementation details as provided by a call to the routine A00AAF. It also calls A00ACF to check the availability of a valid license key if required by the implementation and reports if this is not found; "Status OK" indicates that a valid key was either found or not required.

Note that this program should be closed after use, otherwise performance may be impared.

4.3. Example Programs

This section assumes that you are calling the NAG DLLs from an Intel Fortran program. If you are calling the DLLs from a different compiler, you may wish to modify the batch files accordingly. See Section 4.1 for information on calling the DLLs from various different systems.

The example programs are most easily accessed by the batch files nag_example.bat or nag_example_mkl.bat.

The batch files need the environment variable NAG_FLDLL214ML.

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

  Start|All Programs|NAG|FL21|NAG Fortran Library DLLs
      (FLDLL214ML). Command Prompt
If the shortcut is not used, you need to set this environment variable. You can set this environment variable by running the batch file envvars.bat for this implementation. The default location of this file is:
  c:\Program Files\NAG\FL21\fldll214ml\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll214ml.

nag_example_mkl.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 FLDLL214M_mkl.lib and the MKL. Finally, the executable program will be run. The example program concerned is specified by the argument to nag_example_mkl.bat, e.g.

  nag_example_mkl  e04ucf
will copy the example program and its data into the files e04ucfe.f and e04ucfe.d in the current folder and process them to produce the example program results in the file e04ucfe.r.

Alternatively you could use:

  nag_example  e04ucf

The difference between nag_example_mkl.bat and nag_example.bat is that while nag_example_mkl.bat uses the library FLDLL214M_mkl.lib and the MKL libraries, nag_example.bat uses the self-contained library FLDLL214M_nag.lib. The executables created will use FLDLL214M_mkl.dll and FLDLL214M_nag.dll respectively.

The example programs are supplied in machine-readable form. They are suitable for immediate usage. Note that the distributed example programs are those used in this implementation and may not correspond exactly with the programs published in the Library Manual. The distributed example programs should be used in preference wherever possible.

The distributed example results are those obtained with the NAG self-contained library FLDLL214M_nag.dll, (using the NAG BLAS and LAPACK routines). Running the examples with MKL BLAS or LAPACK may give slightly different results.

4.4. Interpretation of Bold Italicised Terms

For this double precision implementation, the bold italicised terms used in the Library Manual should be interpreted as follows:
real or double precision  - DOUBLE PRECISION (REAL*8)
basic precision           - double precision
complex or complex*16     - COMPLEX*16
additional precision      - quadruple precision (REAL*16,COMPLEX*32)
machine precision         - the machine precision, see the value
                            returned by X02AJF in Section 5
Thus a parameter described as real or double precision should be declared as DOUBLE PRECISION in your program. If a routine accumulates an inner product in additional precision, it is using software to simulate quadruple precision.

All references to routines in Chapter F07 - Linear Equations (LAPACK) and Chapter F08 - Least-squares and Eigenvalue Problems (LAPACK) use the LAPACK name, not the NAG F07/F08 name.

4.5. Explicit Output from NAG Routines

Certain routines produce explicit error messages and advisory messages via output units which either have default values or can be reset by using X04AAF for error messages and X04ABF for advisory messages. (The default values are given in Section 5.) The maximum record lengths of error messages and advisory messages (including carriage control characters) are 80 characters, except where otherwise specified.

4.6. Interface Blocks

The NAG Fortran Library Interface Blocks define the type and arguments of each user callable NAG Fortran Library routine. These are not essential to calling the NAG Fortran Library from Fortran 90/95 programs. Their purpose is to allow the Fortran 90/95 compiler to check that NAG Fortran Library 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
(d) All arguments match in type and structure

These interface blocks have been generated automatically by analysing the source code for the NAG Fortran Library. As a consequence, and because these files have been thoroughly tested, their use is recommended in preference to writing your own declarations.

The NAG Fortran Library Interface Block files are organised by Library chapter. The module names are:

  nag_f77_a_chapter
  nag_f77_c_chapter
  nag_f77_d_chapter
  nag_f77_e_chapter
  nag_f77_f_chapter
  nag_f77_g_chapter
  nag_f77_h_chapter
  nag_f77_m_chapter
  nag_f77_p_chapter
  nag_f77_s_chapter
  nag_f77_x_chapter
These are supplied in pre-compiled form (.mod files) compiled with the Intel Fortran Compiler 9.1, for use with that compiler. The interface blocks are also supplied in source form (.f90 files), which may be compiled for use with other compilers.

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 4.1.1.1), you can use any of the commands described in Section 4.1.1.1 to access these modules since the environment variable INCLUDE will be set.

In order to make use of these modules from existing Fortran 77 code, the following changes need to be made:

The above steps need to be done for each unit (main program, function or subroutine) in your code.

These changes are illustrated by showing the conversion of the Fortran 77 version of the example program for NAG Fortran Library routine D01DAF. Please note that this is not exactly the same as the example program that is distributed with this implementation. Each change is surrounded by comments boxed with asterisks.

*     D01DAF Example Program Text
*****************************************************
* Add USE statements for relevant chapters          *
      USE NAG_F77_D_CHAPTER
*                                                   *
*****************************************************
*     .. Parameters ..
      INTEGER          NOUT
      PARAMETER        (NOUT=6)
*     .. Local Scalars ..
      DOUBLE PRECISION ABSACC, ANS, YA, YB
      INTEGER          IFAIL, NPTS
*     .. External Functions ..
      DOUBLE PRECISION FA, FB, P1, P2A, P2B
      EXTERNAL         FA, FB, P1, P2A, P2B
*     .. External Subroutines ..
******************************************************
* EXTERNAL declarations need to be removed.          *
C     EXTERNAL         D01DAF
*                                                    *
******************************************************
*     .. Executable Statements ..
      WRITE (NOUT,*) 'D01DAF Example Program Results'
      YA = 0.0D0
      YB = 1.0D0
      ABSACC = 1.0D-6
      WRITE (NOUT,*)
      WRITE (NOUT,*) 'First formulation'
      IFAIL = 1
*
      CALL D01DAF(YA,YB,P1,P2A,FA,ABSACC,ANS,NPTS,IFAIL)
*
      WRITE (NOUT,99999) 'Integral =', ANS
      WRITE (NOUT,99998) 'Number of function evaluations =', NPTS
      IF (IFAIL.GT.0) WRITE (NOUT,99997) 'IFAIL = ', IFAIL
      WRITE (NOUT,*)
      WRITE (NOUT,*) 'Second formulation'
      IFAIL = 1
*
      CALL D01DAF(YA,YB,P1,P2B,FB,ABSACC,ANS,NPTS,IFAIL)
*
      WRITE (NOUT,99999) 'Integral =', ANS
      WRITE (NOUT,99998) 'Number of function evaluations =', NPTS
      IF (IFAIL.GT.0) WRITE (NOUT,99997) 'IFAIL = ', IFAIL
      STOP
*
99999 FORMAT (1X,A,F9.4)
99998 FORMAT (1X,A,I5)
99997 FORMAT (1X,A,I2)
      END
*
      DOUBLE PRECISION FUNCTION P1(Y)
*     .. Scalar Arguments ..
      DOUBLE PRECISION             Y
*     .. Executable Statements ..
      P1 = 0.0D0
      RETURN
      END
*
      DOUBLE PRECISION FUNCTION P2A(Y)
*     .. Scalar Arguments ..
      DOUBLE PRECISION              Y
*     .. Intrinsic Functions ..
      INTRINSIC                     SQRT
*     .. Executable Statements ..
      P2A = SQRT(1.0D0-Y*Y)
      RETURN
      END
*
      DOUBLE PRECISION FUNCTION FA(X,Y)
*     .. Scalar Arguments ..
      DOUBLE PRECISION             X, Y
*     .. Executable Statements ..
      FA = X + Y
      RETURN
      END
*
      DOUBLE PRECISION FUNCTION P2B(Y)
*****************************************************
* Add USE statements for relevant chapters          *
      USE NAG_F77_X_CHAPTER
*                                                   *
*****************************************************
*     .. Scalar Arguments ..
      DOUBLE PRECISION              Y
*     .. External Functions ..
******************************************************
* Function Type declarations need to be removed.     *
C     DOUBLE PRECISION              X01AAF
*                                                    *
******************************************************
******************************************************
* EXTERNAL declarations need to be removed.          *
C     EXTERNAL                      X01AAF
*                                                    *
******************************************************
*     .. Executable Statements ..
      P2B = 0.5D0*X01AAF(0.0D0)
      RETURN
      END
*
      DOUBLE PRECISION FUNCTION FB(X,Y)
*     .. Scalar Arguments ..
      DOUBLE PRECISION             X, Y
*     .. Intrinsic Functions ..
      INTRINSIC                    COS, SIN
*     .. Executable Statements ..
      FB = Y*Y*(COS(X)+SIN(X))
      RETURN
      END

5. Routine-specific Information

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

  1. D06

    When running some routines in this chapter you may need to increase the stack size to avoid a stack overflow exception.

  2. F06, F07 and F08

    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 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 the NAG version of the following Basic Linear Algebra Subprograms (BLAS) and linear algebra routines (LAPACK) are included in the library FLDLL214M_mkl.dll to avoid problems with the vendor version:

      DBDSQR    ZBDSQR    DGEBAL    DGEESX    DGEEVX    DGEHRD    DHSEQR
      ZGEBAL    ZGEESX    ZGEEVX    ZGEHRD    ZHSEQR    ZTRSEN
    

  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 this chapter 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.0D+13
            F(2)   = 1.0D-14
    
    S10AAF  E(1)   = 1.8500D+1
    S10ABF  E(1)   = 7.080D+2
    S10ACF  E(1)   = 7.080D+2
    
    S13AAF  x(hi)  = 7.083D+2
    S13ACF  x(hi)  = 1.0D+16
    S13ADF  x(hi)  = 1.0D+17
    
    S14AAF  IFAIL  = 1 if X > 1.70D+2
            IFAIL  = 2 if X < -1.70D+2
            IFAIL  = 3 if abs(X) < 2.23D-308
    S14ABF  IFAIL  = 2 if X > 2.55D+305
    
    S15ADF  x(hi)  = 2.66D+1
            x(low) = -6.25D+0
    S15AEF  x(hi)  = 6.25D+0
    
    S17ACF  IFAIL  = 1 if X > 1.0D+16
    S17ADF  IFAIL  = 1 if X > 1.0D+16
            IFAIL  = 3 if 0.0D+00 < X <= 2.23D-308
    S17AEF  IFAIL  = 1 if abs(X) > 1.0D+16
    S17AFF  IFAIL  = 1 if abs(X) > 1.0D+16
    S17AGF  IFAIL  = 1 if X > 1.038D+2
            IFAIL  = 2 if X < -5.6D+10
    S17AHF  IFAIL  = 1 if X > 1.041D+2
            IFAIL  = 2 if X < -5.6D+10
    S17AJF  IFAIL  = 1 if X > 1.041D+2
            IFAIL  = 2 if X < -1.8D+9
    S17AKF  IFAIL  = 1 if X > 1.041D+2
            IFAIL  = 2 if X < -1.8D+9
    S17DCF  IFAIL  = 2 if abs (Z) < 3.93D-305
            IFAIL  = 4 if abs (Z) or FNU+N-1 > 3.27D+4
            IFAIL  = 5 if abs (Z) or FNU+N-1 > 1.07D+9
    S17DEF  IFAIL  = 2 if imag (Z) > 7.00D+2
            IFAIL  = 3 if abs (Z) or FNU+N-1 > 3.27D+4
            IFAIL  = 4 if abs (Z) or FNU+N-1 > 1.07D+9
    S17DGF  IFAIL  = 3 if abs (Z) > 1.02D+3
            IFAIL  = 4 if abs (Z) > 1.04D+6
    S17DHF  IFAIL  = 3 if abs (Z) > 1.02D+3
            IFAIL  = 4 if abs (Z) > 1.04D+6
    S17DLF  IFAIL  = 2 if abs (Z) < 3.93D-305
            IFAIL  = 4 if abs (Z) or FNU+N-1 > 3.27D+4
            IFAIL  = 5 if abs (Z) or FNU+N-1 > 1.07D+9
    
    S18ADF  IFAIL  = 2 if 0.0D+00 < X <= 2.23D-308
    S18AEF  IFAIL  = 1 if abs(X) > 7.116D+2
    S18AFF  IFAIL  = 1 if abs(X) > 7.116D+2
    S18CDF  IFAIL  = 2 if 0.0D+00 < X <= 2.23D-308
    S18DCF  IFAIL  = 2 if abs (Z) < 3.93D-305
            IFAIL  = 4 if abs (Z) or FNU+N-1 > 3.27D+4
            IFAIL  = 5 if abs (Z) or FNU+N-1 > 1.07D+9
    S18DEF  IFAIL  = 2 if real (Z) > 7.00D+2
            IFAIL  = 3 if abs (Z) or FNU+N-1 > 3.27D+4
            IFAIL  = 4 if abs (Z) or FNU+N-1 > 1.07D+9
    
    S19AAF  IFAIL  = 1 if abs(x) >= 4.95000D+1
    S19ABF  IFAIL  = 1 if abs(x) >= 4.95000D+1
    S19ACF  IFAIL  = 1 if X > 9.9726D+2
    S19ADF  IFAIL  = 1 if X > 9.9726D+2
    
    S21BCF  IFAIL  = 3 if an argument < 1.579D-205
            IFAIL  = 4 if an argument >= 3.774D+202
    S21BDF  IFAIL  = 3 if an argument < 2.820D-103
            IFAIL  = 4 if an argument >= 1.404D+102
    

  6. X01

    The values of the mathematical constants are:
    X01AAF (PI)    = 3.1415926535897932D+00
    X01ABF (GAMMA) = 0.5772156649015329D+00
    

  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.11022302462516D-16
    X02AKF = 2.22507385850721D-308
    X02ALF = 1.79769313486231D+308
    X02AMF = 2.22507385850721D-308
    X02ANF = 4.45014771701441D-308
    

    Parameters of other aspects of the computing environment

    X02AHF = 1.42724769270596D+45
    X02BBF = 2147483647
    X02BEF = 15
    X02DAF = .FALSE.
    

  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.

6. Documentation

The Library Manual is supplied in the form of Portable Document Format (PDF) files, with an HTML index, in the manual folder (either installed locally or on the distribution CD). The introductory material is also provided as HTML files in the manual folder.

A main index file has been provided (manual\html\mark21.html) which contains a fully linked contents document pointing to all the available PDF (and where available HTML) files. This index file is available from the Start Menu under

  Start|All Programs|NAG|FL21|NAG Fortran Library Manual
by default. Use your HTML browser to navigate from here.

In addition the following are provided:

This is available from the Start Menu under
  Start|All Programs|NAG|FL21|NAG Fortran Library DLLs
      (FLDLL214ML). Users' Note
by default.

The Library Manual is also available as an HTML Help file. In order to display the mathematical expressions correctly, you will need to install Design Science's MathPlayer plug-in. MathPlayer may optionally be installed with this NAG Library product, or may be downloaded from Design Science's web site:

  http://www.dessci.com/en/products/mathplayer/download.htm

The HTML Help version of the Library Manual is available from the Start Menu under

  Start|All Programs|NAG|FL21|NAG Fortran Library Manual HTML Help
If the NAG Library materials have been installed on a network drive, you may need to copy the HTML Help file (nagdoc_fl21.chm) to a local drive. If you still have trouble seeing the correct help file materials, e.g. if you see a message such as
  Navigation to the webpage was canceled
the file might have been blocked by security updates in Windows or Internet Explorer 7. Right-click on nagdoc_fl21.chm in Windows Explorer and select Properties from the pop-up menu. If there is an Unblock button at the bottom click on it to unblock the file and then click on OK to close the Properties dialog box.

7. Support from NAG

(a) Contact with NAG

Queries concerning this document or the implementation generally should be directed initially to your local Advisory Service. If you have difficulty in making contact locally, you can contact NAG directly 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 and NAG product code (in this case FLDLL214ML).

(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:

http://www.nag.co.uk/, http://www.nag.com/ or http://www.nag-j.co.jp/

(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 special offers, announcements about new products or product/service enhancements, customer stories and NAG's event diary. You can register via one of our websites, or by contacting us at nagnews@nag.co.uk.

(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 http://www.nag.co.uk/numeric/Library_Registration.asp.

8. 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

NAG Ltd
Wilkinson House
Jordan Hill Road
OXFORD  OX2 8DR                         NAG Ltd Response Centre
United Kingdom                          email: support@nag.co.uk

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

NAG Inc
801 Warrenville Road
Suite 185
Lisle, IL  60532-4332                   NAG Inc Response Center
USA                                     email: support@nag.com

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
4-9-9
Hatchobori
Chuo-ku
Tokyo
104-0032
Japan
email: help@nag-j.co.jp

Tel: +81 (0)3 5542 6311
Fax: +81 (0)3 5542 6312