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.
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.
When the DLL is used with a non-Intel compiler, please note that two input/output systems are in use: those of Intel for library routines and of course the compiler's own input/output routines for the calling program. This means that programs like the E04UDF example program cannot read the data from just one file. This is because the program reads some of the data using its input/output system. When the option setting routine tries to read the data file, the Intel input/output routines are used. The two input/output systems are completely disjoint and so in particular Intel has no knowledge of the position in the data file that the program input/output system has reached. The problem is circumvented by having two separate data files. Routines affected by this are mainly the option setting routines in chapters H02 and E04.
http://www.nag.co.uk/doc/inun/fs24/w32dcl/postrelease.html
for details of any new information related to the applicability or usage of this implementation.
c:\Program Files\NAG\FS24\fsw3224dclIf 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|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|FSW3224DCL Command Prompt
If this shortcut does not exist, please consult the system manager (or the person who did the installation). (Other shortcuts created as part of the Library installation procedure are also assumed to be in this location.)
(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 (FSW3224DC.dll) is accessible at run time, the install dir\bin folder must be on the path. 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 DLL, run the program NAG_Fortran_DLL_info.exe which is available from the Start Menu shortcut
Start|All Programs|NAG|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|Check NAG DLL Accessibility for FSW3224DCL
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\FS24\fsw3224dcl\batch; c:\Program Files\NAG\FS24\fsw3224dcl\bin; c:\Program Files\NAG\FS24\fsw3224dcl\MKL_ia32_11.0\bin; existing pathadd or edit the LIB environment variable to include
c:\Program Files\NAG\FS24\fsw3224dcl\lib; any existing library pathadd or edit the INCLUDE environment variable to include
c:\Program Files\NAG\FS24\fsw3224dcl\nag_interface_blocks; any existing include pathsubstituting the correct folder where the NAG Fortran DLL is installed if necessary.
In the DLL in this implementation, for convenience, the MKL symbols are exported directly from the NAG import library FSW3224DC.lib, so it is not necessary to specify the MKL interface library mkl_rt.lib as well. However, if the MKL interface library is specified, it is important that the NAG import library precedes it, i.e. the order should be
FSW3224DC.lib mkl_rt.libbecause certain parts of the MKL should not be used (see Section 4).
Note that it is particularly important when compiling a user-supplied procedure which is to be passed to a NAG routine as a callback function to make sure that any local variables in the procedure are safe for use in a parallel environment. This is because the callback may be called from inside a parallel region in the NAG library. In particular, you should ensure that local variables are not statically allocated, but are created dynamically on entry to the procedure and destroyed on exit. It may be necessary to use compiler-dependent switches to make this happen. Also, you should avoid the use of any compiler switches with names like -save that cause local variables to be statically allocated, since this is the opposite of what is required.
Information on calling the NAG Fortran DLL 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:
http://www.nag.co.uk/doc/inun/fs24/w32dcl/postrelease.html
set OMP_NUM_THREADS=Nwhere N is the number of threads required. OMP_NUM_THREADS may be re-set between each execution of the program, as desired. It may be set globally via the Control Panel.
In general, the maximum number of threads you are recommended to use is the number of physical cores on your SMP system.
The shortcut:
Start|All Programs|NAG|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|FSW3224DCL 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\FS24\fsw3224dcl\batch\envvars.batIf the file is not in the default location, you can locate it by searching for the file envvars.bat containing fsw3224dcl.
You may then compile and link to the NAG Library on the command line using one of the following commands:
ifort /iface:cvf /MD /Qopenmp driver.f90 FSW3224DC.lib ifort /iface:cvf /MD /Qopenmp driver.f90 FSW3224DC_static.lib mkl_rt.lib user32.libwhere driver.f90 is your application program.
The first command will use the DLL version of the NAG Library. 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 (FSW3224DC.lib) in this instance. (Note that this behaviour may be different from some other NAG library implementations.)
The second command will use the static version of the NAG Library. It is also necessary to add the MKL import library mkl_rt.lib here, as well as the Microsoft run-time library user32.lib.
Notice that in both cases we compile using the /iface:cvf compiler flag. This tells the compiler that we wish to use the CVF calling convention. We also use the /MD compiler flag. This tells the compiler that we wish to link to multi-threaded DLL versions of compiler run-time libraries. Both these flags are important to ensure compatibility with this implementation of the NAG Library for SMP and Multicore. If you do not use them - particularly /iface:cvf - it is likely that your programs will fail to run correctly.
The /Qopenmp flag tells the compiler to heed any OpenMP directives that may be present in your own code. It also causes the linker to link to the compiler threading library, libiomp5md.lib.
Please note that the Intel Visual Fortran compiler environment variables must be set in the command window. Also note that the /Qopenmp compiler switch implies /Qauto and therefore ensures that local variables are not statically allocated, as discussed in Section Section 3.1.1.1. For more details refer to the Users' Guide for the compiler.
To ensure that the NAG DLL is accessible at runtime, the PATH environment variable must be set such that the location of the NAG DLL, specifically the folder install dir\bin, is on the path. 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:
c:\Program Files\NAG\FS24\fsw3224dcl\lib
c:\Program Files\NAG\FS24\fsw3224dcl\nag_interface_blocks
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:
As described earlier when compiling from the command line, you should also tell the compiler to use the /Qopenmp switch. From the Properties form, click/expand Fortran in the leftmost panel and then choose Language. Click on the Process OpenMP Directives entry in the right hand panel and select Generate Parallel Code (/QopenMP) from the drop-down list. Click on the Apply button to accept the changes.
In summary, the setting of the project Additional Dependencies, the project Runtime Library and the PATH environment variable must be consistent as follows:
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_fileIf 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.)
At a command line, commands such as the following may then be used to call the NAG DLL from the NAG Fortran Compiler (nagfor):
nagfor -thread_safe -compatible -I "install dir"\nag_interface_blocks_nagfor
-o driver.exe driver.f90 "install dir\lib\FSW3224DC.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.
Note that the -thread_safe compiler switch ensures that local variables are not statically allocated, as discussed in section 3.1. In this context, it is also important to note that you should definitely not use nagfor's -save switch, since that has the opposite effect on local variables to that required.
The full pathname of the FSW3224DC.lib file must be specified and must be enclosed within quotes if it contains spaces.
Note that on 64-bit Windows machines you will also need to add the -abi32 compiler flag.
Using the DLL from within the Fortran Builder IDE itself is also easy, following steps like these:
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 DLL 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\FSW3224DC.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 DLL 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\FSW3224DC.dll"As with compilation, the full path to the DLL should be specified here, within quotes if the pathname contains spaces. It is worth emphasising that the linker should link directly against the DLL, 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.
Plato is the Integrated Development Environment (IDE) that is provided with the more recent versions of FTN95. To use Plato 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 24 DLL using pgf90 is:
pgf90 -Mrecursive driver.f90 -module nag_interface_blocks_pgi FSW3224DC.lib -o driver.exeNote that nag_interface_blocks_pgi is the directory containing your compiled module files. Note also that the -Mrecursive compiler switch ensures that local variables are not statically allocated, as discussed in section 3.1. In this context, it is also important to note that you should definitely not use the pgf90 -Msave switch, since that has the opposite effect on local variables to that required.
This has been tested using version
Examples of the use of the DLL 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 DLL 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|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|Calling FSW3224DCL 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:
cl driver.c FSW3224DC.libwhere 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 FSW3224DC.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 FSW3224DC.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. You will also need to add install dir\c_headers to the C/C++|General|Additional Include Directories field unless you are using a local copy of nagmk24.h.
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 Library on the command line in the following manner:
icl /I"install dir\c_headers" driver.c FSW3224DC.lib
Examples of use of the DLL 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 DLL from within Excel spreadsheets. See also the VB 6 examples for further illustrations of calling the NAG DLL from VB 6 / VBA.
Key information:
This has been tested using Microsoft Office Excel 2003, 2007 and 2010.
Examples of use of the DLL 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 DLL from VB 6 / VBA.
Key information:
This has been tested using Microsoft Visual Basic 6.0.
Key information:
Imports System.Runtime.InteropServices
This has been tested using Visual Studio .NET 2003, 2005, 2008, 2010 and 2012.
If running on a 64-bit system, it may be necessary to set the Target CPU to x86 to avoid a BadImageFormatException.
Examples of use of the DLL 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.) On 64-bit Windows machines you will need to add the flag /platform:x86.
You may also be interested in the NAG Library for .NET – see http://www.nag.co.uk/microsoft_dotnet.asp for details.
However, it is very much easier to use the NAG Library for Java.
http://www.nag.co.uk/doc/inun/fs24/w32dcl/postrelease.html
or contact us via one of the addresses listed in the Appendix.
Start|All Programs|NAG|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|Check NAG DLL Accessibility for FSW3224DCL
See Section 4.2.3 of the Installer's Note
for details of this utility.
(a) subroutines are called as such;
(b) functions are declared with the right type;
(c) the correct number of arguments are passed; and
(d) all arguments match in type and structure.
The NAG Library 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.f90The 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.
The distributed example results are those obtained with the DLL library FSW3224DC.dll and OMP_NUM_THREADS set to 1.
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_FSW3224DCL.
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_FSW3224DCL. This shortcut is, by default, placed in the Start Menu under
Start|All Programs|NAG|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|FSW3224DCL 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\FS24\fsw3224dcl\batch\envvars.batIf the file is not in the default location, you can locate it by searching for the file envvars.bat containing fsw3224dcl.
Each of the nagsmp_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, and the number of OpenMP threads to use, are specified by the arguments to nagsmp_example_static.bat, e.g.
nagsmp_example_static e04ucf 4will copy the example program e04ucfe.f and its data file e04ucfe.d into the current directory and process them to produce the example program results in the file e04ucfe.r.
Alternatively you could use:
nagsmp_example_dll e04ucf 4
The difference between nagsmp_example_static.bat and nagsmp_example_dll.bat is that while nagsmp_example_static.bat links to the static version of the NAG SMP and MKL Libraries, nagsmp_example_dll.bat links to the DLL versions of the libraries.
REAL(KIND=nag_wp)
appears in documentation of all NAG 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
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.
C06PAF C06PCF C06PFF C06PJF C06PKF C06PPF C06PQF C06PRF C06PSF C06PUF C06PVF C06PWF C06PXF C06PYF C06PZF C06RAF C06RBF C06RCF C06RDFThe Intel DFTI routines allocate their own workspace internally, so no changes are needed to the size of workspace array WORK passed to the NAG C06 routines listed above from that specified in their respective library documents.
C09FAF C09FBF C09FCF C09FDF
In this implementation calls to BLAS and LAPACK routines are implemented by calls to MKL, except for the following routines:
DBDSDC DGEES DGEESX DGERFS DGGES DGGESX DGGEVX DSBEV DSBEVX ZGEES ZGEESX ZGGES ZGGESX ZHBEV ZHBEVX ZTRSEN
F07ADF/DGETRF F07AEF/DGETRS F07ARF/ZGETRF F07ASF/ZGETRS F07AVF/ZGERFS F07BDF/DGBTRF F07BEF/DGBTRS F07BHF/DGBRFS F07BRF/ZGBTRF F07BSF/ZGBTRS F07BVF/ZGBRFS F07CHF/DGTRFS F07CVF/ZGTRFS F07FDF/DPOTRF F07FEF/DPOTRS F07FHF/DPORFS F07FJF/DPOTRI F07FRF/ZPOTRF F07FSF/ZPOTRS F07FVF/ZPORFS F07GEF/DPPTRS F07GHF/DPPRFS F07GSF/ZPPTRS F07GVF/ZPPRFS F07HEF/DPBTRS F07HHF/DPBRFS F07HSF/ZPBTRS F07HVF/ZPBRFS F07JHF/DPTRFS F07JVF/ZPTRFS F07MHF/DSYRFS F07MVF/ZHERFS F07NVF/ZSYRFS F07PHF/DSPRFS F07PVF/ZHPRFS F07QVF/ZSPRFS F07THF/DTRRFS F07TVF/ZTRRFS F07UEF/DTPTRS F07UHF/DTPRFS F07USF/ZTPTRS F07UVF/ZTPRFS F07VEF/DTBTRS F07VHF/DTBRFS F07VSF/ZTBTRS F07VVF/ZTBRFS F08AEF/DGEQRF F08AFF/DORGQR F08AGF/DORMQR F08ASF/ZGEQRF F08ATF/ZUNGQR F08AUF/ZUNMQR F08FEF/DSYTRD F08FFF/DORGTR F08FSF/ZHETRD F08FTF/ZUNGTR F08GFF/DOPGTR F08GTF/ZUPGTR F08JEF/DSTEQR F08JJF/DSTEBZ F08JKF/DSTEIN F08JSF/ZSTEQR F08JXF/ZSTEIN F08KEF/DGEBRD F08KSF/ZGEBRD F08MEF/DBDSQR F08MSF/ZBDSQR F08NEF/DGEHRD F08NGF/DORMHR F08NSF/ZGEHRD F08PEF/DHSEQR F08PKF/DHSEIN F08PSF/ZHSEQR F08PXF/ZHSEIN F08TAF/DSPGV F08TBF/DSPGVX F08TCF/DSPGVD F08TNF/ZHPGV F08TPF/ZHPGVX F08TQF/ZHPGVD
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
The values of the mathematical constants are:
X01AAF (pi) = 3.1415926535897932 X01ABF (gamma) = 0.5772156649015328
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
D03RAF D03RBF E05SAF E05SBF E05UCF E05USF F01ELF F01EMF F01FLF F01FMF F01JBF F01JCF F01KBF F01KCFThus OpenMP directives or pragmas within the user functions should be avoided, unless you are using the same OpenMP runtime library (which normally means using the same compiler) as that used to build your NAG Library implementation, as listed in the Installers' Note. You must also ensure that you use the user workspace arrays IUSER and RUSER in a thread safe manner, which is best achieved by only using them to supply read-only data to the user functions.
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/FSdocumentation.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.htmlIf 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|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|NAG Library Manual Mk24 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 canceledthe 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:
Start|All Programs|NAG|FS24|NAG Library for SMP and Multicore
(FSW3224DCL)|FSW3224DCL Users' Note
by 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 number and NAG product code (in this case FSW3224DCL).
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: 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: naghelp@nag-j.co.jp Tel: +81 3 5542 6311 Tel: +81 3 5542 6311 Fax: +81 3 5542 6312 Fax: +81 3 5542 6312