NAG Fortran Library for Win32 Applications, Mark 24

FLDLL244ML - License Managed

Microsoft Windows, Intel Fortran

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 24 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

As with earlier Marks of the 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/2003 users are advised that the compiled *.mod files (the interface blocks) have been compiled with the Intel Fortran Compiler 13.0 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.

2. Post Release Information

Please check the following URL:

http://www.nag.co.uk/doc/inun/fl24/dll4ml/postrelease.html

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

3. General Information

For best performance, we recommend that you use the variant of the NAG Fortran Library which is based on the supplied Intel ® Math Kernel Library (MKL), i.e. FLDLL244M_mkl.lib/FLDLL244M_mkl.dll. However if you use a version of the MKL different from the version used in creating this implementation and you have problems when calling a NAG routine, we suggest that you use the above library with the supplied MKL, or the self-contained library FLDLL244M_nag.lib/FLDLL244M_nag.dll.

3.1. Accessing the Library

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

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

(Under Windows 8, the shortcuts appear under the list of all applications. To find this, right-click on the background of the Start screen and select All apps from the bottom right hand corner of the screen. The shortcuts are listed under the NAG section.)

To ensure that the NAG DLL (FLDLL244M_mkl.dll or FLDLL244M_nag.dll) is accessible at run time, the install dir\bin folder must be on the path. If the MKL-based version of the Library is to be used, the install dir\MKL_ia32_11.0\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 Basic Linear Algebra Subprograms (BLAS) / Linear Algebra PACKage (LAPACK) routines are included in the NAG Libraries to avoid problems with the vendor versions. (See Section 4 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

  Start|All Programs|NAG|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|Check NAG DLL Accessibility for FLDLL244ML
See Section 4.2.3 of the Installer's Note for details of this utility.

See Section 3.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, Windows 7 or Windows 8 from the Control Panel home select System and Maintenance (on Vista) / System and Security (on Windows 7 or Windows 8), then System | Advanced System Settings | Environment Variables... .) Either the user variables 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\FL24\fldll244ml\batch;
  c:\Program Files\NAG\FL24\fldll244ml\bin;
  c:\Program Files\NAG\FL24\fldll244ml\MKL_ia32_11.0\bin;
  existing path
add or edit the LIB environment variable to include
  c:\Program Files\NAG\FL24\fldll244ml\lib;
  any existing library path
add or edit the INCLUDE environment variable to include
  c:\Program Files\NAG\FL24\fldll244ml\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 FLDLL244M_mkl.lib, so it is not necessary to specify the MKL interface libraries mkl_intel_s_dll.lib, mkl_intel_thread_dll.lib and mkl_core_dll.lib as well. However, if the MKL interface libraries are specified, it is important that the NAG import library precedes them, i.e. the order should be

  FLDLL244M_mkl.lib mkl_intel_s_dll.lib
      mkl_intel_thread_dll.lib mkl_core_dll.lib
because certain parts of the MKL should not be used (see Section 4).

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
More information specific to this product may be available from the Post Release Information page:

http://www.nag.co.uk/doc/inun/fl24/dll4ml/postrelease.html

3.1.1. Calling the DLLs from Intel Fortran

The NAG Fortran DLLs have 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, libmmd.dll and svml_dispmd.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, libmmd.dll and svml_dispmd.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.)

3.1.1.1. From a command window

To access this implementation from a command window some environment variables need to be set.

The shortcut:

  Start|All Programs|NAG|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|FLDLL244ML 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\FL24\fldll244ml\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll244ml.

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

  ifort /iface:cvf /MD driver.f90 FLDLL244M_mkl.lib
  ifort /iface:cvf /MD driver.f90 FLDLL244M_nag.lib
where driver.f90 is your application program.

