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.
for details of any new information related to the applicability or usage of this implementation.
Fortran 90/95/2003 users are advised that the compiled *.mod files (the interface blocks) have been compiled with the Intel Fortran Compiler 12.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.
In this section we assume that the Library has been installed in the default folder:
c:\Program Files\NAG\FL23\fldll234mlIf 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:
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-based version of the Library is to be used, the install_dir\MKL_ia32_10.3\bin folder must also be on the path, but should appear later in the path than the install_dir\bin folder, since the NAG versions of a few Basic Linear Algebra Subprograms (BLAS) / linear algebra routines (LAPACK) are included in FLDLL234M_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
Start|All Programs|NAG|FL23|NAG Fortran Library for Win32 Applications (FLDLL234ML)|Check NAG DLL Accessibility (FLDLL234ML)See Section 4.2.3 of the Installer's Note for details of this utility.
See Section 18.104.22.168 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 or Windows 7 from the Control Panel home select System and Maintenance (on Vista) / System and Security (on Windows 7), 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\FL23\fldll234ml\batch; c:\Program Files\NAG\FL23\fldll234ml\bin; c:\Program Files\NAG\FL23\fldll234ml\MKL_ia32_10.3\bin; existing pathadd or edit the LIB environment variable to include
c:\Program Files\NAG\FL23\fldll234ml\lib; any existing library pathadd or edit the INCLUDE environment variable to include
c:\Program Files\NAG\FL23\fldll234ml\nag_interface_blocks; any existing include pathsubstituting 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 FLDLL234M_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
FLDLL234M_mkl.lib mkl_intel_s_dll.lib mkl_intel_thread_dll.lib mkl_core_dll.libbecause 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.aspMore information specific to this product may be available from the Post Release Information page:
Start|All Programs|NAG|FL23|NAG Fortran Library for Win32 Applications (FLDLL234ML)|FLDLL234ML 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\FL23\fldll234ml\batch\envvars.batIf the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll234ml.
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 FLDLL234M_mkl.lib ifort /iface:cvf /MD driver.f90 FLDLL234M_nag.libwhere driver.f90 is your application program.
The first command will use the DLL without the NAG version of the BLAS/LAPACK procedures (FLDLL234M_mkl.lib) and with the MKL DLLs. The second command will use the DLL with the NAG version of the BLAS/LAPACK procedures (FLDLL234M_nag.lib). The option /MD should be used to ensure linking with the correct run-time libraries.
Note that /MD is equivalent to
If your program uses multiple threads, you should also compile with the /automatic option, e.g.:
ifort /iface:cvf /MD /automatic driver.f90 FLDLL234M_mkl.lib
Please note that the Intel Visual Fortran compiler environment variables must be set in the command window. For more details refer to the User's Guide for the compiler.
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_10.3\bin must also be on the path, but should appear after the install_dir\bin folder.
Once Visual Studio has been opened, it is possible to set up the directories for use with Intel Fortran in this and all subsequent projects which use this compiler. One way to do so is:
Having done this, if an Intel Fortran project requires a library or NAG interface block during the compilation and linking process then the full path to the library and interface block do not need to be specified.
Whilst the above changes will apply to every Intel Fortran project, the following tasks need to be performed for each individual Intel Fortran project.
The library is intended to be run in fully optimised mode, so to avoid any warning messages, you might decide to set the active configuration to Release. You can do this from the Toolbar or alternatively via the Build|Configuration Manager menus. Note that if you work in Debug mode, you may receive a warning message about conflicting C run-time libraries.
There are a number of ways to add the NAG Library to the project. We describe just two; choose the one that most suits you.
If the Solution Explorer window is open then make sure that the group project (the first line) is NOT selected. From the Project menu, choose the project Properties item. (Alternatively right-click on a specific single project in the Solution Explorer and choose Properties.)
From the form, click/expand Linker in the leftmost panel and then choose Input. The right hand panel will now have an Additional Dependencies entry, and you need to type FLDLL234M_nag.lib in this location. Press the OK button.
You will also need to set the calling convention to "CVF". From the Properties form, click/expand Fortran and then choose External Procedures. Click on the Calling Convention entry in the right hand panel and select CVF from the drop-down list. Selecting this option will automatically change the entry for String Length Argument Passing to After Individual String Argument when you click on Apply or OK; this is the convention required by this implementation of the NAG Library.
We also recommend that you use the multithreaded DLL version of the runtime library. From the Properties form, click/expand Fortran in the leftmost panel and then choose Libraries. Click on the Runtime Library entry in the right hand panel and select Multithread DLL from the drop-down list.
For a multithreaded application, as well as selecting a multithreaded run-time library, you should set the /automatic (or /Qauto) compiler flag, to ensure that all local variables are allocated on the stack. To set this option, from the Properties form click/expand Fortran and then choose Data. Click on the Local Variable Storage entry in the right hand panel and select Local Variables AUTOMATIC from the drop-down list. Press the OK button to accept the changes and close the form.
The Properties information may also be accessed via the Toolbar. With the project selected in Solution Explorer, choose the Properties Window button on the Toolbar. In the ensuing window choose then the rightmost Property Pages icon. Select the appropriate settings as detailed in the paragraphs above.
The project should now compile and link using the appropriate choice from the Build menu.
To run a program that does not require input or output redirected from standard input or standard output, from within the Microsoft Development Environment, the program may be executed via the Debug menu (by selecting Start Without Debugging, for example).
If a data file needs to be attached to the standard input or the output of a program needs to be redirected to the standard output, we recommend that you run the executable from a command prompt window to avoid the limitations of Visual Studio.
Commands such as the following may then be used to call the NAG DLLs from the NAG Fortran Compiler (nagfor):
nagfor -f77 -w=obs -I nag_interface_blocks_nagfor -o driver.exe driver.f90 "install_dir\lib\FLDLL234M_mkl.lib"or
nagfor -f77 -w=obs -I nag_interface_blocks_nagfor -o driver.exe driver.f90 "install_dir\lib\FLDLL234M_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 your compiled module files.
The full pathname of the FLDLL234M_mkl.lib or FLDLL234M_nag.lib file must be specified and must be enclosed within quotes if it contains spaces.
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 /f_stdcall /mod_path nag_interface_blocks_ftn95 driver.f90 /import_lib "install_dir\bin\FLDLL234M_mkl.dll" /linkor
ftn95 /f_stdcall /mod_path nag_interface_blocks_ftn95 driver.f90 /import_lib "install_dir\bin\FLDLL234M_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\FLDLL234M_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. 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:
open(6,file='c:\test.res')in the main program before any write statements to channel 6.
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 23 DLLs using pgf90 is:
pgf90 driver.f90 -module nag_interface_blocks_pgi FLDLL234M_mkl.lib -o driver.exe(for the MKL-based variant of the Library), or
pgf90 driver.f90 -module nag_interface_blocks_pgi FLDLL234M_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
install_dir\samples\lahey_fortran_exampleThe advice given here has been tested using Lahey Fortran version 7.2.
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:
DLL_IMPORT OUTand in the user-supplied subroutine or function insert a DLL_EXPORT statement i.e.
DLL_EXPORT OUTshould 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)
Use the compiler switch
lf95 d02cjfe.f "install_dir\lib\FLDLL234M_mkl.lib" -ml bcor
lf95 d02cjfe.f "install_dir\lib\FLDLL234M_nag.lib" -ml bc
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 FLW3223DCL. See the Post Release Notes for that product for details: http://www.nag.co.uk/doc/inun/fl23/w32dcl/postrelease.html
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 4.3.
Commands such as the following may be used for calling the NAG Fortran Library Mark 23 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\FLDLL234M_mkl.lib" -o driver.exeor
gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90 "install_dir\lib\FLDLL234M_nag.lib" -o driver.exeUsing gfortran from a Cygwin xterm:
gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90 "install_dir/lib/FLDLL234M_mkl.lib" -o driver.exeor
gfortran -mrtd -Inag_interface_blocks_gfortran driver.f90 "install_dir/lib/FLDLL234M_nag.lib" -o driver.exeIn 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
Note that NAG example programs which do not call NAG routines with character arguments need no modification for use with gfortran.
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 e04cbfcppclass.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 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|FL23|NAG Fortran Library for Win32 Applications (FLDLL234ML)|C & C++ Header File Informationby 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.
cl driver.c FLDLL234M_mkl.libor
cl driver.c FLDLL234M_nag.libwhere 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 /I"install_dir\c_headers" driver.c FLDLL234M_mkl.libor
cl /I"install_dir\c_headers" driver.c FLDLL234M_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 FLDLL234M_mkl.lib or FLDLL234M_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.
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 FLDLL234M_mkl.libor
icl /I"install_dir\c_headers" driver.c FLDLL234M_nag.libwhere driver.c is your application program.
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\FLDLL234M_mkl.lib" -o driver.exeor
gcc -D _WIN32 -I "install_dir\c_headers" driver.c "install_dir\lib\FLDLL234M_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/FLDLL234M_mkl.lib" -o driver.exeor
gcc -D _WIN32 -I "install_dir/c_headers" driver.c "install_dir/lib/FLDLL234M_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\FLDLL234M_mkl.lib" -o driver.exeor
g++ -D _WIN32 -I "install_dir\c_headers" driver.cpp "install_dir\lib\FLDLL234M_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/FLDLL234M_mkl.lib" -o driver.exeor
g++ -D _WIN32 -I "install_dir/c_headers" driver.cpp "install_dir/lib/FLDLL234M_nag.lib" -o driver.exe
This information has been tested with gcc version 4.3.4 from the from the Cygwin distribution.
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.
This has been tested using Microsoft Office Excel 2003, 2007 and 2010.
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.
This has been tested using Microsoft Visual Basic 6.0.
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.
You may also be interested in the NAG Library for .NET – see http://www.nag.co.uk/microsoft_dotnet.asp for details.
or contact us via one of the addresses listed in the Appendix.
Start|All Programs|NAG|FL23|NAG Fortran Library - Intel Fortran (FLDLL234ML)|Check NAG DLL Accessibility (FLDLL234ML)See Section 4.2.3 of the Installer's Note for details of this utility.
Note that this program should be closed after use (by pressing a key to dismiss the window), otherwise performance may be impared.
(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.
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_precisions nag_blas_consts nag_a_ib nag_c_ib nag_d_ib nag_e_ib nag_f_ib nag_g_ib nag_h_ib nag_m_ib nag_p_ib nag_s_ib nag_x_ib nag_long_namesand these are also aggregated into one module named
nag_libraryA program calling a NAG routine may then use a module for a specific chapter (e.g. nag_s_ib) or for the whole library (i.e. nag_library).
The modules are supplied in pre-compiled form (.mod files) for use by 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 22.214.171.124), and the Intel ifort compiler, you can use any of the commands described in Section 126.96.36.199 to access these modules since the environment variable INCLUDE will be set.
If you wish to use NAG modules with a Fortran compiler other than the Intel compiler, you will need to recompile the interface blocks with your own compiler, as decscribed here.
Copy all the .f90 files from the nag_interface_blocks folder to a new folder of your choice, for example (if you wish to use them with the NAG compiler nagfor) nag_interface_blocks_nagfor. Then compile all the files into objects using your compiler. Because the interface blocks contain some inter-dependencies, the order of compilation is important, but the following compilation order should work (again, using the NAG compiler as an example):
nagfor -f77 -c nag_precisions.f90 nagfor -f77 -c nag_blas_consts.f90 nagfor -f77 -c nag_a_ib.f90 nagfor -f77 -c nag_c_ib.f90 nagfor -f77 -c nag_d_ib.f90 nagfor -f77 -c nag_e_ib.f90 nagfor -f77 -c nag_f_ib.f90 nagfor -f77 -c nag_g_ib.f90 nagfor -f77 -c nag_h_ib.f90 nagfor -f77 -c nag_m_ib.f90 nagfor -f77 -c nag_p_ib.f90 nagfor -f77 -c nag_s_ib.f90 nagfor -f77 -c nag_x_ib.f90 nagfor -f77 -c nag_long_names.f90 nagfor -f77 -c nag_library.f90(N.B. here the nagfor -f77 flag is used to generate modules with the STDCALL calling convention. For other compilers, different flags may be necessary).
The object files generated by the compilation may be discarded - only the module files are needed.
To use the newly compiled module files, you will need a compiler-dependent switch to tell the compiler where to find them when you are compiling programs. For example, with the NAG compiler, the command
nagfor -f77 -I nag_interface_blocks_nagforwill tell the compiler to look in the new folder for module files.
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_FLDLL234ML.
As mentioned in Section 188.8.131.52, the installation procedure provides a shortcut which starts a Command Prompt with local environment variables. The environment variables include NAG_FLDLL234ML. This shortcut is, by default, placed in the Start Menu under
Start|All Programs|NAG|FL23|NAG Fortran Library for Win32 Applications (FLDLL234ML)|FLDLL234ML Command PromptIf 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\FL23\fldll234ml\batch\envvars.batIf the file is not in the default location, you can locate it by searching for the file envvars.bat containing fldll234ml.
Each of the nag_example* batch files mentioned above will provide you with a copy of an example program (and its data, 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, writing its output to a file.
The example program concerned is specified by the argument to the command, e.g.
nag_example_mkl e04ucfwill copy the example program and its data into the files e04ucfe.f90 and e04ucfe.d in the current folder and process them to produce the example program results in the file e04ucfe.r, also sending the results to the screen.
The distributed example results are those obtained with the library FLDLL234M_mkl.dll, (using the MKL BLAS and LAPACK routines). Running the examples with the self-contained library (using the NAG BLAS and LAPACK routines) may give slightly different results.
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
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.
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 Basic Linear Algebra Subprograms (BLAS) and linear algebra routines (LAPACK) are included in the library FLDLL234M_mkl.dll to avoid problems with the vendor version:
DBDSQR DGEBAL DGEESX DGEEVX DGEHRD DGGESX DHSEQR ZBDSQR ZGEBAL ZGEEVX ZHPEVD ZHSEQR ZTRSEN ZTRSV
The constants referred to in the Library Manual have the following values in this implementation:
S07AAF F_1 = 1.0E+13 F_2 = 1.0E-14 S10AAF E_1 = 1.8715E+1 S10ABF E_1 = 7.080E+2 S10ACF E_1 = 7.080E+2 S13AAF x_hi = 7.083E+2 S13ACF x_hi = 1.0E+16 S13ADF x_hi = 1.0E+17 S14AAF IFAIL = 1 if X > 1.70E+2 IFAIL = 2 if X < -1.70E+2 IFAIL = 3 if abs(X) < 2.23E-308 S14ABF IFAIL = 2 if X > x_big = 2.55E+305 S15ADF x_hi = 2.65E+1 S15AEF x_hi = 2.65E+1 S15AFF underflow trap was necessary S15AGF IFAIL = 1 if X >= 2.53E+307 IFAIL = 2 if 4.74E+7 <= X < 2.53E+307 IFAIL = 3 if X < -2.66E+1 S17ACF IFAIL = 1 if X > 1.0E+16 S17ADF IFAIL = 1 if X > 1.0E+16 IFAIL = 3 if 0 < X <= 2.23E-308 S17AEF IFAIL = 1 if abs(X) > 1.0E+16 S17AFF IFAIL = 1 if abs(X) > 1.0E+16 S17AGF IFAIL = 1 if X > 1.038E+2 IFAIL = 2 if X < -5.7E+10 S17AHF IFAIL = 1 if X > 1.041E+2 IFAIL = 2 if X < -5.7E+10 S17AJF IFAIL = 1 if X > 1.041E+2 IFAIL = 2 if X < -1.9E+9 S17AKF IFAIL = 1 if X > 1.041E+2 IFAIL = 2 if X < -1.9E+9 S17DCF IFAIL = 2 if abs(Z) < 3.92223E-305 IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4 IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9 S17DEF IFAIL = 2 if Im(Z) > 7.00921E+2 IFAIL = 3 if abs(Z) or FNU+N-1 > 3.27679E+4 IFAIL = 4 if abs(Z) or FNU+N-1 > 1.07374E+9 S17DGF IFAIL = 3 if abs(Z) > 1.02399E+3 IFAIL = 4 if abs(Z) > 1.04857E+6 S17DHF IFAIL = 3 if abs(Z) > 1.02399E+3 IFAIL = 4 if abs(Z) > 1.04857E+6 S17DLF IFAIL = 2 if abs(Z) < 3.92223E-305 IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4 IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9 S18ADF IFAIL = 2 if 0 < X <= 2.23E-308 S18AEF IFAIL = 1 if abs(X) > 7.116E+2 S18AFF IFAIL = 1 if abs(X) > 7.116E+2 S18DCF IFAIL = 2 if abs(Z) < 3.92223E-305 IFAIL = 4 if abs(Z) or FNU+N-1 > 3.27679E+4 IFAIL = 5 if abs(Z) or FNU+N-1 > 1.07374E+9 S18DEF IFAIL = 2 if Re(Z) > 7.00921E+2 IFAIL = 3 if abs(Z) or FNU+N-1 > 3.27679E+4 IFAIL = 4 if abs(Z) or FNU+N-1 > 1.07374E+9 S19AAF IFAIL = 1 if abs(X) >= 5.04818E+1 S19ABF IFAIL = 1 if abs(X) >= 5.04818E+1 S19ACF IFAIL = 1 if X > 9.9726E+2 S19ADF IFAIL = 1 if X > 9.9726E+2 S21BCF IFAIL = 3 if an argument < 1.583E-205 IFAIL = 4 if an argument >= 3.765E+202 S21BDF IFAIL = 3 if an argument < 2.813E-103 IFAIL = 4 if an argument >= 1.407E+102
X01AAF (pi) = 3.1415926535897932 X01ABF (gamma) = 0.5772156649015328
The basic parameters of the model
X02BHF = 2 X02BJF = 53 X02BKF = -1021 X02BLF = 1024 X02DJF = .TRUE.
Derived parameters of the floating-point arithmetic
X02AJF = 1.11022302462516E-16 X02AKF = 2.22507385850721E-308 X02ALF = 1.79769313486231E+308 X02AMF = 2.22507385850721E-308 X02ANF = 4.45014771701441E-308
Parameters of other aspects of the computing environment
X02AHF = 1.42724769270596E+45 X02BBF = 2147483647 X02BEF = 15 X02DAF = .TRUE.
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.
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_fl23\xhtml\FRONTMATTER\manconts.xml nagdoc_fl23\pdf\FRONTMATTER\manconts.pdf nagdoc_fl23\html\FRONTMATTER\manconts.htmlIf the Library Manual has been installed locally, these index files are available from the Start Menu under
Start|All Programs|NAG|FL23|NAG Fortran Library Manual (XHTML + MathML) Start|All Programs|NAG|FL23|NAG Fortran Library Manual (PDF) Start|All Programs|NAG|FL23|NAG Fortran Library Manual (PDF + HTML Index)respectively, by default. Use your web browser to navigate from here.
Advice on viewing and navigating the formats available can be found in the Online Documentation document.
Note that if you are using Internet Explorer, all links within the XHTML/MathML version to example source, data and results files and PDF files will be diverted from the local file system to the NAG website to avoid security restrictions which prevent the display of these pages. If you are using any other browser then local links to examples and PDF files are retained.
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:
The HTML Help version of the Library Manual is available from the Start Menu under
Start|All Programs|NAG|FL23|NAG Fortran Library Manual HTML HelpIf the NAG Library materials have been installed on a network drive, you may need to copy the HTML Help file (nagdoc_fl23.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 canceledthe file might have been blocked by security updates in Windows or Internet Explorer. Right-click on nagdoc_fl23.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:
Start|All Programs|NAG|FL23|NAG Fortran Library for Win32 Applications (FLDLL234ML)|Users' Noteby default.
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 no. and NAG product code (in this case FLDLL234ML).
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:
NAG Ltd Wilkinson House Jordan Hill Road OXFORD OX2 8DR NAG Ltd Response Centre United Kingdom email: firstname.lastname@example.org 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: email@example.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: firstname.lastname@example.org 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: email@example.com Tel: +886 2 25093288 Tel: +886 2 25093288 Fax: +886 2 25091798 Fax: +886 2 25091798