The first command will use the DLL without the NAG version of the BLAS/LAPACK procedures (FLDLL244M_mkl.lib) in addition to the MKL DLLs. It is not necessary to add the path to the MKL import libraries here, since the BLAS and LAPACK symbols are exported from the NAG import library (FLDLL244M_mkl.lib) in this instance. (Note that this behaviour may be different from some other NAG library implementations.) The second command will use the DLL with the NAG version of the BLAS/LAPACK procedures (FLDLL244M_nag.lib). The option /MD should be used to ensure linking with the correct run-time libraries.

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

3.1.1.2. From MS Visual Studio

The instructions given here are for Visual Studio .NET 2005/2008/2010/2012 with Intel Fortran Compiler 13.0. 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. If the MKL version of the DLL is required, the location of the MKL DLLs, install dir\MKL_ia32_11.0\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 Fortran (or Intel 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.) With newer versions of the Intel compiler, click on Intel Composer XE, then select Visual Fortran and then choose Compilers.

  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\FL24\fldll244ml\lib
    

  5. In this implementation, there is no need to add the path to the MKL import libraries, since the BLAS and LAPACK symbols are exported from the NAG import library (FLDLL244M_mkl.lib). (Note that this behaviour may be different from some other NAG 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 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\FL24\fldll244ml\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.

The following steps show how to add the NAG Library to the project:

  1. Open the Property Pages for the project. There are several ways of doing this including:

  2. 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 FLDLL244M_mkl.lib in this location to use the FLDLL244M_mkl library and MKL. Click on the Apply button to accept the changes. If you wish to use the self-contained NAG Library FLDLL244M_nag then you need to add FLDLL244M_nag.lib instead.

  3. 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. Click on the Apply button to accept the changes. This is the convention required by this implementation of the NAG Library.

  4. Before you can compile the project you need to specify the correct run-time library needed. From the Properties form, click/expand Fortran in the leftmost panel and then choose Libraries. The right hand panel will now have a Runtime Library entry, and you need to select Multithreaded DLL. After you select the correct run-time library click on the Apply button to accept the changes.

  5. Click on the OK button to close the form.

In summary, the setting of the project Additional Dependencies, the project Runtime Library and the PATH environment variable must be consistent as follows:

If you are running on a 64-bit system, make sure the Target CPU is set to x86 (to ensure compatibility with this 32-bit implementation of the NAG Library). The project should now compile and link using the appropriate choice from the Build menu.

To run a program from within the Microsoft Development Environment, the program may be executed via the Debug menu (by selecting Start Without Debugging, for example).

For Visual Studio 2005 and later, 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, this can be achieved by selecting the Debugging section on the Properties form and inserting the appropriate commands in the Command Arguments field, e.g.

  < input_file > output_file
If the input and output files are not in the application's working directory, full or relative paths may need to be specified. For NAG examples that use an .opt file, this should be placed in the working directory. This directory may be set via the Working Directory field, which is also on the Debugging page of the Properties form. (Note that input / output redirection is broken in some versions of Visual Studio 2008.)

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.2 for details.

3.1.3. Calling the DLLs from NAG Fortran Builder

NAG Fortran Library interface blocks suitable for use with the NAG Fortran compiler are distributed with this product, located in the nag_interface_blocks_nagfor folder of the installation. They were compiled with version 5.3 of the NAG compiler. If you have a newer version of the NAG compiler, you may first need to recompile the module files as described in Section 3.2. Note that in this case it is important to use the -compatible compiler flag when compiling the interface blocks, to make sure that they are compatible with the library.

At a command line, commands such as the following may then be used to call the NAG DLLs from the NAG Fortran Compiler (nagfor):

  nagfor -compatible -I "install dir"\nag_interface_blocks_nagfor -o driver.exe
         driver.f90 "install dir\lib\FLDLL244M_mkl.lib"
or
  nagfor -compatible -I "install dir"\nag_interface_blocks_nagfor -o driver.exe
         driver.f90 "install dir\lib\FLDLL244M_nag.lib"
where driver.f90 is your application program and driver.exe is the executable produced, and nag_interface_blocks_nagfor is the directory containing the compiled module files.

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

Using the DLLs from within the Fortran Builder IDE itself is also easy, following steps like these:

Note that if you build your project in Debug mode (the default), it is not possible to use the Undefined variables option which is accessible on the Fortran Compiler / Runtime Check tab of Project Settings. This is because the NAG Library was not compiled with this option. Trying to use it will cause a compile-time error in Fortran Builder, showing an "Incompatible option setting" when using the NAG interface blocks.

3.1.4. Calling the DLLs from Silverfrost (Salford) FTN95

If you wish to use the NAG Fortran Library interface blocks (e.g. if you are compiling a NAG example program) you will probably first need to create the module files as described in Section 3.2. When compiling the interface blocks with FTN95 you should use the /f_stdcall switch to the compiler to ensure the STDCALL calling convention is in force.

It is important to note that the interface file nag_precisions.f90 may need to be modified before it can be compiled with FTN95. The Fortran kind function may not be recognised by the compiler as an intrinsic function. If that is the case, you should delete the intrinsic declarations of kind and selected_int_kind, and change the other parameters to look like this:

       INTEGER, PARAMETER              :: HP = 2
       INTEGER, PARAMETER              :: I4B = 3
       INTEGER, PARAMETER              :: RP = 1
       INTEGER, PARAMETER              :: WP = 2

In addition, the interface file nag_e_ib.f90 has been observed to fail to compile with FTN95 due to a declaration of the intrinsic function MAX. Simply deleting the declaration should make it work.

Since FTN95 uses a variant of the cdecl calling convention, the compiler must 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 /f_stdcall /mod_path nag_interface_blocks_ftn95 driver.f90
        /import_lib "install dir\bin\FLDLL244M_mkl.dll" /link
or
  ftn95 /f_stdcall /mod_path nag_interface_blocks_ftn95 driver.f90
        /import_lib "install dir\bin\FLDLL244M_nag.dll" /link
(This assumes that you have placed the compiled NAG interface blocks into directory nag_interface_blocks_ftn95).

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 /mod_path nag_interface_blocks_ftn95 driver.f90
  slink driver.obj "install dir\bin\FLDLL244M_mkl.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.

A possible limitation of the FTN95 compiler means that if the driver program itself contains a Fortran MODULE defining a routine to be passed as an argument to a NAG routine, the argument may not be given the STDCALL attribute, and linking may fail (or the program may fail at run time). This limitation has been observed during testing with version 6.00.0 of FTN95. Internal modules are used in many of the NAG Example Programs. You are advised to replace such internal modules by external routine declarations.

Another minor limitation of FTN95 is that it does not support the Fortran FLUSH statement (which is part of the Fortran 2003 standard). Some NAG example programs use FLUSH to ensure that output from the NAG DLL comes out in the expected order. You may need to comment out calls to FLUSH in order to compile.

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 e01bafe.f90.
  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. FLDLL244M_mkl.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. If your code uses the NAG interface blocks, you can specify their location by going to Project | Properties | Compiler Options | Source and entering the directory where the compiled module files are under 'Specify MODULE paths'. (See the beginning of this section for information on generating the module files.)
  8. 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.

3.1.5. Calling the DLLs from PGI Fortran

If you wish to use the NAG Fortran Library interface blocks (e.g. if you are compiling a NAG example program) you may first need to create the module files as described in Section 3.2.

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 24 DLLs using pgf90 is:

  pgf90 driver.f90 -module nag_interface_blocks_pgi FLDLL244M_mkl.lib -o driver.exe
(for the MKL-based variant of the Library), or
  pgf90 driver.f90 -module nag_interface_blocks_pgi FLDLL244M_nag.lib -o driver.exe
(for the self-contained variant of the Library). In both cases nag_interface_blocks_pgi is the directory containing your compiled module files.

This has been tested using version 13.4 of the PGI pgf90 compiler.

3.1.6. Calling the DLLs from Lahey/Fujitsu Fortran

A modified version of the example program D02CJFE 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.2.
  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\FLDLL244M_mkl.lib" -ml bc
    
    or
          lf95 d02cjfe.f "install dir\lib\FLDLL244M_nag.lib" -ml bc
    
  3. Execution

    Ensure that the DLLs are on the PATH.

Note that, because of the different calling conventions used, when calling the NAG Fortran Library from the Lahey Compiler, it may be easier to use the DLLs included with the product FLW3224DC. Details may be given in the Post Release Notes for that product: http://www.nag.co.uk/doc/inun/fl24/w32dc/postrelease.html

3.1.7. Calling the DLLs from GNU gfortran

Warning: before using this NAG Library with gfortran see the important note about dealing with character type arguments below.

If you wish to use the NAG Fortran Library interface blocks (e.g. if you are compiling a NAG example program) you may first need to create the module files as described in Section 3.2.

Commands such as the following may be used for calling the NAG Fortran Library Mark 24 DLLs from gfortran, where driver.f90 is your application program and driver.exe is the executable produced.

Using gfortran from a Windows Command Prompt:

  gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90
           "install dir\lib\FLDLL244M_mkl.lib" -o driver.exe
or
  gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90
           "install dir\lib\FLDLL244M_nag.lib" -o driver.exe
Using gfortran from a Cygwin xterm:
  gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90
           "install dir/lib/FLDLL244M_mkl.lib" -o driver.exe
or
  gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90
           "install dir/lib/FLDLL244M_nag.lib" -o driver.exe
In all cases, nag_interface_blocks_gfortran is the directory containing your compiled module files.

Character string arguments demand special attention. The NAG Library uses the Intel ifort /iface:cvf calling convention, part of which means that the compiler inserts "hidden" arguments immediately after each argument of Fortran type character. These hidden arguments are the lengths of the character strings. The gfortran compiler puts these hidden arguments at the end of the argument list, thus causing a mismatch when calling library routines. If you do not attend to this problem, your code is likely to crash. Currently there is no way to tell gfortran to insert the hidden arguments anywhere but at the end of the argument list.

The solution to this problem is to explicitly insert the values of the hidden arguments.

Immediately after each character string argument in the call of a NAG routine, pass by value the length of the string. For example the first argument of function g01faf is a character tail. Call g01faf like this:

         dev = g01faf(tail,%VAL(1),p,ifail)
where %VAL(1) tells the compiler to pass the length 1 by value.

Unfortunately, explicitly adding this extra hidden argument means that the call of g01faf no longer matches the NAG interface block declaration of g01faf, so the compiler will complain if you try to USE the interface block. Instead, you should declare g01faf to be external and of the correct type in your program.

In a similar way, in the example program d02cjfe.f90, you need to replace the formal argument relabs (actual argument 'Default') in all the calls to the routine d02cjf by:

         'Default',%VAL(7)
and declare d02cjf as external rather than getting it from the NAG interface block module.

For library routines where an argument is a character array, pass the length of each array element.

This information has been tested with GNU Fortran 4.3.4 which comes from the Cygwin distribution.

Modified versions of the example programs d02cjfe.f90 and g01fafe.f are provided to illustrate the use of the NAG DLLs with gfortran. These files can be found in the folder

  install dir\samples\gfortran_examples

Note that NAG example programs which do not call NAG routines with character arguments need no modification for use with gfortran.

3.1.8. Calling the DLLs from Microsoft Visual C++ / Visual Studio

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 C/C++ header file nagmk24.h is 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 (making sure that the relevant #defines etc. are also copied from the top of the file) or simply include the 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.

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

  Start|All Programs|NAG|FL24|NAG Fortran Library for Win32
      Applications (FLDLL244ML)|Calling FLDLL244ML from C & C++
by default. Note that some changes will be needed if you paste code from one of the C examples given there into a C++ file since, if __cplusplus is defined, the header file provided uses C++ reference arguments for scalars, and therefore the "address of" operator should not be used. See Section 3 of the techdoc.html document for more details.

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 FLDLL244M_mkl.lib
or
  cl driver.c FLDLL244M_nag.lib
where driver.c is your application program. This assumes that the folder containing the header file has been added to the INCLUDE environment variable. If not, you could use:
  cl /I"install dir\c_headers" driver.c FLDLL244M_mkl.lib
or
  cl /I"install dir\c_headers" driver.c FLDLL244M_nag.lib

The following instuctions apply to Visual Studio .NET 2003, Visual Studio 2005 and Visual Studio 2008. 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 FLDLL244M_mkl.lib or FLDLL244M_nag.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.

Note that, with Microsoft C++, you may need to use the /EHsc compiler switch with the command line C++ examples.

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

The header file 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 /I"install dir\c_headers" driver.c FLDLL244M_mkl.lib
or
  icl /I"install dir\c_headers" driver.c FLDLL244M_nag.lib
where driver.c is your application program.

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

The header file 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 for Win32 Applications from gcc or g++, where driver.c or driver.cpp is your application program and driver.exe is the executable produced.

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

  gcc -D _WIN32 -I "install dir\c_headers" driver.c
      "install dir\lib\FLDLL244M_mkl.lib" -o driver.exe
or
  gcc -D _WIN32 -I "install dir\c_headers" driver.c
      "install dir\lib\FLDLL244M_nag.lib" -o driver.exe

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

  gcc -D _WIN32 -I "install dir/c_headers" driver.c
      "install dir/lib/FLDLL244M_mkl.lib" -o driver.exe
or
  gcc -D _WIN32 -I "install dir/c_headers" driver.c
      "install dir/lib/FLDLL244M_nag.lib" -o driver.exe

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

  g++ -D _WIN32 -I "install dir\c_headers" driver.cpp
      "install dir\lib\FLDLL244M_mkl.lib" -o driver.exe
or
  g++ -D _WIN32 -I "install dir\c_headers" driver.cpp
      "install dir\lib\FLDLL244M_nag.lib" -o driver.exe

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

  g++ -D _WIN32 -I "install dir/c_headers" driver.cpp
      "install dir/lib/FLDLL244M_mkl.lib" -o driver.exe
or
  g++ -D _WIN32 -I "install dir/c_headers" driver.cpp
      "install dir/lib/FLDLL244M_nag.lib" -o driver.exe

This information has been tested with gcc version 4.3.4 from the from the Cygwin distribution.

3.1.11. Calling the DLLs from Microsoft Visual Basic for Applications / Excel (32-bit)

The Fortran DLLs provided in this implementation 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.) The information here applies to 32-bit versions of Excel.

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.html. 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:

This has been tested using Microsoft Office Excel 2003, 2007 and 2010.

3.1.12. 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:

This has been tested using Microsoft Visual Basic 6.0.

3.1.13. 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:

This has been tested using Visual Studio .NET 2003, 2005, 2008 and 2010.

If running on a 64-bit system, it may be necessary to set the Target CPU to x86 to avoid a BadImageFormatException.

3.1.14. 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. The method illustrated there is applicable to the DLLs in this implementation.

Examples of use of the DLLs from C# are given in the install dir\samples\cs_examples folder. They may be compiled with the C# compiler in a command line like this:

  csc driver.cs
(Note that the DLL name is embedded in the example files.)

You may also be interested in the NAG Library for .NET – see http://www.nag.co.uk/microsoft_dotnet.asp for details.

3.1.15. Calling the DLLs from Java

It is possible to call the DLLs in this implementation from Java - see http://www.nag.co.uk/doc/TechRep/html/Tr2_09/Tr2_09.asp. for details of how to do this.

However, it is very much easier to use the NAG Library for Java.

3.1.16. 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. The method illustrated there is applicable to the DLLs in this implementation.

3.1.17. Calling the DLLs from R

For information on calling the NAG Fortran Library DLLs from R see http://www.nag.co.uk/numeric/RunderWindows.asp. The method illustrated there is applicable to the DLLs in this implementation.

3.1.18. The NAG Library edition of Simfit

The NAG Library edition of Simfit uses a 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.

3.1.19. Calling the DLLs from Other Environments

For information on calling the NAG Fortran Library for Win32 Applications from environments not mentioned above, please see the Post Release Information page:

http://www.nag.co.uk/doc/inun/fl24/dll4ml/postrelease.html

or contact us via one of the addresses listed in the Appendix.

3.1.20. Accessibility Check

To check whether the DLLs included in this library implementation are accessible from the current environment, run the program NAG_Fortran_DLL_info.exe which is available from the Start Menu shortcut
  Start|All Programs|NAG|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|Check NAG DLL Accessibility for FLDLL244ML
See Section 4.2.3 of the Installer's Note for details of this utility.

3.2. 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 programs. However, they are required if the supplied examples are used. Their purpose is to allow the Fortran 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; and
(d) all arguments match in type and structure.

The NAG Fortran Library interface block files are organised by Library chapter. They are aggregated into one module named

  nag_library

The modules are supplied in pre-compiled form (.mod files) for the Intel Fortran compiler, ifort.

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.1), and the Intel ifort compiler, you can use any of the commands described in Section 3.1.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.2 of the Installer's Note. Such module files are compiler-dependent, so if you wish to use the NAG example programs, or use the interface blocks in your own programs, when using a compiler that is incompatible with these modules, you will first need to create your own module files, as described here.

Create a folder named nag_interface_blocks_original in a location of your choice (the exact folder name is not important), and copy the contents of nag_interface_blocks to nag_interface_blocks_original, thus saving the original set of interface blocks.

Then in folder nag_interface_blocks recompile all the .f90 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. Here we use the Intel compiler ifort for illustration - you should replace ifort /iface:cvf by the name of the compiler you wish to use along with any necessary compiler switches.

  ifort /iface:cvf -c nag_precisions.f90
  ifort /iface:cvf -c nag_a_ib.f90
  ifort /iface:cvf -c nag_blast_ib.f90
  ifort /iface:cvf -c nag_blas_consts.f90
  ifort /iface:cvf -c nag_blas_ib.f90
  ifort /iface:cvf -c nag_c_ib.f90
  ifort /iface:cvf -c nag_d_ib.f90
  ifort /iface:cvf -c nag_e_ib.f90
  ifort /iface:cvf -c nag_f_ib.f90
  ifort /iface:cvf -c nag_g_ib.f90
  ifort /iface:cvf -c nag_h_ib.f90
  ifort /iface:cvf -c nag_lapack_ib.f90
  ifort /iface:cvf -c nag_m_ib.f90
  ifort /iface:cvf -c nag_omp_ib.f90
  ifort /iface:cvf -c nag_s_ib.f90
  ifort /iface:cvf -c nag_w_ib.f90
  ifort /iface:cvf -c nag_x_ib.f90
  ifort /iface:cvf -c nag_long_names.f90
  ifort /iface:cvf -c nag_library.f90
The object files generated by the compilation may be discarded - only the module files are needed.

You should now be able to use the newly compiled module files in the usual way.

3.3. Example Programs

The example results distributed were generated at Mark 24, 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 BLAS or 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.

The distributed example results are those obtained with the DLL library FLDLL244M_mkl.lib, (i.e. using the MKL BLAS and LAPACK routines).

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 one of the following batch files:

The batch files need the environment variable NAG_FLDLL244ML.

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

  Start|All Programs|NAG|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|FLDLL244ML 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\FL24\fldll244ml\batch\envvars.bat
If the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll244ml.

Each of the nag_example* batch files mentioned above will provide you with a copy of an example program (and its data and options file, if any), compile the program and link it with the appropriate libraries (showing you the compile command so that you can recompile your own version of the program). Finally, the executable program will be run with appropriate arguments specifying data, options and results files as needed.

The example program concerned is specified by the argument to the command, e.g.

  nag_example_mkl e04nrf
will copy the example program and its data and options files (e04nrfe.f90, e04nrfe.d and e04nrfe.opt) into the current folder and process them to produce the example program results in the file e04nrfe.r.

3.4. Fortran Types and Interpretation of Bold Italicised Terms

This implementation of the NAG Fortran Library uses 32-bit integers.

The NAG Library and documentation use parameterized types for floating-point variables. Thus, the type

      REAL(KIND=nag_wp)
appears in documentation of all NAG Fortran Library 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

      REAL(KIND=nag_rp)
where nag_rp stands for "reduced precision type". Another type, not currently used in the library, is
      REAL(KIND=nag_hp)
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.5. 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.)

4. Routine-specific Information

Any further information which applies to one or more routines in this implementation is listed below, chapter by chapter.
  1. F06, F07, F08 and F16

    In Chapters F06, F07, F08 and F16, alternate routine names are available for BLAS and LAPACK derived routines. For details of the alternate routine names please refer to the relevant Chapter Introduction. Note that applications should reference routines by their BLAS/LAPACK names, rather than their NAG-style names, for optimum performance.

    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 may require a different amount of workspace from 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 BLAS and LAPACK routines are included in the library FLDLL244M_mkl.dll to avoid problems with the vendor version:

      DBDSDC     DGEES      DGEESX     DGERFS     DGGES     DGGESX
      DGGEVX     DSBEV      DSBEVX     ZGEES      ZGEESX    ZGGES
      ZGGESX     ZHBEV      ZHBEVX     ZTRSEN
    
  2. G02

    The value of ACC, the machine-dependent constant mentioned in several documents in the chapter, is 1.0D-13.
  3. 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 AIMAG(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 REAL(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
    
  4. X01

    The values of the mathematical constants are:

    X01AAF (pi) = 3.1415926535897932
    X01ABF (gamma) = 0.5772156649015328
    
  5. X02

    The values of the machine constants are:

    The basic parameters of the model

    X02BHF   = 2
    X02BJF   = 53
    X02BKF   = -1021
    X02BLF   = 1024
    

    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
  6. 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 a separate installation, via download from the NAG website, or from the distribution CD if you have one. It is also available directly on the CD. The most up-to-date version of the documentation is accessible via the NAG website at http://www.nag.co.uk/numeric/FL/FLdocumentation.asp.

The Library Manual is supplied in the following formats:

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

	nagdoc_fl24\html\FRONTMATTER\manconts.html
	nagdoc_fl24\pdf\FRONTMATTER\manconts.pdf
	nagdoc_fl24\pdf\FRONTMATTER\manconts.html
If the Library Manual has been installed locally, these index files are available from the Start Menu under
  Start|All Programs|NAG|Mark 24 Manual|
      NAG Library Manual Mark 24 (HTML5)
  Start|All Programs|NAG|Mark 24 Manual|
      NAG Library Manual Mark 24 (PDF)
  Start|All Programs|NAG|Mark 24 Manual|
      NAG Library Manual Mark 24 (PDF + HTML Index)
respectively, by default. Use your web browser to navigate from here. For convenience, a master index file containing links to the above files has been provided at
	nagdoc_fl24\index.html

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

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

  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|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|NAG Library Manual Mark 24 HTML Help
If the NAG Library materials have been installed on a network drive, you may need to copy the HTML Help file (nagdoc_fl24.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. Right-click on nagdoc_fl24.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.

In addition the following are provided:

The latter is available from the Start Menu under
  Start|All Programs|NAG|FL24|NAG Fortran Library for
      Win32 Applications (FLDLL244ML)|FLDLL244ML Users' Note
by default.

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 FLDLL244ML).

(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/, http://www.nag-j.co.jp/ or http://www.nag-gc.com/

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

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

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                          Nihon NAG Response Centre
Japan                                   email: support@nag-j.co.jp

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: support@nag-gc.com

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