diff options
| author | kaloz <kaloz@3c298f89-4303-0410-b956-a3cf2f4a3e73> | 2010-01-26 12:46:05 +0000 |
|---|---|---|
| committer | kaloz <kaloz@3c298f89-4303-0410-b956-a3cf2f4a3e73> | 2010-01-26 12:46:05 +0000 |
| commit | 285ff19141818b8da76116d211c55ec01b4c6ef5 (patch) | |
| tree | eb804fc58a60e3f5b9d8ba00b3f1c81c24efc032 | |
| parent | f7c2a3fc303114ddf861e20d7bd53789655a302b (diff) | |
cleanup patch
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@19345 3c298f89-4303-0410-b956-a3cf2f4a3e73
| -rw-r--r-- | toolchain/gcc/patches/4.4.1+cs/000-codesourcery_2009q3_68.patch | 15044 |
1 files changed, 0 insertions, 15044 deletions
diff --git a/toolchain/gcc/patches/4.4.1+cs/000-codesourcery_2009q3_68.patch b/toolchain/gcc/patches/4.4.1+cs/000-codesourcery_2009q3_68.patch index a0432f4783..88be9a85ff 100644 --- a/toolchain/gcc/patches/4.4.1+cs/000-codesourcery_2009q3_68.patch +++ b/toolchain/gcc/patches/4.4.1+cs/000-codesourcery_2009q3_68.patch @@ -24081,15050 +24081,6 @@ diff -Nur a/gcc/fortran/cpp.c b/gcc/fortran/cpp.c /* Callback called when -fworking-director and -E to emit working directory in cpp output file. */ -diff -Nur a/gcc/fortran/gfortran.info b/gcc/fortran/gfortran.info ---- a/gcc/fortran/gfortran.info 2009-07-22 10:33:04.000000000 +0200 -+++ b/gcc/fortran/gfortran.info 1970-01-01 01:00:00.000000000 +0100 -@@ -1,15040 +0,0 @@ --This is doc/gfortran.info, produced by makeinfo version 4.13 from --/d/gcc-4.4.1/gcc-4.4.1/gcc/fortran/gfortran.texi. -- --Copyright (C) 1999-2008 Free Software Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this document --under the terms of the GNU Free Documentation License, Version 1.2 or --any later version published by the Free Software Foundation; with the --Invariant Sections being "Funding Free Software", the Front-Cover Texts --being (a) (see below), and with the Back-Cover Texts being (b) (see --below). A copy of the license is included in the section entitled "GNU --Free Documentation License". -- -- (a) The FSF's Front-Cover Text is: -- -- A GNU Manual -- -- (b) The FSF's Back-Cover Text is: -- -- You have freedom to copy and modify this GNU Manual, like GNU --software. Copies published by the Free Software Foundation raise --funds for GNU development. -- --INFO-DIR-SECTION Software development --START-INFO-DIR-ENTRY --* gfortran: (gfortran). The GNU Fortran Compiler. --END-INFO-DIR-ENTRY -- This file documents the use and the internals of the GNU Fortran --compiler, (`gfortran'). -- -- Published by the Free Software Foundation 51 Franklin Street, Fifth --Floor Boston, MA 02110-1301 USA -- -- Copyright (C) 1999-2008 Free Software Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this document --under the terms of the GNU Free Documentation License, Version 1.2 or --any later version published by the Free Software Foundation; with the --Invariant Sections being "Funding Free Software", the Front-Cover Texts --being (a) (see below), and with the Back-Cover Texts being (b) (see --below). A copy of the license is included in the section entitled "GNU --Free Documentation License". -- -- (a) The FSF's Front-Cover Text is: -- -- A GNU Manual -- -- (b) The FSF's Back-Cover Text is: -- -- You have freedom to copy and modify this GNU Manual, like GNU --software. Copies published by the Free Software Foundation raise --funds for GNU development. -- -- --File: gfortran.info, Node: Top, Next: Introduction, Up: (dir) -- --Introduction --************ -- --This manual documents the use of `gfortran', the GNU Fortran compiler. --You can find in this manual how to invoke `gfortran', as well as its --features and incompatibilities. -- --* Menu: -- --* Introduction:: -- --Part I: Invoking GNU Fortran --* Invoking GNU Fortran:: Command options supported by `gfortran'. --* Runtime:: Influencing runtime behavior with environment variables. -- --Part II: Language Reference --* Fortran 2003 and 2008 status:: Fortran 2003 and 2008 features supported by GNU Fortran. --* Compiler Characteristics:: KIND type parameters supported. --* Extensions:: Language extensions implemented by GNU Fortran. --* Intrinsic Procedures:: Intrinsic procedures supported by GNU Fortran. --* Intrinsic Modules:: Intrinsic modules supported by GNU Fortran. -- --* Contributing:: How you can help. --* Copying:: GNU General Public License says -- how you can copy and share GNU Fortran. --* GNU Free Documentation License:: -- How you can copy and share this manual. --* Funding:: How to help assure continued work for free software. --* Option Index:: Index of command line options --* Keyword Index:: Index of concepts -- -- --File: gfortran.info, Node: Introduction, Next: Invoking GNU Fortran, Prev: Top, Up: Top -- --1 Introduction --************** -- --The GNU Fortran compiler front end was designed initially as a free --replacement for, or alternative to, the unix `f95' command; `gfortran' --is the command you'll use to invoke the compiler. -- --* Menu: -- --* About GNU Fortran:: What you should know about the GNU Fortran compiler. --* GNU Fortran and GCC:: You can compile Fortran, C, or other programs. --* Preprocessing and conditional compilation:: The Fortran preprocessor --* GNU Fortran and G77:: Why we chose to start from scratch. --* Project Status:: Status of GNU Fortran, roadmap, proposed extensions. --* Standards:: Standards supported by GNU Fortran. -- -- --File: gfortran.info, Node: About GNU Fortran, Next: GNU Fortran and GCC, Up: Introduction -- --1.1 About GNU Fortran --===================== -- --The GNU Fortran compiler is still in an early state of development. It --can generate code for most constructs and expressions, but much work --remains to be done. -- -- When the GNU Fortran compiler is finished, it will do everything you --expect from any decent compiler: -- -- * Read a user's program, stored in a file and containing -- instructions written in Fortran 77, Fortran 90, Fortran 95, -- Fortran 2003 or Fortran 2008. This file contains "source code". -- -- * Translate the user's program into instructions a computer can -- carry out more quickly than it takes to translate the instructions -- in the first place. The result after compilation of a program is -- "machine code", code designed to be efficiently translated and -- processed by a machine such as your computer. Humans usually -- aren't as good writing machine code as they are at writing Fortran -- (or C++, Ada, or Java), because it is easy to make tiny mistakes -- writing machine code. -- -- * Provide the user with information about the reasons why the -- compiler is unable to create a binary from the source code. -- Usually this will be the case if the source code is flawed. The -- Fortran 90 standard requires that the compiler can point out -- mistakes to the user. An incorrect usage of the language causes -- an "error message". -- -- The compiler will also attempt to diagnose cases where the user's -- program contains a correct usage of the language, but instructs -- the computer to do something questionable. This kind of -- diagnostics message is called a "warning message". -- -- * Provide optional information about the translation passes from the -- source code to machine code. This can help a user of the compiler -- to find the cause of certain bugs which may not be obvious in the -- source code, but may be more easily found at a lower level -- compiler output. It also helps developers to find bugs in the -- compiler itself. -- -- * Provide information in the generated machine code that can make it -- easier to find bugs in the program (using a debugging tool, called -- a "debugger", such as the GNU Debugger `gdb'). -- -- * Locate and gather machine code already generated to perform -- actions requested by statements in the user's program. This -- machine code is organized into "modules" and is located and -- "linked" to the user program. -- -- The GNU Fortran compiler consists of several components: -- -- * A version of the `gcc' command (which also might be installed as -- the system's `cc' command) that also understands and accepts -- Fortran source code. The `gcc' command is the "driver" program for -- all the languages in the GNU Compiler Collection (GCC); With `gcc', -- you can compile the source code of any language for which a front -- end is available in GCC. -- -- * The `gfortran' command itself, which also might be installed as the -- system's `f95' command. `gfortran' is just another driver program, -- but specifically for the Fortran compiler only. The difference -- with `gcc' is that `gfortran' will automatically link the correct -- libraries to your program. -- -- * A collection of run-time libraries. These libraries contain the -- machine code needed to support capabilities of the Fortran -- language that are not directly provided by the machine code -- generated by the `gfortran' compilation phase, such as intrinsic -- functions and subroutines, and routines for interaction with files -- and the operating system. -- -- * The Fortran compiler itself, (`f951'). This is the GNU Fortran -- parser and code generator, linked to and interfaced with the GCC -- backend library. `f951' "translates" the source code to assembler -- code. You would typically not use this program directly; instead, -- the `gcc' or `gfortran' driver programs will call it for you. -- -- --File: gfortran.info, Node: GNU Fortran and GCC, Next: Preprocessing and conditional compilation, Prev: About GNU Fortran, Up: Introduction -- --1.2 GNU Fortran and GCC --======================= -- --GNU Fortran is a part of GCC, the "GNU Compiler Collection". GCC --consists of a collection of front ends for various languages, which --translate the source code into a language-independent form called --"GENERIC". This is then processed by a common middle end which --provides optimization, and then passed to one of a collection of back --ends which generate code for different computer architectures and --operating systems. -- -- Functionally, this is implemented with a driver program (`gcc') --which provides the command-line interface for the compiler. It calls --the relevant compiler front-end program (e.g., `f951' for Fortran) for --each file in the source code, and then calls the assembler and linker --as appropriate to produce the compiled output. In a copy of GCC which --has been compiled with Fortran language support enabled, `gcc' will --recognize files with `.f', `.for', `.ftn', `.f90', `.f95', `.f03' and --`.f08' extensions as Fortran source code, and compile it accordingly. A --`gfortran' driver program is also provided, which is identical to `gcc' --except that it automatically links the Fortran runtime libraries into --the compiled program. -- -- Source files with `.f', `.for', `.fpp', `.ftn', `.F', `.FOR', --`.FPP', and `.FTN' extensions are treated as fixed form. Source files --with `.f90', `.f95', `.f03', `.f08', `.F90', `.F95', `.F03' and `.F08' --extensions are treated as free form. The capitalized versions of --either form are run through preprocessing. Source files with the lower --case `.fpp' extension are also run through preprocessing. -- -- This manual specifically documents the Fortran front end, which --handles the programming language's syntax and semantics. The aspects --of GCC which relate to the optimization passes and the back-end code --generation are documented in the GCC manual; see *note Introduction: --(gcc)Top. The two manuals together provide a complete reference for --the GNU Fortran compiler. -- -- --File: gfortran.info, Node: Preprocessing and conditional compilation, Next: GNU Fortran and G77, Prev: GNU Fortran and GCC, Up: Introduction -- --1.3 Preprocessing and conditional compilation --============================================= -- --Many Fortran compilers including GNU Fortran allow passing the source --code through a C preprocessor (CPP; sometimes also called the Fortran --preprocessor, FPP) to allow for conditional compilation. In the case of --GNU Fortran, this is the GNU C Preprocessor in the traditional mode. On --systems with case-preserving file names, the preprocessor is --automatically invoked if the filename extension is `.F', `.FOR', --`.FTN', `.fpp', `.FPP', `.F90', `.F95', `.F03' or `.F08'. To manually --invoke the preprocessor on any file, use `-cpp', to disable --preprocessing on files where the preprocessor is run automatically, use --`-nocpp'. -- -- If a preprocessed file includes another file with the Fortran --`INCLUDE' statement, the included file is not preprocessed. To --preprocess included files, use the equivalent preprocessor statement --`#include'. -- -- If GNU Fortran invokes the preprocessor, `__GFORTRAN__' is defined --and `__GNUC__', `__GNUC_MINOR__' and `__GNUC_PATCHLEVEL__' can be used --to determine the version of the compiler. See *note Overview: (cpp)Top. --for details. -- -- While CPP is the de-facto standard for preprocessing Fortran code, --Part 3 of the Fortran 95 standard (ISO/IEC 1539-3:1998) defines --Conditional Compilation, which is not widely used and not directly --supported by the GNU Fortran compiler. You can use the program coco to --preprocess such files (`http://users.erols.com/dnagle/coco.html'). -- -- --File: gfortran.info, Node: GNU Fortran and G77, Next: Project Status, Prev: Preprocessing and conditional compilation, Up: Introduction -- --1.4 GNU Fortran and G77 --======================= -- --The GNU Fortran compiler is the successor to `g77', the Fortran 77 --front end included in GCC prior to version 4. It is an entirely new --program that has been designed to provide Fortran 95 support and --extensibility for future Fortran language standards, as well as --providing backwards compatibility for Fortran 77 and nearly all of the --GNU language extensions supported by `g77'. -- -- --File: gfortran.info, Node: Project Status, Next: Standards, Prev: GNU Fortran and G77, Up: Introduction -- --1.5 Project Status --================== -- -- As soon as `gfortran' can parse all of the statements correctly, -- it will be in the "larva" state. When we generate code, the -- "puppa" state. When `gfortran' is done, we'll see if it will be a -- beautiful butterfly, or just a big bug.... -- -- -Andy Vaught, April 2000 -- -- The start of the GNU Fortran 95 project was announced on the GCC --homepage in March 18, 2000 (even though Andy had already been working --on it for a while, of course). -- -- The GNU Fortran compiler is able to compile nearly all --standard-compliant Fortran 95, Fortran 90, and Fortran 77 programs, --including a number of standard and non-standard extensions, and can be --used on real-world programs. In particular, the supported extensions --include OpenMP, Cray-style pointers, and several Fortran 2003 and --Fortran 2008 features such as enumeration, stream I/O, and some of the --enhancements to allocatable array support from TR 15581. However, it is --still under development and has a few remaining rough edges. -- -- At present, the GNU Fortran compiler passes the NIST Fortran 77 Test --Suite (http://www.fortran-2000.com/ArnaudRecipes/fcvs21_f95.html), and --produces acceptable results on the LAPACK Test Suite --(http://www.netlib.org/lapack/faq.html#1.21). It also provides --respectable performance on the Polyhedron Fortran compiler benchmarks --(http://www.polyhedron.com/pb05.html) and the Livermore Fortran Kernels --test --(http://www.llnl.gov/asci_benchmarks/asci/limited/lfk/README.html). It --has been used to compile a number of large real-world programs, --including the HIRLAM weather-forecasting code --(http://mysite.verizon.net/serveall/moene.pdf) and the Tonto quantum --chemistry package (http://www.theochem.uwa.edu.au/tonto/); see --`http://gcc.gnu.org/wiki/GfortranApps' for an extended list. -- -- Among other things, the GNU Fortran compiler is intended as a --replacement for G77. At this point, nearly all programs that could be --compiled with G77 can be compiled with GNU Fortran, although there are --a few minor known regressions. -- -- The primary work remaining to be done on GNU Fortran falls into three --categories: bug fixing (primarily regarding the treatment of invalid --code and providing useful error messages), improving the compiler --optimizations and the performance of compiled code, and extending the --compiler to support future standards--in particular, Fortran 2003. -- -- --File: gfortran.info, Node: Standards, Prev: Project Status, Up: Introduction -- --1.6 Standards --============= -- --The GNU Fortran compiler implements ISO/IEC 1539:1997 (Fortran 95). As --such, it can also compile essentially all standard-compliant Fortran 90 --and Fortran 77 programs. It also supports the ISO/IEC TR-15581 --enhancements to allocatable arrays, and the OpenMP Application Program --Interface v2.5 (http://www.openmp.org/drupal/mp-documents/spec25.pdf) --specification. -- -- In the future, the GNU Fortran compiler will also support ISO/IEC --1539-1:2004 (Fortran 2003) and future Fortran standards. Partial support --of that standard is already provided; the current status of Fortran 2003 --support is reported in the *note Fortran 2003 status:: section of the --documentation. -- -- The next version of the Fortran standard after Fortran 2003 is --currently being developed and the GNU Fortran compiler supports some of --its new features. This support is based on the latest draft of the --standard (available from `http://www.nag.co.uk/sc22wg5/') and no --guarantee of future compatibility is made, as the final standard might --differ from the draft. For more information, see the *note Fortran 2008 --status:: section. -- -- --File: gfortran.info, Node: Invoking GNU Fortran, Next: Runtime, Prev: Introduction, Up: Top -- --2 GNU Fortran Command Options --***************************** -- --The `gfortran' command supports all the options supported by the `gcc' --command. Only options specific to GNU Fortran are documented here. -- -- *Note GCC Command Options: (gcc)Invoking GCC, for information on the --non-Fortran-specific aspects of the `gcc' command (and, therefore, the --`gfortran' command). -- -- All GCC and GNU Fortran options are accepted both by `gfortran' and --by `gcc' (as well as any other drivers built at the same time, such as --`g++'), since adding GNU Fortran to the GCC distribution enables --acceptance of GNU Fortran options by all of the relevant drivers. -- -- In some cases, options have positive and negative forms; the --negative form of `-ffoo' would be `-fno-foo'. This manual documents --only one of these two forms, whichever one is not the default. -- --* Menu: -- --* Option Summary:: Brief list of all `gfortran' options, -- without explanations. --* Fortran Dialect Options:: Controlling the variant of Fortran language -- compiled. --* Preprocessing Options:: Enable and customize preprocessing. --* Error and Warning Options:: How picky should the compiler be? --* Debugging Options:: Symbol tables, measurements, and debugging dumps. --* Directory Options:: Where to find module files --* Link Options :: Influencing the linking step --* Runtime Options:: Influencing runtime behavior --* Code Gen Options:: Specifying conventions for function calls, data layout -- and register usage. --* Environment Variables:: Environment variables that affect `gfortran'. -- -- --File: gfortran.info, Node: Option Summary, Next: Fortran Dialect Options, Up: Invoking GNU Fortran -- --2.1 Option summary --================== -- --Here is a summary of all the options specific to GNU Fortran, grouped --by type. Explanations are in the following sections. -- --_Fortran Language Options_ -- *Note Options controlling Fortran dialect: Fortran Dialect Options. -- -fall-intrinsics -ffree-form -fno-fixed-form -- -fdollar-ok -fimplicit-none -fmax-identifier-length -- -std=STD -fd-lines-as-code -fd-lines-as-comments -- -ffixed-line-length-N -ffixed-line-length-none -- -ffree-line-length-N -ffree-line-length-none -- -fdefault-double-8 -fdefault-integer-8 -fdefault-real-8 -- -fcray-pointer -fopenmp -fno-range-check -fbackslash -fmodule-private -- --_Preprocessing Options_ -- *Note Enable and customize preprocessing: Preprocessing Options. -- -cpp -dD -dI -dM -dN -dU -fworking-directory -- -imultilib DIR -iprefix FILE -isysroot DIR -- -iquote -isystem DIR -nocpp -nostdinc -undef -- -AQUESTION=ANSWER -A-QUESTION[=ANSWER] -- -C -CC -DMACRO[=DEFN] -UMACRO -H -P -- --_Error and Warning Options_ -- *Note Options to request or suppress errors and warnings: Error -- and Warning Options. -- -fmax-errors=N -- -fsyntax-only -pedantic -pedantic-errors -- -Wall -Waliasing -Wampersand -Warray-bounds -Wcharacter-truncation -- -Wconversion -Wimplicit-interface -Wline-truncation -Wintrinsics-std -- -Wsurprising -Wno-tabs -Wunderflow -Wunused-parameter -Wintrinsics-shadow -- -Wno-align-commons -- --_Debugging Options_ -- *Note Options for debugging your program or GNU Fortran: Debugging -- Options. -- -fdump-parse-tree -ffpe-trap=LIST -- -fdump-core -fbacktrace -- --_Directory Options_ -- *Note Options for directory search: Directory Options. -- -IDIR -JDIR -MDIR -- -fintrinsic-modules-path DIR -- --_Link Options_ -- *Note Options for influencing the linking step: Link Options. -- -static-libgfortran -- --_Runtime Options_ -- *Note Options for influencing runtime behavior: Runtime Options. -- -fconvert=CONVERSION -fno-range-check -- -frecord-marker=LENGTH -fmax-subrecord-length=LENGTH -- -fsign-zero -- --_Code Generation Options_ -- *Note Options for code generation conventions: Code Gen Options. -- -fno-automatic -ff2c -fno-underscoring -- -fsecond-underscore -- -fbounds-check -fcheck-array-temporaries -fmax-array-constructor =N -- -fmax-stack-var-size=N -- -fpack-derived -frepack-arrays -fshort-enums -fexternal-blas -- -fblas-matmul-limit=N -frecursive -finit-local-zero -- -finit-integer=N -finit-real=<ZERO|INF|-INF|NAN> -- -finit-logical=<TRUE|FALSE> -finit-character=N -fno-align-commons -- -- --* Menu: -- --* Fortran Dialect Options:: Controlling the variant of Fortran language -- compiled. --* Preprocessing Options:: Enable and customize preprocessing. --* Error and Warning Options:: How picky should the compiler be? --* Debugging Options:: Symbol tables, measurements, and debugging dumps. --* Directory Options:: Where to find module files --* Link Options :: Influencing the linking step --* Runtime Options:: Influencing runtime behavior --* Code Gen Options:: Specifying conventions for function calls, data layout -- and register usage. -- -- --File: gfortran.info, Node: Fortran Dialect Options, Next: Preprocessing Options, Prev: Option Summary, Up: Invoking GNU Fortran -- --2.2 Options controlling Fortran dialect --======================================= -- --The following options control the details of the Fortran dialect --accepted by the compiler: -- --`-ffree-form' -- --`-ffixed-form' -- Specify the layout used by the source file. The free form layout -- was introduced in Fortran 90. Fixed form was traditionally used in -- older Fortran programs. When neither option is specified, the -- source form is determined by the file extension. -- --`-fall-intrinsics' -- This option causes all intrinsic procedures (including the -- GNU-specific extensions) to be accepted. This can be useful with -- `-std=f95' to force standard-compliance but get access to the full -- range of intrinsics available with `gfortran'. As a consequence, -- `-Wintrinsics-std' will be ignored and no user-defined procedure -- with the same name as any intrinsic will be called except when it -- is explicitly declared `EXTERNAL'. -- --`-fd-lines-as-code' -- --`-fd-lines-as-comments' -- Enable special treatment for lines beginning with `d' or `D' in -- fixed form sources. If the `-fd-lines-as-code' option is given -- they are treated as if the first column contained a blank. If the -- `-fd-lines-as-comments' option is given, they are treated as -- comment lines. -- --`-fdefault-double-8' -- Set the `DOUBLE PRECISION' type to an 8 byte wide type. If -- `-fdefault-real-8' is given, `DOUBLE PRECISION' would instead be -- promoted to 16 bytes if possible, and `-fdefault-double-8' can be -- used to prevent this. The kind of real constants like `1.d0' will -- not be changed by `-fdefault-real-8' though, so also -- `-fdefault-double-8' does not affect it. -- --`-fdefault-integer-8' -- Set the default integer and logical types to an 8 byte wide type. -- Do nothing if this is already the default. This option also -- affects the kind of integer constants like `42'. -- --`-fdefault-real-8' -- Set the default real type to an 8 byte wide type. Do nothing if -- this is already the default. This option also affects the kind of -- non-double real constants like `1.0', and does promote the default -- width of `DOUBLE PRECISION' to 16 bytes if possible, unless -- `-fdefault-double-8' is given, too. -- --`-fdollar-ok' -- Allow `$' as a valid character in a symbol name. -- --`-fbackslash' -- Change the interpretation of backslashes in string literals from a -- single backslash character to "C-style" escape characters. The -- following combinations are expanded `\a', `\b', `\f', `\n', `\r', -- `\t', `\v', `\\', and `\0' to the ASCII characters alert, -- backspace, form feed, newline, carriage return, horizontal tab, -- vertical tab, backslash, and NUL, respectively. Additionally, -- `\x'NN, `\u'NNNN and `\U'NNNNNNNN (where each N is a hexadecimal -- digit) are translated into the Unicode characters corresponding to -- the specified code points. All other combinations of a character -- preceded by \ are unexpanded. -- --`-fmodule-private' -- Set the default accessibility of module entities to `PRIVATE'. -- Use-associated entities will not be accessible unless they are -- explicitly declared as `PUBLIC'. -- --`-ffixed-line-length-N' -- Set column after which characters are ignored in typical fixed-form -- lines in the source file, and through which spaces are assumed (as -- if padded to that length) after the ends of short fixed-form lines. -- -- Popular values for N include 72 (the standard and the default), 80 -- (card image), and 132 (corresponding to "extended-source" options -- in some popular compilers). N may also be `none', meaning that -- the entire line is meaningful and that continued character -- constants never have implicit spaces appended to them to fill out -- the line. `-ffixed-line-length-0' means the same thing as -- `-ffixed-line-length-none'. -- --`-ffree-line-length-N' -- Set column after which characters are ignored in typical free-form -- lines in the source file. The default value is 132. N may be -- `none', meaning that the entire line is meaningful. -- `-ffree-line-length-0' means the same thing as -- `-ffree-line-length-none'. -- --`-fmax-identifier-length=N' -- Specify the maximum allowed identifier length. Typical values are -- 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008). -- --`-fimplicit-none' -- Specify that no implicit typing is allowed, unless overridden by -- explicit `IMPLICIT' statements. This is the equivalent of adding -- `implicit none' to the start of every procedure. -- --`-fcray-pointer' -- Enable the Cray pointer extension, which provides C-like pointer -- functionality. -- --`-fopenmp' -- Enable the OpenMP extensions. This includes OpenMP `!$omp' -- directives in free form and `c$omp', `*$omp' and `!$omp' -- directives in fixed form, `!$' conditional compilation sentinels -- in free form and `c$', `*$' and `!$' sentinels in fixed form, and -- when linking arranges for the OpenMP runtime library to be linked -- in. The option `-fopenmp' implies `-frecursive'. -- --`-fno-range-check' -- Disable range checking on results of simplification of constant -- expressions during compilation. For example, GNU Fortran will give -- an error at compile time when simplifying `a = 1. / 0'. With this -- option, no error will be given and `a' will be assigned the value -- `+Infinity'. If an expression evaluates to a value outside of the -- relevant range of [`-HUGE()':`HUGE()'], then the expression will -- be replaced by `-Inf' or `+Inf' as appropriate. Similarly, `DATA -- i/Z'FFFFFFFF'/' will result in an integer overflow on most -- systems, but with `-fno-range-check' the value will "wrap around" -- and `i' will be initialized to -1 instead. -- --`-std=STD' -- Specify the standard to which the program is expected to conform, -- which may be one of `f95', `f2003', `f2008', `gnu', or `legacy'. -- The default value for STD is `gnu', which specifies a superset of -- the Fortran 95 standard that includes all of the extensions -- supported by GNU Fortran, although warnings will be given for -- obsolete extensions not recommended for use in new code. The -- `legacy' value is equivalent but without the warnings for obsolete -- extensions, and may be useful for old non-standard programs. The -- `f95', `f2003' and `f2008' values specify strict conformance to -- the Fortran 95, Fortran 2003 and Fortran 2008 standards, -- respectively; errors are given for all extensions beyond the -- relevant language standard, and warnings are given for the Fortran -- 77 features that are permitted but obsolescent in later standards. -- -- -- --File: gfortran.info, Node: Preprocessing Options, Next: Error and Warning Options, Prev: Fortran Dialect Options, Up: Invoking GNU Fortran -- --2.3 Enable and customize preprocessing --====================================== -- --Preprocessor related options. See section *note Preprocessing and --conditional compilation:: for more detailed information on --preprocessing in `gfortran'. -- --`-cpp' -- --`-nocpp' -- Enable preprocessing. The preprocessor is automatically invoked if -- the file extension is `.fpp', `.FPP', `.F', `.FOR', `.FTN', -- `.F90', `.F95', `.F03' or `.F08'. Use this option to manually -- enable preprocessing of any kind of Fortran file. -- -- To disable preprocessing of files with any of the above listed -- extensions, use the negative form: `-nocpp'. -- -- The preprocessor is run in traditional mode, be aware that any -- restrictions of the file-format, e.g. fixed-form line width, apply -- for preprocessed output as well. -- --`-dM' -- Instead of the normal output, generate a list of `'#define'' -- directives for all the macros defined during the execution of the -- preprocessor, including predefined macros. This gives you a way of -- finding out what is predefined in your version of the preprocessor. -- Assuming you have no file `foo.f90', the command -- touch foo.f90; gfortran -cpp -dM foo.f90 -- will show all the predefined macros. -- --`-dD' -- Like `-dM' except in two respects: it does not include the -- predefined macros, and it outputs both the `#define' directives -- and the result of preprocessing. Both kinds of output go to the -- standard output file. -- --`-dN' -- Like `-dD', but emit only the macro names, not their expansions. -- --`-dU' -- Like `dD' except that only macros that are expanded, or whose -- definedness is tested in preprocessor directives, are output; the -- output is delayed until the use or test of the macro; and -- `'#undef'' directives are also output for macros tested but -- undefined at the time. -- --`-dI' -- Output `'#include'' directives in addition to the result of -- preprocessing. -- --`-fworking-directory' -- Enable generation of linemarkers in the preprocessor output that -- will let the compiler know the current working directory at the -- time of preprocessing. When this option is enabled, the -- preprocessor will emit, after the initial linemarker, a second -- linemarker with the current working directory followed by two -- slashes. GCC will use this directory, when it's present in the -- preprocessed input, as the directory emitted as the current -- working directory in some debugging information formats. This -- option is implicitly enabled if debugging information is enabled, -- but this can be inhibited with the negated form -- `-fno-working-directory'. If the `-P' flag is present in the -- command line, this option has no effect, since no `#line' -- directives are emitted whatsoever. -- --`-idirafter DIR' -- Search DIR for include files, but do it after all directories -- specified with `-I' and the standard system directories have been -- exhausted. DIR is treated as a system include directory. If dir -- begins with `=', then the `=' will be replaced by the sysroot -- prefix; see `--sysroot' and `-isysroot'. -- --`-imultilib DIR' -- Use DIR as a subdirectory of the directory containing -- target-specific C++ headers. -- --`-iprefix PREFIX' -- Specify PREFIX as the prefix for subsequent `-iwithprefix' -- options. If the PREFIX represents a directory, you should include -- the final `'/''. -- --`-isysroot DIR' -- This option is like the `--sysroot' option, but applies only to -- header files. See the `--sysroot' option for more information. -- --`-iquote DIR' -- Search DIR only for header files requested with `#include "file"'; -- they are not searched for `#include <file>', before all directories -- specified by `-I' and before the standard system directories. If -- DIR begins with `=', then the `=' will be replaced by the sysroot -- prefix; see `--sysroot' and `-isysroot'. -- --`-isystem DIR' -- Search DIR for header files, after all directories specified by -- `-I' but before the standard system directories. Mark it as a -- system directory, so that it gets the same special treatment as is -- applied to the standard system directories. If DIR begins with -- `=', then the `=' will be replaced by the sysroot prefix; see -- `--sysroot' and `-isysroot'. -- --`-nostdinc' -- Do not search the standard system directories for header files. -- Only the directories you have specified with `-I' options (and the -- directory of the current file, if appropriate) are searched. -- --`-undef' -- Do not predefine any system-specific or GCC-specific macros. The -- standard predefined macros remain defined. -- --`-APREDICATE=ANSWER' -- Make an assertion with the predicate PREDICATE and answer ANSWER. -- This form is preferred to the older form -A predicate(answer), -- which is still supported, because it does not use shell special -- characters. -- --`-A-PREDICATE=ANSWER' -- Cancel an assertion with the predicate PREDICATE and answer ANSWER. -- --`-C' -- Do not discard comments. All comments are passed through to the -- output file, except for comments in processed directives, which -- are deleted along with the directive. -- -- You should be prepared for side effects when using `-C'; it causes -- the preprocessor to treat comments as tokens in their own right. -- For example, comments appearing at the start of what would be a -- directive line have the effect of turning that line into an -- ordinary source line, since the first token on the line is no -- longer a `'#''. -- -- Warning: this currently handles C-Style comments only. The -- preprocessor does not yet recognize Fortran-style comments. -- --`-CC' -- Do not discard comments, including during macro expansion. This is -- like `-C', except that comments contained within macros are also -- passed through to the output file where the macro is expanded. -- -- In addition to the side-effects of the `-C' option, the `-CC' -- option causes all C++-style comments inside a macro to be -- converted to C-style comments. This is to prevent later use of -- that macro from inadvertently commenting out the remainder of the -- source line. The `-CC' option is generally used to support lint -- comments. -- -- Warning: this currently handles C- and C++-Style comments only. The -- preprocessor does not yet recognize Fortran-style comments. -- --`-DNAME' -- Predefine name as a macro, with definition `1'. -- --`-DNAME=DEFINITION' -- The contents of DEFINITION are tokenized and processed as if they -- appeared during translation phase three in a `'#define'' directive. -- In particular, the definition will be truncated by embedded newline -- characters. -- -- If you are invoking the preprocessor from a shell or shell-like -- program you may need to use the shell's quoting syntax to protect -- characters such as spaces that have a meaning in the shell syntax. -- -- If you wish to define a function-like macro on the command line, -- write its argument list with surrounding parentheses before the -- equals sign (if any). Parentheses are meaningful to most shells, -- so you will need to quote the option. With sh and csh, -- `-D'name(args...)=definition'' works. -- -- `-D' and `-U' options are processed in the order they are given on -- the command line. All -imacros file and -include file options are -- processed after all -D and -U options. -- --`-H' -- Print the name of each header file used, in addition to other -- normal activities. Each name is indented to show how deep in the -- `'#include'' stack it is. -- --`-P' -- Inhibit generation of linemarkers in the output from the -- preprocessor. This might be useful when running the preprocessor -- on something that is not C code, and will be sent to a program -- which might be confused by the linemarkers. -- --`-UNAME' -- Cancel any previous definition of NAME, either built in or provided -- with a `-D' option. -- -- --File: gfortran.info, Node: Error and Warning Options, Next: Debugging Options, Prev: Preprocessing Options, Up: Invoking GNU Fortran -- --2.4 Options to request or suppress errors and warnings --====================================================== -- --Errors are diagnostic messages that report that the GNU Fortran compiler --cannot compile the relevant piece of source code. The compiler will --continue to process the program in an attempt to report further errors --to aid in debugging, but will not produce any compiled output. -- -- Warnings are diagnostic messages that report constructions which are --not inherently erroneous but which are risky or suggest there is likely --to be a bug in the program. Unless `-Werror' is specified, they do not --prevent compilation of the program. -- -- You can request many specific warnings with options beginning `-W', --for example `-Wimplicit' to request warnings on implicit declarations. --Each of these specific warning options also has a negative form --beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'. --This manual lists only one of the two forms, whichever is not the --default. -- -- These options control the amount and kinds of errors and warnings --produced by GNU Fortran: -- --`-fmax-errors=N' -- Limits the maximum number of error messages to N, at which point -- GNU Fortran bails out rather than attempting to continue -- processing the source code. If N is 0, there is no limit on the -- number of error messages produced. -- --`-fsyntax-only' -- Check the code for syntax errors, but don't actually compile it. -- This will generate module files for each module present in the -- code, but no other output file. -- --`-pedantic' -- Issue warnings for uses of extensions to Fortran 95. `-pedantic' -- also applies to C-language constructs where they occur in GNU -- Fortran source files, such as use of `\e' in a character constant -- within a directive like `#include'. -- -- Valid Fortran 95 programs should compile properly with or without -- this option. However, without this option, certain GNU extensions -- and traditional Fortran features are supported as well. With this -- option, many of them are rejected. -- -- Some users try to use `-pedantic' to check programs for -- conformance. They soon find that it does not do quite what they -- want--it finds some nonstandard practices, but not all. However, -- improvements to GNU Fortran in this area are welcome. -- -- This should be used in conjunction with `-std=f95', `-std=f2003' -- or `-std=f2008'. -- --`-pedantic-errors' -- Like `-pedantic', except that errors are produced rather than -- warnings. -- --`-Wall' -- Enables commonly used warning options pertaining to usage that we -- recommend avoiding and that we believe are easy to avoid. This -- currently includes `-Waliasing', `-Wampersand', `-Wsurprising', -- `-Wintrinsics-std', `-Wno-tabs', `-Wintrinsic-shadow' and -- `-Wline-truncation'. -- --`-Waliasing' -- Warn about possible aliasing of dummy arguments. Specifically, it -- warns if the same actual argument is associated with a dummy -- argument with `INTENT(IN)' and a dummy argument with `INTENT(OUT)' -- in a call with an explicit interface. -- -- The following example will trigger the warning. -- interface -- subroutine bar(a,b) -- integer, intent(in) :: a -- integer, intent(out) :: b -- end subroutine -- end interface -- integer :: a -- -- call bar(a,a) -- --`-Wampersand' -- Warn about missing ampersand in continued character constants. The -- warning is given with `-Wampersand', `-pedantic', `-std=f95', -- `-std=f2003' and `-std=f2008'. Note: With no ampersand given in a -- continued character constant, GNU Fortran assumes continuation at -- the first non-comment, non-whitespace character after the ampersand -- that initiated the continuation. -- --`-Warray-temporaries' -- Warn about array temporaries generated by the compiler. The -- information generated by this warning is sometimes useful in -- optimization, in order to avoid such temporaries. -- --`-Wcharacter-truncation' -- Warn when a character assignment will truncate the assigned string. -- --`-Wline-truncation' -- Warn when a source code line will be truncated. -- --`-Wconversion' -- Warn about implicit conversions between different types. -- --`-Wimplicit-interface' -- Warn if a procedure is called without an explicit interface. Note -- this only checks that an explicit interface is present. It does -- not check that the declared interfaces are consistent across -- program units. -- --`-Wintrinsics-std' -- Warn if `gfortran' finds a procedure named like an intrinsic not -- available in the currently selected standard (with `-std') and -- treats it as `EXTERNAL' procedure because of this. -- `-fall-intrinsics' can be used to never trigger this behaviour and -- always link to the intrinsic regardless of the selected standard. -- --`-Wsurprising' -- Produce a warning when "suspicious" code constructs are -- encountered. While technically legal these usually indicate that -- an error has been made. -- -- This currently produces a warning under the following -- circumstances: -- -- * An INTEGER SELECT construct has a CASE that can never be -- matched as its lower value is greater than its upper value. -- -- * A LOGICAL SELECT construct has three CASE statements. -- -- * A TRANSFER specifies a source that is shorter than the -- destination. -- -- * The type of a function result is declared more than once with -- the same type. If `-pedantic' or standard-conforming mode is -- enabled, this is an error. -- --`-Wtabs' -- By default, tabs are accepted as whitespace, but tabs are not -- members of the Fortran Character Set. For continuation lines, a -- tab followed by a digit between 1 and 9 is supported. `-Wno-tabs' -- will cause a warning to be issued if a tab is encountered. Note, -- `-Wno-tabs' is active for `-pedantic', `-std=f95', `-std=f2003', -- `-std=f2008' and `-Wall'. -- --`-Wunderflow' -- Produce a warning when numerical constant expressions are -- encountered, which yield an UNDERFLOW during compilation. -- --`-Wintrinsic-shadow' -- Warn if a user-defined procedure or module procedure has the same -- name as an intrinsic; in this case, an explicit interface or -- `EXTERNAL' or `INTRINSIC' declaration might be needed to get calls -- later resolved to the desired intrinsic/procedure. -- --`-Wunused-parameter' -- Contrary to `gcc''s meaning of `-Wunused-parameter', `gfortran''s -- implementation of this option does not warn about unused dummy -- arguments, but about unused `PARAMETER' values. -- `-Wunused-parameter' is not included in `-Wall' but is implied by -- `-Wall -Wextra'. -- --`-Walign-commons' -- By default, `gfortran' warns about any occasion of variables being -- padded for proper alignment inside a COMMON block. This warning -- can be turned off via `-Wno-align-commons'. See also -- `-falign-commons'. -- --`-Werror' -- Turns all warnings into errors. -- -- *Note Options to Request or Suppress Errors and Warnings: (gcc)Error --and Warning Options, for information on more options offered by the GBE --shared by `gfortran', `gcc' and other GNU compilers. -- -- Some of these have no effect when compiling programs written in --Fortran. -- -- --File: gfortran.info, Node: Debugging Options, Next: Directory Options, Prev: Error and Warning Options, Up: Invoking GNU Fortran -- --2.5 Options for debugging your program or GNU Fortran --===================================================== -- --GNU Fortran has various special options that are used for debugging --either your program or the GNU Fortran compiler. -- --`-fdump-parse-tree' -- Output the internal parse tree before starting code generation. -- Only really useful for debugging the GNU Fortran compiler itself. -- --`-ffpe-trap=LIST' -- Specify a list of IEEE exceptions when a Floating Point Exception -- (FPE) should be raised. On most systems, this will result in a -- SIGFPE signal being sent and the program being interrupted, -- producing a core file useful for debugging. LIST is a (possibly -- empty) comma-separated list of the following IEEE exceptions: -- `invalid' (invalid floating point operation, such as -- `SQRT(-1.0)'), `zero' (division by zero), `overflow' (overflow in -- a floating point operation), `underflow' (underflow in a floating -- point operation), `precision' (loss of precision during operation) -- and `denormal' (operation produced a denormal value). -- -- Some of the routines in the Fortran runtime library, like -- `CPU_TIME', are likely to trigger floating point exceptions when -- `ffpe-trap=precision' is used. For this reason, the use of -- `ffpe-trap=precision' is not recommended. -- --`-fbacktrace' -- Specify that, when a runtime error is encountered or a deadly -- signal is emitted (segmentation fault, illegal instruction, bus -- error or floating-point exception), the Fortran runtime library -- should output a backtrace of the error. This option only has -- influence for compilation of the Fortran main program. -- --`-fdump-core' -- Request that a core-dump file is written to disk when a runtime -- error is encountered on systems that support core dumps. This -- option is only effective for the compilation of the Fortran main -- program. -- -- *Note Options for Debugging Your Program or GCC: (gcc)Debugging --Options, for more information on debugging options. -- -- --File: gfortran.info, Node: Directory Options, Next: Link Options, Prev: Debugging Options, Up: Invoking GNU Fortran -- --2.6 Options for directory search --================================ -- --These options affect how GNU Fortran searches for files specified by --the `INCLUDE' directive and where it searches for previously compiled --modules. -- -- It also affects the search paths used by `cpp' when used to --preprocess Fortran source. -- --`-IDIR' -- These affect interpretation of the `INCLUDE' directive (as well as -- of the `#include' directive of the `cpp' preprocessor). -- -- Also note that the general behavior of `-I' and `INCLUDE' is -- pretty much the same as of `-I' with `#include' in the `cpp' -- preprocessor, with regard to looking for `header.gcc' files and -- other such things. -- -- This path is also used to search for `.mod' files when previously -- compiled modules are required by a `USE' statement. -- -- *Note Options for Directory Search: (gcc)Directory Options, for -- information on the `-I' option. -- --`-JDIR' -- --`-MDIR' -- This option specifies where to put `.mod' files for compiled -- modules. It is also added to the list of directories to searched -- by an `USE' statement. -- -- The default is the current directory. -- -- `-M' is deprecated to avoid conflicts with existing GCC options. -- --`-fintrinsic-modules-path DIR' -- This option specifies the location of pre-compiled intrinsic -- modules, if they are not in the default location expected by the -- compiler. -- -- --File: gfortran.info, Node: Link Options, Next: Runtime Options, Prev: Directory Options, Up: Invoking GNU Fortran -- --2.7 Influencing the linking step --================================ -- --These options come into play when the compiler links object files into --an executable output file. They are meaningless if the compiler is not --doing a link step. -- --`-static-libgfortran' -- On systems that provide `libgfortran' as a shared and a static -- library, this option forces the use of the static version. If no -- shared version of `libgfortran' was built when the compiler was -- configured, this option has no effect. -- -- --File: gfortran.info, Node: Runtime Options, Next: Code Gen Options, Prev: Link Options, Up: Invoking GNU Fortran -- --2.8 Influencing runtime behavior --================================ -- --These options affect the runtime behavior of programs compiled with GNU --Fortran. --`-fconvert=CONVERSION' -- Specify the representation of data for unformatted files. Valid -- values for conversion are: `native', the default; `swap', swap -- between big- and little-endian; `big-endian', use big-endian -- representation for unformatted files; `little-endian', use -- little-endian representation for unformatted files. -- -- _This option has an effect only when used in the main program. -- The `CONVERT' specifier and the GFORTRAN_CONVERT_UNIT environment -- variable override the default specified by `-fconvert'._ -- --`-fno-range-check' -- Disable range checking of input values during integer `READ' -- operations. For example, GNU Fortran will give an error if an -- input value is outside of the relevant range of -- [`-HUGE()':`HUGE()']. In other words, with `INTEGER (kind=4) :: i' -- , attempting to read -2147483648 will give an error unless -- `-fno-range-check' is given. -- --`-frecord-marker=LENGTH' -- Specify the length of record markers for unformatted files. Valid -- values for LENGTH are 4 and 8. Default is 4. _This is different -- from previous versions of `gfortran'_, which specified a default -- record marker length of 8 on most systems. If you want to read or -- write files compatible with earlier versions of `gfortran', use -- `-frecord-marker=8'. -- --`-fmax-subrecord-length=LENGTH' -- Specify the maximum length for a subrecord. The maximum permitted -- value for length is 2147483639, which is also the default. Only -- really useful for use by the gfortran testsuite. -- --`-fsign-zero' -- When writing zero values, show the negative sign if the sign bit -- is set. `fno-sign-zero' does not print the negative sign of zero -- values for compatibility with F77. Default behavior is to show -- the negative sign. -- -- --File: gfortran.info, Node: Code Gen Options, Next: Environment Variables, Prev: Runtime Options, Up: Invoking GNU Fortran -- --2.9 Options for code generation conventions --=========================================== -- --These machine-independent options control the interface conventions --used in code generation. -- -- Most of them have both positive and negative forms; the negative form --of `-ffoo' would be `-fno-foo'. In the table below, only one of the --forms is listed--the one which is not the default. You can figure out --the other form by either removing `no-' or adding it. -- --`-fno-automatic' -- Treat each program unit (except those marked as RECURSIVE) as if -- the `SAVE' statement were specified for every local variable and -- array referenced in it. Does not affect common blocks. (Some -- Fortran compilers provide this option under the name `-static' or -- `-save'.) The default, which is `-fautomatic', uses the stack for -- local variables smaller than the value given by -- `-fmax-stack-var-size'. Use the option `-frecursive' to use no -- static memory. -- --`-ff2c' -- Generate code designed to be compatible with code generated by -- `g77' and `f2c'. -- -- The calling conventions used by `g77' (originally implemented in -- `f2c') require functions that return type default `REAL' to -- actually return the C type `double', and functions that return -- type `COMPLEX' to return the values via an extra argument in the -- calling sequence that points to where to store the return value. -- Under the default GNU calling conventions, such functions simply -- return their results as they would in GNU C--default `REAL' -- functions return the C type `float', and `COMPLEX' functions -- return the GNU C type `complex'. Additionally, this option -- implies the `-fsecond-underscore' option, unless -- `-fno-second-underscore' is explicitly requested. -- -- This does not affect the generation of code that interfaces with -- the `libgfortran' library. -- -- _Caution:_ It is not a good idea to mix Fortran code compiled with -- `-ff2c' with code compiled with the default `-fno-f2c' calling -- conventions as, calling `COMPLEX' or default `REAL' functions -- between program parts which were compiled with different calling -- conventions will break at execution time. -- -- _Caution:_ This will break code which passes intrinsic functions -- of type default `REAL' or `COMPLEX' as actual arguments, as the -- library implementations use the `-fno-f2c' calling conventions. -- --`-fno-underscoring' -- Do not transform names of entities specified in the Fortran source -- file by appending underscores to them. -- -- With `-funderscoring' in effect, GNU Fortran appends one -- underscore to external names with no underscores. This is done to -- ensure compatibility with code produced by many UNIX Fortran -- compilers. -- -- _Caution_: The default behavior of GNU Fortran is incompatible -- with `f2c' and `g77', please use the `-ff2c' option if you want -- object files compiled with GNU Fortran to be compatible with -- object code created with these tools. -- -- Use of `-fno-underscoring' is not recommended unless you are -- experimenting with issues such as integration of GNU Fortran into -- existing system environments (vis-a`-vis existing libraries, tools, -- and so on). -- -- For example, with `-funderscoring', and assuming other defaults -- like `-fcase-lower' and that `j()' and `max_count()' are external -- functions while `my_var' and `lvar' are local variables, a -- statement like -- I = J() + MAX_COUNT (MY_VAR, LVAR) -- is implemented as something akin to: -- i = j_() + max_count__(&my_var__, &lvar); -- -- With `-fno-underscoring', the same statement is implemented as: -- -- i = j() + max_count(&my_var, &lvar); -- -- Use of `-fno-underscoring' allows direct specification of -- user-defined names while debugging and when interfacing GNU Fortran -- code with other languages. -- -- Note that just because the names match does _not_ mean that the -- interface implemented by GNU Fortran for an external name matches -- the interface implemented by some other language for that same -- name. That is, getting code produced by GNU Fortran to link to -- code produced by some other compiler using this or any other -- method can be only a small part of the overall solution--getting -- the code generated by both compilers to agree on issues other than -- naming can require significant effort, and, unlike naming -- disagreements, linkers normally cannot detect disagreements in -- these other areas. -- -- Also, note that with `-fno-underscoring', the lack of appended -- underscores introduces the very real possibility that a -- user-defined external name will conflict with a name in a system -- library, which could make finding unresolved-reference bugs quite -- difficult in some cases--they might occur at program run time, and -- show up only as buggy behavior at run time. -- -- In future versions of GNU Fortran we hope to improve naming and -- linking issues so that debugging always involves using the names -- as they appear in the source, even if the names as seen by the -- linker are mangled to prevent accidental linking between -- procedures with incompatible interfaces. -- --`-fsecond-underscore' -- By default, GNU Fortran appends an underscore to external names. -- If this option is used GNU Fortran appends two underscores to -- names with underscores and one underscore to external names with -- no underscores. GNU Fortran also appends two underscores to -- internal names with underscores to avoid naming collisions with -- external names. -- -- This option has no effect if `-fno-underscoring' is in effect. It -- is implied by the `-ff2c' option. -- -- Otherwise, with this option, an external name such as `MAX_COUNT' -- is implemented as a reference to the link-time external symbol -- `max_count__', instead of `max_count_'. This is required for -- compatibility with `g77' and `f2c', and is implied by use of the -- `-ff2c' option. -- --`-fbounds-check' -- Enable generation of run-time checks for array subscripts and -- against the declared minimum and maximum values. It also checks -- array indices for assumed and deferred shape arrays against the -- actual allocated bounds and ensures that all string lengths are -- equal for character array constructors without an explicit -- typespec. -- -- Some checks require that `-fbounds-check' is set for the -- compilation of the main program. -- -- Note: In the future this may also include other forms of checking, -- e.g., checking substring references. -- --`fcheck-array-temporaries' -- Warns at run time when for passing an actual argument a temporary -- array had to be generated. The information generated by this -- warning is sometimes useful in optimization, in order to avoid -- such temporaries. -- -- Note: The warning is only printed once per location. -- --`-fmax-array-constructor=N' -- This option can be used to increase the upper limit permitted in -- array constructors. The code below requires this option to expand -- the array at compile time. -- -- `program test' -- `implicit none' -- `integer j' -- `integer, parameter :: n = 100000' -- `integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)' -- `print '(10(I0,1X))', i' -- `end program test' -- -- _Caution: This option can lead to long compile times and -- excessively large object files._ -- -- The default value for N is 65535. -- --`-fmax-stack-var-size=N' -- This option specifies the size in bytes of the largest array that -- will be put on the stack; if the size is exceeded static memory is -- used (except in procedures marked as RECURSIVE). Use the option -- `-frecursive' to allow for recursive procedures which do not have -- a RECURSIVE attribute or for parallel programs. Use -- `-fno-automatic' to never use the stack. -- -- This option currently only affects local arrays declared with -- constant bounds, and may not apply to all character variables. -- Future versions of GNU Fortran may improve this behavior. -- -- The default value for N is 32768. -- --`-fpack-derived' -- This option tells GNU Fortran to pack derived type members as -- closely as possible. Code compiled with this option is likely to -- be incompatible with code compiled without this option, and may -- execute slower. -- --`-frepack-arrays' -- In some circumstances GNU Fortran may pass assumed shape array -- sections via a descriptor describing a noncontiguous area of -- memory. This option adds code to the function prologue to repack -- the data into a contiguous block at runtime. -- -- This should result in faster accesses to the array. However it -- can introduce significant overhead to the function call, -- especially when the passed data is noncontiguous. -- --`-fshort-enums' -- This option is provided for interoperability with C code that was -- compiled with the `-fshort-enums' option. It will make GNU -- Fortran choose the smallest `INTEGER' kind a given enumerator set -- will fit in, and give all its enumerators this kind. -- --`-fexternal-blas' -- This option will make `gfortran' generate calls to BLAS functions -- for some matrix operations like `MATMUL', instead of using our own -- algorithms, if the size of the matrices involved is larger than a -- given limit (see `-fblas-matmul-limit'). This may be profitable -- if an optimized vendor BLAS library is available. The BLAS -- library will have to be specified at link time. -- --`-fblas-matmul-limit=N' -- Only significant when `-fexternal-blas' is in effect. Matrix -- multiplication of matrices with size larger than (or equal to) N -- will be performed by calls to BLAS functions, while others will be -- handled by `gfortran' internal algorithms. If the matrices -- involved are not square, the size comparison is performed using the -- geometric mean of the dimensions of the argument and result -- matrices. -- -- The default value for N is 30. -- --`-frecursive' -- Allow indirect recursion by forcing all local arrays to be -- allocated on the stack. This flag cannot be used together with -- `-fmax-stack-var-size=' or `-fno-automatic'. -- --`-finit-local-zero' -- --`-finit-integer=N' -- --`-finit-real=<ZERO|INF|-INF|NAN>' -- --`-finit-logical=<TRUE|FALSE>' -- --`-finit-character=N' -- The `-finit-local-zero' option instructs the compiler to -- initialize local `INTEGER', `REAL', and `COMPLEX' variables to -- zero, `LOGICAL' variables to false, and `CHARACTER' variables to a -- string of null bytes. Finer-grained initialization options are -- provided by the `-finit-integer=N', -- `-finit-real=<ZERO|INF|-INF|NAN>' (which also initializes the real -- and imaginary parts of local `COMPLEX' variables), -- `-finit-logical=<TRUE|FALSE>', and `-finit-character=N' (where N -- is an ASCII character value) options. These options do not -- initialize components of derived type variables, nor do they -- initialize variables that appear in an `EQUIVALENCE' statement. -- (This limitation may be removed in future releases). -- -- Note that the `-finit-real=nan' option initializes `REAL' and -- `COMPLEX' variables with a quiet NaN. -- --`-falign-commons' -- By default, `gfortran' enforces proper alignment of all variables -- in a COMMON block by padding them as needed. On certain platforms -- this is mandatory, on others it increases performance. If a COMMON -- block is not declared with consistent data types everywhere, this -- padding can cause trouble, and `-fno-align-commons ' can be used -- to disable automatic alignment. The same form of this option -- should be used for all files that share a COMMON block. To avoid -- potential alignment issues in COMMON blocks, it is recommended to -- order objects from largests to smallest. -- -- *Note Options for Code Generation Conventions: (gcc)Code Gen --Options, for information on more options offered by the GBE shared by --`gfortran', `gcc', and other GNU compilers. -- -- --File: gfortran.info, Node: Environment Variables, Prev: Code Gen Options, Up: Invoking GNU Fortran -- --2.10 Environment variables affecting `gfortran' --=============================================== -- --The `gfortran' compiler currently does not make use of any environment --variables to control its operation above and beyond those that affect --the operation of `gcc'. -- -- *Note Environment Variables Affecting GCC: (gcc)Environment --Variables, for information on environment variables. -- -- *Note Runtime::, for environment variables that affect the run-time --behavior of programs compiled with GNU Fortran. -- -- --File: gfortran.info, Node: Runtime, Next: Fortran 2003 and 2008 status, Prev: Invoking GNU Fortran, Up: Top -- --3 Runtime: Influencing runtime behavior with environment variables --******************************************************************* -- --The behavior of the `gfortran' can be influenced by environment --variables. -- -- Malformed environment variables are silently ignored. -- --* Menu: -- --* GFORTRAN_STDIN_UNIT:: Unit number for standard input --* GFORTRAN_STDOUT_UNIT:: Unit number for standard output --* GFORTRAN_STDERR_UNIT:: Unit number for standard error --* GFORTRAN_USE_STDERR:: Send library output to standard error --* GFORTRAN_TMPDIR:: Directory for scratch files --* GFORTRAN_UNBUFFERED_ALL:: Don't buffer I/O for all units. --* GFORTRAN_UNBUFFERED_PRECONNECTED:: Don't buffer I/O for preconnected units. --* GFORTRAN_SHOW_LOCUS:: Show location for runtime errors --* GFORTRAN_OPTIONAL_PLUS:: Print leading + where permitted --* GFORTRAN_DEFAULT_RECL:: Default record length for new files --* GFORTRAN_LIST_SEPARATOR:: Separator for list output --* GFORTRAN_CONVERT_UNIT:: Set endianness for unformatted I/O --* GFORTRAN_ERROR_DUMPCORE:: Dump core on run-time errors --* GFORTRAN_ERROR_BACKTRACE:: Show backtrace on run-time errors -- -- --File: gfortran.info, Node: GFORTRAN_STDIN_UNIT, Next: GFORTRAN_STDOUT_UNIT, Up: Runtime -- --3.1 `GFORTRAN_STDIN_UNIT'--Unit number for standard input --========================================================= -- --This environment variable can be used to select the unit number --preconnected to standard input. This must be a positive integer. The --default value is 5. -- -- --File: gfortran.info, Node: GFORTRAN_STDOUT_UNIT, Next: GFORTRAN_STDERR_UNIT, Prev: GFORTRAN_STDIN_UNIT, Up: Runtime -- --3.2 `GFORTRAN_STDOUT_UNIT'--Unit number for standard output --=========================================================== -- --This environment variable can be used to select the unit number --preconnected to standard output. This must be a positive integer. The --default value is 6. -- -- --File: gfortran.info, Node: GFORTRAN_STDERR_UNIT, Next: GFORTRAN_USE_STDERR, Prev: GFORTRAN_STDOUT_UNIT, Up: Runtime -- --3.3 `GFORTRAN_STDERR_UNIT'--Unit number for standard error --========================================================== -- --This environment variable can be used to select the unit number --preconnected to standard error. This must be a positive integer. The --default value is 0. -- -- --File: gfortran.info, Node: GFORTRAN_USE_STDERR, Next: GFORTRAN_TMPDIR, Prev: GFORTRAN_STDERR_UNIT, Up: Runtime -- --3.4 `GFORTRAN_USE_STDERR'--Send library output to standard error --================================================================ -- --This environment variable controls where library output is sent. If --the first letter is `y', `Y' or `1', standard error is used. If the --first letter is `n', `N' or `0', standard output is used. -- -- --File: gfortran.info, Node: GFORTRAN_TMPDIR, Next: GFORTRAN_UNBUFFERED_ALL, Prev: GFORTRAN_USE_STDERR, Up: Runtime -- --3.5 `GFORTRAN_TMPDIR'--Directory for scratch files --================================================== -- --This environment variable controls where scratch files are created. If --this environment variable is missing, GNU Fortran searches for the --environment variable `TMP'. If this is also missing, the default is --`/tmp'. -- -- --File: gfortran.info, Node: GFORTRAN_UNBUFFERED_ALL, Next: GFORTRAN_UNBUFFERED_PRECONNECTED, Prev: GFORTRAN_TMPDIR, Up: Runtime -- --3.6 `GFORTRAN_UNBUFFERED_ALL'--Don't buffer I/O on all units --============================================================ -- --This environment variable controls whether all I/O is unbuffered. If --the first letter is `y', `Y' or `1', all I/O is unbuffered. This will --slow down small sequential reads and writes. If the first letter is --`n', `N' or `0', I/O is buffered. This is the default. -- -- --File: gfortran.info, Node: GFORTRAN_UNBUFFERED_PRECONNECTED, Next: GFORTRAN_SHOW_LOCUS, Prev: GFORTRAN_UNBUFFERED_ALL, Up: Runtime -- --3.7 `GFORTRAN_UNBUFFERED_PRECONNECTED'--Don't buffer I/O on preconnected units --============================================================================== -- --The environment variable named `GFORTRAN_UNBUFFERED_PRECONNECTED' --controls whether I/O on a preconnected unit (i.e. STDOUT or STDERR) is --unbuffered. If the first letter is `y', `Y' or `1', I/O is unbuffered. --This will slow down small sequential reads and writes. If the first --letter is `n', `N' or `0', I/O is buffered. This is the default. -- -- --File: gfortran.info, Node: GFORTRAN_SHOW_LOCUS, Next: GFORTRAN_OPTIONAL_PLUS, Prev: GFORTRAN_UNBUFFERED_PRECONNECTED, Up: Runtime -- --3.8 `GFORTRAN_SHOW_LOCUS'--Show location for runtime errors --=========================================================== -- --If the first letter is `y', `Y' or `1', filename and line numbers for --runtime errors are printed. If the first letter is `n', `N' or `0', --don't print filename and line numbers for runtime errors. The default --is to print the location. -- -- --File: gfortran.info, Node: GFORTRAN_OPTIONAL_PLUS, Next: GFORTRAN_DEFAULT_RECL, Prev: GFORTRAN_SHOW_LOCUS, Up: Runtime -- --3.9 `GFORTRAN_OPTIONAL_PLUS'--Print leading + where permitted --============================================================= -- --If the first letter is `y', `Y' or `1', a plus sign is printed where --permitted by the Fortran standard. If the first letter is `n', `N' or --`0', a plus sign is not printed in most cases. Default is not to print --plus signs. -- -- --File: gfortran.info, Node: GFORTRAN_DEFAULT_RECL, Next: GFORTRAN_LIST_SEPARATOR, Prev: GFORTRAN_OPTIONAL_PLUS, Up: Runtime -- --3.10 `GFORTRAN_DEFAULT_RECL'--Default record length for new files --================================================================= -- --This environment variable specifies the default record length, in --bytes, for files which are opened without a `RECL' tag in the `OPEN' --statement. This must be a positive integer. The default value is --1073741824 bytes (1 GB). -- -- --File: gfortran.info, Node: GFORTRAN_LIST_SEPARATOR, Next: GFORTRAN_CONVERT_UNIT, Prev: GFORTRAN_DEFAULT_RECL, Up: Runtime -- --3.11 `GFORTRAN_LIST_SEPARATOR'--Separator for list output --========================================================= -- --This environment variable specifies the separator when writing --list-directed output. It may contain any number of spaces and at most --one comma. If you specify this on the command line, be sure to quote --spaces, as in -- $ GFORTRAN_LIST_SEPARATOR=' , ' ./a.out -- when `a.out' is the compiled Fortran program that you want to run. --Default is a single space. -- -- --File: gfortran.info, Node: GFORTRAN_CONVERT_UNIT, Next: GFORTRAN_ERROR_DUMPCORE, Prev: GFORTRAN_LIST_SEPARATOR, Up: Runtime -- --3.12 `GFORTRAN_CONVERT_UNIT'--Set endianness for unformatted I/O --================================================================ -- --By setting the `GFORTRAN_CONVERT_UNIT' variable, it is possible to --change the representation of data for unformatted files. The syntax --for the `GFORTRAN_CONVERT_UNIT' variable is: -- GFORTRAN_CONVERT_UNIT: mode | mode ';' exception | exception ; -- mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ; -- exception: mode ':' unit_list | unit_list ; -- unit_list: unit_spec | unit_list unit_spec ; -- unit_spec: INTEGER | INTEGER '-' INTEGER ; -- The variable consists of an optional default mode, followed by a --list of optional exceptions, which are separated by semicolons from the --preceding default and each other. Each exception consists of a format --and a comma-separated list of units. Valid values for the modes are --the same as for the `CONVERT' specifier: -- -- `NATIVE' Use the native format. This is the default. -- -- `SWAP' Swap between little- and big-endian. -- -- `LITTLE_ENDIAN' Use the little-endian format for unformatted files. -- -- `BIG_ENDIAN' Use the big-endian format for unformatted files. -- A missing mode for an exception is taken to mean `BIG_ENDIAN'. --Examples of values for `GFORTRAN_CONVERT_UNIT' are: -- `'big_endian'' Do all unformatted I/O in big_endian mode. -- -- `'little_endian;native:10-20,25'' Do all unformatted I/O in -- little_endian mode, except for units 10 to 20 and 25, which are in -- native format. -- -- `'10-20'' Units 10 to 20 are big-endian, the rest is native. -- -- Setting the environment variables should be done on the command line --or via the `export' command for `sh'-compatible shells and via `setenv' --for `csh'-compatible shells. -- -- Example for `sh': -- $ gfortran foo.f90 -- $ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out -- -- Example code for `csh': -- % gfortran foo.f90 -- % setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20' -- % ./a.out -- -- Using anything but the native representation for unformatted data --carries a significant speed overhead. If speed in this area matters to --you, it is best if you use this only for data that needs to be portable. -- -- *Note CONVERT specifier::, for an alternative way to specify the --data representation for unformatted files. *Note Runtime Options::, for --setting a default data representation for the whole program. The --`CONVERT' specifier overrides the `-fconvert' compile options. -- -- _Note that the values specified via the GFORTRAN_CONVERT_UNIT --environment variable will override the CONVERT specifier in the open --statement_. This is to give control over data formats to users who do --not have the source code of their program available. -- -- --File: gfortran.info, Node: GFORTRAN_ERROR_DUMPCORE, Next: GFORTRAN_ERROR_BACKTRACE, Prev: GFORTRAN_CONVERT_UNIT, Up: Runtime -- --3.13 `GFORTRAN_ERROR_DUMPCORE'--Dump core on run-time errors --============================================================ -- --If the `GFORTRAN_ERROR_DUMPCORE' variable is set to `y', `Y' or `1' --(only the first letter is relevant) then library run-time errors cause --core dumps. To disable the core dumps, set the variable to `n', `N', --`0'. Default is not to core dump unless the `-fdump-core' compile option --was used. -- -- --File: gfortran.info, Node: GFORTRAN_ERROR_BACKTRACE, Prev: GFORTRAN_ERROR_DUMPCORE, Up: Runtime -- --3.14 `GFORTRAN_ERROR_BACKTRACE'--Show backtrace on run-time errors --================================================================== -- --If the `GFORTRAN_ERROR_BACKTRACE' variable is set to `y', `Y' or `1' --(only the first letter is relevant) then a backtrace is printed when a --run-time error occurs. To disable the backtracing, set the variable to --`n', `N', `0'. Default is not to print a backtrace unless the --`-fbacktrace' compile option was used. -- -- --File: gfortran.info, Node: Fortran 2003 and 2008 status, Next: Compiler Characteristics, Prev: Runtime, Up: Top -- --4 Fortran 2003 and 2008 Status --****************************** -- --* Menu: -- --* Fortran 2003 status:: --* Fortran 2008 status:: -- -- --File: gfortran.info, Node: Fortran 2003 status, Next: Fortran 2008 status, Up: Fortran 2003 and 2008 status -- --4.1 Fortran 2003 status --======================= -- --Although GNU Fortran focuses on implementing the Fortran 95 standard --for the time being, a few Fortran 2003 features are currently available. -- -- * Intrinsics `command_argument_count', `get_command', -- `get_command_argument', `get_environment_variable', and -- `move_alloc'. -- -- * Array constructors using square brackets. That is, `[...]' rather -- than `(/.../)'. -- -- * `FLUSH' statement. -- -- * `IOMSG=' specifier for I/O statements. -- -- * Support for the declaration of enumeration constants via the -- `ENUM' and `ENUMERATOR' statements. Interoperability with `gcc' -- is guaranteed also for the case where the `-fshort-enums' command -- line option is given. -- -- * TR 15581: -- * `ALLOCATABLE' dummy arguments. -- -- * `ALLOCATABLE' function results -- -- * `ALLOCATABLE' components of derived types -- -- * The `OPEN' statement supports the `ACCESS='STREAM'' specifier, -- allowing I/O without any record structure. -- -- * Namelist input/output for internal files. -- -- * The `PROTECTED' statement and attribute. -- -- * The `VALUE' statement and attribute. -- -- * The `VOLATILE' statement and attribute. -- -- * The `IMPORT' statement, allowing to import host-associated derived -- types. -- -- * `USE' statement with `INTRINSIC' and `NON_INTRINSIC' attribute; -- supported intrinsic modules: `ISO_FORTRAN_ENV', `OMP_LIB' and -- `OMP_LIB_KINDS'. -- -- * Renaming of operators in the `USE' statement. -- -- * Interoperability with C (ISO C Bindings) -- -- * BOZ as argument of INT, REAL, DBLE and CMPLX. -- -- -- --File: gfortran.info, Node: Fortran 2008 status, Prev: Fortran 2003 status, Up: Fortran 2003 and 2008 status -- --4.2 Fortran 2008 status --======================= -- --The next version of the Fortran standard after Fortran 2003 is currently --being worked on by the Working Group 5 of Sub-Committee 22 of the Joint --Technical Committee 1 of the International Organization for --Standardization (ISO) and the International Electrotechnical Commission --(IEC). This group is known at WG5 (http://www.nag.co.uk/sc22wg5/). The --next revision of the Fortran standard is informally referred to as --Fortran 2008, reflecting its planned release year. The GNU Fortran --compiler has support for some of the new features in Fortran 2008. This --support is based on the latest draft, available from --`http://www.nag.co.uk/sc22wg5/'. However, as the final standard may --differ from the drafts, no guarantee of backward compatibility can be --made and you should only use it for experimental purposes. -- -- --File: gfortran.info, Node: Compiler Characteristics, Next: Extensions, Prev: Fortran 2003 and 2008 status, Up: Top -- --5 Compiler Characteristics --************************** -- --This chapter describes certain characteristics of the GNU Fortran --compiler, namely the KIND type parameter values supported. -- --* Menu: -- --* KIND Type Parameters:: -- -- --File: gfortran.info, Node: KIND Type Parameters, Up: Compiler Characteristics -- --5.1 KIND Type Parameters --======================== -- --The `KIND' type parameters supported by GNU Fortran for the primitive --data types are: -- --`INTEGER' -- 1, 2, 4, 8*, 16*, default: 4 (1) -- --`LOGICAL' -- 1, 2, 4, 8*, 16*, default: 4 (1) -- --`REAL' -- 4, 8, 10**, 16**, default: 4 (2) -- --`COMPLEX' -- 4, 8, 10**, 16**, default: 4 (2) -- --`CHARACTER' -- 1, 4, default: 1 -- -- --* = not available on all systems --** = not available on all systems; additionally 10 and 16 are never --available at the same time --(1) Unless -fdefault-integer-8 is used --(2) Unless -fdefault-real-8 is used -- --The `KIND' value matches the storage size in bytes, except for --`COMPLEX' where the storage size is twice as much (or both real and --imaginary part are a real value of the given size). It is recommended --to use the `SELECT_*_KIND' intrinsics instead of the concrete values. -- -- --File: gfortran.info, Node: Extensions, Next: Intrinsic Procedures, Prev: Compiler Characteristics, Up: Top -- --6 Extensions --************ -- --The two sections below detail the extensions to standard Fortran that --are implemented in GNU Fortran, as well as some of the popular or --historically important extensions that are not (or not yet) implemented. --For the latter case, we explain the alternatives available to GNU --Fortran users, including replacement by standard-conforming code or GNU --extensions. -- --* Menu: -- --* Extensions implemented in GNU Fortran:: --* Extensions not implemented in GNU Fortran:: -- -- --File: gfortran.info, Node: Extensions implemented in GNU Fortran, Next: Extensions not implemented in GNU Fortran, Up: Extensions -- --6.1 Extensions implemented in GNU Fortran --========================================= -- --GNU Fortran implements a number of extensions over standard Fortran. --This chapter contains information on their syntax and meaning. There --are currently two categories of GNU Fortran extensions, those that --provide functionality beyond that provided by any standard, and those --that are supported by GNU Fortran purely for backward compatibility --with legacy compilers. By default, `-std=gnu' allows the compiler to --accept both types of extensions, but to warn about the use of the --latter. Specifying either `-std=f95', `-std=f2003' or `-std=f2008' --disables both types of extensions, and `-std=legacy' allows both --without warning. -- --* Menu: -- --* Old-style kind specifications:: --* Old-style variable initialization:: --* Extensions to namelist:: --* X format descriptor without count field:: --* Commas in FORMAT specifications:: --* Missing period in FORMAT specifications:: --* I/O item lists:: --* BOZ literal constants:: --* Real array indices:: --* Unary operators:: --* Implicitly convert LOGICAL and INTEGER values:: --* Hollerith constants support:: --* Cray pointers:: --* CONVERT specifier:: --* OpenMP:: --* Argument list functions:: -- -- --File: gfortran.info, Node: Old-style kind specifications, Next: Old-style variable initialization, Up: Extensions implemented in GNU Fortran -- --6.1.1 Old-style kind specifications ------------------------------------- -- --GNU Fortran allows old-style kind specifications in declarations. These --look like: -- TYPESPEC*size x,y,z -- where `TYPESPEC' is a basic type (`INTEGER', `REAL', etc.), and --where `size' is a byte count corresponding to the storage size of a --valid kind for that type. (For `COMPLEX' variables, `size' is the --total size of the real and imaginary parts.) The statement then --declares `x', `y' and `z' to be of type `TYPESPEC' with the appropriate --kind. This is equivalent to the standard-conforming declaration -- TYPESPEC(k) x,y,z -- where `k' is the kind parameter suitable for the intended precision. --As kind parameters are implementation-dependent, use the `KIND', --`SELECTED_INT_KIND' and `SELECTED_REAL_KIND' intrinsics to retrieve the --correct value, for instance `REAL*8 x' can be replaced by: -- INTEGER, PARAMETER :: dbl = KIND(1.0d0) -- REAL(KIND=dbl) :: x -- -- --File: gfortran.info, Node: Old-style variable initialization, Next: Extensions to namelist, Prev: Old-style kind specifications, Up: Extensions implemented in GNU Fortran -- --6.1.2 Old-style variable initialization ----------------------------------------- -- --GNU Fortran allows old-style initialization of variables of the form: -- INTEGER i/1/,j/2/ -- REAL x(2,2) /3*0.,1./ -- The syntax for the initializers is as for the `DATA' statement, but --unlike in a `DATA' statement, an initializer only applies to the --variable immediately preceding the initialization. In other words, --something like `INTEGER I,J/2,3/' is not valid. This style of --initialization is only allowed in declarations without double colons --(`::'); the double colons were introduced in Fortran 90, which also --introduced a standard syntax for initializing variables in type --declarations. -- -- Examples of standard-conforming code equivalent to the above example --are: -- ! Fortran 90 -- INTEGER :: i = 1, j = 2 -- REAL :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x)) -- ! Fortran 77 -- INTEGER i, j -- REAL x(2,2) -- DATA i/1/, j/2/, x/3*0.,1./ -- -- Note that variables which are explicitly initialized in declarations --or in `DATA' statements automatically acquire the `SAVE' attribute. -- -- --File: gfortran.info, Node: Extensions to namelist, Next: X format descriptor without count field, Prev: Old-style variable initialization, Up: Extensions implemented in GNU Fortran -- --6.1.3 Extensions to namelist ------------------------------ -- --GNU Fortran fully supports the Fortran 95 standard for namelist I/O --including array qualifiers, substrings and fully qualified derived --types. The output from a namelist write is compatible with namelist --read. The output has all names in upper case and indentation to column --1 after the namelist name. Two extensions are permitted: -- -- Old-style use of `$' instead of `&' -- $MYNML -- X(:)%Y(2) = 1.0 2.0 3.0 -- CH(1:4) = "abcd" -- $END -- -- It should be noted that the default terminator is `/' rather than --`&END'. -- -- Querying of the namelist when inputting from stdin. After at least --one space, entering `?' sends to stdout the namelist name and the names --of the variables in the namelist: -- ? -- -- &mynml -- x -- x%y -- ch -- &end -- -- Entering `=?' outputs the namelist to stdout, as if `WRITE(*,NML = --mynml)' had been called: -- =? -- -- &MYNML -- X(1)%Y= 0.000000 , 1.000000 , 0.000000 , -- X(2)%Y= 0.000000 , 2.000000 , 0.000000 , -- X(3)%Y= 0.000000 , 3.000000 , 0.000000 , -- CH=abcd, / -- -- To aid this dialog, when input is from stdin, errors send their --messages to stderr and execution continues, even if `IOSTAT' is set. -- -- `PRINT' namelist is permitted. This causes an error if `-std=f95' --is used. -- PROGRAM test_print -- REAL, dimension (4) :: x = (/1.0, 2.0, 3.0, 4.0/) -- NAMELIST /mynml/ x -- PRINT mynml -- END PROGRAM test_print -- -- Expanded namelist reads are permitted. This causes an error if --`-std=f95' is used. In the following example, the first element of the --array will be given the value 0.00 and the two succeeding elements will --be given the values 1.00 and 2.00. -- &MYNML -- X(1,1) = 0.00 , 1.00 , 2.00 -- / -- -- --File: gfortran.info, Node: X format descriptor without count field, Next: Commas in FORMAT specifications, Prev: Extensions to namelist, Up: Extensions implemented in GNU Fortran -- --6.1.4 `X' format descriptor without count field ------------------------------------------------- -- --To support legacy codes, GNU Fortran permits the count field of the `X' --edit descriptor in `FORMAT' statements to be omitted. When omitted, --the count is implicitly assumed to be one. -- -- PRINT 10, 2, 3 -- 10 FORMAT (I1, X, I1) -- -- --File: gfortran.info, Node: Commas in FORMAT specifications, Next: Missing period in FORMAT specifications, Prev: X format descriptor without count field, Up: Extensions implemented in GNU Fortran -- --6.1.5 Commas in `FORMAT' specifications ----------------------------------------- -- --To support legacy codes, GNU Fortran allows the comma separator to be --omitted immediately before and after character string edit descriptors --in `FORMAT' statements. -- -- PRINT 10, 2, 3 -- 10 FORMAT ('FOO='I1' BAR='I2) -- -- --File: gfortran.info, Node: Missing period in FORMAT specifications, Next: I/O item lists, Prev: Commas in FORMAT specifications, Up: Extensions implemented in GNU Fortran -- --6.1.6 Missing period in `FORMAT' specifications ------------------------------------------------- -- --To support legacy codes, GNU Fortran allows missing periods in format --specifications if and only if `-std=legacy' is given on the command --line. This is considered non-conforming code and is discouraged. -- -- REAL :: value -- READ(*,10) value -- 10 FORMAT ('F4') -- -- --File: gfortran.info, Node: I/O item lists, Next: BOZ literal constants, Prev: Missing period in FORMAT specifications, Up: Extensions implemented in GNU Fortran -- --6.1.7 I/O item lists ---------------------- -- --To support legacy codes, GNU Fortran allows the input item list of the --`READ' statement, and the output item lists of the `WRITE' and `PRINT' --statements, to start with a comma. -- -- --File: gfortran.info, Node: BOZ literal constants, Next: Real array indices, Prev: I/O item lists, Up: Extensions implemented in GNU Fortran -- --6.1.8 BOZ literal constants ----------------------------- -- --Besides decimal constants, Fortran also supports binary (`b'), octal --(`o') and hexadecimal (`z') integer constants. The syntax is: `prefix --quote digits quote', were the prefix is either `b', `o' or `z', quote --is either `'' or `"' and the digits are for binary `0' or `1', for --octal between `0' and `7', and for hexadecimal between `0' and `F'. --(Example: `b'01011101''.) -- -- Up to Fortran 95, BOZ literals were only allowed to initialize --integer variables in DATA statements. Since Fortran 2003 BOZ literals --are also allowed as argument of `REAL', `DBLE', `INT' and `CMPLX'; the --result is the same as if the integer BOZ literal had been converted by --`TRANSFER' to, respectively, `real', `double precision', `integer' or --`complex'. As GNU Fortran extension the intrinsic procedures `FLOAT', --`DFLOAT', `COMPLEX' and `DCMPLX' are treated alike. -- -- As an extension, GNU Fortran allows hexadecimal BOZ literal --constants to be specified using the `X' prefix, in addition to the --standard `Z' prefix. The BOZ literal can also be specified by adding a --suffix to the string, for example, `Z'ABC'' and `'ABC'Z' are equivalent. -- -- Furthermore, GNU Fortran allows using BOZ literal constants outside --DATA statements and the four intrinsic functions allowed by Fortran --2003. In DATA statements, in direct assignments, where the right-hand --side only contains a BOZ literal constant, and for old-style --initializers of the form `integer i /o'0173'/', the constant is --transferred as if `TRANSFER' had been used; for `COMPLEX' numbers, only --the real part is initialized unless `CMPLX' is used. In all other --cases, the BOZ literal constant is converted to an `INTEGER' value with --the largest decimal representation. This value is then converted --numerically to the type and kind of the variable in question. (For --instance `real :: r = b'0000001' + 1' initializes `r' with `2.0'.) As --different compilers implement the extension differently, one should be --careful when doing bitwise initialization of non-integer variables. -- -- Note that initializing an `INTEGER' variable with a statement such --as `DATA i/Z'FFFFFFFF'/' will give an integer overflow error rather --than the desired result of -1 when `i' is a 32-bit integer on a system --that supports 64-bit integers. The `-fno-range-check' option can be --used as a workaround for legacy code that initializes integers in this --manner. -- -- --File: gfortran.info, Node: Real array indices, Next: Unary operators, Prev: BOZ literal constants, Up: Extensions implemented in GNU Fortran -- --6.1.9 Real array indices -------------------------- -- --As an extension, GNU Fortran allows the use of `REAL' expressions or --variables as array indices. -- -- --File: gfortran.info, Node: Unary operators, Next: Implicitly convert LOGICAL and INTEGER values, Prev: Real array indices, Up: Extensions implemented in GNU Fortran -- --6.1.10 Unary operators ------------------------ -- --As an extension, GNU Fortran allows unary plus and unary minus operators --to appear as the second operand of binary arithmetic operators without --the need for parenthesis. -- -- X = Y * -Z -- -- --File: gfortran.info, Node: Implicitly convert LOGICAL and INTEGER values, Next: Hollerith constants support, Prev: Unary operators, Up: Extensions implemented in GNU Fortran -- --6.1.11 Implicitly convert `LOGICAL' and `INTEGER' values ---------------------------------------------------------- -- --As an extension for backwards compatibility with other compilers, GNU --Fortran allows the implicit conversion of `LOGICAL' values to `INTEGER' --values and vice versa. When converting from a `LOGICAL' to an --`INTEGER', `.FALSE.' is interpreted as zero, and `.TRUE.' is --interpreted as one. When converting from `INTEGER' to `LOGICAL', the --value zero is interpreted as `.FALSE.' and any nonzero value is --interpreted as `.TRUE.'. -- -- LOGICAL :: l -- l = 1 -- -- INTEGER :: i -- i = .TRUE. -- -- However, there is no implicit conversion of `INTEGER' values in --`if'-statements, nor of `LOGICAL' or `INTEGER' values in I/O operations. -- -- --File: gfortran.info, Node: Hollerith constants support, Next: Cray pointers, Prev: Implicitly convert LOGICAL and INTEGER values, Up: Extensions implemented in GNU Fortran -- --6.1.12 Hollerith constants support ------------------------------------ -- --GNU Fortran supports Hollerith constants in assignments, function --arguments, and `DATA' and `ASSIGN' statements. A Hollerith constant is --written as a string of characters preceded by an integer constant --indicating the character count, and the letter `H' or `h', and stored --in bytewise fashion in a numeric (`INTEGER', `REAL', or `complex') or --`LOGICAL' variable. The constant will be padded or truncated to fit --the size of the variable in which it is stored. -- -- Examples of valid uses of Hollerith constants: -- complex*16 x(2) -- data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/ -- x(1) = 16HABCDEFGHIJKLMNOP -- call foo (4h abc) -- -- Invalid Hollerith constants examples: -- integer*4 a -- a = 8H12345678 ! Valid, but the Hollerith constant will be truncated. -- a = 0H ! At least one character is needed. -- -- In general, Hollerith constants were used to provide a rudimentary --facility for handling character strings in early Fortran compilers, --prior to the introduction of `CHARACTER' variables in Fortran 77; in --those cases, the standard-compliant equivalent is to convert the --program to use proper character strings. On occasion, there may be a --case where the intent is specifically to initialize a numeric variable --with a given byte sequence. In these cases, the same result can be --obtained by using the `TRANSFER' statement, as in this example. -- INTEGER(KIND=4) :: a -- a = TRANSFER ("abcd", a) ! equivalent to: a = 4Habcd -- -- --File: gfortran.info, Node: Cray pointers, Next: CONVERT specifier, Prev: Hollerith constants support, Up: Extensions implemented in GNU Fortran -- --6.1.13 Cray pointers ---------------------- -- --Cray pointers are part of a non-standard extension that provides a --C-like pointer in Fortran. This is accomplished through a pair of --variables: an integer "pointer" that holds a memory address, and a --"pointee" that is used to dereference the pointer. -- -- Pointer/pointee pairs are declared in statements of the form: -- pointer ( <pointer> , <pointee> ) -- or, -- pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ... -- The pointer is an integer that is intended to hold a memory address. --The pointee may be an array or scalar. A pointee can be an assumed --size array--that is, the last dimension may be left unspecified by --using a `*' in place of a value--but a pointee cannot be an assumed --shape array. No space is allocated for the pointee. -- -- The pointee may have its type declared before or after the pointer --statement, and its array specification (if any) may be declared before, --during, or after the pointer statement. The pointer may be declared as --an integer prior to the pointer statement. However, some machines have --default integer sizes that are different than the size of a pointer, --and so the following code is not portable: -- integer ipt -- pointer (ipt, iarr) -- If a pointer is declared with a kind that is too small, the compiler --will issue a warning; the resulting binary will probably not work --correctly, because the memory addresses stored in the pointers may be --truncated. It is safer to omit the first line of the above example; if --explicit declaration of ipt's type is omitted, then the compiler will --ensure that ipt is an integer variable large enough to hold a pointer. -- -- Pointer arithmetic is valid with Cray pointers, but it is not the --same as C pointer arithmetic. Cray pointers are just ordinary --integers, so the user is responsible for determining how many bytes to --add to a pointer in order to increment it. Consider the following --example: -- real target(10) -- real pointee(10) -- pointer (ipt, pointee) -- ipt = loc (target) -- ipt = ipt + 1 -- The last statement does not set `ipt' to the address of `target(1)', --as it would in C pointer arithmetic. Adding `1' to `ipt' just adds one --byte to the address stored in `ipt'. -- -- Any expression involving the pointee will be translated to use the --value stored in the pointer as the base address. -- -- To get the address of elements, this extension provides an intrinsic --function `LOC()'. The `LOC()' function is equivalent to the `&' --operator in C, except the address is cast to an integer type: -- real ar(10) -- pointer(ipt, arpte(10)) -- real arpte -- ipt = loc(ar) ! Makes arpte is an alias for ar -- arpte(1) = 1.0 ! Sets ar(1) to 1.0 -- The pointer can also be set by a call to the `MALLOC' intrinsic (see --*note MALLOC::). -- -- Cray pointees often are used to alias an existing variable. For --example: -- integer target(10) -- integer iarr(10) -- pointer (ipt, iarr) -- ipt = loc(target) -- As long as `ipt' remains unchanged, `iarr' is now an alias for --`target'. The optimizer, however, will not detect this aliasing, so it --is unsafe to use `iarr' and `target' simultaneously. Using a pointee --in any way that violates the Fortran aliasing rules or assumptions is --illegal. It is the user's responsibility to avoid doing this; the --compiler works under the assumption that no such aliasing occurs. -- -- Cray pointers will work correctly when there is no aliasing (i.e., --when they are used to access a dynamically allocated block of memory), --and also in any routine where a pointee is used, but any variable with --which it shares storage is not used. Code that violates these rules --may not run as the user intends. This is not a bug in the optimizer; --any code that violates the aliasing rules is illegal. (Note that this --is not unique to GNU Fortran; any Fortran compiler that supports Cray --pointers will "incorrectly" optimize code with illegal aliasing.) -- -- There are a number of restrictions on the attributes that can be --applied to Cray pointers and pointees. Pointees may not have the --`ALLOCATABLE', `INTENT', `OPTIONAL', `DUMMY', `TARGET', `INTRINSIC', or --`POINTER' attributes. Pointers may not have the `DIMENSION', `POINTER', --`TARGET', `ALLOCATABLE', `EXTERNAL', or `INTRINSIC' attributes. --Pointees may not occur in more than one pointer statement. A pointee --cannot be a pointer. Pointees cannot occur in equivalence, common, or --data statements. -- -- A Cray pointer may also point to a function or a subroutine. For --example, the following excerpt is valid: -- implicit none -- external sub -- pointer (subptr,subpte) -- external subpte -- subptr = loc(sub) -- call subpte() -- [...] -- subroutine sub -- [...] -- end subroutine sub -- -- A pointer may be modified during the course of a program, and this --will change the location to which the pointee refers. However, when --pointees are passed as arguments, they are treated as ordinary --variables in the invoked function. Subsequent changes to the pointer --will not change the base address of the array that was passed. -- -- --File: gfortran.info, Node: CONVERT specifier, Next: OpenMP, Prev: Cray pointers, Up: Extensions implemented in GNU Fortran -- --6.1.14 `CONVERT' specifier ---------------------------- -- --GNU Fortran allows the conversion of unformatted data between little- --and big-endian representation to facilitate moving of data between --different systems. The conversion can be indicated with the `CONVERT' --specifier on the `OPEN' statement. *Note GFORTRAN_CONVERT_UNIT::, for --an alternative way of specifying the data format via an environment --variable. -- -- Valid values for `CONVERT' are: -- `CONVERT='NATIVE'' Use the native format. This is the default. -- -- `CONVERT='SWAP'' Swap between little- and big-endian. -- -- `CONVERT='LITTLE_ENDIAN'' Use the little-endian representation for -- unformatted files. -- -- `CONVERT='BIG_ENDIAN'' Use the big-endian representation for -- unformatted files. -- -- Using the option could look like this: -- open(file='big.dat',form='unformatted',access='sequential', & -- convert='big_endian') -- -- The value of the conversion can be queried by using --`INQUIRE(CONVERT=ch)'. The values returned are `'BIG_ENDIAN'' and --`'LITTLE_ENDIAN''. -- -- `CONVERT' works between big- and little-endian for `INTEGER' values --of all supported kinds and for `REAL' on IEEE systems of kinds 4 and 8. --Conversion between different "extended double" types on different --architectures such as m68k and x86_64, which GNU Fortran supports as --`REAL(KIND=10)' and `REAL(KIND=16)', will probably not work. -- -- _Note that the values specified via the GFORTRAN_CONVERT_UNIT --environment variable will override the CONVERT specifier in the open --statement_. This is to give control over data formats to users who do --not have the source code of their program available. -- -- Using anything but the native representation for unformatted data --carries a significant speed overhead. If speed in this area matters to --you, it is best if you use this only for data that needs to be portable. -- -- --File: gfortran.info, Node: OpenMP, Next: Argument list functions, Prev: CONVERT specifier, Up: Extensions implemented in GNU Fortran -- --6.1.15 OpenMP --------------- -- --OpenMP (Open Multi-Processing) is an application programming interface --(API) that supports multi-platform shared memory multiprocessing --programming in C/C++ and Fortran on many architectures, including Unix --and Microsoft Windows platforms. It consists of a set of compiler --directives, library routines, and environment variables that influence --run-time behavior. -- -- GNU Fortran strives to be compatible to the OpenMP Application --Program Interface v2.5 --(http://www.openmp.org/drupal/mp-documents/spec25.pdf). -- -- To enable the processing of the OpenMP directive `!$omp' in --free-form source code; the `c$omp', `*$omp' and `!$omp' directives in --fixed form; the `!$' conditional compilation sentinels in free form; --and the `c$', `*$' and `!$' sentinels in fixed form, `gfortran' needs --to be invoked with the `-fopenmp'. This also arranges for automatic --linking of the GNU OpenMP runtime library *note libgomp: (libgomp)Top. -- -- The OpenMP Fortran runtime library routines are provided both in a --form of a Fortran 90 module named `omp_lib' and in a form of a Fortran --`include' file named `omp_lib.h'. -- -- An example of a parallelized loop taken from Appendix A.1 of the --OpenMP Application Program Interface v2.5: -- SUBROUTINE A1(N, A, B) -- INTEGER I, N -- REAL B(N), A(N) -- !$OMP PARALLEL DO !I is private by default -- DO I=2,N -- B(I) = (A(I) + A(I-1)) / 2.0 -- ENDDO -- !$OMP END PARALLEL DO -- END SUBROUTINE A1 -- -- Please note: -- * `-fopenmp' implies `-frecursive', i.e., all local arrays will be -- allocated on the stack. When porting existing code to OpenMP, this -- may lead to surprising results, especially to segmentation faults -- if the stacksize is limited. -- -- * On glibc-based systems, OpenMP enabled applications can not be -- statically linked due to limitations of the underlying -- pthreads-implementation. It might be possible to get a working -- solution if `-Wl,--whole-archive -lpthread -Wl,--no-whole-archive' -- is added to the command line. However, this is not supported by -- `gcc' and thus not recommended. -- -- --File: gfortran.info, Node: Argument list functions, Prev: OpenMP, Up: Extensions implemented in GNU Fortran -- --6.1.16 Argument list functions `%VAL', `%REF' and `%LOC' ---------------------------------------------------------- -- --GNU Fortran supports argument list functions `%VAL', `%REF' and `%LOC' --statements, for backward compatibility with g77. It is recommended --that these should be used only for code that is accessing facilities --outside of GNU Fortran, such as operating system or windowing --facilities. It is best to constrain such uses to isolated portions of a --program-portions that deal specifically and exclusively with low-level, --system-dependent facilities. Such portions might well provide a --portable interface for use by the program as a whole, but are --themselves not portable, and should be thoroughly tested each time they --are rebuilt using a new compiler or version of a compiler. -- -- `%VAL' passes a scalar argument by value, `%REF' passes it by --reference and `%LOC' passes its memory location. Since gfortran --already passes scalar arguments by reference, `%REF' is in effect a --do-nothing. `%LOC' has the same effect as a fortran pointer. -- -- An example of passing an argument by value to a C subroutine foo.: -- C -- C prototype void foo_ (float x); -- C -- external foo -- real*4 x -- x = 3.14159 -- call foo (%VAL (x)) -- end -- -- For details refer to the g77 manual --`http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/index.html#Top'. -- -- Also, the gfortran testsuite c_by_val.f and its partner c_by_val.c --are worth a look. -- -- --File: gfortran.info, Node: Extensions not implemented in GNU Fortran, Prev: Extensions implemented in GNU Fortran, Up: Extensions -- --6.2 Extensions not implemented in GNU Fortran --============================================= -- --The long history of the Fortran language, its wide use and broad --userbase, the large number of different compiler vendors and the lack of --some features crucial to users in the first standards have lead to the --existence of a number of important extensions to the language. While --some of the most useful or popular extensions are supported by the GNU --Fortran compiler, not all existing extensions are supported. This --section aims at listing these extensions and offering advice on how --best make code that uses them running with the GNU Fortran compiler. -- --* Menu: -- --* STRUCTURE and RECORD:: --* ENCODE and DECODE statements:: -- -- --File: gfortran.info, Node: STRUCTURE and RECORD, Next: ENCODE and DECODE statements, Up: Extensions not implemented in GNU Fortran -- --6.2.1 `STRUCTURE' and `RECORD' -------------------------------- -- --Structures are user-defined aggregate data types; this functionality was --standardized in Fortran 90 with an different syntax, under the name of --"derived types". Here is an example of code using the non portable --structure syntax: -- -- ! Declaring a structure named ``item'' and containing three fields: -- ! an integer ID, an description string and a floating-point price. -- STRUCTURE /item/ -- INTEGER id -- CHARACTER(LEN=200) description -- REAL price -- END STRUCTURE -- -- ! Define two variables, an single record of type ``item'' -- ! named ``pear'', and an array of items named ``store_catalog'' -- RECORD /item/ pear, store_catalog(100) -- -- ! We can directly access the fields of both variables -- pear.id = 92316 -- pear.description = "juicy D'Anjou pear" -- pear.price = 0.15 -- store_catalog(7).id = 7831 -- store_catalog(7).description = "milk bottle" -- store_catalog(7).price = 1.2 -- -- ! We can also manipulate the whole structure -- store_catalog(12) = pear -- print *, store_catalog(12) -- --This code can easily be rewritten in the Fortran 90 syntax as following: -- -- ! ``STRUCTURE /name/ ... END STRUCTURE'' becomes -- ! ``TYPE name ... END TYPE'' -- TYPE item -- INTEGER id -- CHARACTER(LEN=200) description -- REAL price -- END TYPE -- -- ! ``RECORD /name/ variable'' becomes ``TYPE(name) variable'' -- TYPE(item) pear, store_catalog(100) -- -- ! Instead of using a dot (.) to access fields of a record, the -- ! standard syntax uses a percent sign (%) -- pear%id = 92316 -- pear%description = "juicy D'Anjou pear" -- pear%price = 0.15 -- store_catalog(7)%id = 7831 -- store_catalog(7)%description = "milk bottle" -- store_catalog(7)%price = 1.2 -- -- ! Assignments of a whole variable don't change -- store_catalog(12) = pear -- print *, store_catalog(12) -- -- --File: gfortran.info, Node: ENCODE and DECODE statements, Prev: STRUCTURE and RECORD, Up: Extensions not implemented in GNU Fortran -- --6.2.2 `ENCODE' and `DECODE' statements ---------------------------------------- -- --GNU Fortran doesn't support the `ENCODE' and `DECODE' statements. --These statements are best replaced by `READ' and `WRITE' statements --involving internal files (`CHARACTER' variables and arrays), which have --been part of the Fortran standard since Fortran 77. For example, --replace a code fragment like -- -- INTEGER*1 LINE(80) -- REAL A, B, C -- c ... Code that sets LINE -- DECODE (80, 9000, LINE) A, B, C -- 9000 FORMAT (1X, 3(F10.5)) -- --with the following: -- -- CHARACTER(LEN=80) LINE -- REAL A, B, C -- c ... Code that sets LINE -- READ (UNIT=LINE, FMT=9000) A, B, C -- 9000 FORMAT (1X, 3(F10.5)) -- -- Similarly, replace a code fragment like -- -- INTEGER*1 LINE(80) -- REAL A, B, C -- c ... Code that sets A, B and C -- ENCODE (80, 9000, LINE) A, B, C -- 9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5)) -- --with the following: -- -- INTEGER*1 LINE(80) -- REAL A, B, C -- c ... Code that sets A, B and C -- WRITE (UNIT=LINE, FMT=9000) A, B, C -- 9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5)) -- -- --File: gfortran.info, Node: Intrinsic Procedures, Next: Intrinsic Modules, Prev: Extensions, Up: Top -- --7 Intrinsic Procedures --********************** -- --* Menu: -- --* Introduction: Introduction to Intrinsics --* `ABORT': ABORT, Abort the program --* `ABS': ABS, Absolute value --* `ACCESS': ACCESS, Checks file access modes --* `ACHAR': ACHAR, Character in ASCII collating sequence --* `ACOS': ACOS, Arccosine function --* `ACOSH': ACOSH, Hyperbolic arccosine function --* `ADJUSTL': ADJUSTL, Left adjust a string --* `ADJUSTR': ADJUSTR, Right adjust a string --* `AIMAG': AIMAG, Imaginary part of complex number --* `AINT': AINT, Truncate to a whole number --* `ALARM': ALARM, Set an alarm clock --* `ALL': ALL, Determine if all values are true --* `ALLOCATED': ALLOCATED, Status of allocatable entity --* `AND': AND, Bitwise logical AND --* `ANINT': ANINT, Nearest whole number --* `ANY': ANY, Determine if any values are true --* `ASIN': ASIN, Arcsine function --* `ASINH': ASINH, Hyperbolic arcsine function --* `ASSOCIATED': ASSOCIATED, Status of a pointer or pointer/target pair --* `ATAN': ATAN, Arctangent function --* `ATAN2': ATAN2, Arctangent function --* `ATANH': ATANH, Hyperbolic arctangent function --* `BESSEL_J0': BESSEL_J0, Bessel function of the first kind of order 0 --* `BESSEL_J1': BESSEL_J1, Bessel function of the first kind of order 1 --* `BESSEL_JN': BESSEL_JN, Bessel function of the first kind --* `BESSEL_Y0': BESSEL_Y0, Bessel function of the second kind of order 0 --* `BESSEL_Y1': BESSEL_Y1, Bessel function of the second kind of order 1 --* `BESSEL_YN': BESSEL_YN, Bessel function of the second kind --* `BIT_SIZE': BIT_SIZE, Bit size inquiry function --* `BTEST': BTEST, Bit test function --* `C_ASSOCIATED': C_ASSOCIATED, Status of a C pointer --* `C_F_POINTER': C_F_POINTER, Convert C into Fortran pointer --* `C_F_PROCPOINTER': C_F_PROCPOINTER, Convert C into Fortran procedure pointer --* `C_FUNLOC': C_FUNLOC, Obtain the C address of a procedure --* `C_LOC': C_LOC, Obtain the C address of an object --* `C_SIZEOF': C_SIZEOF, Size in bytes of an expression --* `CEILING': CEILING, Integer ceiling function --* `CHAR': CHAR, Integer-to-character conversion function --* `CHDIR': CHDIR, Change working directory --* `CHMOD': CHMOD, Change access permissions of files --* `CMPLX': CMPLX, Complex conversion function --* `COMMAND_ARGUMENT_COUNT': COMMAND_ARGUMENT_COUNT, Get number of command line arguments --* `COMPLEX': COMPLEX, Complex conversion function --* `CONJG': CONJG, Complex conjugate function --* `COS': COS, Cosine function --* `COSH': COSH, Hyperbolic cosine function --* `COUNT': COUNT, Count occurrences of TRUE in an array --* `CPU_TIME': CPU_TIME, CPU time subroutine --* `CSHIFT': CSHIFT, Circular shift elements of an array --* `CTIME': CTIME, Subroutine (or function) to convert a time into a string --* `DATE_AND_TIME': DATE_AND_TIME, Date and time subroutine --* `DBLE': DBLE, Double precision conversion function --* `DCMPLX': DCMPLX, Double complex conversion function --* `DFLOAT': DFLOAT, Double precision conversion function --* `DIGITS': DIGITS, Significant digits function --* `DIM': DIM, Positive difference --* `DOT_PRODUCT': DOT_PRODUCT, Dot product function --* `DPROD': DPROD, Double product function --* `DREAL': DREAL, Double real part function --* `DTIME': DTIME, Execution time subroutine (or function) --* `EOSHIFT': EOSHIFT, End-off shift elements of an array --* `EPSILON': EPSILON, Epsilon function --* `ERF': ERF, Error function --* `ERFC': ERFC, Complementary error function --* `ERFC_SCALED': ERFC_SCALED, Exponentially-scaled complementary error function --* `ETIME': ETIME, Execution time subroutine (or function) --* `EXIT': EXIT, Exit the program with status. --* `EXP': EXP, Exponential function --* `EXPONENT': EXPONENT, Exponent function --* `FDATE': FDATE, Subroutine (or function) to get the current time as a string --* `FGET': FGET, Read a single character in stream mode from stdin --* `FGETC': FGETC, Read a single character in stream mode --* `FLOAT': FLOAT, Convert integer to default real --* `FLOOR': FLOOR, Integer floor function --* `FLUSH': FLUSH, Flush I/O unit(s) --* `FNUM': FNUM, File number function --* `FPUT': FPUT, Write a single character in stream mode to stdout --* `FPUTC': FPUTC, Write a single character in stream mode --* `FRACTION': FRACTION, Fractional part of the model representation --* `FREE': FREE, Memory de-allocation subroutine --* `FSEEK': FSEEK, Low level file positioning subroutine --* `FSTAT': FSTAT, Get file status --* `FTELL': FTELL, Current stream position --* `GAMMA': GAMMA, Gamma function --* `GERROR': GERROR, Get last system error message --* `GETARG': GETARG, Get command line arguments --* `GET_COMMAND': GET_COMMAND, Get the entire command line --* `GET_COMMAND_ARGUMENT': GET_COMMAND_ARGUMENT, Get command line arguments --* `GETCWD': GETCWD, Get current working directory --* `GETENV': GETENV, Get an environmental variable --* `GET_ENVIRONMENT_VARIABLE': GET_ENVIRONMENT_VARIABLE, Get an environmental variable --* `GETGID': GETGID, Group ID function --* `GETLOG': GETLOG, Get login name --* `GETPID': GETPID, Process ID function --* `GETUID': GETUID, User ID function --* `GMTIME': GMTIME, Convert time to GMT info --* `HOSTNM': HOSTNM, Get system host name --* `HUGE': HUGE, Largest number of a kind --* `HYPOT': HYPOT, Euclidian distance function --* `IACHAR': IACHAR, Code in ASCII collating sequence --* `IAND': IAND, Bitwise logical and --* `IARGC': IARGC, Get the number of command line arguments --* `IBCLR': IBCLR, Clear bit --* `IBITS': IBITS, Bit extraction --* `IBSET': IBSET, Set bit --* `ICHAR': ICHAR, Character-to-integer conversion function --* `IDATE': IDATE, Current local time (day/month/year) --* `IEOR': IEOR, Bitwise logical exclusive or --* `IERRNO': IERRNO, Function to get the last system error number --* `INDEX': INDEX intrinsic, Position of a substring within a string --* `INT': INT, Convert to integer type --* `INT2': INT2, Convert to 16-bit integer type --* `INT8': INT8, Convert to 64-bit integer type --* `IOR': IOR, Bitwise logical or --* `IRAND': IRAND, Integer pseudo-random number --* `IS_IOSTAT_END': IS_IOSTAT_END, Test for end-of-file value --* `IS_IOSTAT_EOR': IS_IOSTAT_EOR, Test for end-of-record value --* `ISATTY': ISATTY, Whether a unit is a terminal device --* `ISHFT': ISHFT, Shift bits --* `ISHFTC': ISHFTC, Shift bits circularly --* `ISNAN': ISNAN, Tests for a NaN --* `ITIME': ITIME, Current local time (hour/minutes/seconds) --* `KILL': KILL, Send a signal to a process --* `KIND': KIND, Kind of an entity --* `LBOUND': LBOUND, Lower dimension bounds of an array --* `LEADZ': LEADZ, Number of leading zero bits of an integer --* `LEN': LEN, Length of a character entity --* `LEN_TRIM': LEN_TRIM, Length of a character entity without trailing blank characters --* `LOG_GAMMA': LOG_GAMMA, Logarithm of the Gamma function --* `LGE': LGE, Lexical greater than or equal --* `LGT': LGT, Lexical greater than --* `LINK': LINK, Create a hard link --* `LLE': LLE, Lexical less than or equal --* `LLT': LLT, Lexical less than --* `LNBLNK': LNBLNK, Index of the last non-blank character in a string --* `LOC': LOC, Returns the address of a variable --* `LOG': LOG, Logarithm function --* `LOG10': LOG10, Base 10 logarithm function --* `LOGICAL': LOGICAL, Convert to logical type --* `LONG': LONG, Convert to integer type --* `LSHIFT': LSHIFT, Left shift bits --* `LSTAT': LSTAT, Get file status --* `LTIME': LTIME, Convert time to local time info --* `MALLOC': MALLOC, Dynamic memory allocation function --* `MATMUL': MATMUL, matrix multiplication --* `MAX': MAX, Maximum value of an argument list --* `MAXEXPONENT': MAXEXPONENT, Maximum exponent of a real kind --* `MAXLOC': MAXLOC, Location of the maximum value within an array --* `MAXVAL': MAXVAL, Maximum value of an array --* `MCLOCK': MCLOCK, Time function --* `MCLOCK8': MCLOCK8, Time function (64-bit) --* `MERGE': MERGE, Merge arrays --* `MIN': MIN, Minimum value of an argument list --* `MINEXPONENT': MINEXPONENT, Minimum exponent of a real kind --* `MINLOC': MINLOC, Location of the minimum value within an array --* `MINVAL': MINVAL, Minimum value of an array --* `MOD': MOD, Remainder function --* `MODULO': MODULO, Modulo function --* `MOVE_ALLOC': MOVE_ALLOC, Move allocation from one object to another --* `MVBITS': MVBITS, Move bits from one integer to another --* `NEAREST': NEAREST, Nearest representable number --* `NEW_LINE': NEW_LINE, New line character --* `NINT': NINT, Nearest whole number --* `NOT': NOT, Logical negation --* `NULL': NULL, Function that returns an disassociated pointer --* `OR': OR, Bitwise logical OR --* `PACK': PACK, Pack an array into an array of rank one --* `PERROR': PERROR, Print system error message --* `PRECISION': PRECISION, Decimal precision of a real kind --* `PRESENT': PRESENT, Determine whether an optional dummy argument is specified --* `PRODUCT': PRODUCT, Product of array elements --* `RADIX': RADIX, Base of a data model --* `RANDOM_NUMBER': RANDOM_NUMBER, Pseudo-random number --* `RANDOM_SEED': RANDOM_SEED, Initialize a pseudo-random number sequence --* `RAND': RAND, Real pseudo-random number --* `RANGE': RANGE, Decimal exponent range --* `RAN': RAN, Real pseudo-random number --* `REAL': REAL, Convert to real type --* `RENAME': RENAME, Rename a file --* `REPEAT': REPEAT, Repeated string concatenation --* `RESHAPE': RESHAPE, Function to reshape an array --* `RRSPACING': RRSPACING, Reciprocal of the relative spacing --* `RSHIFT': RSHIFT, Right shift bits --* `SCALE': SCALE, Scale a real value --* `SCAN': SCAN, Scan a string for the presence of a set of characters --* `SECNDS': SECNDS, Time function --* `SECOND': SECOND, CPU time function --* `SELECTED_CHAR_KIND': SELECTED_CHAR_KIND, Choose character kind --* `SELECTED_INT_KIND': SELECTED_INT_KIND, Choose integer kind --* `SELECTED_REAL_KIND': SELECTED_REAL_KIND, Choose real kind --* `SET_EXPONENT': SET_EXPONENT, Set the exponent of the model --* `SHAPE': SHAPE, Determine the shape of an array --* `SIGN': SIGN, Sign copying function --* `SIGNAL': SIGNAL, Signal handling subroutine (or function) --* `SIN': SIN, Sine function --* `SINH': SINH, Hyperbolic sine function --* `SIZE': SIZE, Function to determine the size of an array --* `SIZEOF': SIZEOF, Determine the size in bytes of an expression --* `SLEEP': SLEEP, Sleep for the specified number of seconds --* `SNGL': SNGL, Convert double precision real to default real --* `SPACING': SPACING, Smallest distance between two numbers of a given type --* `SPREAD': SPREAD, Add a dimension to an array --* `SQRT': SQRT, Square-root function --* `SRAND': SRAND, Reinitialize the random number generator --* `STAT': STAT, Get file status --* `SUM': SUM, Sum of array elements --* `SYMLNK': SYMLNK, Create a symbolic link --* `SYSTEM': SYSTEM, Execute a shell command --* `SYSTEM_CLOCK': SYSTEM_CLOCK, Time function --* `TAN': TAN, Tangent function --* `TANH': TANH, Hyperbolic tangent function --* `TIME': TIME, Time function --* `TIME8': TIME8, Time function (64-bit) --* `TINY': TINY, Smallest positive number of a real kind --* `TRAILZ': TRAILZ, Number of trailing zero bits of an integer --* `TRANSFER': TRANSFER, Transfer bit patterns --* `TRANSPOSE': TRANSPOSE, Transpose an array of rank two --* `TRIM': TRIM, Remove trailing blank characters of a string --* `TTYNAM': TTYNAM, Get the name of a terminal device. --* `UBOUND': UBOUND, Upper dimension bounds of an array --* `UMASK': UMASK, Set the file creation mask --* `UNLINK': UNLINK, Remove a file from the file system --* `UNPACK': UNPACK, Unpack an array of rank one into an array --* `VERIFY': VERIFY, Scan a string for the absence of a set of characters --* `XOR': XOR, Bitwise logical exclusive or -- -- --File: gfortran.info, Node: Introduction to Intrinsics, Next: ABORT, Up: Intrinsic Procedures -- --7.1 Introduction to intrinsic procedures --======================================== -- --The intrinsic procedures provided by GNU Fortran include all of the --intrinsic procedures required by the Fortran 95 standard, a set of --intrinsic procedures for backwards compatibility with G77, and a --selection of intrinsic procedures from the Fortran 2003 and Fortran 2008 --standards. Any conflict between a description here and a description in --either the Fortran 95 standard, the Fortran 2003 standard or the Fortran --2008 standard is unintentional, and the standard(s) should be considered --authoritative. -- -- The enumeration of the `KIND' type parameter is processor defined in --the Fortran 95 standard. GNU Fortran defines the default integer type --and default real type by `INTEGER(KIND=4)' and `REAL(KIND=4)', --respectively. The standard mandates that both data types shall have --another kind, which have more precision. On typical target --architectures supported by `gfortran', this kind type parameter is --`KIND=8'. Hence, `REAL(KIND=8)' and `DOUBLE PRECISION' are equivalent. --In the description of generic intrinsic procedures, the kind type --parameter will be specified by `KIND=*', and in the description of --specific names for an intrinsic procedure the kind type parameter will --be explicitly given (e.g., `REAL(KIND=4)' or `REAL(KIND=8)'). Finally, --for brevity the optional `KIND=' syntax will be omitted. -- -- Many of the intrinsic procedures take one or more optional arguments. --This document follows the convention used in the Fortran 95 standard, --and denotes such arguments by square brackets. -- -- GNU Fortran offers the `-std=f95' and `-std=gnu' options, which can --be used to restrict the set of intrinsic procedures to a given --standard. By default, `gfortran' sets the `-std=gnu' option, and so --all intrinsic procedures described here are accepted. There is one --caveat. For a select group of intrinsic procedures, `g77' implemented --both a function and a subroutine. Both classes have been implemented --in `gfortran' for backwards compatibility with `g77'. It is noted here --that these functions and subroutines cannot be intermixed in a given --subprogram. In the descriptions that follow, the applicable standard --for each intrinsic procedure is noted. -- -- --File: gfortran.info, Node: ABORT, Next: ABS, Prev: Introduction to Intrinsics, Up: Intrinsic Procedures -- --7.2 `ABORT' -- Abort the program --================================ -- --_Description_: -- `ABORT' causes immediate termination of the program. On operating -- systems that support a core dump, `ABORT' will produce a core dump -- even if the option `-fno-dump-core' is in effect, which is -- suitable for debugging purposes. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL ABORT' -- --_Return value_: -- Does not return. -- --_Example_: -- program test_abort -- integer :: i = 1, j = 2 -- if (i /= j) call abort -- end program test_abort -- --_See also_: -- *note EXIT::, *note KILL:: -- -- -- --File: gfortran.info, Node: ABS, Next: ACCESS, Prev: ABORT, Up: Intrinsic Procedures -- --7.3 `ABS' -- Absolute value --=========================== -- --_Description_: -- `ABS(A)' computes the absolute value of `A'. -- --_Standard_: -- Fortran 77 and later, has overloads that are GNU extensions -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ABS(A)' -- --_Arguments_: -- A The type of the argument shall be an `INTEGER', -- `REAL', or `COMPLEX'. -- --_Return value_: -- The return value is of the same type and kind as the argument -- except the return value is `REAL' for a `COMPLEX' argument. -- --_Example_: -- program test_abs -- integer :: i = -1 -- real :: x = -1.e0 -- complex :: z = (-1.e0,0.e0) -- i = abs(i) -- x = abs(x) -- x = abs(z) -- end program test_abs -- --_Specific names_: -- Name Argument Return type Standard -- `CABS(A)' `COMPLEX(4) `REAL(4)' Fortran 77 and -- Z' later -- `DABS(A)' `REAL(8) `REAL(8)' Fortran 77 and -- X' later -- `IABS(A)' `INTEGER(4) `INTEGER(4)' Fortran 77 and -- I' later -- `ZABS(A)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- Z' -- `CDABS(A)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- Z' -- -- --File: gfortran.info, Node: ACCESS, Next: ACHAR, Prev: ABS, Up: Intrinsic Procedures -- --7.4 `ACCESS' -- Checks file access modes --======================================== -- --_Description_: -- `ACCESS(NAME, MODE)' checks whether the file NAME exists, is -- readable, writable or executable. Except for the executable check, -- `ACCESS' can be replaced by Fortran 95's `INQUIRE'. -- --_Standard_: -- GNU extension -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = ACCESS(NAME, MODE)' -- --_Arguments_: -- NAME Scalar `CHARACTER' of default kind with the -- file name. Tailing blank are ignored unless -- the character `achar(0)' is present, then all -- characters up to and excluding `achar(0)' are -- used as file name. -- MODE Scalar `CHARACTER' of default kind with the -- file access mode, may be any concatenation of -- `"r"' (readable), `"w"' (writable) and `"x"' -- (executable), or `" "' to check for existence. -- --_Return value_: -- Returns a scalar `INTEGER', which is `0' if the file is accessible -- in the given mode; otherwise or if an invalid argument has been -- given for `MODE' the value `1' is returned. -- --_Example_: -- program access_test -- implicit none -- character(len=*), parameter :: file = 'test.dat' -- character(len=*), parameter :: file2 = 'test.dat '//achar(0) -- if(access(file,' ') == 0) print *, trim(file),' is exists' -- if(access(file,'r') == 0) print *, trim(file),' is readable' -- if(access(file,'w') == 0) print *, trim(file),' is writable' -- if(access(file,'x') == 0) print *, trim(file),' is executable' -- if(access(file2,'rwx') == 0) & -- print *, trim(file2),' is readable, writable and executable' -- end program access_test -- --_Specific names_: -- --_See also_: -- -- --File: gfortran.info, Node: ACHAR, Next: ACOS, Prev: ACCESS, Up: Intrinsic Procedures -- --7.5 `ACHAR' -- Character in ASCII collating sequence --==================================================== -- --_Description_: -- `ACHAR(I)' returns the character located at position `I' in the -- ASCII collating sequence. -- --_Standard_: -- Fortran 77 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ACHAR(I [, KIND])' -- --_Arguments_: -- I The type shall be `INTEGER'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `CHARACTER' with a length of one. If -- the KIND argument is present, the return value is of the specified -- kind and of the default kind otherwise. -- --_Example_: -- program test_achar -- character c -- c = achar(32) -- end program test_achar -- --_Note_: -- See *note ICHAR:: for a discussion of converting between numerical -- values and formatted string representations. -- --_See also_: -- *note CHAR::, *note IACHAR::, *note ICHAR:: -- -- -- --File: gfortran.info, Node: ACOS, Next: ACOSH, Prev: ACHAR, Up: Intrinsic Procedures -- --7.6 `ACOS' -- Arccosine function --================================ -- --_Description_: -- `ACOS(X)' computes the arccosine of X (inverse of `COS(X)'). -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ACOS(X)' -- --_Arguments_: -- X The type shall be `REAL' with a magnitude that -- is less than or equal to one. -- --_Return value_: -- The return value is of type `REAL' and it lies in the range 0 -- \leq \acos(x) \leq \pi. The return value if of the same kind as X. -- --_Example_: -- program test_acos -- real(8) :: x = 0.866_8 -- x = acos(x) -- end program test_acos -- --_Specific names_: -- Name Argument Return type Standard -- `DACOS(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- --_See also_: -- Inverse function: *note COS:: -- -- -- --File: gfortran.info, Node: ACOSH, Next: ADJUSTL, Prev: ACOS, Up: Intrinsic Procedures -- --7.7 `ACOSH' -- Hyperbolic arccosine function --============================================ -- --_Description_: -- `ACOSH(X)' computes the hyperbolic arccosine of X (inverse of -- `COSH(X)'). -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ACOSH(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value has the same type and kind as X -- --_Example_: -- PROGRAM test_acosh -- REAL(8), DIMENSION(3) :: x = (/ 1.0, 2.0, 3.0 /) -- WRITE (*,*) ACOSH(x) -- END PROGRAM -- --_Specific names_: -- Name Argument Return type Standard -- `DACOSH(X)' `REAL(8) X' `REAL(8)' GNU extension -- --_See also_: -- Inverse function: *note COSH:: -- -- --File: gfortran.info, Node: ADJUSTL, Next: ADJUSTR, Prev: ACOSH, Up: Intrinsic Procedures -- --7.8 `ADJUSTL' -- Left adjust a string --===================================== -- --_Description_: -- `ADJUSTL(STRING)' will left adjust a string by removing leading -- spaces. Spaces are inserted at the end of the string as needed. -- --_Standard_: -- Fortran 90 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ADJUSTL(STRING)' -- --_Arguments_: -- STRING The type shall be `CHARACTER'. -- --_Return value_: -- The return value is of type `CHARACTER' and of the same kind as -- STRING where leading spaces are removed and the same number of -- spaces are inserted on the end of STRING. -- --_Example_: -- program test_adjustl -- character(len=20) :: str = ' gfortran' -- str = adjustl(str) -- print *, str -- end program test_adjustl -- --_See also_: -- *note ADJUSTR::, *note TRIM:: -- -- --File: gfortran.info, Node: ADJUSTR, Next: AIMAG, Prev: ADJUSTL, Up: Intrinsic Procedures -- --7.9 `ADJUSTR' -- Right adjust a string --====================================== -- --_Description_: -- `ADJUSTR(STRING)' will right adjust a string by removing trailing -- spaces. Spaces are inserted at the start of the string as needed. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ADJUSTR(STRING)' -- --_Arguments_: -- STR The type shall be `CHARACTER'. -- --_Return value_: -- The return value is of type `CHARACTER' and of the same kind as -- STRING where trailing spaces are removed and the same number of -- spaces are inserted at the start of STRING. -- --_Example_: -- program test_adjustr -- character(len=20) :: str = 'gfortran' -- str = adjustr(str) -- print *, str -- end program test_adjustr -- --_See also_: -- *note ADJUSTL::, *note TRIM:: -- -- --File: gfortran.info, Node: AIMAG, Next: AINT, Prev: ADJUSTR, Up: Intrinsic Procedures -- --7.10 `AIMAG' -- Imaginary part of complex number --================================================ -- --_Description_: -- `AIMAG(Z)' yields the imaginary part of complex argument `Z'. The -- `IMAG(Z)' and `IMAGPART(Z)' intrinsic functions are provided for -- compatibility with `g77', and their use in new code is strongly -- discouraged. -- --_Standard_: -- Fortran 77 and later, has overloads that are GNU extensions -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = AIMAG(Z)' -- --_Arguments_: -- Z The type of the argument shall be `COMPLEX'. -- --_Return value_: -- The return value is of type `REAL' with the kind type parameter of -- the argument. -- --_Example_: -- program test_aimag -- complex(4) z4 -- complex(8) z8 -- z4 = cmplx(1.e0_4, 0.e0_4) -- z8 = cmplx(0.e0_8, 1.e0_8) -- print *, aimag(z4), dimag(z8) -- end program test_aimag -- --_Specific names_: -- Name Argument Return type Standard -- `DIMAG(Z)' `COMPLEX(8) `REAL(8)' GNU extension -- Z' -- `IMAG(Z)' `COMPLEX Z' `REAL' GNU extension -- `IMAGPART(Z)' `COMPLEX Z' `REAL' GNU extension -- -- --File: gfortran.info, Node: AINT, Next: ALARM, Prev: AIMAG, Up: Intrinsic Procedures -- --7.11 `AINT' -- Truncate to a whole number --========================================= -- --_Description_: -- `AINT(A [, KIND])' truncates its argument to a whole number. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = AINT(A [, KIND])' -- --_Arguments_: -- A The type of the argument shall be `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `REAL' with the kind type parameter of -- the argument if the optional KIND is absent; otherwise, the kind -- type parameter will be given by KIND. If the magnitude of X is -- less than one, `AINT(X)' returns zero. If the magnitude is equal -- to or greater than one then it returns the largest whole number -- that does not exceed its magnitude. The sign is the same as the -- sign of X. -- --_Example_: -- program test_aint -- real(4) x4 -- real(8) x8 -- x4 = 1.234E0_4 -- x8 = 4.321_8 -- print *, aint(x4), dint(x8) -- x8 = aint(x4,8) -- end program test_aint -- --_Specific names_: -- Name Argument Return type Standard -- `DINT(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- -- --File: gfortran.info, Node: ALARM, Next: ALL, Prev: AINT, Up: Intrinsic Procedures -- --7.12 `ALARM' -- Execute a routine after a given delay --===================================================== -- --_Description_: -- `ALARM(SECONDS, HANDLER [, STATUS])' causes external subroutine -- HANDLER to be executed after a delay of SECONDS by using -- `alarm(2)' to set up a signal and `signal(2)' to catch it. If -- STATUS is supplied, it will be returned with the number of seconds -- remaining until any previously scheduled alarm was due to be -- delivered, or zero if there was no previously scheduled alarm. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL ALARM(SECONDS, HANDLER [, STATUS])' -- --_Arguments_: -- SECONDS The type of the argument shall be a scalar -- `INTEGER'. It is `INTENT(IN)'. -- HANDLER Signal handler (`INTEGER FUNCTION' or -- `SUBROUTINE') or dummy/global `INTEGER' -- scalar. The scalar values may be either -- `SIG_IGN=1' to ignore the alarm generated or -- `SIG_DFL=0' to set the default action. It is -- `INTENT(IN)'. -- STATUS (Optional) STATUS shall be a scalar variable -- of the default `INTEGER' kind. It is -- `INTENT(OUT)'. -- --_Example_: -- program test_alarm -- external handler_print -- integer i -- call alarm (3, handler_print, i) -- print *, i -- call sleep(10) -- end program test_alarm -- This will cause the external routine HANDLER_PRINT to be called -- after 3 seconds. -- -- --File: gfortran.info, Node: ALL, Next: ALLOCATED, Prev: ALARM, Up: Intrinsic Procedures -- --7.13 `ALL' -- All values in MASK along DIM are true --=================================================== -- --_Description_: -- `ALL(MASK [, DIM])' determines if all the values are true in MASK -- in the array along dimension DIM. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = ALL(MASK [, DIM])' -- --_Arguments_: -- MASK The type of the argument shall be `LOGICAL' and -- it shall not be scalar. -- DIM (Optional) DIM shall be a scalar integer with -- a value that lies between one and the rank of -- MASK. -- --_Return value_: -- `ALL(MASK)' returns a scalar value of type `LOGICAL' where the -- kind type parameter is the same as the kind type parameter of -- MASK. If DIM is present, then `ALL(MASK, DIM)' returns an array -- with the rank of MASK minus 1. The shape is determined from the -- shape of MASK where the DIM dimension is elided. -- -- (A) -- `ALL(MASK)' is true if all elements of MASK are true. It -- also is true if MASK has zero size; otherwise, it is false. -- -- (B) -- If the rank of MASK is one, then `ALL(MASK,DIM)' is equivalent -- to `ALL(MASK)'. If the rank is greater than one, then -- `ALL(MASK,DIM)' is determined by applying `ALL' to the array -- sections. -- --_Example_: -- program test_all -- logical l -- l = all((/.true., .true., .true./)) -- print *, l -- call section -- contains -- subroutine section -- integer a(2,3), b(2,3) -- a = 1 -- b = 1 -- b(2,2) = 2 -- print *, all(a .eq. b, 1) -- print *, all(a .eq. b, 2) -- end subroutine section -- end program test_all -- -- --File: gfortran.info, Node: ALLOCATED, Next: AND, Prev: ALL, Up: Intrinsic Procedures -- --7.14 `ALLOCATED' -- Status of an allocatable entity --=================================================== -- --_Description_: -- `ALLOCATED(ARRAY)' checks the status of whether X is allocated. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = ALLOCATED(ARRAY)' -- --_Arguments_: -- ARRAY The argument shall be an `ALLOCATABLE' array. -- --_Return value_: -- The return value is a scalar `LOGICAL' with the default logical -- kind type parameter. If ARRAY is allocated, `ALLOCATED(ARRAY)' is -- `.TRUE.'; otherwise, it returns `.FALSE.' -- --_Example_: -- program test_allocated -- integer :: i = 4 -- real(4), allocatable :: x(:) -- if (.not. allocated(x)) allocate(x(i)) -- end program test_allocated -- -- --File: gfortran.info, Node: AND, Next: ANINT, Prev: ALLOCATED, Up: Intrinsic Procedures -- --7.15 `AND' -- Bitwise logical AND --================================= -- --_Description_: -- Bitwise logical `AND'. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. For integer arguments, programmers should consider -- the use of the *note IAND:: intrinsic defined by the Fortran -- standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = AND(I, J)' -- --_Arguments_: -- I The type shall be either a scalar `INTEGER' -- type or a scalar `LOGICAL' type. -- J The type shall be the same as the type of I. -- --_Return value_: -- The return type is either a scalar `INTEGER' or a scalar -- `LOGICAL'. If the kind type parameters differ, then the smaller -- kind type is implicitly converted to larger kind, and the return -- has the larger kind. -- --_Example_: -- PROGRAM test_and -- LOGICAL :: T = .TRUE., F = .FALSE. -- INTEGER :: a, b -- DATA a / Z'F' /, b / Z'3' / -- -- WRITE (*,*) AND(T, T), AND(T, F), AND(F, T), AND(F, F) -- WRITE (*,*) AND(a, b) -- END PROGRAM -- --_See also_: -- Fortran 95 elemental function: *note IAND:: -- -- --File: gfortran.info, Node: ANINT, Next: ANY, Prev: AND, Up: Intrinsic Procedures -- --7.16 `ANINT' -- Nearest whole number --==================================== -- --_Description_: -- `ANINT(A [, KIND])' rounds its argument to the nearest whole -- number. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ANINT(A [, KIND])' -- --_Arguments_: -- A The type of the argument shall be `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type real with the kind type parameter of -- the argument if the optional KIND is absent; otherwise, the kind -- type parameter will be given by KIND. If A is greater than zero, -- `ANINT(A)' returns `AINT(X+0.5)'. If A is less than or equal to -- zero then it returns `AINT(X-0.5)'. -- --_Example_: -- program test_anint -- real(4) x4 -- real(8) x8 -- x4 = 1.234E0_4 -- x8 = 4.321_8 -- print *, anint(x4), dnint(x8) -- x8 = anint(x4,8) -- end program test_anint -- --_Specific names_: -- Name Argument Return type Standard -- `DNINT(A)' `REAL(8) A' `REAL(8)' Fortran 77 and -- later -- -- --File: gfortran.info, Node: ANY, Next: ASIN, Prev: ANINT, Up: Intrinsic Procedures -- --7.17 `ANY' -- Any value in MASK along DIM is true --================================================= -- --_Description_: -- `ANY(MASK [, DIM])' determines if any of the values in the logical -- array MASK along dimension DIM are `.TRUE.'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = ANY(MASK [, DIM])' -- --_Arguments_: -- MASK The type of the argument shall be `LOGICAL' and -- it shall not be scalar. -- DIM (Optional) DIM shall be a scalar integer with -- a value that lies between one and the rank of -- MASK. -- --_Return value_: -- `ANY(MASK)' returns a scalar value of type `LOGICAL' where the -- kind type parameter is the same as the kind type parameter of -- MASK. If DIM is present, then `ANY(MASK, DIM)' returns an array -- with the rank of MASK minus 1. The shape is determined from the -- shape of MASK where the DIM dimension is elided. -- -- (A) -- `ANY(MASK)' is true if any element of MASK is true; -- otherwise, it is false. It also is false if MASK has zero -- size. -- -- (B) -- If the rank of MASK is one, then `ANY(MASK,DIM)' is equivalent -- to `ANY(MASK)'. If the rank is greater than one, then -- `ANY(MASK,DIM)' is determined by applying `ANY' to the array -- sections. -- --_Example_: -- program test_any -- logical l -- l = any((/.true., .true., .true./)) -- print *, l -- call section -- contains -- subroutine section -- integer a(2,3), b(2,3) -- a = 1 -- b = 1 -- b(2,2) = 2 -- print *, any(a .eq. b, 1) -- print *, any(a .eq. b, 2) -- end subroutine section -- end program test_any -- -- --File: gfortran.info, Node: ASIN, Next: ASINH, Prev: ANY, Up: Intrinsic Procedures -- --7.18 `ASIN' -- Arcsine function --=============================== -- --_Description_: -- `ASIN(X)' computes the arcsine of its X (inverse of `SIN(X)'). -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ASIN(X)' -- --_Arguments_: -- X The type shall be `REAL', and a magnitude that -- is less than or equal to one. -- --_Return value_: -- The return value is of type `REAL' and it lies in the range -\pi / -- 2 \leq \asin (x) \leq \pi / 2. The kind type parameter is the -- same as X. -- --_Example_: -- program test_asin -- real(8) :: x = 0.866_8 -- x = asin(x) -- end program test_asin -- --_Specific names_: -- Name Argument Return type Standard -- `DASIN(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- --_See also_: -- Inverse function: *note SIN:: -- -- -- --File: gfortran.info, Node: ASINH, Next: ASSOCIATED, Prev: ASIN, Up: Intrinsic Procedures -- --7.19 `ASINH' -- Hyperbolic arcsine function --=========================================== -- --_Description_: -- `ASINH(X)' computes the hyperbolic arcsine of X (inverse of -- `SINH(X)'). -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ASINH(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value is of the same type and kind as X. -- --_Example_: -- PROGRAM test_asinh -- REAL(8), DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /) -- WRITE (*,*) ASINH(x) -- END PROGRAM -- --_Specific names_: -- Name Argument Return type Standard -- `DASINH(X)' `REAL(8) X' `REAL(8)' GNU extension. -- --_See also_: -- Inverse function: *note SINH:: -- -- --File: gfortran.info, Node: ASSOCIATED, Next: ATAN, Prev: ASINH, Up: Intrinsic Procedures -- --7.20 `ASSOCIATED' -- Status of a pointer or pointer/target pair --=============================================================== -- --_Description_: -- `ASSOCIATED(POINTER [, TARGET])' determines the status of the -- pointer POINTER or if POINTER is associated with the target TARGET. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = ASSOCIATED(POINTER [, TARGET])' -- --_Arguments_: -- POINTER POINTER shall have the `POINTER' attribute and -- it can be of any type. -- TARGET (Optional) TARGET shall be a pointer or a -- target. It must have the same type, kind type -- parameter, and array rank as POINTER. -- The association status of neither POINTER nor TARGET shall be -- undefined. -- --_Return value_: -- `ASSOCIATED(POINTER)' returns a scalar value of type `LOGICAL(4)'. -- There are several cases: -- (A) When the optional TARGET is not present then -- `ASSOCIATED(POINTER)' is true if POINTER is associated with a -- target; otherwise, it returns false. -- -- (B) If TARGET is present and a scalar target, the result is true if -- TARGET is not a zero-sized storage sequence and the target -- associated with POINTER occupies the same storage units. If -- POINTER is disassociated, the result is false. -- -- (C) If TARGET is present and an array target, the result is true if -- TARGET and POINTER have the same shape, are not zero-sized -- arrays, are arrays whose elements are not zero-sized storage -- sequences, and TARGET and POINTER occupy the same storage -- units in array element order. As in case(B), the result is -- false, if POINTER is disassociated. -- -- (D) If TARGET is present and an scalar pointer, the result is true -- if TARGET is associated with POINTER, the target associated -- with TARGET are not zero-sized storage sequences and occupy -- the same storage units. The result is false, if either -- TARGET or POINTER is disassociated. -- -- (E) If TARGET is present and an array pointer, the result is true if -- target associated with POINTER and the target associated with -- TARGET have the same shape, are not zero-sized arrays, are -- arrays whose elements are not zero-sized storage sequences, -- and TARGET and POINTER occupy the same storage units in array -- element order. The result is false, if either TARGET or -- POINTER is disassociated. -- --_Example_: -- program test_associated -- implicit none -- real, target :: tgt(2) = (/1., 2./) -- real, pointer :: ptr(:) -- ptr => tgt -- if (associated(ptr) .eqv. .false.) call abort -- if (associated(ptr,tgt) .eqv. .false.) call abort -- end program test_associated -- --_See also_: -- *note NULL:: -- -- --File: gfortran.info, Node: ATAN, Next: ATAN2, Prev: ASSOCIATED, Up: Intrinsic Procedures -- --7.21 `ATAN' -- Arctangent function --================================== -- --_Description_: -- `ATAN(X)' computes the arctangent of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ATAN(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' and it lies in the range - \pi -- / 2 \leq \atan (x) \leq \pi / 2. -- --_Example_: -- program test_atan -- real(8) :: x = 2.866_8 -- x = atan(x) -- end program test_atan -- --_Specific names_: -- Name Argument Return type Standard -- `DATAN(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- --_See also_: -- Inverse function: *note TAN:: -- -- -- --File: gfortran.info, Node: ATAN2, Next: ATANH, Prev: ATAN, Up: Intrinsic Procedures -- --7.22 `ATAN2' -- Arctangent function --=================================== -- --_Description_: -- `ATAN2(Y, X)' computes the arctangent of the complex number X + i -- Y. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ATAN2(Y, X)' -- --_Arguments_: -- Y The type shall be `REAL'. -- X The type and kind type parameter shall be the -- same as Y. If Y is zero, then X must be -- nonzero. -- --_Return value_: -- The return value has the same type and kind type parameter as Y. -- It is the principal value of the complex number X + i Y. If X is -- nonzero, then it lies in the range -\pi \le \atan (x) \leq \pi. -- The sign is positive if Y is positive. If Y is zero, then the -- return value is zero if X is positive and \pi if X is negative. -- Finally, if X is zero, then the magnitude of the result is \pi/2. -- --_Example_: -- program test_atan2 -- real(4) :: x = 1.e0_4, y = 0.5e0_4 -- x = atan2(y,x) -- end program test_atan2 -- --_Specific names_: -- Name Argument Return type Standard -- `DATAN2(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- -- --File: gfortran.info, Node: ATANH, Next: BESSEL_J0, Prev: ATAN2, Up: Intrinsic Procedures -- --7.23 `ATANH' -- Hyperbolic arctangent function --============================================== -- --_Description_: -- `ATANH(X)' computes the hyperbolic arctangent of X (inverse of -- `TANH(X)'). -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ATANH(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value has same type and kind as X. -- --_Example_: -- PROGRAM test_atanh -- REAL, DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /) -- WRITE (*,*) ATANH(x) -- END PROGRAM -- --_Specific names_: -- Name Argument Return type Standard -- `DATANH(X)' `REAL(8) X' `REAL(8)' GNU extension -- --_See also_: -- Inverse function: *note TANH:: -- -- --File: gfortran.info, Node: BESSEL_J0, Next: BESSEL_J1, Prev: ATANH, Up: Intrinsic Procedures -- --7.24 `BESSEL_J0' -- Bessel function of the first kind of order 0 --================================================================ -- --_Description_: -- `BESSEL_J0(X)' computes the Bessel function of the first kind of -- order 0 of X. This function is available under the name `BESJ0' as -- a GNU extension. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_J0(X)' -- --_Arguments_: -- X The type shall be `REAL', and it shall be -- scalar. -- --_Return value_: -- The return value is of type `REAL' and lies in the range - -- 0.4027... \leq Bessel (0,x) \leq 1. It has the same kind as X. -- --_Example_: -- program test_besj0 -- real(8) :: x = 0.0_8 -- x = bessel_j0(x) -- end program test_besj0 -- --_Specific names_: -- Name Argument Return type Standard -- `DBESJ0(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: BESSEL_J1, Next: BESSEL_JN, Prev: BESSEL_J0, Up: Intrinsic Procedures -- --7.25 `BESSEL_J1' -- Bessel function of the first kind of order 1 --================================================================ -- --_Description_: -- `BESSEL_J1(X)' computes the Bessel function of the first kind of -- order 1 of X. This function is available under the name `BESJ1' as -- a GNU extension. -- --_Standard_: -- Fortran 2008 -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_J1(X)' -- --_Arguments_: -- X The type shall be `REAL', and it shall be -- scalar. -- --_Return value_: -- The return value is of type `REAL' and it lies in the range - -- 0.5818... \leq Bessel (0,x) \leq 0.5818 . It has the same kind as -- X. -- --_Example_: -- program test_besj1 -- real(8) :: x = 1.0_8 -- x = bessel_j1(x) -- end program test_besj1 -- --_Specific names_: -- Name Argument Return type Standard -- `DBESJ1(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: BESSEL_JN, Next: BESSEL_Y0, Prev: BESSEL_J1, Up: Intrinsic Procedures -- --7.26 `BESSEL_JN' -- Bessel function of the first kind --===================================================== -- --_Description_: -- `BESSEL_JN(N, X)' computes the Bessel function of the first kind of -- order N of X. This function is available under the name `BESJN' as -- a GNU extension. -- -- If both arguments are arrays, their ranks and shapes shall conform. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_JN(N, X)' -- --_Arguments_: -- N Shall be a scalar or an array of type -- `INTEGER'. -- X Shall be a scalar or an array of type `REAL'. -- --_Return value_: -- The return value is a scalar of type `REAL'. It has the same kind -- as X. -- --_Example_: -- program test_besjn -- real(8) :: x = 1.0_8 -- x = bessel_jn(5,x) -- end program test_besjn -- --_Specific names_: -- Name Argument Return type Standard -- `DBESJN(X)' `INTEGER N' `REAL(8)' GNU extension -- `REAL(8) X' -- -- --File: gfortran.info, Node: BESSEL_Y0, Next: BESSEL_Y1, Prev: BESSEL_JN, Up: Intrinsic Procedures -- --7.27 `BESSEL_Y0' -- Bessel function of the second kind of order 0 --================================================================= -- --_Description_: -- `BESSEL_Y0(X)' computes the Bessel function of the second kind of -- order 0 of X. This function is available under the name `BESY0' as -- a GNU extension. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_Y0(X)' -- --_Arguments_: -- X The type shall be `REAL', and it shall be -- scalar. -- --_Return value_: -- The return value is a scalar of type `REAL'. It has the same kind -- as X. -- --_Example_: -- program test_besy0 -- real(8) :: x = 0.0_8 -- x = bessel_y0(x) -- end program test_besy0 -- --_Specific names_: -- Name Argument Return type Standard -- `DBESY0(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: BESSEL_Y1, Next: BESSEL_YN, Prev: BESSEL_Y0, Up: Intrinsic Procedures -- --7.28 `BESSEL_Y1' -- Bessel function of the second kind of order 1 --================================================================= -- --_Description_: -- `BESSEL_Y1(X)' computes the Bessel function of the second kind of -- order 1 of X. This function is available under the name `BESY1' as -- a GNU extension. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_Y1(X)' -- --_Arguments_: -- X The type shall be `REAL', and it shall be -- scalar. -- --_Return value_: -- The return value is a scalar of type `REAL'. It has the same kind -- as X. -- --_Example_: -- program test_besy1 -- real(8) :: x = 1.0_8 -- x = bessel_y1(x) -- end program test_besy1 -- --_Specific names_: -- Name Argument Return type Standard -- `DBESY1(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: BESSEL_YN, Next: BIT_SIZE, Prev: BESSEL_Y1, Up: Intrinsic Procedures -- --7.29 `BESSEL_YN' -- Bessel function of the second kind --====================================================== -- --_Description_: -- `BESSEL_YN(N, X)' computes the Bessel function of the second kind -- of order N of X. This function is available under the name `BESYN' -- as a GNU extension. -- -- If both arguments are arrays, their ranks and shapes shall conform. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BESSEL_YN(N, X)' -- --_Arguments_: -- N Shall be a scalar or an array of type -- `INTEGER'. -- X Shall be a scalar or an array of type `REAL'. -- --_Return value_: -- The return value is a scalar of type `REAL'. It has the same kind -- as X. -- --_Example_: -- program test_besyn -- real(8) :: x = 1.0_8 -- x = bessel_yn(5,x) -- end program test_besyn -- --_Specific names_: -- Name Argument Return type Standard -- `DBESYN(N,X)' `INTEGER N' `REAL(8)' GNU extension -- `REAL(8) -- X' -- -- --File: gfortran.info, Node: BIT_SIZE, Next: BTEST, Prev: BESSEL_YN, Up: Intrinsic Procedures -- --7.30 `BIT_SIZE' -- Bit size inquiry function --============================================ -- --_Description_: -- `BIT_SIZE(I)' returns the number of bits (integer precision plus -- sign bit) represented by the type of I. The result of -- `BIT_SIZE(I)' is independent of the actual value of I. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = BIT_SIZE(I)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' -- --_Example_: -- program test_bit_size -- integer :: i = 123 -- integer :: size -- size = bit_size(i) -- print *, size -- end program test_bit_size -- -- --File: gfortran.info, Node: BTEST, Next: C_ASSOCIATED, Prev: BIT_SIZE, Up: Intrinsic Procedures -- --7.31 `BTEST' -- Bit test function --================================= -- --_Description_: -- `BTEST(I,POS)' returns logical `.TRUE.' if the bit at POS in I is -- set. The counting of the bits starts at 0. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = BTEST(I, POS)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- POS The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `LOGICAL' -- --_Example_: -- program test_btest -- integer :: i = 32768 + 1024 + 64 -- integer :: pos -- logical :: bool -- do pos=0,16 -- bool = btest(i, pos) -- print *, pos, bool -- end do -- end program test_btest -- -- --File: gfortran.info, Node: C_ASSOCIATED, Next: C_F_POINTER, Prev: BTEST, Up: Intrinsic Procedures -- --7.32 `C_ASSOCIATED' -- Status of a C pointer --============================================ -- --_Description_: -- `C_ASSOCIATED(c_prt_1[, c_ptr_2])' determines the status of the C -- pointer C_PTR_1 or if C_PTR_1 is associated with the target -- C_PTR_2. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = C_ASSOCIATED(c_prt_1[, c_ptr_2])' -- --_Arguments_: -- C_PTR_1 Scalar of the type `C_PTR' or `C_FUNPTR'. -- C_PTR_2 (Optional) Scalar of the same type as C_PTR_1. -- --_Return value_: -- The return value is of type `LOGICAL'; it is `.false.' if either -- C_PTR_1 is a C NULL pointer or if C_PTR1 and C_PTR_2 point to -- different addresses. -- --_Example_: -- subroutine association_test(a,b) -- use iso_c_binding, only: c_associated, c_loc, c_ptr -- implicit none -- real, pointer :: a -- type(c_ptr) :: b -- if(c_associated(b, c_loc(a))) & -- stop 'b and a do not point to same target' -- end subroutine association_test -- --_See also_: -- *note C_LOC::, *note C_FUNLOC:: -- -- --File: gfortran.info, Node: C_FUNLOC, Next: C_LOC, Prev: C_F_PROCPOINTER, Up: Intrinsic Procedures -- --7.33 `C_FUNLOC' -- Obtain the C address of a procedure --====================================================== -- --_Description_: -- `C_FUNLOC(x)' determines the C address of the argument. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = C_FUNLOC(x)' -- --_Arguments_: -- X Interoperable function or pointer to such -- function. -- --_Return value_: -- The return value is of type `C_FUNPTR' and contains the C address -- of the argument. -- --_Example_: -- module x -- use iso_c_binding -- implicit none -- contains -- subroutine sub(a) bind(c) -- real(c_float) :: a -- a = sqrt(a)+5.0 -- end subroutine sub -- end module x -- program main -- use iso_c_binding -- use x -- implicit none -- interface -- subroutine my_routine(p) bind(c,name='myC_func') -- import :: c_funptr -- type(c_funptr), intent(in) :: p -- end subroutine -- end interface -- call my_routine(c_funloc(sub)) -- end program main -- --_See also_: -- *note C_ASSOCIATED::, *note C_LOC::, *note C_F_POINTER::, *note -- C_F_PROCPOINTER:: -- -- --File: gfortran.info, Node: C_F_PROCPOINTER, Next: C_FUNLOC, Prev: C_F_POINTER, Up: Intrinsic Procedures -- --7.34 `C_F_PROCPOINTER' -- Convert C into Fortran procedure pointer --================================================================== -- --_Description_: -- `C_F_PROCPOINTER(CPTR, FPTR)' Assign the target of the C function -- pointer CPTR to the Fortran procedure pointer FPTR. -- -- Note: Due to the currently lacking support of procedure pointers -- in GNU Fortran this function is not fully operable. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL C_F_PROCPOINTER(cptr, fptr)' -- --_Arguments_: -- CPTR scalar of the type `C_FUNPTR'. It is -- `INTENT(IN)'. -- FPTR procedure pointer interoperable with CPTR. It -- is `INTENT(OUT)'. -- --_Example_: -- program main -- use iso_c_binding -- implicit none -- abstract interface -- function func(a) -- import :: c_float -- real(c_float), intent(in) :: a -- real(c_float) :: func -- end function -- end interface -- interface -- function getIterFunc() bind(c,name="getIterFunc") -- import :: c_funptr -- type(c_funptr) :: getIterFunc -- end function -- end interface -- type(c_funptr) :: cfunptr -- procedure(func), pointer :: myFunc -- cfunptr = getIterFunc() -- call c_f_procpointer(cfunptr, myFunc) -- end program main -- --_See also_: -- *note C_LOC::, *note C_F_POINTER:: -- -- --File: gfortran.info, Node: C_F_POINTER, Next: C_F_PROCPOINTER, Prev: C_ASSOCIATED, Up: Intrinsic Procedures -- --7.35 `C_F_POINTER' -- Convert C into Fortran pointer --==================================================== -- --_Description_: -- `C_F_POINTER(CPTR, FPTR[, SHAPE])' Assign the target the C pointer -- CPTR to the Fortran pointer FPTR and specify its shape. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL C_F_POINTER(CPTR, FPTR[, SHAPE])' -- --_Arguments_: -- CPTR scalar of the type `C_PTR'. It is `INTENT(IN)'. -- FPTR pointer interoperable with CPTR. It is -- `INTENT(OUT)'. -- SHAPE (Optional) Rank-one array of type `INTEGER' -- with `INTENT(IN)'. It shall be present if and -- only if FPTR is an array. The size must be -- equal to the rank of FPTR. -- --_Example_: -- program main -- use iso_c_binding -- implicit none -- interface -- subroutine my_routine(p) bind(c,name='myC_func') -- import :: c_ptr -- type(c_ptr), intent(out) :: p -- end subroutine -- end interface -- type(c_ptr) :: cptr -- real,pointer :: a(:) -- call my_routine(cptr) -- call c_f_pointer(cptr, a, [12]) -- end program main -- --_See also_: -- *note C_LOC::, *note C_F_PROCPOINTER:: -- -- --File: gfortran.info, Node: C_LOC, Next: C_SIZEOF, Prev: C_FUNLOC, Up: Intrinsic Procedures -- --7.36 `C_LOC' -- Obtain the C address of an object --================================================= -- --_Description_: -- `C_LOC(X)' determines the C address of the argument. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = C_LOC(X)' -- --_Arguments_: -- X Associated scalar pointer or interoperable -- scalar or allocated allocatable variable with -- `TARGET' attribute. -- --_Return value_: -- The return value is of type `C_PTR' and contains the C address of -- the argument. -- --_Example_: -- subroutine association_test(a,b) -- use iso_c_binding, only: c_associated, c_loc, c_ptr -- implicit none -- real, pointer :: a -- type(c_ptr) :: b -- if(c_associated(b, c_loc(a))) & -- stop 'b and a do not point to same target' -- end subroutine association_test -- --_See also_: -- *note C_ASSOCIATED::, *note C_FUNLOC::, *note C_F_POINTER::, *note -- C_F_PROCPOINTER:: -- -- --File: gfortran.info, Node: C_SIZEOF, Next: CEILING, Prev: C_LOC, Up: Intrinsic Procedures -- --7.37 `C_SIZEOF' -- Size in bytes of an expression --================================================= -- --_Description_: -- `C_SIZEOF(X)' calculates the number of bytes of storage the -- expression `X' occupies. -- --_Standard_: -- Fortran 2008 -- --_Class_: -- Intrinsic function -- --_Syntax_: -- `N = C_SIZEOF(X)' -- --_Arguments_: -- X The argument shall be of any type, rank or -- shape. -- --_Return value_: -- The return value is of type integer and of the system-dependent -- kind C_SIZE_T (from the ISO_C_BINDING module). Its value is the -- number of bytes occupied by the argument. If the argument has the -- `POINTER' attribute, the number of bytes of the storage area -- pointed to is returned. If the argument is of a derived type with -- `POINTER' or `ALLOCATABLE' components, the return value doesn't -- account for the sizes of the data pointed to by these components. -- --_Example_: -- use iso_c_binding -- integer(c_int) :: i -- real(c_float) :: r, s(5) -- print *, (c_sizeof(s)/c_sizeof(r) == 5) -- end -- The example will print `.TRUE.' unless you are using a platform -- where default `REAL' variables are unusually padded. -- --_See also_: -- *note SIZEOF:: -- -- --File: gfortran.info, Node: CEILING, Next: CHAR, Prev: C_SIZEOF, Up: Intrinsic Procedures -- --7.38 `CEILING' -- Integer ceiling function --========================================== -- --_Description_: -- `CEILING(A)' returns the least integer greater than or equal to A. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = CEILING(A [, KIND])' -- --_Arguments_: -- A The type shall be `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER(KIND)' if KIND is present and -- a default-kind `INTEGER' otherwise. -- --_Example_: -- program test_ceiling -- real :: x = 63.29 -- real :: y = -63.59 -- print *, ceiling(x) ! returns 64 -- print *, ceiling(y) ! returns -63 -- end program test_ceiling -- --_See also_: -- *note FLOOR::, *note NINT:: -- -- -- --File: gfortran.info, Node: CHAR, Next: CHDIR, Prev: CEILING, Up: Intrinsic Procedures -- --7.39 `CHAR' -- Character conversion function --============================================ -- --_Description_: -- `CHAR(I [, KIND])' returns the character represented by the -- integer I. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = CHAR(I [, KIND])' -- --_Arguments_: -- I The type shall be `INTEGER'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `CHARACTER(1)' -- --_Example_: -- program test_char -- integer :: i = 74 -- character(1) :: c -- c = char(i) -- print *, i, c ! returns 'J' -- end program test_char -- --_Note_: -- See *note ICHAR:: for a discussion of converting between numerical -- values and formatted string representations. -- --_See also_: -- *note ACHAR::, *note IACHAR::, *note ICHAR:: -- -- -- --File: gfortran.info, Node: CHDIR, Next: CHMOD, Prev: CHAR, Up: Intrinsic Procedures -- --7.40 `CHDIR' -- Change working directory --======================================== -- --_Description_: -- Change current working directory to a specified path. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL CHDIR(NAME [, STATUS])' -- `STATUS = CHDIR(NAME)' -- --_Arguments_: -- NAME The type shall be `CHARACTER' of default kind -- and shall specify a valid path within the file -- system. -- STATUS (Optional) `INTEGER' status flag of the default -- kind. Returns 0 on success, and a system -- specific and nonzero error code otherwise. -- --_Example_: -- PROGRAM test_chdir -- CHARACTER(len=255) :: path -- CALL getcwd(path) -- WRITE(*,*) TRIM(path) -- CALL chdir("/tmp") -- CALL getcwd(path) -- WRITE(*,*) TRIM(path) -- END PROGRAM -- --_See also_: -- *note GETCWD:: -- -- --File: gfortran.info, Node: CHMOD, Next: CMPLX, Prev: CHDIR, Up: Intrinsic Procedures -- --7.41 `CHMOD' -- Change access permissions of files --================================================== -- --_Description_: -- `CHMOD' changes the permissions of a file. This function invokes -- `/bin/chmod' and might therefore not work on all platforms. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL CHMOD(NAME, MODE[, STATUS])' -- `STATUS = CHMOD(NAME, MODE)' -- --_Arguments_: -- NAME Scalar `CHARACTER' of default kind with the -- file name. Trailing blanks are ignored unless -- the character `achar(0)' is present, then all -- characters up to and excluding `achar(0)' are -- used as the file name. -- MODE Scalar `CHARACTER' of default kind giving the -- file permission. MODE uses the same syntax as -- the MODE argument of `/bin/chmod'. -- STATUS (optional) scalar `INTEGER', which is `0' on -- success and nonzero otherwise. -- --_Return value_: -- In either syntax, STATUS is set to `0' on success and nonzero -- otherwise. -- --_Example_: -- `CHMOD' as subroutine -- program chmod_test -- implicit none -- integer :: status -- call chmod('test.dat','u+x',status) -- print *, 'Status: ', status -- end program chmod_test -- `CHMOD' as function: -- program chmod_test -- implicit none -- integer :: status -- status = chmod('test.dat','u+x') -- print *, 'Status: ', status -- end program chmod_test -- -- -- --File: gfortran.info, Node: CMPLX, Next: COMMAND_ARGUMENT_COUNT, Prev: CHMOD, Up: Intrinsic Procedures -- --7.42 `CMPLX' -- Complex conversion function --=========================================== -- --_Description_: -- `CMPLX(X [, Y [, KIND]])' returns a complex number where X is -- converted to the real component. If Y is present it is converted -- to the imaginary component. If Y is not present then the -- imaginary component is set to 0.0. If X is complex then Y must -- not be present. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = CMPLX(X [, Y [, KIND]])' -- --_Arguments_: -- X The type may be `INTEGER', `REAL', or -- `COMPLEX'. -- Y (Optional; only allowed if X is not -- `COMPLEX'.) May be `INTEGER' or `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of `COMPLEX' type, with a kind equal to KIND -- if it is specified. If KIND is not specified, the result is of -- the default `COMPLEX' kind, regardless of the kinds of X and Y. -- --_Example_: -- program test_cmplx -- integer :: i = 42 -- real :: x = 3.14 -- complex :: z -- z = cmplx(i, x) -- print *, z, cmplx(x) -- end program test_cmplx -- --_See also_: -- *note COMPLEX:: -- -- --File: gfortran.info, Node: COMMAND_ARGUMENT_COUNT, Next: COMPLEX, Prev: CMPLX, Up: Intrinsic Procedures -- --7.43 `COMMAND_ARGUMENT_COUNT' -- Get number of command line arguments --===================================================================== -- --_Description_: -- `COMMAND_ARGUMENT_COUNT()' returns the number of arguments passed -- on the command line when the containing program was invoked. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = COMMAND_ARGUMENT_COUNT()' -- --_Arguments_: -- None -- --_Return value_: -- The return value is of type `INTEGER(4)' -- --_Example_: -- program test_command_argument_count -- integer :: count -- count = command_argument_count() -- print *, count -- end program test_command_argument_count -- --_See also_: -- *note GET_COMMAND::, *note GET_COMMAND_ARGUMENT:: -- -- --File: gfortran.info, Node: COMPLEX, Next: CONJG, Prev: COMMAND_ARGUMENT_COUNT, Up: Intrinsic Procedures -- --7.44 `COMPLEX' -- Complex conversion function --============================================= -- --_Description_: -- `COMPLEX(X, Y)' returns a complex number where X is converted to -- the real component and Y is converted to the imaginary component. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = COMPLEX(X, Y)' -- --_Arguments_: -- X The type may be `INTEGER' or `REAL'. -- Y The type may be `INTEGER' or `REAL'. -- --_Return value_: -- If X and Y are both of `INTEGER' type, then the return value is of -- default `COMPLEX' type. -- -- If X and Y are of `REAL' type, or one is of `REAL' type and one is -- of `INTEGER' type, then the return value is of `COMPLEX' type with -- a kind equal to that of the `REAL' argument with the highest -- precision. -- --_Example_: -- program test_complex -- integer :: i = 42 -- real :: x = 3.14 -- print *, complex(i, x) -- end program test_complex -- --_See also_: -- *note CMPLX:: -- -- --File: gfortran.info, Node: CONJG, Next: COS, Prev: COMPLEX, Up: Intrinsic Procedures -- --7.45 `CONJG' -- Complex conjugate function --========================================== -- --_Description_: -- `CONJG(Z)' returns the conjugate of Z. If Z is `(x, y)' then the -- result is `(x, -y)' -- --_Standard_: -- Fortran 77 and later, has overloads that are GNU extensions -- --_Class_: -- Elemental function -- --_Syntax_: -- `Z = CONJG(Z)' -- --_Arguments_: -- Z The type shall be `COMPLEX'. -- --_Return value_: -- The return value is of type `COMPLEX'. -- --_Example_: -- program test_conjg -- complex :: z = (2.0, 3.0) -- complex(8) :: dz = (2.71_8, -3.14_8) -- z= conjg(z) -- print *, z -- dz = dconjg(dz) -- print *, dz -- end program test_conjg -- --_Specific names_: -- Name Argument Return type Standard -- `DCONJG(Z)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- Z' -- -- --File: gfortran.info, Node: COS, Next: COSH, Prev: CONJG, Up: Intrinsic Procedures -- --7.46 `COS' -- Cosine function --============================= -- --_Description_: -- `COS(X)' computes the cosine of X. -- --_Standard_: -- Fortran 77 and later, has overloads that are GNU extensions -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = COS(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value is of type `REAL' and it lies in the range -1 -- \leq \cos (x) \leq 1. The kind type parameter is the same as X. -- --_Example_: -- program test_cos -- real :: x = 0.0 -- x = cos(x) -- end program test_cos -- --_Specific names_: -- Name Argument Return type Standard -- `DCOS(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- `CCOS(X)' `COMPLEX(4) `COMPLEX(4)' Fortran 77 and -- X' later -- `ZCOS(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- `CDCOS(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- --_See also_: -- Inverse function: *note ACOS:: -- -- -- --File: gfortran.info, Node: COSH, Next: COUNT, Prev: COS, Up: Intrinsic Procedures -- --7.47 `COSH' -- Hyperbolic cosine function --========================================= -- --_Description_: -- `COSH(X)' computes the hyperbolic cosine of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `X = COSH(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' and it is positive ( \cosh (x) -- \geq 0 ). For a `REAL' argument X, \cosh (x) \geq 1 . The -- return value is of the same kind as X. -- --_Example_: -- program test_cosh -- real(8) :: x = 1.0_8 -- x = cosh(x) -- end program test_cosh -- --_Specific names_: -- Name Argument Return type Standard -- `DCOSH(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- --_See also_: -- Inverse function: *note ACOSH:: -- -- -- --File: gfortran.info, Node: COUNT, Next: CPU_TIME, Prev: COSH, Up: Intrinsic Procedures -- --7.48 `COUNT' -- Count function --============================== -- --_Description_: -- `COUNT(MASK [, DIM [, KIND]])' counts the number of `.TRUE.' -- elements of MASK along the dimension of DIM. If DIM is omitted it -- is taken to be `1'. DIM is a scalar of type `INTEGER' in the -- range of 1 /leq DIM /leq n) where n is the rank of MASK. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = COUNT(MASK [, DIM [, KIND]])' -- --_Arguments_: -- MASK The type shall be `LOGICAL'. -- DIM (Optional) The type shall be `INTEGER'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. The result -- has a rank equal to that of MASK. -- --_Example_: -- program test_count -- integer, dimension(2,3) :: a, b -- logical, dimension(2,3) :: mask -- a = reshape( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /)) -- b = reshape( (/ 0, 7, 3, 4, 5, 8 /), (/ 2, 3 /)) -- print '(3i3)', a(1,:) -- print '(3i3)', a(2,:) -- print * -- print '(3i3)', b(1,:) -- print '(3i3)', b(2,:) -- print * -- mask = a.ne.b -- print '(3l3)', mask(1,:) -- print '(3l3)', mask(2,:) -- print * -- print '(3i3)', count(mask) -- print * -- print '(3i3)', count(mask, 1) -- print * -- print '(3i3)', count(mask, 2) -- end program test_count -- -- --File: gfortran.info, Node: CPU_TIME, Next: CSHIFT, Prev: COUNT, Up: Intrinsic Procedures -- --7.49 `CPU_TIME' -- CPU elapsed time in seconds --============================================== -- --_Description_: -- Returns a `REAL' value representing the elapsed CPU time in -- seconds. This is useful for testing segments of code to determine -- execution time. -- -- If a time source is available, time will be reported with -- microsecond resolution. If no time source is available, TIME is -- set to `-1.0'. -- -- Note that TIME may contain a, system dependent, arbitrary offset -- and may not start with `0.0'. For `CPU_TIME', the absolute value -- is meaningless, only differences between subsequent calls to this -- subroutine, as shown in the example below, should be used. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL CPU_TIME(TIME)' -- --_Arguments_: -- TIME The type shall be `REAL' with `INTENT(OUT)'. -- --_Return value_: -- None -- --_Example_: -- program test_cpu_time -- real :: start, finish -- call cpu_time(start) -- ! put code to test here -- call cpu_time(finish) -- print '("Time = ",f6.3," seconds.")',finish-start -- end program test_cpu_time -- --_See also_: -- *note SYSTEM_CLOCK::, *note DATE_AND_TIME:: -- -- --File: gfortran.info, Node: CSHIFT, Next: CTIME, Prev: CPU_TIME, Up: Intrinsic Procedures -- --7.50 `CSHIFT' -- Circular shift elements of an array --==================================================== -- --_Description_: -- `CSHIFT(ARRAY, SHIFT [, DIM])' performs a circular shift on -- elements of ARRAY along the dimension of DIM. If DIM is omitted -- it is taken to be `1'. DIM is a scalar of type `INTEGER' in the -- range of 1 /leq DIM /leq n) where n is the rank of ARRAY. If the -- rank of ARRAY is one, then all elements of ARRAY are shifted by -- SHIFT places. If rank is greater than one, then all complete rank -- one sections of ARRAY along the given dimension are shifted. -- Elements shifted out one end of each rank one section are shifted -- back in the other end. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = CSHIFT(ARRAY, SHIFT [, DIM])' -- --_Arguments_: -- ARRAY Shall be an array of any type. -- SHIFT The type shall be `INTEGER'. -- DIM The type shall be `INTEGER'. -- --_Return value_: -- Returns an array of same type and rank as the ARRAY argument. -- --_Example_: -- program test_cshift -- integer, dimension(3,3) :: a -- a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /)) -- print '(3i3)', a(1,:) -- print '(3i3)', a(2,:) -- print '(3i3)', a(3,:) -- a = cshift(a, SHIFT=(/1, 2, -1/), DIM=2) -- print * -- print '(3i3)', a(1,:) -- print '(3i3)', a(2,:) -- print '(3i3)', a(3,:) -- end program test_cshift -- -- --File: gfortran.info, Node: CTIME, Next: DATE_AND_TIME, Prev: CSHIFT, Up: Intrinsic Procedures -- --7.51 `CTIME' -- Convert a time into a string --============================================ -- --_Description_: -- `CTIME' converts a system time value, such as returned by -- `TIME8()', to a string of the form `Sat Aug 19 18:13:14 1995'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL CTIME(TIME, RESULT)'. -- `RESULT = CTIME(TIME)', (not recommended). -- --_Arguments_: -- TIME The type shall be of type `INTEGER(KIND=8)'. -- RESULT The type shall be of type `CHARACTER' and of -- default kind. -- --_Return value_: -- The converted date and time as a string. -- --_Example_: -- program test_ctime -- integer(8) :: i -- character(len=30) :: date -- i = time8() -- -- ! Do something, main part of the program -- -- call ctime(i,date) -- print *, 'Program was started on ', date -- end program test_ctime -- --_See Also_: -- *note GMTIME::, *note LTIME::, *note TIME::, *note TIME8:: -- -- --File: gfortran.info, Node: DATE_AND_TIME, Next: DBLE, Prev: CTIME, Up: Intrinsic Procedures -- --7.52 `DATE_AND_TIME' -- Date and time subroutine --================================================ -- --_Description_: -- `DATE_AND_TIME(DATE, TIME, ZONE, VALUES)' gets the corresponding -- date and time information from the real-time system clock. DATE is -- `INTENT(OUT)' and has form ccyymmdd. TIME is `INTENT(OUT)' and -- has form hhmmss.sss. ZONE is `INTENT(OUT)' and has form (+-)hhmm, -- representing the difference with respect to Coordinated Universal -- Time (UTC). Unavailable time and date parameters return blanks. -- -- VALUES is `INTENT(OUT)' and provides the following: -- -- `VALUE(1)': The year -- `VALUE(2)': The month -- `VALUE(3)': The day of the month -- `VALUE(4)': Time difference with UTC -- in minutes -- `VALUE(5)': The hour of the day -- `VALUE(6)': The minutes of the hour -- `VALUE(7)': The seconds of the minute -- `VALUE(8)': The milliseconds of the -- second -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])' -- --_Arguments_: -- DATE (Optional) The type shall be `CHARACTER(LEN=8)' -- or larger, and of default kind. -- TIME (Optional) The type shall be -- `CHARACTER(LEN=10)' or larger, and of default -- kind. -- ZONE (Optional) The type shall be `CHARACTER(LEN=5)' -- or larger, and of default kind. -- VALUES (Optional) The type shall be `INTEGER(8)'. -- --_Return value_: -- None -- --_Example_: -- program test_time_and_date -- character(8) :: date -- character(10) :: time -- character(5) :: zone -- integer,dimension(8) :: values -- ! using keyword arguments -- call date_and_time(date,time,zone,values) -- call date_and_time(DATE=date,ZONE=zone) -- call date_and_time(TIME=time) -- call date_and_time(VALUES=values) -- print '(a,2x,a,2x,a)', date, time, zone -- print '(8i5))', values -- end program test_time_and_date -- --_See also_: -- *note CPU_TIME::, *note SYSTEM_CLOCK:: -- -- --File: gfortran.info, Node: DBLE, Next: DCMPLX, Prev: DATE_AND_TIME, Up: Intrinsic Procedures -- --7.53 `DBLE' -- Double conversion function --========================================= -- --_Description_: -- `DBLE(A)' Converts A to double precision real type. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DBLE(A)' -- --_Arguments_: -- A The type shall be `INTEGER', `REAL', or -- `COMPLEX'. -- --_Return value_: -- The return value is of type double precision real. -- --_Example_: -- program test_dble -- real :: x = 2.18 -- integer :: i = 5 -- complex :: z = (2.3,1.14) -- print *, dble(x), dble(i), dble(z) -- end program test_dble -- --_See also_: -- *note DFLOAT::, *note FLOAT::, *note REAL:: -- -- --File: gfortran.info, Node: DCMPLX, Next: DFLOAT, Prev: DBLE, Up: Intrinsic Procedures -- --7.54 `DCMPLX' -- Double complex conversion function --=================================================== -- --_Description_: -- `DCMPLX(X [,Y])' returns a double complex number where X is -- converted to the real component. If Y is present it is converted -- to the imaginary component. If Y is not present then the -- imaginary component is set to 0.0. If X is complex then Y must -- not be present. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DCMPLX(X [, Y])' -- --_Arguments_: -- X The type may be `INTEGER', `REAL', or -- `COMPLEX'. -- Y (Optional if X is not `COMPLEX'.) May be -- `INTEGER' or `REAL'. -- --_Return value_: -- The return value is of type `COMPLEX(8)' -- --_Example_: -- program test_dcmplx -- integer :: i = 42 -- real :: x = 3.14 -- complex :: z -- z = cmplx(i, x) -- print *, dcmplx(i) -- print *, dcmplx(x) -- print *, dcmplx(z) -- print *, dcmplx(x,i) -- end program test_dcmplx -- -- --File: gfortran.info, Node: DFLOAT, Next: DIGITS, Prev: DCMPLX, Up: Intrinsic Procedures -- --7.55 `DFLOAT' -- Double conversion function --=========================================== -- --_Description_: -- `DFLOAT(A)' Converts A to double precision real type. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DFLOAT(A)' -- --_Arguments_: -- A The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type double precision real. -- --_Example_: -- program test_dfloat -- integer :: i = 5 -- print *, dfloat(i) -- end program test_dfloat -- --_See also_: -- *note DBLE::, *note FLOAT::, *note REAL:: -- -- --File: gfortran.info, Node: DIGITS, Next: DIM, Prev: DFLOAT, Up: Intrinsic Procedures -- --7.56 `DIGITS' -- Significant binary digits function --=================================================== -- --_Description_: -- `DIGITS(X)' returns the number of significant binary digits of the -- internal model representation of X. For example, on a system -- using a 32-bit floating point representation, a default real -- number would likely return 24. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = DIGITS(X)' -- --_Arguments_: -- X The type may be `INTEGER' or `REAL'. -- --_Return value_: -- The return value is of type `INTEGER'. -- --_Example_: -- program test_digits -- integer :: i = 12345 -- real :: x = 3.143 -- real(8) :: y = 2.33 -- print *, digits(i) -- print *, digits(x) -- print *, digits(y) -- end program test_digits -- -- --File: gfortran.info, Node: DIM, Next: DOT_PRODUCT, Prev: DIGITS, Up: Intrinsic Procedures -- --7.57 `DIM' -- Positive difference --================================= -- --_Description_: -- `DIM(X,Y)' returns the difference `X-Y' if the result is positive; -- otherwise returns zero. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DIM(X, Y)' -- --_Arguments_: -- X The type shall be `INTEGER' or `REAL' -- Y The type shall be the same type and kind as X. -- --_Return value_: -- The return value is of type `INTEGER' or `REAL'. -- --_Example_: -- program test_dim -- integer :: i -- real(8) :: x -- i = dim(4, 15) -- x = dim(4.345_8, 2.111_8) -- print *, i -- print *, x -- end program test_dim -- --_Specific names_: -- Name Argument Return type Standard -- `IDIM(X,Y)' `INTEGER(4) `INTEGER(4)' Fortran 77 and -- X,Y' later -- `DDIM(X,Y)' `REAL(8) `REAL(8)' Fortran 77 and -- X,Y' later -- -- --File: gfortran.info, Node: DOT_PRODUCT, Next: DPROD, Prev: DIM, Up: Intrinsic Procedures -- --7.58 `DOT_PRODUCT' -- Dot product function --========================================== -- --_Description_: -- `DOT_PRODUCT(VECTOR_A, VECTOR_B)' computes the dot product -- multiplication of two vectors VECTOR_A and VECTOR_B. The two -- vectors may be either numeric or logical and must be arrays of -- rank one and of equal size. If the vectors are `INTEGER' or -- `REAL', the result is `SUM(VECTOR_A*VECTOR_B)'. If the vectors are -- `COMPLEX', the result is `SUM(CONJG(VECTOR_A)*VECTOR_B)'. If the -- vectors are `LOGICAL', the result is `ANY(VECTOR_A .AND. -- VECTOR_B)'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = DOT_PRODUCT(VECTOR_A, VECTOR_B)' -- --_Arguments_: -- VECTOR_A The type shall be numeric or `LOGICAL', rank 1. -- VECTOR_B The type shall be numeric if VECTOR_A is of -- numeric type or `LOGICAL' if VECTOR_A is of -- type `LOGICAL'. VECTOR_B shall be a rank-one -- array. -- --_Return value_: -- If the arguments are numeric, the return value is a scalar of -- numeric type, `INTEGER', `REAL', or `COMPLEX'. If the arguments -- are `LOGICAL', the return value is `.TRUE.' or `.FALSE.'. -- --_Example_: -- program test_dot_prod -- integer, dimension(3) :: a, b -- a = (/ 1, 2, 3 /) -- b = (/ 4, 5, 6 /) -- print '(3i3)', a -- print * -- print '(3i3)', b -- print * -- print *, dot_product(a,b) -- end program test_dot_prod -- -- --File: gfortran.info, Node: DPROD, Next: DREAL, Prev: DOT_PRODUCT, Up: Intrinsic Procedures -- --7.59 `DPROD' -- Double product function --======================================= -- --_Description_: -- `DPROD(X,Y)' returns the product `X*Y'. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DPROD(X, Y)' -- --_Arguments_: -- X The type shall be `REAL'. -- Y The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL(8)'. -- --_Example_: -- program test_dprod -- real :: x = 5.2 -- real :: y = 2.3 -- real(8) :: d -- d = dprod(x,y) -- print *, d -- end program test_dprod -- -- --File: gfortran.info, Node: DREAL, Next: DTIME, Prev: DPROD, Up: Intrinsic Procedures -- --7.60 `DREAL' -- Double real part function --========================================= -- --_Description_: -- `DREAL(Z)' returns the real part of complex variable Z. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = DREAL(A)' -- --_Arguments_: -- A The type shall be `COMPLEX(8)'. -- --_Return value_: -- The return value is of type `REAL(8)'. -- --_Example_: -- program test_dreal -- complex(8) :: z = (1.3_8,7.2_8) -- print *, dreal(z) -- end program test_dreal -- --_See also_: -- *note AIMAG:: -- -- -- --File: gfortran.info, Node: DTIME, Next: EOSHIFT, Prev: DREAL, Up: Intrinsic Procedures -- --7.61 `DTIME' -- Execution time subroutine (or function) --======================================================= -- --_Description_: -- `DTIME(TARRAY, RESULT)' initially returns the number of seconds of -- runtime since the start of the process's execution in RESULT. -- TARRAY returns the user and system components of this time in -- `TARRAY(1)' and `TARRAY(2)' respectively. RESULT is equal to -- `TARRAY(1) + TARRAY(2)'. -- -- Subsequent invocations of `DTIME' return values accumulated since -- the previous invocation. -- -- On some systems, the underlying timings are represented using -- types with sufficiently small limits that overflows (wrap around) -- are possible, such as 32-bit types. Therefore, the values returned -- by this intrinsic might be, or become, negative, or numerically -- less than previous values, during a single run of the compiled -- program. -- -- Please note, that this implementation is thread safe if used -- within OpenMP directives, i.e., its state will be consistent while -- called from multiple threads. However, if `DTIME' is called from -- multiple threads, the result is still the time since the last -- invocation. This may not give the intended results. If possible, -- use `CPU_TIME' instead. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- TARRAY and RESULT are `INTENT(OUT)' and provide the following: -- -- `TARRAY(1)': User time in seconds. -- `TARRAY(2)': System time in seconds. -- `RESULT': Run time since start in -- seconds. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL DTIME(TARRAY, RESULT)'. -- `RESULT = DTIME(TARRAY)', (not recommended). -- --_Arguments_: -- TARRAY The type shall be `REAL, DIMENSION(2)'. -- RESULT The type shall be `REAL'. -- --_Return value_: -- Elapsed time in seconds since the last invocation or since the -- start of program execution if not called before. -- --_Example_: -- program test_dtime -- integer(8) :: i, j -- real, dimension(2) :: tarray -- real :: result -- call dtime(tarray, result) -- print *, result -- print *, tarray(1) -- print *, tarray(2) -- do i=1,100000000 ! Just a delay -- j = i * i - i -- end do -- call dtime(tarray, result) -- print *, result -- print *, tarray(1) -- print *, tarray(2) -- end program test_dtime -- --_See also_: -- *note CPU_TIME:: -- -- -- --File: gfortran.info, Node: EOSHIFT, Next: EPSILON, Prev: DTIME, Up: Intrinsic Procedures -- --7.62 `EOSHIFT' -- End-off shift elements of an array --==================================================== -- --_Description_: -- `EOSHIFT(ARRAY, SHIFT[, BOUNDARY, DIM])' performs an end-off shift -- on elements of ARRAY along the dimension of DIM. If DIM is -- omitted it is taken to be `1'. DIM is a scalar of type `INTEGER' -- in the range of 1 /leq DIM /leq n) where n is the rank of ARRAY. -- If the rank of ARRAY is one, then all elements of ARRAY are -- shifted by SHIFT places. If rank is greater than one, then all -- complete rank one sections of ARRAY along the given dimension are -- shifted. Elements shifted out one end of each rank one section -- are dropped. If BOUNDARY is present then the corresponding value -- of from BOUNDARY is copied back in the other end. If BOUNDARY is -- not present then the following are copied in depending on the type -- of ARRAY. -- -- _Array _Boundary Value_ -- Type_ -- Numeric 0 of the type and kind of ARRAY. -- Logical `.FALSE.'. -- Character(LEN)LEN blanks. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = EOSHIFT(ARRAY, SHIFT [, BOUNDARY, DIM])' -- --_Arguments_: -- ARRAY May be any type, not scalar. -- SHIFT The type shall be `INTEGER'. -- BOUNDARY Same type as ARRAY. -- DIM The type shall be `INTEGER'. -- --_Return value_: -- Returns an array of same type and rank as the ARRAY argument. -- --_Example_: -- program test_eoshift -- integer, dimension(3,3) :: a -- a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /)) -- print '(3i3)', a(1,:) -- print '(3i3)', a(2,:) -- print '(3i3)', a(3,:) -- a = EOSHIFT(a, SHIFT=(/1, 2, 1/), BOUNDARY=-5, DIM=2) -- print * -- print '(3i3)', a(1,:) -- print '(3i3)', a(2,:) -- print '(3i3)', a(3,:) -- end program test_eoshift -- -- --File: gfortran.info, Node: EPSILON, Next: ERF, Prev: EOSHIFT, Up: Intrinsic Procedures -- --7.63 `EPSILON' -- Epsilon function --================================== -- --_Description_: -- `EPSILON(X)' returns the smallest number E of the same kind as X -- such that 1 + E > 1. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = EPSILON(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of same type as the argument. -- --_Example_: -- program test_epsilon -- real :: x = 3.143 -- real(8) :: y = 2.33 -- print *, EPSILON(x) -- print *, EPSILON(y) -- end program test_epsilon -- -- --File: gfortran.info, Node: ERF, Next: ERFC, Prev: EPSILON, Up: Intrinsic Procedures -- --7.64 `ERF' -- Error function --============================ -- --_Description_: -- `ERF(X)' computes the error function of X. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ERF(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL', of the same kind as X and lies -- in the range -1 \leq erf (x) \leq 1 . -- --_Example_: -- program test_erf -- real(8) :: x = 0.17_8 -- x = erf(x) -- end program test_erf -- --_Specific names_: -- Name Argument Return type Standard -- `DERF(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: ERFC, Next: ERFC_SCALED, Prev: ERF, Up: Intrinsic Procedures -- --7.65 `ERFC' -- Error function --============================= -- --_Description_: -- `ERFC(X)' computes the complementary error function of X. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ERFC(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' and of the same kind as X. It -- lies in the range 0 \leq erfc (x) \leq 2 . -- --_Example_: -- program test_erfc -- real(8) :: x = 0.17_8 -- x = erfc(x) -- end program test_erfc -- --_Specific names_: -- Name Argument Return type Standard -- `DERFC(X)' `REAL(8) X' `REAL(8)' GNU extension -- -- --File: gfortran.info, Node: ERFC_SCALED, Next: ETIME, Prev: ERFC, Up: Intrinsic Procedures -- --7.66 `ERFC_SCALED' -- Error function --==================================== -- --_Description_: -- `ERFC_SCALED(X)' computes the exponentially-scaled complementary -- error function of X. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ERFC_SCALED(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' and of the same kind as X. -- --_Example_: -- program test_erfc_scaled -- real(8) :: x = 0.17_8 -- x = erfc_scaled(x) -- end program test_erfc_scaled -- -- --File: gfortran.info, Node: ETIME, Next: EXIT, Prev: ERFC_SCALED, Up: Intrinsic Procedures -- --7.67 `ETIME' -- Execution time subroutine (or function) --======================================================= -- --_Description_: -- `ETIME(TARRAY, RESULT)' returns the number of seconds of runtime -- since the start of the process's execution in RESULT. TARRAY -- returns the user and system components of this time in `TARRAY(1)' -- and `TARRAY(2)' respectively. RESULT is equal to `TARRAY(1) + -- TARRAY(2)'. -- -- On some systems, the underlying timings are represented using -- types with sufficiently small limits that overflows (wrap around) -- are possible, such as 32-bit types. Therefore, the values returned -- by this intrinsic might be, or become, negative, or numerically -- less than previous values, during a single run of the compiled -- program. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- TARRAY and RESULT are `INTENT(OUT)' and provide the following: -- -- `TARRAY(1)': User time in seconds. -- `TARRAY(2)': System time in seconds. -- `RESULT': Run time since start in seconds. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL ETIME(TARRAY, RESULT)'. -- `RESULT = ETIME(TARRAY)', (not recommended). -- --_Arguments_: -- TARRAY The type shall be `REAL, DIMENSION(2)'. -- RESULT The type shall be `REAL'. -- --_Return value_: -- Elapsed time in seconds since the start of program execution. -- --_Example_: -- program test_etime -- integer(8) :: i, j -- real, dimension(2) :: tarray -- real :: result -- call ETIME(tarray, result) -- print *, result -- print *, tarray(1) -- print *, tarray(2) -- do i=1,100000000 ! Just a delay -- j = i * i - i -- end do -- call ETIME(tarray, result) -- print *, result -- print *, tarray(1) -- print *, tarray(2) -- end program test_etime -- --_See also_: -- *note CPU_TIME:: -- -- -- --File: gfortran.info, Node: EXIT, Next: EXP, Prev: ETIME, Up: Intrinsic Procedures -- --7.68 `EXIT' -- Exit the program with status. --============================================ -- --_Description_: -- `EXIT' causes immediate termination of the program with status. -- If status is omitted it returns the canonical _success_ for the -- system. All Fortran I/O units are closed. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL EXIT([STATUS])' -- --_Arguments_: -- STATUS Shall be an `INTEGER' of the default kind. -- --_Return value_: -- `STATUS' is passed to the parent process on exit. -- --_Example_: -- program test_exit -- integer :: STATUS = 0 -- print *, 'This program is going to exit.' -- call EXIT(STATUS) -- end program test_exit -- --_See also_: -- *note ABORT::, *note KILL:: -- -- --File: gfortran.info, Node: EXP, Next: EXPONENT, Prev: EXIT, Up: Intrinsic Procedures -- --7.69 `EXP' -- Exponential function --================================== -- --_Description_: -- `EXP(X)' computes the base e exponential of X. -- --_Standard_: -- Fortran 77 and later, has overloads that are GNU extensions -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = EXP(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value has same type and kind as X. -- --_Example_: -- program test_exp -- real :: x = 1.0 -- x = exp(x) -- end program test_exp -- --_Specific names_: -- Name Argument Return type Standard -- `DEXP(X)' `REAL(8) X' `REAL(8)' Fortran 77 and -- later -- `CEXP(X)' `COMPLEX(4) `COMPLEX(4)' Fortran 77 and -- X' later -- `ZEXP(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- `CDEXP(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- -- --File: gfortran.info, Node: EXPONENT, Next: FDATE, Prev: EXP, Up: Intrinsic Procedures -- --7.70 `EXPONENT' -- Exponent function --==================================== -- --_Description_: -- `EXPONENT(X)' returns the value of the exponent part of X. If X is -- zero the value returned is zero. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = EXPONENT(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type default `INTEGER'. -- --_Example_: -- program test_exponent -- real :: x = 1.0 -- integer :: i -- i = exponent(x) -- print *, i -- print *, exponent(0.0) -- end program test_exponent -- -- --File: gfortran.info, Node: FDATE, Next: FGET, Prev: EXPONENT, Up: Intrinsic Procedures -- --7.71 `FDATE' -- Get the current time as a string --================================================ -- --_Description_: -- `FDATE(DATE)' returns the current date (using the same format as -- `CTIME') in DATE. It is equivalent to `CALL CTIME(DATE, TIME())'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- DATE is an `INTENT(OUT)' `CHARACTER' variable of the default kind. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FDATE(DATE)'. -- `DATE = FDATE()', (not recommended). -- --_Arguments_: -- DATE The type shall be of type `CHARACTER' of the -- default kind -- --_Return value_: -- The current date as a string. -- --_Example_: -- program test_fdate -- integer(8) :: i, j -- character(len=30) :: date -- call fdate(date) -- print *, 'Program started on ', date -- do i = 1, 100000000 ! Just a delay -- j = i * i - i -- end do -- call fdate(date) -- print *, 'Program ended on ', date -- end program test_fdate -- -- --File: gfortran.info, Node: FLOAT, Next: FLOOR, Prev: FGETC, Up: Intrinsic Procedures -- --7.72 `FLOAT' -- Convert integer to default real --=============================================== -- --_Description_: -- `FLOAT(A)' converts the integer A to a default real value. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = FLOAT(A)' -- --_Arguments_: -- A The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type default `REAL'. -- --_Example_: -- program test_float -- integer :: i = 1 -- if (float(i) /= 1.) call abort -- end program test_float -- --_See also_: -- *note DBLE::, *note DFLOAT::, *note REAL:: -- -- --File: gfortran.info, Node: FGET, Next: FGETC, Prev: FDATE, Up: Intrinsic Procedures -- --7.73 `FGET' -- Read a single character in stream mode from stdin --================================================================ -- --_Description_: -- Read a single character in stream mode from stdin by bypassing -- normal formatted output. Stream I/O should not be mixed with -- normal record-oriented (formatted or unformatted) I/O on the same -- unit; the results are unpredictable. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- Note that the `FGET' intrinsic is provided for backwards -- compatibility with `g77'. GNU Fortran provides the Fortran 2003 -- Stream facility. Programmers should consider the use of new -- stream IO feature in new code for future portability. See also -- *note Fortran 2003 status::. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FGET(C [, STATUS])' -- --_Arguments_: -- C The type shall be `CHARACTER' and of default -- kind. -- STATUS (Optional) status flag of type `INTEGER'. -- Returns 0 on success, -1 on end-of-file, and a -- system specific positive error code otherwise. -- --_Example_: -- PROGRAM test_fget -- INTEGER, PARAMETER :: strlen = 100 -- INTEGER :: status, i = 1 -- CHARACTER(len=strlen) :: str = "" -- -- WRITE (*,*) 'Enter text:' -- DO -- CALL fget(str(i:i), status) -- if (status /= 0 .OR. i > strlen) exit -- i = i + 1 -- END DO -- WRITE (*,*) TRIM(str) -- END PROGRAM -- --_See also_: -- *note FGETC::, *note FPUT::, *note FPUTC:: -- -- --File: gfortran.info, Node: FGETC, Next: FLOAT, Prev: FGET, Up: Intrinsic Procedures -- --7.74 `FGETC' -- Read a single character in stream mode --====================================================== -- --_Description_: -- Read a single character in stream mode by bypassing normal -- formatted output. Stream I/O should not be mixed with normal -- record-oriented (formatted or unformatted) I/O on the same unit; -- the results are unpredictable. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- Note that the `FGET' intrinsic is provided for backwards -- compatibility with `g77'. GNU Fortran provides the Fortran 2003 -- Stream facility. Programmers should consider the use of new -- stream IO feature in new code for future portability. See also -- *note Fortran 2003 status::. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FGETC(UNIT, C [, STATUS])' -- --_Arguments_: -- UNIT The type shall be `INTEGER'. -- C The type shall be `CHARACTER' and of default -- kind. -- STATUS (Optional) status flag of type `INTEGER'. -- Returns 0 on success, -1 on end-of-file and a -- system specific positive error code otherwise. -- --_Example_: -- PROGRAM test_fgetc -- INTEGER :: fd = 42, status -- CHARACTER :: c -- -- OPEN(UNIT=fd, FILE="/etc/passwd", ACTION="READ", STATUS = "OLD") -- DO -- CALL fgetc(fd, c, status) -- IF (status /= 0) EXIT -- call fput(c) -- END DO -- CLOSE(UNIT=fd) -- END PROGRAM -- --_See also_: -- *note FGET::, *note FPUT::, *note FPUTC:: -- -- --File: gfortran.info, Node: FLOOR, Next: FLUSH, Prev: FLOAT, Up: Intrinsic Procedures -- --7.75 `FLOOR' -- Integer floor function --====================================== -- --_Description_: -- `FLOOR(A)' returns the greatest integer less than or equal to X. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = FLOOR(A [, KIND])' -- --_Arguments_: -- A The type shall be `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER(KIND)' if KIND is present and -- of default-kind `INTEGER' otherwise. -- --_Example_: -- program test_floor -- real :: x = 63.29 -- real :: y = -63.59 -- print *, floor(x) ! returns 63 -- print *, floor(y) ! returns -64 -- end program test_floor -- --_See also_: -- *note CEILING::, *note NINT:: -- -- -- --File: gfortran.info, Node: FLUSH, Next: FNUM, Prev: FLOOR, Up: Intrinsic Procedures -- --7.76 `FLUSH' -- Flush I/O unit(s) --================================= -- --_Description_: -- Flushes Fortran unit(s) currently open for output. Without the -- optional argument, all units are flushed, otherwise just the unit -- specified. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL FLUSH(UNIT)' -- --_Arguments_: -- UNIT (Optional) The type shall be `INTEGER'. -- --_Note_: -- Beginning with the Fortran 2003 standard, there is a `FLUSH' -- statement that should be preferred over the `FLUSH' intrinsic. -- -- -- --File: gfortran.info, Node: FNUM, Next: FPUT, Prev: FLUSH, Up: Intrinsic Procedures -- --7.77 `FNUM' -- File number function --=================================== -- --_Description_: -- `FNUM(UNIT)' returns the POSIX file descriptor number -- corresponding to the open Fortran I/O unit `UNIT'. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = FNUM(UNIT)' -- --_Arguments_: -- UNIT The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' -- --_Example_: -- program test_fnum -- integer :: i -- open (unit=10, status = "scratch") -- i = fnum(10) -- print *, i -- close (10) -- end program test_fnum -- -- --File: gfortran.info, Node: FPUT, Next: FPUTC, Prev: FNUM, Up: Intrinsic Procedures -- --7.78 `FPUT' -- Write a single character in stream mode to stdout --================================================================ -- --_Description_: -- Write a single character in stream mode to stdout by bypassing -- normal formatted output. Stream I/O should not be mixed with -- normal record-oriented (formatted or unformatted) I/O on the same -- unit; the results are unpredictable. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- Note that the `FGET' intrinsic is provided for backwards -- compatibility with `g77'. GNU Fortran provides the Fortran 2003 -- Stream facility. Programmers should consider the use of new -- stream IO feature in new code for future portability. See also -- *note Fortran 2003 status::. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FPUT(C [, STATUS])' -- --_Arguments_: -- C The type shall be `CHARACTER' and of default -- kind. -- STATUS (Optional) status flag of type `INTEGER'. -- Returns 0 on success, -1 on end-of-file and a -- system specific positive error code otherwise. -- --_Example_: -- PROGRAM test_fput -- CHARACTER(len=10) :: str = "gfortran" -- INTEGER :: i -- DO i = 1, len_trim(str) -- CALL fput(str(i:i)) -- END DO -- END PROGRAM -- --_See also_: -- *note FPUTC::, *note FGET::, *note FGETC:: -- -- --File: gfortran.info, Node: FPUTC, Next: FRACTION, Prev: FPUT, Up: Intrinsic Procedures -- --7.79 `FPUTC' -- Write a single character in stream mode --======================================================= -- --_Description_: -- Write a single character in stream mode by bypassing normal -- formatted output. Stream I/O should not be mixed with normal -- record-oriented (formatted or unformatted) I/O on the same unit; -- the results are unpredictable. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- -- Note that the `FGET' intrinsic is provided for backwards -- compatibility with `g77'. GNU Fortran provides the Fortran 2003 -- Stream facility. Programmers should consider the use of new -- stream IO feature in new code for future portability. See also -- *note Fortran 2003 status::. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FPUTC(UNIT, C [, STATUS])' -- --_Arguments_: -- UNIT The type shall be `INTEGER'. -- C The type shall be `CHARACTER' and of default -- kind. -- STATUS (Optional) status flag of type `INTEGER'. -- Returns 0 on success, -1 on end-of-file and a -- system specific positive error code otherwise. -- --_Example_: -- PROGRAM test_fputc -- CHARACTER(len=10) :: str = "gfortran" -- INTEGER :: fd = 42, i -- -- OPEN(UNIT = fd, FILE = "out", ACTION = "WRITE", STATUS="NEW") -- DO i = 1, len_trim(str) -- CALL fputc(fd, str(i:i)) -- END DO -- CLOSE(fd) -- END PROGRAM -- --_See also_: -- *note FPUT::, *note FGET::, *note FGETC:: -- -- --File: gfortran.info, Node: FRACTION, Next: FREE, Prev: FPUTC, Up: Intrinsic Procedures -- --7.80 `FRACTION' -- Fractional part of the model representation --============================================================== -- --_Description_: -- `FRACTION(X)' returns the fractional part of the model -- representation of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `Y = FRACTION(X)' -- --_Arguments_: -- X The type of the argument shall be a `REAL'. -- --_Return value_: -- The return value is of the same type and kind as the argument. -- The fractional part of the model representation of `X' is returned; -- it is `X * RADIX(X)**(-EXPONENT(X))'. -- --_Example_: -- program test_fraction -- real :: x -- x = 178.1387e-4 -- print *, fraction(x), x * radix(x)**(-exponent(x)) -- end program test_fraction -- -- -- --File: gfortran.info, Node: FREE, Next: FSEEK, Prev: FRACTION, Up: Intrinsic Procedures -- --7.81 `FREE' -- Frees memory --=========================== -- --_Description_: -- Frees memory previously allocated by `MALLOC()'. The `FREE' -- intrinsic is an extension intended to be used with Cray pointers, -- and is provided in GNU Fortran to allow user to compile legacy -- code. For new code using Fortran 95 pointers, the memory -- de-allocation intrinsic is `DEALLOCATE'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL FREE(PTR)' -- --_Arguments_: -- PTR The type shall be `INTEGER'. It represents the -- location of the memory that should be -- de-allocated. -- --_Return value_: -- None -- --_Example_: -- See `MALLOC' for an example. -- --_See also_: -- *note MALLOC:: -- -- --File: gfortran.info, Node: FSEEK, Next: FSTAT, Prev: FREE, Up: Intrinsic Procedures -- --7.82 `FSEEK' -- Low level file positioning subroutine --===================================================== -- --_Description_: -- Moves UNIT to the specified OFFSET. If WHENCE is set to 0, the -- OFFSET is taken as an absolute value `SEEK_SET', if set to 1, -- OFFSET is taken to be relative to the current position `SEEK_CUR', -- and if set to 2 relative to the end of the file `SEEK_END'. On -- error, STATUS is set to a nonzero value. If STATUS the seek fails -- silently. -- -- This intrinsic routine is not fully backwards compatible with -- `g77'. In `g77', the `FSEEK' takes a statement label instead of a -- STATUS variable. If FSEEK is used in old code, change -- CALL FSEEK(UNIT, OFFSET, WHENCE, *label) -- to -- INTEGER :: status -- CALL FSEEK(UNIT, OFFSET, WHENCE, status) -- IF (status /= 0) GOTO label -- -- Please note that GNU Fortran provides the Fortran 2003 Stream -- facility. Programmers should consider the use of new stream IO -- feature in new code for future portability. See also *note Fortran -- 2003 status::. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL FSEEK(UNIT, OFFSET, WHENCE[, STATUS])' -- --_Arguments_: -- UNIT Shall be a scalar of type `INTEGER'. -- OFFSET Shall be a scalar of type `INTEGER'. -- WHENCE Shall be a scalar of type `INTEGER'. Its -- value shall be either 0, 1 or 2. -- STATUS (Optional) shall be a scalar of type -- `INTEGER(4)'. -- --_Example_: -- PROGRAM test_fseek -- INTEGER, PARAMETER :: SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2 -- INTEGER :: fd, offset, ierr -- -- ierr = 0 -- offset = 5 -- fd = 10 -- -- OPEN(UNIT=fd, FILE="fseek.test") -- CALL FSEEK(fd, offset, SEEK_SET, ierr) ! move to OFFSET -- print *, FTELL(fd), ierr -- -- CALL FSEEK(fd, 0, SEEK_END, ierr) ! move to end -- print *, FTELL(fd), ierr -- -- CALL FSEEK(fd, 0, SEEK_SET, ierr) ! move to beginning -- print *, FTELL(fd), ierr -- -- CLOSE(UNIT=fd) -- END PROGRAM -- --_See also_: -- *note FTELL:: -- -- --File: gfortran.info, Node: FSTAT, Next: FTELL, Prev: FSEEK, Up: Intrinsic Procedures -- --7.83 `FSTAT' -- Get file status --=============================== -- --_Description_: -- `FSTAT' is identical to *note STAT::, except that information -- about an already opened file is obtained. -- -- The elements in `BUFF' are the same as described by *note STAT::. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FSTAT(UNIT, BUFF [, STATUS])' -- --_Arguments_: -- UNIT An open I/O unit number of type `INTEGER'. -- BUFF The type shall be `INTEGER(4), DIMENSION(13)'. -- STATUS (Optional) status flag of type `INTEGER(4)'. -- Returns 0 on success and a system specific -- error code otherwise. -- --_Example_: -- See *note STAT:: for an example. -- --_See also_: -- To stat a link: *note LSTAT::, to stat a file: *note STAT:: -- -- --File: gfortran.info, Node: FTELL, Next: GAMMA, Prev: FSTAT, Up: Intrinsic Procedures -- --7.84 `FTELL' -- Current stream position --======================================= -- --_Description_: -- Retrieves the current position within an open file. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL FTELL(UNIT, OFFSET)' -- `OFFSET = FTELL(UNIT)' -- --_Arguments_: -- OFFSET Shall of type `INTEGER'. -- UNIT Shall of type `INTEGER'. -- --_Return value_: -- In either syntax, OFFSET is set to the current offset of unit -- number UNIT, or to -1 if the unit is not currently open. -- --_Example_: -- PROGRAM test_ftell -- INTEGER :: i -- OPEN(10, FILE="temp.dat") -- CALL ftell(10,i) -- WRITE(*,*) i -- END PROGRAM -- --_See also_: -- *note FSEEK:: -- -- --File: gfortran.info, Node: GAMMA, Next: GERROR, Prev: FTELL, Up: Intrinsic Procedures -- --7.85 `GAMMA' -- Gamma function --============================== -- --_Description_: -- `GAMMA(X)' computes Gamma (\Gamma) of X. For positive, integer -- values of X the Gamma function simplifies to the factorial -- function \Gamma(x)=(x-1)!. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `X = GAMMA(X)' -- --_Arguments_: -- X Shall be of type `REAL' and neither zero nor a -- negative integer. -- --_Return value_: -- The return value is of type `REAL' of the same kind as X. -- --_Example_: -- program test_gamma -- real :: x = 1.0 -- x = gamma(x) ! returns 1.0 -- end program test_gamma -- --_Specific names_: -- Name Argument Return type Standard -- `GAMMA(X)' `REAL(4) X' `REAL(4)' GNU Extension -- `DGAMMA(X)' `REAL(8) X' `REAL(8)' GNU Extension -- --_See also_: -- Logarithm of the Gamma function: *note LOG_GAMMA:: -- -- -- --File: gfortran.info, Node: GERROR, Next: GETARG, Prev: GAMMA, Up: Intrinsic Procedures -- --7.86 `GERROR' -- Get last system error message --============================================== -- --_Description_: -- Returns the system error message corresponding to the last system -- error. This resembles the functionality of `strerror(3)' in C. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GERROR(RESULT)' -- --_Arguments_: -- RESULT Shall of type `CHARACTER' and of default -- --_Example_: -- PROGRAM test_gerror -- CHARACTER(len=100) :: msg -- CALL gerror(msg) -- WRITE(*,*) msg -- END PROGRAM -- --_See also_: -- *note IERRNO::, *note PERROR:: -- -- --File: gfortran.info, Node: GETARG, Next: GET_COMMAND, Prev: GERROR, Up: Intrinsic Procedures -- --7.87 `GETARG' -- Get command line arguments --=========================================== -- --_Description_: -- Retrieve the POS-th argument that was passed on the command line -- when the containing program was invoked. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. In new code, programmers should consider the use -- of the *note GET_COMMAND_ARGUMENT:: intrinsic defined by the -- Fortran 2003 standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GETARG(POS, VALUE)' -- --_Arguments_: -- POS Shall be of type `INTEGER' and not wider than -- the default integer kind; POS \geq 0 -- VALUE Shall be of type `CHARACTER' and of default -- kind. -- VALUE Shall be of type `CHARACTER'. -- --_Return value_: -- After `GETARG' returns, the VALUE argument holds the POSth command -- line argument. If VALUE can not hold the argument, it is truncated -- to fit the length of VALUE. If there are less than POS arguments -- specified at the command line, VALUE will be filled with blanks. -- If POS = 0, VALUE is set to the name of the program (on systems -- that support this feature). -- --_Example_: -- PROGRAM test_getarg -- INTEGER :: i -- CHARACTER(len=32) :: arg -- -- DO i = 1, iargc() -- CALL getarg(i, arg) -- WRITE (*,*) arg -- END DO -- END PROGRAM -- --_See also_: -- GNU Fortran 77 compatibility function: *note IARGC:: -- -- Fortran 2003 functions and subroutines: *note GET_COMMAND::, *note -- GET_COMMAND_ARGUMENT::, *note COMMAND_ARGUMENT_COUNT:: -- -- --File: gfortran.info, Node: GET_COMMAND, Next: GET_COMMAND_ARGUMENT, Prev: GETARG, Up: Intrinsic Procedures -- --7.88 `GET_COMMAND' -- Get the entire command line --================================================= -- --_Description_: -- Retrieve the entire command line that was used to invoke the -- program. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GET_COMMAND(COMMAND)' -- --_Arguments_: -- COMMAND Shall be of type `CHARACTER' and of default -- kind. -- --_Return value_: -- Stores the entire command line that was used to invoke the program -- in COMMAND. If COMMAND is not large enough, the command will be -- truncated. -- --_Example_: -- PROGRAM test_get_command -- CHARACTER(len=255) :: cmd -- CALL get_command(cmd) -- WRITE (*,*) TRIM(cmd) -- END PROGRAM -- --_See also_: -- *note GET_COMMAND_ARGUMENT::, *note COMMAND_ARGUMENT_COUNT:: -- -- --File: gfortran.info, Node: GET_COMMAND_ARGUMENT, Next: GETCWD, Prev: GET_COMMAND, Up: Intrinsic Procedures -- --7.89 `GET_COMMAND_ARGUMENT' -- Get command line arguments --========================================================= -- --_Description_: -- Retrieve the NUMBER-th argument that was passed on the command -- line when the containing program was invoked. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GET_COMMAND_ARGUMENT(NUMBER [, VALUE, LENGTH, STATUS])' -- --_Arguments_: -- NUMBER Shall be a scalar of type `INTEGER(4)', NUMBER -- \geq 0 -- VALUE Shall be a scalar of type `CHARACTER' and of -- default kind. -- LENGTH (Option) Shall be a scalar of type -- `INTEGER(4)'. -- STATUS (Option) Shall be a scalar of type -- `INTEGER(4)'. -- --_Return value_: -- After `GET_COMMAND_ARGUMENT' returns, the VALUE argument holds the -- NUMBER-th command line argument. If VALUE can not hold the -- argument, it is truncated to fit the length of VALUE. If there are -- less than NUMBER arguments specified at the command line, VALUE -- will be filled with blanks. If NUMBER = 0, VALUE is set to the -- name of the program (on systems that support this feature). The -- LENGTH argument contains the length of the NUMBER-th command line -- argument. If the argument retrieval fails, STATUS is a positive -- number; if VALUE contains a truncated command line argument, -- STATUS is -1; and otherwise the STATUS is zero. -- --_Example_: -- PROGRAM test_get_command_argument -- INTEGER :: i -- CHARACTER(len=32) :: arg -- -- i = 0 -- DO -- CALL get_command_argument(i, arg) -- IF (LEN_TRIM(arg) == 0) EXIT -- -- WRITE (*,*) TRIM(arg) -- i = i+1 -- END DO -- END PROGRAM -- --_See also_: -- *note GET_COMMAND::, *note COMMAND_ARGUMENT_COUNT:: -- -- --File: gfortran.info, Node: GETCWD, Next: GETENV, Prev: GET_COMMAND_ARGUMENT, Up: Intrinsic Procedures -- --7.90 `GETCWD' -- Get current working directory --============================================== -- --_Description_: -- Get current working directory. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL GETCWD(C [, STATUS])' -- --_Arguments_: -- C The type shall be `CHARACTER' and of default -- kind. -- STATUS (Optional) status flag. Returns 0 on success, -- a system specific and nonzero error code -- otherwise. -- --_Example_: -- PROGRAM test_getcwd -- CHARACTER(len=255) :: cwd -- CALL getcwd(cwd) -- WRITE(*,*) TRIM(cwd) -- END PROGRAM -- --_See also_: -- *note CHDIR:: -- -- --File: gfortran.info, Node: GETENV, Next: GET_ENVIRONMENT_VARIABLE, Prev: GETCWD, Up: Intrinsic Procedures -- --7.91 `GETENV' -- Get an environmental variable --============================================== -- --_Description_: -- Get the VALUE of the environmental variable NAME. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. In new code, programmers should consider the use -- of the *note GET_ENVIRONMENT_VARIABLE:: intrinsic defined by the -- Fortran 2003 standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GETENV(NAME, VALUE)' -- --_Arguments_: -- NAME Shall be of type `CHARACTER' and of default -- kind. -- VALUE Shall be of type `CHARACTER' and of default -- kind. -- --_Return value_: -- Stores the value of NAME in VALUE. If VALUE is not large enough to -- hold the data, it is truncated. If NAME is not set, VALUE will be -- filled with blanks. -- --_Example_: -- PROGRAM test_getenv -- CHARACTER(len=255) :: homedir -- CALL getenv("HOME", homedir) -- WRITE (*,*) TRIM(homedir) -- END PROGRAM -- --_See also_: -- *note GET_ENVIRONMENT_VARIABLE:: -- -- --File: gfortran.info, Node: GET_ENVIRONMENT_VARIABLE, Next: GETGID, Prev: GETENV, Up: Intrinsic Procedures -- --7.92 `GET_ENVIRONMENT_VARIABLE' -- Get an environmental variable --================================================================ -- --_Description_: -- Get the VALUE of the environmental variable NAME. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GET_ENVIRONMENT_VARIABLE(NAME[, VALUE, LENGTH, STATUS, -- TRIM_NAME)' -- --_Arguments_: -- NAME Shall be a scalar of type `CHARACTER(1)'. -- VALUE Shall be a scalar of type `CHARACTER(1)'. -- LENGTH Shall be a scalar of type `INTEGER(4)'. -- STATUS Shall be a scalar of type `INTEGER(4)'. -- TRIM_NAME Shall be a scalar of type `LOGICAL(4)'. -- --_Return value_: -- Stores the value of NAME in VALUE. If VALUE is not large enough to -- hold the data, it is truncated. If NAME is not set, VALUE will be -- filled with blanks. Argument LENGTH contains the length needed for -- storing the environment variable NAME or zero if it is not -- present. STATUS is -1 if VALUE is present but too short for the -- environment variable; it is 1 if the environment variable does not -- exist and 2 if the processor does not support environment -- variables; in all other cases STATUS is zero. If TRIM_NAME is -- present with the value `.FALSE.', the trailing blanks in NAME are -- significant; otherwise they are not part of the environment -- variable name. -- --_Example_: -- PROGRAM test_getenv -- CHARACTER(len=255) :: homedir -- CALL get_environment_variable("HOME", homedir) -- WRITE (*,*) TRIM(homedir) -- END PROGRAM -- -- --File: gfortran.info, Node: GETGID, Next: GETLOG, Prev: GET_ENVIRONMENT_VARIABLE, Up: Intrinsic Procedures -- --7.93 `GETGID' -- Group ID function --================================== -- --_Description_: -- Returns the numerical group ID of the current process. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = GETGID()' -- --_Return value_: -- The return value of `GETGID' is an `INTEGER' of the default kind. -- --_Example_: -- See `GETPID' for an example. -- --_See also_: -- *note GETPID::, *note GETUID:: -- -- --File: gfortran.info, Node: GETLOG, Next: GETPID, Prev: GETGID, Up: Intrinsic Procedures -- --7.94 `GETLOG' -- Get login name --=============================== -- --_Description_: -- Gets the username under which the program is running. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GETLOG(C)' -- --_Arguments_: -- C Shall be of type `CHARACTER' and of default -- kind. -- --_Return value_: -- Stores the current user name in LOGIN. (On systems where POSIX -- functions `geteuid' and `getpwuid' are not available, and the -- `getlogin' function is not implemented either, this will return a -- blank string.) -- --_Example_: -- PROGRAM TEST_GETLOG -- CHARACTER(32) :: login -- CALL GETLOG(login) -- WRITE(*,*) login -- END PROGRAM -- --_See also_: -- *note GETUID:: -- -- --File: gfortran.info, Node: GETPID, Next: GETUID, Prev: GETLOG, Up: Intrinsic Procedures -- --7.95 `GETPID' -- Process ID function --==================================== -- --_Description_: -- Returns the numerical process identifier of the current process. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = GETPID()' -- --_Return value_: -- The return value of `GETPID' is an `INTEGER' of the default kind. -- --_Example_: -- program info -- print *, "The current process ID is ", getpid() -- print *, "Your numerical user ID is ", getuid() -- print *, "Your numerical group ID is ", getgid() -- end program info -- --_See also_: -- *note GETGID::, *note GETUID:: -- -- --File: gfortran.info, Node: GETUID, Next: GMTIME, Prev: GETPID, Up: Intrinsic Procedures -- --7.96 `GETUID' -- User ID function --================================= -- --_Description_: -- Returns the numerical user ID of the current process. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = GETUID()' -- --_Return value_: -- The return value of `GETUID' is an `INTEGER' of the default kind. -- --_Example_: -- See `GETPID' for an example. -- --_See also_: -- *note GETPID::, *note GETLOG:: -- -- --File: gfortran.info, Node: GMTIME, Next: HOSTNM, Prev: GETUID, Up: Intrinsic Procedures -- --7.97 `GMTIME' -- Convert time to GMT info --========================================= -- --_Description_: -- Given a system time value TIME (as provided by the `TIME8()' -- intrinsic), fills VALUES with values extracted from it appropriate -- to the UTC time zone (Universal Coordinated Time, also known in -- some countries as GMT, Greenwich Mean Time), using `gmtime(3)'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL GMTIME(TIME, VALUES)' -- --_Arguments_: -- TIME An `INTEGER' scalar expression corresponding -- to a system time, with `INTENT(IN)'. -- VALUES A default `INTEGER' array with 9 elements, -- with `INTENT(OUT)'. -- --_Return value_: -- The elements of VALUES are assigned as follows: -- 1. Seconds after the minute, range 0-59 or 0-61 to allow for leap -- seconds -- -- 2. Minutes after the hour, range 0-59 -- -- 3. Hours past midnight, range 0-23 -- -- 4. Day of month, range 0-31 -- -- 5. Number of months since January, range 0-12 -- -- 6. Years since 1900 -- -- 7. Number of days since Sunday, range 0-6 -- -- 8. Days since January 1 -- -- 9. Daylight savings indicator: positive if daylight savings is in -- effect, zero if not, and negative if the information is not -- available. -- --_See also_: -- *note CTIME::, *note LTIME::, *note TIME::, *note TIME8:: -- -- -- --File: gfortran.info, Node: HOSTNM, Next: HUGE, Prev: GMTIME, Up: Intrinsic Procedures -- --7.98 `HOSTNM' -- Get system host name --===================================== -- --_Description_: -- Retrieves the host name of the system on which the program is -- running. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL HOSTNM(C [, STATUS])' -- `STATUS = HOSTNM(NAME)' -- --_Arguments_: -- C Shall of type `CHARACTER' and of default kind. -- STATUS (Optional) status flag of type `INTEGER'. -- Returns 0 on success, or a system specific -- error code otherwise. -- --_Return value_: -- In either syntax, NAME is set to the current hostname if it can be -- obtained, or to a blank string otherwise. -- -- -- --File: gfortran.info, Node: HUGE, Next: HYPOT, Prev: HOSTNM, Up: Intrinsic Procedures -- --7.99 `HUGE' -- Largest number of a kind --======================================= -- --_Description_: -- `HUGE(X)' returns the largest number that is not an infinity in -- the model of the type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = HUGE(X)' -- --_Arguments_: -- X Shall be of type `REAL' or `INTEGER'. -- --_Return value_: -- The return value is of the same type and kind as X -- --_Example_: -- program test_huge_tiny -- print *, huge(0), huge(0.0), huge(0.0d0) -- print *, tiny(0.0), tiny(0.0d0) -- end program test_huge_tiny -- -- --File: gfortran.info, Node: HYPOT, Next: IACHAR, Prev: HUGE, Up: Intrinsic Procedures -- --7.100 `HYPOT' -- Euclidean distance function --============================================ -- --_Description_: -- `HYPOT(X,Y)' is the Euclidean distance function. It is equal to -- \sqrtX^2 + Y^2, without undue underflow or overflow. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = HYPOT(X, Y)' -- --_Arguments_: -- X The type shall be `REAL'. -- Y The type and kind type parameter shall be the -- same as X. -- --_Return value_: -- The return value has the same type and kind type parameter as X. -- --_Example_: -- program test_hypot -- real(4) :: x = 1.e0_4, y = 0.5e0_4 -- x = hypot(x,y) -- end program test_hypot -- -- --File: gfortran.info, Node: IACHAR, Next: IAND, Prev: HYPOT, Up: Intrinsic Procedures -- --7.101 `IACHAR' -- Code in ASCII collating sequence --================================================== -- --_Description_: -- `IACHAR(C)' returns the code for the ASCII character in the first -- character position of `C'. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IACHAR(C [, KIND])' -- --_Arguments_: -- C Shall be a scalar `CHARACTER', with -- `INTENT(IN)' -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_Example_: -- program test_iachar -- integer i -- i = iachar(' ') -- end program test_iachar -- --_Note_: -- See *note ICHAR:: for a discussion of converting between numerical -- values and formatted string representations. -- --_See also_: -- *note ACHAR::, *note CHAR::, *note ICHAR:: -- -- -- --File: gfortran.info, Node: IAND, Next: IARGC, Prev: IACHAR, Up: Intrinsic Procedures -- --7.102 `IAND' -- Bitwise logical and --=================================== -- --_Description_: -- Bitwise logical `AND'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IAND(I, J)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- J The type shall be `INTEGER', of the same kind -- as I. (As a GNU extension, different kinds -- are also permitted.) -- --_Return value_: -- The return type is `INTEGER', of the same kind as the arguments. -- (If the argument kinds differ, it is of the same kind as the -- larger argument.) -- --_Example_: -- PROGRAM test_iand -- INTEGER :: a, b -- DATA a / Z'F' /, b / Z'3' / -- WRITE (*,*) IAND(a, b) -- END PROGRAM -- --_See also_: -- *note IOR::, *note IEOR::, *note IBITS::, *note IBSET::, *note -- IBCLR::, *note NOT:: -- -- -- --File: gfortran.info, Node: IARGC, Next: IBCLR, Prev: IAND, Up: Intrinsic Procedures -- --7.103 `IARGC' -- Get the number of command line arguments --========================================================= -- --_Description_: -- `IARGC()' returns the number of arguments passed on the command -- line when the containing program was invoked. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. In new code, programmers should consider the use -- of the *note COMMAND_ARGUMENT_COUNT:: intrinsic defined by the -- Fortran 2003 standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = IARGC()' -- --_Arguments_: -- None. -- --_Return value_: -- The number of command line arguments, type `INTEGER(4)'. -- --_Example_: -- See *note GETARG:: -- --_See also_: -- GNU Fortran 77 compatibility subroutine: *note GETARG:: -- -- Fortran 2003 functions and subroutines: *note GET_COMMAND::, *note -- GET_COMMAND_ARGUMENT::, *note COMMAND_ARGUMENT_COUNT:: -- -- --File: gfortran.info, Node: IBCLR, Next: IBITS, Prev: IARGC, Up: Intrinsic Procedures -- --7.104 `IBCLR' -- Clear bit --========================== -- --_Description_: -- `IBCLR' returns the value of I with the bit at position POS set to -- zero. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IBCLR(I, POS)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- POS The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note IBITS::, *note IBSET::, *note IAND::, *note IOR::, *note -- IEOR::, *note MVBITS:: -- -- -- --File: gfortran.info, Node: IBITS, Next: IBSET, Prev: IBCLR, Up: Intrinsic Procedures -- --7.105 `IBITS' -- Bit extraction --=============================== -- --_Description_: -- `IBITS' extracts a field of length LEN from I, starting from bit -- position POS and extending left for LEN bits. The result is -- right-justified and the remaining bits are zeroed. The value of -- `POS+LEN' must be less than or equal to the value `BIT_SIZE(I)'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IBITS(I, POS, LEN)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- POS The type shall be `INTEGER'. -- LEN The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note BIT_SIZE::, *note IBCLR::, *note IBSET::, *note IAND::, -- *note IOR::, *note IEOR:: -- -- --File: gfortran.info, Node: IBSET, Next: ICHAR, Prev: IBITS, Up: Intrinsic Procedures -- --7.106 `IBSET' -- Set bit --======================== -- --_Description_: -- `IBSET' returns the value of I with the bit at position POS set to -- one. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IBSET(I, POS)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- POS The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note IBCLR::, *note IBITS::, *note IAND::, *note IOR::, *note -- IEOR::, *note MVBITS:: -- -- -- --File: gfortran.info, Node: ICHAR, Next: IDATE, Prev: IBSET, Up: Intrinsic Procedures -- --7.107 `ICHAR' -- Character-to-integer conversion function --========================================================= -- --_Description_: -- `ICHAR(C)' returns the code for the character in the first -- character position of `C' in the system's native character set. -- The correspondence between characters and their codes is not -- necessarily the same across different GNU Fortran implementations. -- --_Standard_: -- Fortan 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ICHAR(C [, KIND])' -- --_Arguments_: -- C Shall be a scalar `CHARACTER', with -- `INTENT(IN)' -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_Example_: -- program test_ichar -- integer i -- i = ichar(' ') -- end program test_ichar -- --_Note_: -- No intrinsic exists to convert between a numeric value and a -- formatted character string representation - for instance, given the -- `CHARACTER' value `'154'', obtaining an `INTEGER' or `REAL' value -- with the value 154, or vice versa. Instead, this functionality is -- provided by internal-file I/O, as in the following example: -- program read_val -- integer value -- character(len=10) string, string2 -- string = '154' -- -- ! Convert a string to a numeric value -- read (string,'(I10)') value -- print *, value -- -- ! Convert a value to a formatted string -- write (string2,'(I10)') value -- print *, string2 -- end program read_val -- --_See also_: -- *note ACHAR::, *note CHAR::, *note IACHAR:: -- -- -- --File: gfortran.info, Node: IDATE, Next: IEOR, Prev: ICHAR, Up: Intrinsic Procedures -- --7.108 `IDATE' -- Get current local time subroutine (day/month/year) --=================================================================== -- --_Description_: -- `IDATE(TARRAY)' Fills TARRAY with the numerical values at the -- current local time. The day (in the range 1-31), month (in the -- range 1-12), and year appear in elements 1, 2, and 3 of TARRAY, -- respectively. The year has four significant digits. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL IDATE(VALUES)' -- --_Arguments_: -- VALUES The type shall be `INTEGER, DIMENSION(3)' and -- the kind shall be the default integer kind. -- --_Return value_: -- Does not return anything. -- --_Example_: -- program test_idate -- integer, dimension(3) :: tarray -- call idate(tarray) -- print *, tarray(1) -- print *, tarray(2) -- print *, tarray(3) -- end program test_idate -- -- --File: gfortran.info, Node: IEOR, Next: IERRNO, Prev: IDATE, Up: Intrinsic Procedures -- --7.109 `IEOR' -- Bitwise logical exclusive or --============================================ -- --_Description_: -- `IEOR' returns the bitwise boolean exclusive-OR of I and J. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IEOR(I, J)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- J The type shall be `INTEGER', of the same kind -- as I. (As a GNU extension, different kinds -- are also permitted.) -- --_Return value_: -- The return type is `INTEGER', of the same kind as the arguments. -- (If the argument kinds differ, it is of the same kind as the -- larger argument.) -- --_See also_: -- *note IOR::, *note IAND::, *note IBITS::, *note IBSET::, *note -- IBCLR::, *note NOT:: -- -- --File: gfortran.info, Node: IERRNO, Next: INDEX intrinsic, Prev: IEOR, Up: Intrinsic Procedures -- --7.110 `IERRNO' -- Get the last system error number --================================================== -- --_Description_: -- Returns the last system error number, as given by the C `errno()' -- function. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = IERRNO()' -- --_Arguments_: -- None. -- --_Return value_: -- The return value is of type `INTEGER' and of the default integer -- kind. -- --_See also_: -- *note PERROR:: -- -- --File: gfortran.info, Node: INDEX intrinsic, Next: INT, Prev: IERRNO, Up: Intrinsic Procedures -- --7.111 `INDEX' -- Position of a substring within a string --======================================================== -- --_Description_: -- Returns the position of the start of the first occurrence of string -- SUBSTRING as a substring in STRING, counting from one. If -- SUBSTRING is not present in STRING, zero is returned. If the BACK -- argument is present and true, the return value is the start of the -- last occurrence rather than the first. -- --_Standard_: -- Fortran 77 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = INDEX(STRING, SUBSTRING [, BACK [, KIND]])' -- --_Arguments_: -- STRING Shall be a scalar `CHARACTER', with -- `INTENT(IN)' -- SUBSTRING Shall be a scalar `CHARACTER', with -- `INTENT(IN)' -- BACK (Optional) Shall be a scalar `LOGICAL', with -- `INTENT(IN)' -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_See also_: -- *note SCAN::, *note VERIFY:: -- -- --File: gfortran.info, Node: INT, Next: INT2, Prev: INDEX intrinsic, Up: Intrinsic Procedures -- --7.112 `INT' -- Convert to integer type --====================================== -- --_Description_: -- Convert to integer type -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = INT(A [, KIND))' -- --_Arguments_: -- A Shall be of type `INTEGER', `REAL', or -- `COMPLEX'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- These functions return a `INTEGER' variable or array under the -- following rules: -- -- (A) -- If A is of type `INTEGER', `INT(A) = A' -- -- (B) -- If A is of type `REAL' and |A| < 1, `INT(A)' equals `0'. If -- |A| \geq 1, then `INT(A)' equals the largest integer that -- does not exceed the range of A and whose sign is the same as -- the sign of A. -- -- (C) -- If A is of type `COMPLEX', rule B is applied to the real part -- of A. -- --_Example_: -- program test_int -- integer :: i = 42 -- complex :: z = (-3.7, 1.0) -- print *, int(i) -- print *, int(z), int(z,8) -- end program -- --_Specific names_: -- Name Argument Return type Standard -- `IFIX(A)' `REAL(4) A' `INTEGER' Fortran 77 and -- later -- `IDINT(A)' `REAL(8) A' `INTEGER' Fortran 77 and -- later -- -- -- --File: gfortran.info, Node: INT2, Next: INT8, Prev: INT, Up: Intrinsic Procedures -- --7.113 `INT2' -- Convert to 16-bit integer type --============================================== -- --_Description_: -- Convert to a `KIND=2' integer type. This is equivalent to the -- standard `INT' intrinsic with an optional argument of `KIND=2', -- and is only included for backwards compatibility. -- -- The `SHORT' intrinsic is equivalent to `INT2'. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = INT2(A)' -- --_Arguments_: -- A Shall be of type `INTEGER', `REAL', or -- `COMPLEX'. -- --_Return value_: -- The return value is a `INTEGER(2)' variable. -- --_See also_: -- *note INT::, *note INT8::, *note LONG:: -- -- --File: gfortran.info, Node: INT8, Next: IOR, Prev: INT2, Up: Intrinsic Procedures -- --7.114 `INT8' -- Convert to 64-bit integer type --============================================== -- --_Description_: -- Convert to a `KIND=8' integer type. This is equivalent to the -- standard `INT' intrinsic with an optional argument of `KIND=8', -- and is only included for backwards compatibility. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = INT8(A)' -- --_Arguments_: -- A Shall be of type `INTEGER', `REAL', or -- `COMPLEX'. -- --_Return value_: -- The return value is a `INTEGER(8)' variable. -- --_See also_: -- *note INT::, *note INT2::, *note LONG:: -- -- --File: gfortran.info, Node: IOR, Next: IRAND, Prev: INT8, Up: Intrinsic Procedures -- --7.115 `IOR' -- Bitwise logical or --================================= -- --_Description_: -- `IOR' returns the bitwise boolean inclusive-OR of I and J. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IOR(I, J)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- J The type shall be `INTEGER', of the same kind -- as I. (As a GNU extension, different kinds -- are also permitted.) -- --_Return value_: -- The return type is `INTEGER', of the same kind as the arguments. -- (If the argument kinds differ, it is of the same kind as the -- larger argument.) -- --_See also_: -- *note IEOR::, *note IAND::, *note IBITS::, *note IBSET::, *note -- IBCLR::, *note NOT:: -- -- --File: gfortran.info, Node: IRAND, Next: IS_IOSTAT_END, Prev: IOR, Up: Intrinsic Procedures -- --7.116 `IRAND' -- Integer pseudo-random number --============================================= -- --_Description_: -- `IRAND(FLAG)' returns a pseudo-random number from a uniform -- distribution between 0 and a system-dependent limit (which is in -- most cases 2147483647). If FLAG is 0, the next number in the -- current sequence is returned; if FLAG is 1, the generator is -- restarted by `CALL SRAND(0)'; if FLAG has any other value, it is -- used as a new seed with `SRAND'. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. It implements a simple modulo generator as provided -- by `g77'. For new code, one should consider the use of *note -- RANDOM_NUMBER:: as it implements a superior algorithm. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = IRAND(I)' -- --_Arguments_: -- I Shall be a scalar `INTEGER' of kind 4. -- --_Return value_: -- The return value is of `INTEGER(kind=4)' type. -- --_Example_: -- program test_irand -- integer,parameter :: seed = 86456 -- -- call srand(seed) -- print *, irand(), irand(), irand(), irand() -- print *, irand(seed), irand(), irand(), irand() -- end program test_irand -- -- -- --File: gfortran.info, Node: IS_IOSTAT_END, Next: IS_IOSTAT_EOR, Prev: IRAND, Up: Intrinsic Procedures -- --7.117 `IS_IOSTAT_END' -- Test for end-of-file value --=================================================== -- --_Description_: -- `IS_IOSTAT_END' tests whether an variable has the value of the I/O -- status "end of file". The function is equivalent to comparing the -- variable with the `IOSTAT_END' parameter of the intrinsic module -- `ISO_FORTRAN_ENV'. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IS_IOSTAT_END(I)' -- --_Arguments_: -- I Shall be of the type `INTEGER'. -- --_Return value_: -- Returns a `LOGICAL' of the default kind, which `.TRUE.' if I has -- the value which indicates an end of file condition for IOSTAT= -- specifiers, and is `.FALSE.' otherwise. -- --_Example_: -- PROGRAM iostat -- IMPLICIT NONE -- INTEGER :: stat, i -- OPEN(88, FILE='test.dat') -- READ(88, *, IOSTAT=stat) i -- IF(IS_IOSTAT_END(stat)) STOP 'END OF FILE' -- END PROGRAM -- -- --File: gfortran.info, Node: IS_IOSTAT_EOR, Next: ISATTY, Prev: IS_IOSTAT_END, Up: Intrinsic Procedures -- --7.118 `IS_IOSTAT_EOR' -- Test for end-of-record value --===================================================== -- --_Description_: -- `IS_IOSTAT_EOR' tests whether an variable has the value of the I/O -- status "end of record". The function is equivalent to comparing the -- variable with the `IOSTAT_EOR' parameter of the intrinsic module -- `ISO_FORTRAN_ENV'. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = IS_IOSTAT_EOR(I)' -- --_Arguments_: -- I Shall be of the type `INTEGER'. -- --_Return value_: -- Returns a `LOGICAL' of the default kind, which `.TRUE.' if I has -- the value which indicates an end of file condition for IOSTAT= -- specifiers, and is `.FALSE.' otherwise. -- --_Example_: -- PROGRAM iostat -- IMPLICIT NONE -- INTEGER :: stat, i(50) -- OPEN(88, FILE='test.dat', FORM='UNFORMATTED') -- READ(88, IOSTAT=stat) i -- IF(IS_IOSTAT_EOR(stat)) STOP 'END OF RECORD' -- END PROGRAM -- -- --File: gfortran.info, Node: ISATTY, Next: ISHFT, Prev: IS_IOSTAT_EOR, Up: Intrinsic Procedures -- --7.119 `ISATTY' -- Whether a unit is a terminal device. --====================================================== -- --_Description_: -- Determine whether a unit is connected to a terminal device. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = ISATTY(UNIT)' -- --_Arguments_: -- UNIT Shall be a scalar `INTEGER'. -- --_Return value_: -- Returns `.TRUE.' if the UNIT is connected to a terminal device, -- `.FALSE.' otherwise. -- --_Example_: -- PROGRAM test_isatty -- INTEGER(kind=1) :: unit -- DO unit = 1, 10 -- write(*,*) isatty(unit=unit) -- END DO -- END PROGRAM -- --_See also_: -- *note TTYNAM:: -- -- --File: gfortran.info, Node: ISHFT, Next: ISHFTC, Prev: ISATTY, Up: Intrinsic Procedures -- --7.120 `ISHFT' -- Shift bits --=========================== -- --_Description_: -- `ISHFT' returns a value corresponding to I with all of the bits -- shifted SHIFT places. A value of SHIFT greater than zero -- corresponds to a left shift, a value of zero corresponds to no -- shift, and a value less than zero corresponds to a right shift. -- If the absolute value of SHIFT is greater than `BIT_SIZE(I)', the -- value is undefined. Bits shifted out from the left end or right -- end are lost; zeros are shifted in from the opposite end. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ISHFT(I, SHIFT)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- SHIFT The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note ISHFTC:: -- -- --File: gfortran.info, Node: ISHFTC, Next: ISNAN, Prev: ISHFT, Up: Intrinsic Procedures -- --7.121 `ISHFTC' -- Shift bits circularly --======================================= -- --_Description_: -- `ISHFTC' returns a value corresponding to I with the rightmost -- SIZE bits shifted circularly SHIFT places; that is, bits shifted -- out one end are shifted into the opposite end. A value of SHIFT -- greater than zero corresponds to a left shift, a value of zero -- corresponds to no shift, and a value less than zero corresponds to -- a right shift. The absolute value of SHIFT must be less than -- SIZE. If the SIZE argument is omitted, it is taken to be -- equivalent to `BIT_SIZE(I)'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = ISHFTC(I, SHIFT [, SIZE])' -- --_Arguments_: -- I The type shall be `INTEGER'. -- SHIFT The type shall be `INTEGER'. -- SIZE (Optional) The type shall be `INTEGER'; the -- value must be greater than zero and less than -- or equal to `BIT_SIZE(I)'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note ISHFT:: -- -- --File: gfortran.info, Node: ISNAN, Next: ITIME, Prev: ISHFTC, Up: Intrinsic Procedures -- --7.122 `ISNAN' -- Test for a NaN --=============================== -- --_Description_: -- `ISNAN' tests whether a floating-point value is an IEEE -- Not-a-Number (NaN). -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `ISNAN(X)' -- --_Arguments_: -- X Variable of the type `REAL'. -- --_Return value_: -- Returns a default-kind `LOGICAL'. The returned value is `TRUE' if -- X is a NaN and `FALSE' otherwise. -- --_Example_: -- program test_nan -- implicit none -- real :: x -- x = -1.0 -- x = sqrt(x) -- if (isnan(x)) stop '"x" is a NaN' -- end program test_nan -- -- --File: gfortran.info, Node: ITIME, Next: KILL, Prev: ISNAN, Up: Intrinsic Procedures -- --7.123 `ITIME' -- Get current local time subroutine (hour/minutes/seconds) --========================================================================= -- --_Description_: -- `IDATE(VALUES)' Fills VALUES with the numerical values at the -- current local time. The hour (in the range 1-24), minute (in the -- range 1-60), and seconds (in the range 1-60) appear in elements 1, -- 2, and 3 of VALUES, respectively. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL ITIME(VALUES)' -- --_Arguments_: -- VALUES The type shall be `INTEGER, DIMENSION(3)' and -- the kind shall be the default integer kind. -- --_Return value_: -- Does not return anything. -- --_Example_: -- program test_itime -- integer, dimension(3) :: tarray -- call itime(tarray) -- print *, tarray(1) -- print *, tarray(2) -- print *, tarray(3) -- end program test_itime -- -- --File: gfortran.info, Node: KILL, Next: KIND, Prev: ITIME, Up: Intrinsic Procedures -- --7.124 `KILL' -- Send a signal to a process --========================================== -- --_Description_: -- --_Standard_: -- Sends the signal specified by SIGNAL to the process PID. See -- `kill(2)'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL KILL(C, VALUE [, STATUS])' -- --_Arguments_: -- C Shall be a scalar `INTEGER', with `INTENT(IN)' -- VALUE Shall be a scalar `INTEGER', with `INTENT(IN)' -- STATUS (Optional) status flag of type `INTEGER(4)' or -- `INTEGER(8)'. Returns 0 on success, or a -- system-specific error code otherwise. -- --_See also_: -- *note ABORT::, *note EXIT:: -- -- --File: gfortran.info, Node: KIND, Next: LBOUND, Prev: KILL, Up: Intrinsic Procedures -- --7.125 `KIND' -- Kind of an entity --================================= -- --_Description_: -- `KIND(X)' returns the kind value of the entity X. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `K = KIND(X)' -- --_Arguments_: -- X Shall be of type `LOGICAL', `INTEGER', `REAL', -- `COMPLEX' or `CHARACTER'. -- --_Return value_: -- The return value is a scalar of type `INTEGER' and of the default -- integer kind. -- --_Example_: -- program test_kind -- integer,parameter :: kc = kind(' ') -- integer,parameter :: kl = kind(.true.) -- -- print *, "The default character kind is ", kc -- print *, "The default logical kind is ", kl -- end program test_kind -- -- -- --File: gfortran.info, Node: LBOUND, Next: LEADZ, Prev: KIND, Up: Intrinsic Procedures -- --7.126 `LBOUND' -- Lower dimension bounds of an array --==================================================== -- --_Description_: -- Returns the lower bounds of an array, or a single lower bound -- along the DIM dimension. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = LBOUND(ARRAY [, DIM [, KIND]])' -- --_Arguments_: -- ARRAY Shall be an array, of any type. -- DIM (Optional) Shall be a scalar `INTEGER'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. If DIM is -- absent, the result is an array of the lower bounds of ARRAY. If -- DIM is present, the result is a scalar corresponding to the lower -- bound of the array along that dimension. If ARRAY is an -- expression rather than a whole array or array structure component, -- or if it has a zero extent along the relevant dimension, the lower -- bound is taken to be 1. -- --_See also_: -- *note UBOUND:: -- -- --File: gfortran.info, Node: LEADZ, Next: LEN, Prev: LBOUND, Up: Intrinsic Procedures -- --7.127 `LEADZ' -- Number of leading zero bits of an integer --========================================================== -- --_Description_: -- `LEADZ' returns the number of leading zero bits of an integer. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LEADZ(I)' -- --_Arguments_: -- I Shall be of type `INTEGER'. -- --_Return value_: -- The type of the return value is the default `INTEGER'. If all the -- bits of `I' are zero, the result value is `BIT_SIZE(I)'. -- --_Example_: -- PROGRAM test_leadz -- WRITE (*,*) LEADZ(1) ! prints 8 if BITSIZE(I) has the value 32 -- END PROGRAM -- --_See also_: -- *note BIT_SIZE::, *note TRAILZ:: -- -- --File: gfortran.info, Node: LEN, Next: LEN_TRIM, Prev: LEADZ, Up: Intrinsic Procedures -- --7.128 `LEN' -- Length of a character entity --=========================================== -- --_Description_: -- Returns the length of a character string. If STRING is an array, -- the length of an element of STRING is returned. Note that STRING -- need not be defined when this intrinsic is invoked, since only the -- length, not the content, of STRING is needed. -- --_Standard_: -- Fortran 77 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `L = LEN(STRING [, KIND])' -- --_Arguments_: -- STRING Shall be a scalar or array of type -- `CHARACTER', with `INTENT(IN)' -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_See also_: -- *note LEN_TRIM::, *note ADJUSTL::, *note ADJUSTR:: -- -- --File: gfortran.info, Node: LEN_TRIM, Next: LOG_GAMMA, Prev: LEN, Up: Intrinsic Procedures -- --7.129 `LEN_TRIM' -- Length of a character entity without trailing blank characters --================================================================================== -- --_Description_: -- Returns the length of a character string, ignoring any trailing -- blanks. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LEN_TRIM(STRING [, KIND])' -- --_Arguments_: -- STRING Shall be a scalar of type `CHARACTER', with -- `INTENT(IN)' -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_See also_: -- *note LEN::, *note ADJUSTL::, *note ADJUSTR:: -- -- --File: gfortran.info, Node: LGE, Next: LGT, Prev: LOG_GAMMA, Up: Intrinsic Procedures -- --7.130 `LGE' -- Lexical greater than or equal --============================================ -- --_Description_: -- Determines whether one string is lexically greater than or equal to -- another string, where the two strings are interpreted as containing -- ASCII character codes. If the String A and String B are not the -- same length, the shorter is compared as if spaces were appended to -- it to form a value that has the same length as the longer. -- -- In general, the lexical comparison intrinsics `LGE', `LGT', `LLE', -- and `LLT' differ from the corresponding intrinsic operators -- `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the -- processor's character ordering (which is not ASCII on some -- targets), whereas the former always use the ASCII ordering. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LGE(STRING_A, STRING_B)' -- --_Arguments_: -- STRING_A Shall be of default `CHARACTER' type. -- STRING_B Shall be of default `CHARACTER' type. -- --_Return value_: -- Returns `.TRUE.' if `STRING_A >= STRING_B', and `.FALSE.' -- otherwise, based on the ASCII ordering. -- --_See also_: -- *note LGT::, *note LLE::, *note LLT:: -- -- --File: gfortran.info, Node: LGT, Next: LINK, Prev: LGE, Up: Intrinsic Procedures -- --7.131 `LGT' -- Lexical greater than --=================================== -- --_Description_: -- Determines whether one string is lexically greater than another -- string, where the two strings are interpreted as containing ASCII -- character codes. If the String A and String B are not the same -- length, the shorter is compared as if spaces were appended to it -- to form a value that has the same length as the longer. -- -- In general, the lexical comparison intrinsics `LGE', `LGT', `LLE', -- and `LLT' differ from the corresponding intrinsic operators -- `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the -- processor's character ordering (which is not ASCII on some -- targets), whereas the former always use the ASCII ordering. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LGT(STRING_A, STRING_B)' -- --_Arguments_: -- STRING_A Shall be of default `CHARACTER' type. -- STRING_B Shall be of default `CHARACTER' type. -- --_Return value_: -- Returns `.TRUE.' if `STRING_A > STRING_B', and `.FALSE.' -- otherwise, based on the ASCII ordering. -- --_See also_: -- *note LGE::, *note LLE::, *note LLT:: -- -- --File: gfortran.info, Node: LINK, Next: LLE, Prev: LGT, Up: Intrinsic Procedures -- --7.132 `LINK' -- Create a hard link --================================== -- --_Description_: -- Makes a (hard) link from file PATH1 to PATH2. A null character -- (`CHAR(0)') can be used to mark the end of the names in PATH1 and -- PATH2; otherwise, trailing blanks in the file names are ignored. -- If the STATUS argument is supplied, it contains 0 on success or a -- nonzero error code upon return; see `link(2)'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL LINK(PATH1, PATH2 [, STATUS])' -- `STATUS = LINK(PATH1, PATH2)' -- --_Arguments_: -- PATH1 Shall be of default `CHARACTER' type. -- PATH2 Shall be of default `CHARACTER' type. -- STATUS (Optional) Shall be of default `INTEGER' type. -- --_See also_: -- *note SYMLNK::, *note UNLINK:: -- -- --File: gfortran.info, Node: LLE, Next: LLT, Prev: LINK, Up: Intrinsic Procedures -- --7.133 `LLE' -- Lexical less than or equal --========================================= -- --_Description_: -- Determines whether one string is lexically less than or equal to -- another string, where the two strings are interpreted as -- containing ASCII character codes. If the String A and String B -- are not the same length, the shorter is compared as if spaces were -- appended to it to form a value that has the same length as the -- longer. -- -- In general, the lexical comparison intrinsics `LGE', `LGT', `LLE', -- and `LLT' differ from the corresponding intrinsic operators -- `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the -- processor's character ordering (which is not ASCII on some -- targets), whereas the former always use the ASCII ordering. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LLE(STRING_A, STRING_B)' -- --_Arguments_: -- STRING_A Shall be of default `CHARACTER' type. -- STRING_B Shall be of default `CHARACTER' type. -- --_Return value_: -- Returns `.TRUE.' if `STRING_A <= STRING_B', and `.FALSE.' -- otherwise, based on the ASCII ordering. -- --_See also_: -- *note LGE::, *note LGT::, *note LLT:: -- -- --File: gfortran.info, Node: LLT, Next: LNBLNK, Prev: LLE, Up: Intrinsic Procedures -- --7.134 `LLT' -- Lexical less than --================================ -- --_Description_: -- Determines whether one string is lexically less than another -- string, where the two strings are interpreted as containing ASCII -- character codes. If the String A and String B are not the same -- length, the shorter is compared as if spaces were appended to it -- to form a value that has the same length as the longer. -- -- In general, the lexical comparison intrinsics `LGE', `LGT', `LLE', -- and `LLT' differ from the corresponding intrinsic operators -- `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the -- processor's character ordering (which is not ASCII on some -- targets), whereas the former always use the ASCII ordering. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LLT(STRING_A, STRING_B)' -- --_Arguments_: -- STRING_A Shall be of default `CHARACTER' type. -- STRING_B Shall be of default `CHARACTER' type. -- --_Return value_: -- Returns `.TRUE.' if `STRING_A < STRING_B', and `.FALSE.' -- otherwise, based on the ASCII ordering. -- --_See also_: -- *note LGE::, *note LGT::, *note LLE:: -- -- --File: gfortran.info, Node: LNBLNK, Next: LOC, Prev: LLT, Up: Intrinsic Procedures -- --7.135 `LNBLNK' -- Index of the last non-blank character in a string --=================================================================== -- --_Description_: -- Returns the length of a character string, ignoring any trailing -- blanks. This is identical to the standard `LEN_TRIM' intrinsic, -- and is only included for backwards compatibility. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LNBLNK(STRING)' -- --_Arguments_: -- STRING Shall be a scalar of type `CHARACTER', with -- `INTENT(IN)' -- --_Return value_: -- The return value is of `INTEGER(kind=4)' type. -- --_See also_: -- *note INDEX intrinsic::, *note LEN_TRIM:: -- -- --File: gfortran.info, Node: LOC, Next: LOG, Prev: LNBLNK, Up: Intrinsic Procedures -- --7.136 `LOC' -- Returns the address of a variable --================================================ -- --_Description_: -- `LOC(X)' returns the address of X as an integer. -- --_Standard_: -- GNU extension -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = LOC(X)' -- --_Arguments_: -- X Variable of any type. -- --_Return value_: -- The return value is of type `INTEGER', with a `KIND' corresponding -- to the size (in bytes) of a memory address on the target machine. -- --_Example_: -- program test_loc -- integer :: i -- real :: r -- i = loc(r) -- print *, i -- end program test_loc -- -- --File: gfortran.info, Node: LOG, Next: LOG10, Prev: LOC, Up: Intrinsic Procedures -- --7.137 `LOG' -- Logarithm function --================================= -- --_Description_: -- `LOG(X)' computes the logarithm of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LOG(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value is of type `REAL' or `COMPLEX'. The kind type -- parameter is the same as X. If X is `COMPLEX', the imaginary part -- \omega is in the range -\pi \leq \omega \leq \pi. -- --_Example_: -- program test_log -- real(8) :: x = 1.0_8 -- complex :: z = (1.0, 2.0) -- x = log(x) -- z = log(z) -- end program test_log -- --_Specific names_: -- Name Argument Return type Standard -- `ALOG(X)' `REAL(4) X' `REAL(4)' f95, gnu -- `DLOG(X)' `REAL(8) X' `REAL(8)' f95, gnu -- `CLOG(X)' `COMPLEX(4) `COMPLEX(4)' f95, gnu -- X' -- `ZLOG(X)' `COMPLEX(8) `COMPLEX(8)' f95, gnu -- X' -- `CDLOG(X)' `COMPLEX(8) `COMPLEX(8)' f95, gnu -- X' -- -- --File: gfortran.info, Node: LOG10, Next: LOGICAL, Prev: LOG, Up: Intrinsic Procedures -- --7.138 `LOG10' -- Base 10 logarithm function --=========================================== -- --_Description_: -- `LOG10(X)' computes the base 10 logarithm of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LOG10(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' or `COMPLEX'. The kind type -- parameter is the same as X. -- --_Example_: -- program test_log10 -- real(8) :: x = 10.0_8 -- x = log10(x) -- end program test_log10 -- --_Specific names_: -- Name Argument Return type Standard -- `ALOG10(X)' `REAL(4) X' `REAL(4)' Fortran 95 and -- later -- `DLOG10(X)' `REAL(8) X' `REAL(8)' Fortran 95 and -- later -- -- --File: gfortran.info, Node: LOG_GAMMA, Next: LGE, Prev: LEN_TRIM, Up: Intrinsic Procedures -- --7.139 `LOG_GAMMA' -- Logarithm of the Gamma function --==================================================== -- --_Description_: -- `LOG_GAMMA(X)' computes the natural logarithm of the absolute value -- of the Gamma (\Gamma) function. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `X = LOG_GAMMA(X)' -- --_Arguments_: -- X Shall be of type `REAL' and neither zero nor a -- negative integer. -- --_Return value_: -- The return value is of type `REAL' of the same kind as X. -- --_Example_: -- program test_log_gamma -- real :: x = 1.0 -- x = lgamma(x) ! returns 0.0 -- end program test_log_gamma -- --_Specific names_: -- Name Argument Return type Standard -- `LGAMMA(X)' `REAL(4) X' `REAL(4)' GNU Extension -- `ALGAMA(X)' `REAL(4) X' `REAL(4)' GNU Extension -- `DLGAMA(X)' `REAL(8) X' `REAL(8)' GNU Extension -- --_See also_: -- Gamma function: *note GAMMA:: -- -- -- --File: gfortran.info, Node: LOGICAL, Next: LONG, Prev: LOG10, Up: Intrinsic Procedures -- --7.140 `LOGICAL' -- Convert to logical type --========================================== -- --_Description_: -- Converts one kind of `LOGICAL' variable to another. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LOGICAL(L [, KIND])' -- --_Arguments_: -- L The type shall be `LOGICAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is a `LOGICAL' value equal to L, with a kind -- corresponding to KIND, or of the default logical kind if KIND is -- not given. -- --_See also_: -- *note INT::, *note REAL::, *note CMPLX:: -- -- --File: gfortran.info, Node: LONG, Next: LSHIFT, Prev: LOGICAL, Up: Intrinsic Procedures -- --7.141 `LONG' -- Convert to integer type --======================================= -- --_Description_: -- Convert to a `KIND=4' integer type, which is the same size as a C -- `long' integer. This is equivalent to the standard `INT' -- intrinsic with an optional argument of `KIND=4', and is only -- included for backwards compatibility. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LONG(A)' -- --_Arguments_: -- A Shall be of type `INTEGER', `REAL', or -- `COMPLEX'. -- --_Return value_: -- The return value is a `INTEGER(4)' variable. -- --_See also_: -- *note INT::, *note INT2::, *note INT8:: -- -- --File: gfortran.info, Node: LSHIFT, Next: LSTAT, Prev: LONG, Up: Intrinsic Procedures -- --7.142 `LSHIFT' -- Left shift bits --================================= -- --_Description_: -- `LSHIFT' returns a value corresponding to I with all of the bits -- shifted left by SHIFT places. If the absolute value of SHIFT is -- greater than `BIT_SIZE(I)', the value is undefined. Bits shifted -- out from the left end are lost; zeros are shifted in from the -- opposite end. -- -- This function has been superseded by the `ISHFT' intrinsic, which -- is standard in Fortran 95 and later. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = LSHIFT(I, SHIFT)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- SHIFT The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note ISHFT::, *note ISHFTC::, *note RSHIFT:: -- -- -- --File: gfortran.info, Node: LSTAT, Next: LTIME, Prev: LSHIFT, Up: Intrinsic Procedures -- --7.143 `LSTAT' -- Get file status --================================ -- --_Description_: -- `LSTAT' is identical to *note STAT::, except that if path is a -- symbolic link, then the link itself is statted, not the file that -- it refers to. -- -- The elements in `BUFF' are the same as described by *note STAT::. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL LSTAT(FILE, BUFF [, STATUS])' -- --_Arguments_: -- FILE The type shall be `CHARACTER' of the default -- kind, a valid path within the file system. -- BUFF The type shall be `INTEGER(4), DIMENSION(13)'. -- STATUS (Optional) status flag of type `INTEGER(4)'. -- Returns 0 on success and a system specific -- error code otherwise. -- --_Example_: -- See *note STAT:: for an example. -- --_See also_: -- To stat an open file: *note FSTAT::, to stat a file: *note STAT:: -- -- --File: gfortran.info, Node: LTIME, Next: MALLOC, Prev: LSTAT, Up: Intrinsic Procedures -- --7.144 `LTIME' -- Convert time to local time info --================================================ -- --_Description_: -- Given a system time value STIME (as provided by the `TIME8()' -- intrinsic), fills TARRAY with values extracted from it appropriate -- to the local time zone using `localtime(3)'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL LTIME(STIME, TARRAY)' -- --_Arguments_: -- STIME An `INTEGER' scalar expression corresponding -- to a system time, with `INTENT(IN)'. -- TARRAY A default `INTEGER' array with 9 elements, -- with `INTENT(OUT)'. -- --_Return value_: -- The elements of TARRAY are assigned as follows: -- 1. Seconds after the minute, range 0-59 or 0-61 to allow for leap -- seconds -- -- 2. Minutes after the hour, range 0-59 -- -- 3. Hours past midnight, range 0-23 -- -- 4. Day of month, range 0-31 -- -- 5. Number of months since January, range 0-12 -- -- 6. Years since 1900 -- -- 7. Number of days since Sunday, range 0-6 -- -- 8. Days since January 1 -- -- 9. Daylight savings indicator: positive if daylight savings is in -- effect, zero if not, and negative if the information is not -- available. -- --_See also_: -- *note CTIME::, *note GMTIME::, *note TIME::, *note TIME8:: -- -- -- --File: gfortran.info, Node: MALLOC, Next: MATMUL, Prev: LTIME, Up: Intrinsic Procedures -- --7.145 `MALLOC' -- Allocate dynamic memory --========================================= -- --_Description_: -- `MALLOC(SIZE)' allocates SIZE bytes of dynamic memory and returns -- the address of the allocated memory. The `MALLOC' intrinsic is an -- extension intended to be used with Cray pointers, and is provided -- in GNU Fortran to allow the user to compile legacy code. For new -- code using Fortran 95 pointers, the memory allocation intrinsic is -- `ALLOCATE'. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `PTR = MALLOC(SIZE)' -- --_Arguments_: -- SIZE The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER(K)', with K such that -- variables of type `INTEGER(K)' have the same size as C pointers -- (`sizeof(void *)'). -- --_Example_: -- The following example demonstrates the use of `MALLOC' and `FREE' -- with Cray pointers. -- -- program test_malloc -- implicit none -- integer i -- real*8 x(*), z -- pointer(ptr_x,x) -- -- ptr_x = malloc(20*8) -- do i = 1, 20 -- x(i) = sqrt(1.0d0 / i) -- end do -- z = 0 -- do i = 1, 20 -- z = z + x(i) -- print *, z -- end do -- call free(ptr_x) -- end program test_malloc -- --_See also_: -- *note FREE:: -- -- --File: gfortran.info, Node: MATMUL, Next: MAX, Prev: MALLOC, Up: Intrinsic Procedures -- --7.146 `MATMUL' -- matrix multiplication --======================================= -- --_Description_: -- Performs a matrix multiplication on numeric or logical arguments. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = MATMUL(MATRIX_A, MATRIX_B)' -- --_Arguments_: -- MATRIX_A An array of `INTEGER', `REAL', `COMPLEX', or -- `LOGICAL' type, with a rank of one or two. -- MATRIX_B An array of `INTEGER', `REAL', or `COMPLEX' -- type if MATRIX_A is of a numeric type; -- otherwise, an array of `LOGICAL' type. The -- rank shall be one or two, and the first (or -- only) dimension of MATRIX_B shall be equal to -- the last (or only) dimension of MATRIX_A. -- --_Return value_: -- The matrix product of MATRIX_A and MATRIX_B. The type and kind of -- the result follow the usual type and kind promotion rules, as for -- the `*' or `.AND.' operators. -- --_See also_: -- -- --File: gfortran.info, Node: MAX, Next: MAXEXPONENT, Prev: MATMUL, Up: Intrinsic Procedures -- --7.147 `MAX' -- Maximum value of an argument list --================================================ -- --_Description_: -- Returns the argument with the largest (most positive) value. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = MAX(A1, A2 [, A3 [, ...]])' -- --_Arguments_: -- A1 The type shall be `INTEGER' or `REAL'. -- A2, A3, An expression of the same type and kind as A1. -- ... (As a GNU extension, arguments of different -- kinds are permitted.) -- --_Return value_: -- The return value corresponds to the maximum value among the -- arguments, and has the same type and kind as the first argument. -- --_Specific names_: -- Name Argument Return type Standard -- `MAX0(I)' `INTEGER(4) `INTEGER(4)' Fortran 77 and -- I' later -- `AMAX0(I)' `INTEGER(4) `REAL(MAX(X))'Fortran 77 and -- I' later -- `MAX1(X)' `REAL X' `INT(MAX(X))' Fortran 77 and -- later -- `AMAX1(X)' `REAL(4) `REAL(4)' Fortran 77 and -- X' later -- `DMAX1(X)' `REAL(8) `REAL(8)' Fortran 77 and -- X' later -- --_See also_: -- *note MAXLOC:: *note MAXVAL::, *note MIN:: -- -- -- --File: gfortran.info, Node: MAXEXPONENT, Next: MAXLOC, Prev: MAX, Up: Intrinsic Procedures -- --7.148 `MAXEXPONENT' -- Maximum exponent of a real kind --====================================================== -- --_Description_: -- `MAXEXPONENT(X)' returns the maximum exponent in the model of the -- type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = MAXEXPONENT(X)' -- --_Arguments_: -- X Shall be of type `REAL'. -- --_Return value_: -- The return value is of type `INTEGER' and of the default integer -- kind. -- --_Example_: -- program exponents -- real(kind=4) :: x -- real(kind=8) :: y -- -- print *, minexponent(x), maxexponent(x) -- print *, minexponent(y), maxexponent(y) -- end program exponents -- -- --File: gfortran.info, Node: MAXLOC, Next: MAXVAL, Prev: MAXEXPONENT, Up: Intrinsic Procedures -- --7.149 `MAXLOC' -- Location of the maximum value within an array --=============================================================== -- --_Description_: -- Determines the location of the element in the array with the -- maximum value, or, if the DIM argument is supplied, determines the -- locations of the maximum element along each row of the array in the -- DIM direction. If MASK is present, only the elements for which -- MASK is `.TRUE.' are considered. If more than one element in the -- array has the maximum value, the location returned is that of the -- first such element in array element order. If the array has zero -- size, or all of the elements of MASK are `.FALSE.', then the -- result is an array of zeroes. Similarly, if DIM is supplied and -- all of the elements of MASK along a given row are zero, the result -- value for that row is zero. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = MAXLOC(ARRAY, DIM [, MASK])' -- `RESULT = MAXLOC(ARRAY [, MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL', -- or `CHARACTER'. -- DIM (Optional) Shall be a scalar of type -- `INTEGER', with a value between one and the -- rank of ARRAY, inclusive. It may not be an -- optional dummy argument. -- MASK Shall be an array of type `LOGICAL', and -- conformable with ARRAY. -- --_Return value_: -- If DIM is absent, the result is a rank-one array with a length -- equal to the rank of ARRAY. If DIM is present, the result is an -- array with a rank one less than the rank of ARRAY, and a size -- corresponding to the size of ARRAY with the DIM dimension removed. -- If DIM is present and ARRAY has a rank of one, the result is a -- scalar. In all cases, the result is of default `INTEGER' type. -- --_See also_: -- *note MAX::, *note MAXVAL:: -- -- -- --File: gfortran.info, Node: MAXVAL, Next: MCLOCK, Prev: MAXLOC, Up: Intrinsic Procedures -- --7.150 `MAXVAL' -- Maximum value of an array --=========================================== -- --_Description_: -- Determines the maximum value of the elements in an array value, -- or, if the DIM argument is supplied, determines the maximum value -- along each row of the array in the DIM direction. If MASK is -- present, only the elements for which MASK is `.TRUE.' are -- considered. If the array has zero size, or all of the elements of -- MASK are `.FALSE.', then the result is `-HUGE(ARRAY)' if ARRAY is -- numeric, or a string of nulls if ARRAY is of character type. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = MAXVAL(ARRAY, DIM [, MASK])' -- `RESULT = MAXVAL(ARRAY [, MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL', -- or `CHARACTER'. -- DIM (Optional) Shall be a scalar of type -- `INTEGER', with a value between one and the -- rank of ARRAY, inclusive. It may not be an -- optional dummy argument. -- MASK Shall be an array of type `LOGICAL', and -- conformable with ARRAY. -- --_Return value_: -- If DIM is absent, or if ARRAY has a rank of one, the result is a -- scalar. If DIM is present, the result is an array with a rank one -- less than the rank of ARRAY, and a size corresponding to the size -- of ARRAY with the DIM dimension removed. In all cases, the result -- is of the same type and kind as ARRAY. -- --_See also_: -- *note MAX::, *note MAXLOC:: -- -- --File: gfortran.info, Node: MCLOCK, Next: MCLOCK8, Prev: MAXVAL, Up: Intrinsic Procedures -- --7.151 `MCLOCK' -- Time function --=============================== -- --_Description_: -- Returns the number of clock ticks since the start of the process, -- based on the UNIX function `clock(3)'. -- -- This intrinsic is not fully portable, such as to systems with -- 32-bit `INTEGER' types but supporting times wider than 32 bits. -- Therefore, the values returned by this intrinsic might be, or -- become, negative, or numerically less than previous values, during -- a single run of the compiled program. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = MCLOCK()' -- --_Return value_: -- The return value is a scalar of type `INTEGER(4)', equal to the -- number of clock ticks since the start of the process, or `-1' if -- the system does not support `clock(3)'. -- --_See also_: -- *note CTIME::, *note GMTIME::, *note LTIME::, *note MCLOCK::, -- *note TIME:: -- -- -- --File: gfortran.info, Node: MCLOCK8, Next: MERGE, Prev: MCLOCK, Up: Intrinsic Procedures -- --7.152 `MCLOCK8' -- Time function (64-bit) --========================================= -- --_Description_: -- Returns the number of clock ticks since the start of the process, -- based on the UNIX function `clock(3)'. -- -- _Warning:_ this intrinsic does not increase the range of the timing -- values over that returned by `clock(3)'. On a system with a 32-bit -- `clock(3)', `MCLOCK8()' will return a 32-bit value, even though it -- is converted to a 64-bit `INTEGER(8)' value. That means overflows -- of the 32-bit value can still occur. Therefore, the values -- returned by this intrinsic might be or become negative or -- numerically less than previous values during a single run of the -- compiled program. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = MCLOCK8()' -- --_Return value_: -- The return value is a scalar of type `INTEGER(8)', equal to the -- number of clock ticks since the start of the process, or `-1' if -- the system does not support `clock(3)'. -- --_See also_: -- *note CTIME::, *note GMTIME::, *note LTIME::, *note MCLOCK::, -- *note TIME8:: -- -- -- --File: gfortran.info, Node: MERGE, Next: MIN, Prev: MCLOCK8, Up: Intrinsic Procedures -- --7.153 `MERGE' -- Merge variables --================================ -- --_Description_: -- Select values from two arrays according to a logical mask. The -- result is equal to TSOURCE if MASK is `.TRUE.', or equal to -- FSOURCE if it is `.FALSE.'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = MERGE(TSOURCE, FSOURCE, MASK)' -- --_Arguments_: -- TSOURCE May be of any type. -- FSOURCE Shall be of the same type and type parameters -- as TSOURCE. -- MASK Shall be of type `LOGICAL'. -- --_Return value_: -- The result is of the same type and type parameters as TSOURCE. -- -- -- --File: gfortran.info, Node: MIN, Next: MINEXPONENT, Prev: MERGE, Up: Intrinsic Procedures -- --7.154 `MIN' -- Minimum value of an argument list --================================================ -- --_Description_: -- Returns the argument with the smallest (most negative) value. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = MIN(A1, A2 [, A3, ...])' -- --_Arguments_: -- A1 The type shall be `INTEGER' or `REAL'. -- A2, A3, An expression of the same type and kind as A1. -- ... (As a GNU extension, arguments of different -- kinds are permitted.) -- --_Return value_: -- The return value corresponds to the maximum value among the -- arguments, and has the same type and kind as the first argument. -- --_Specific names_: -- Name Argument Return type Standard -- `MIN0(I)' `INTEGER(4) `INTEGER(4)' Fortran 77 and -- I' later -- `AMIN0(I)' `INTEGER(4) `REAL(MIN(X))'Fortran 77 and -- I' later -- `MIN1(X)' `REAL X' `INT(MIN(X))' Fortran 77 and -- later -- `AMIN1(X)' `REAL(4) `REAL(4)' Fortran 77 and -- X' later -- `DMIN1(X)' `REAL(8) `REAL(8)' Fortran 77 and -- X' later -- --_See also_: -- *note MAX::, *note MINLOC::, *note MINVAL:: -- -- --File: gfortran.info, Node: MINEXPONENT, Next: MINLOC, Prev: MIN, Up: Intrinsic Procedures -- --7.155 `MINEXPONENT' -- Minimum exponent of a real kind --====================================================== -- --_Description_: -- `MINEXPONENT(X)' returns the minimum exponent in the model of the -- type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = MINEXPONENT(X)' -- --_Arguments_: -- X Shall be of type `REAL'. -- --_Return value_: -- The return value is of type `INTEGER' and of the default integer -- kind. -- --_Example_: -- See `MAXEXPONENT' for an example. -- -- --File: gfortran.info, Node: MINLOC, Next: MINVAL, Prev: MINEXPONENT, Up: Intrinsic Procedures -- --7.156 `MINLOC' -- Location of the minimum value within an array --=============================================================== -- --_Description_: -- Determines the location of the element in the array with the -- minimum value, or, if the DIM argument is supplied, determines the -- locations of the minimum element along each row of the array in the -- DIM direction. If MASK is present, only the elements for which -- MASK is `.TRUE.' are considered. If more than one element in the -- array has the minimum value, the location returned is that of the -- first such element in array element order. If the array has zero -- size, or all of the elements of MASK are `.FALSE.', then the -- result is an array of zeroes. Similarly, if DIM is supplied and -- all of the elements of MASK along a given row are zero, the result -- value for that row is zero. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = MINLOC(ARRAY, DIM [, MASK])' -- `RESULT = MINLOC(ARRAY [, MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL', -- or `CHARACTER'. -- DIM (Optional) Shall be a scalar of type -- `INTEGER', with a value between one and the -- rank of ARRAY, inclusive. It may not be an -- optional dummy argument. -- MASK Shall be an array of type `LOGICAL', and -- conformable with ARRAY. -- --_Return value_: -- If DIM is absent, the result is a rank-one array with a length -- equal to the rank of ARRAY. If DIM is present, the result is an -- array with a rank one less than the rank of ARRAY, and a size -- corresponding to the size of ARRAY with the DIM dimension removed. -- If DIM is present and ARRAY has a rank of one, the result is a -- scalar. In all cases, the result is of default `INTEGER' type. -- --_See also_: -- *note MIN::, *note MINVAL:: -- -- -- --File: gfortran.info, Node: MINVAL, Next: MOD, Prev: MINLOC, Up: Intrinsic Procedures -- --7.157 `MINVAL' -- Minimum value of an array --=========================================== -- --_Description_: -- Determines the minimum value of the elements in an array value, -- or, if the DIM argument is supplied, determines the minimum value -- along each row of the array in the DIM direction. If MASK is -- present, only the elements for which MASK is `.TRUE.' are -- considered. If the array has zero size, or all of the elements of -- MASK are `.FALSE.', then the result is `HUGE(ARRAY)' if ARRAY is -- numeric, or a string of `CHAR(255)' characters if ARRAY is of -- character type. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = MINVAL(ARRAY, DIM [, MASK])' -- `RESULT = MINVAL(ARRAY [, MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL', -- or `CHARACTER'. -- DIM (Optional) Shall be a scalar of type -- `INTEGER', with a value between one and the -- rank of ARRAY, inclusive. It may not be an -- optional dummy argument. -- MASK Shall be an array of type `LOGICAL', and -- conformable with ARRAY. -- --_Return value_: -- If DIM is absent, or if ARRAY has a rank of one, the result is a -- scalar. If DIM is present, the result is an array with a rank one -- less than the rank of ARRAY, and a size corresponding to the size -- of ARRAY with the DIM dimension removed. In all cases, the result -- is of the same type and kind as ARRAY. -- --_See also_: -- *note MIN::, *note MINLOC:: -- -- -- --File: gfortran.info, Node: MOD, Next: MODULO, Prev: MINVAL, Up: Intrinsic Procedures -- --7.158 `MOD' -- Remainder function --================================= -- --_Description_: -- `MOD(A,P)' computes the remainder of the division of A by P. It is -- calculated as `A - (INT(A/P) * P)'. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = MOD(A, P)' -- --_Arguments_: -- A Shall be a scalar of type `INTEGER' or `REAL' -- P Shall be a scalar of the same type as A and not -- equal to zero -- --_Return value_: -- The kind of the return value is the result of cross-promoting the -- kinds of the arguments. -- --_Example_: -- program test_mod -- print *, mod(17,3) -- print *, mod(17.5,5.5) -- print *, mod(17.5d0,5.5) -- print *, mod(17.5,5.5d0) -- -- print *, mod(-17,3) -- print *, mod(-17.5,5.5) -- print *, mod(-17.5d0,5.5) -- print *, mod(-17.5,5.5d0) -- -- print *, mod(17,-3) -- print *, mod(17.5,-5.5) -- print *, mod(17.5d0,-5.5) -- print *, mod(17.5,-5.5d0) -- end program test_mod -- --_Specific names_: -- Name Arguments Return type Standard -- `AMOD(A,P)' `REAL(4)' `REAL(4)' Fortran 95 and -- later -- `DMOD(A,P)' `REAL(8)' `REAL(8)' Fortran 95 and -- later -- -- --File: gfortran.info, Node: MODULO, Next: MOVE_ALLOC, Prev: MOD, Up: Intrinsic Procedures -- --7.159 `MODULO' -- Modulo function --================================= -- --_Description_: -- `MODULO(A,P)' computes the A modulo P. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = MODULO(A, P)' -- --_Arguments_: -- A Shall be a scalar of type `INTEGER' or `REAL' -- P Shall be a scalar of the same type and kind as -- A -- --_Return value_: -- The type and kind of the result are those of the arguments. -- If A and P are of type `INTEGER': -- `MODULO(A,P)' has the value R such that `A=Q*P+R', where Q is -- an integer and R is between 0 (inclusive) and P (exclusive). -- -- If A and P are of type `REAL': -- `MODULO(A,P)' has the value of `A - FLOOR (A / P) * P'. -- In all cases, if P is zero the result is processor-dependent. -- --_Example_: -- program test_modulo -- print *, modulo(17,3) -- print *, modulo(17.5,5.5) -- -- print *, modulo(-17,3) -- print *, modulo(-17.5,5.5) -- -- print *, modulo(17,-3) -- print *, modulo(17.5,-5.5) -- end program -- -- -- --File: gfortran.info, Node: MOVE_ALLOC, Next: MVBITS, Prev: MODULO, Up: Intrinsic Procedures -- --7.160 `MOVE_ALLOC' -- Move allocation from one object to another --================================================================ -- --_Description_: -- `MOVE_ALLOC(SRC, DEST)' moves the allocation from SRC to DEST. -- SRC will become deallocated in the process. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL MOVE_ALLOC(SRC, DEST)' -- --_Arguments_: -- SRC `ALLOCATABLE', `INTENT(INOUT)', may be of any -- type and kind. -- DEST `ALLOCATABLE', `INTENT(OUT)', shall be of the -- same type, kind and rank as SRC. -- --_Return value_: -- None -- --_Example_: -- program test_move_alloc -- integer, allocatable :: a(:), b(:) -- -- allocate(a(3)) -- a = [ 1, 2, 3 ] -- call move_alloc(a, b) -- print *, allocated(a), allocated(b) -- print *, b -- end program test_move_alloc -- -- --File: gfortran.info, Node: MVBITS, Next: NEAREST, Prev: MOVE_ALLOC, Up: Intrinsic Procedures -- --7.161 `MVBITS' -- Move bits from one integer to another --======================================================= -- --_Description_: -- Moves LEN bits from positions FROMPOS through `FROMPOS+LEN-1' of -- FROM to positions TOPOS through `TOPOS+LEN-1' of TO. The portion -- of argument TO not affected by the movement of bits is unchanged. -- The values of `FROMPOS+LEN-1' and `TOPOS+LEN-1' must be less than -- `BIT_SIZE(FROM)'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental subroutine -- --_Syntax_: -- `CALL MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)' -- --_Arguments_: -- FROM The type shall be `INTEGER'. -- FROMPOS The type shall be `INTEGER'. -- LEN The type shall be `INTEGER'. -- TO The type shall be `INTEGER', of the same kind -- as FROM. -- TOPOS The type shall be `INTEGER'. -- --_See also_: -- *note IBCLR::, *note IBSET::, *note IBITS::, *note IAND::, *note -- IOR::, *note IEOR:: -- -- --File: gfortran.info, Node: NEAREST, Next: NEW_LINE, Prev: MVBITS, Up: Intrinsic Procedures -- --7.162 `NEAREST' -- Nearest representable number --=============================================== -- --_Description_: -- `NEAREST(X, S)' returns the processor-representable number nearest -- to `X' in the direction indicated by the sign of `S'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = NEAREST(X, S)' -- --_Arguments_: -- X Shall be of type `REAL'. -- S (Optional) shall be of type `REAL' and not -- equal to zero. -- --_Return value_: -- The return value is of the same type as `X'. If `S' is positive, -- `NEAREST' returns the processor-representable number greater than -- `X' and nearest to it. If `S' is negative, `NEAREST' returns the -- processor-representable number smaller than `X' and nearest to it. -- --_Example_: -- program test_nearest -- real :: x, y -- x = nearest(42.0, 1.0) -- y = nearest(42.0, -1.0) -- write (*,"(3(G20.15))") x, y, x - y -- end program test_nearest -- -- --File: gfortran.info, Node: NEW_LINE, Next: NINT, Prev: NEAREST, Up: Intrinsic Procedures -- --7.163 `NEW_LINE' -- New line character --====================================== -- --_Description_: -- `NEW_LINE(C)' returns the new-line character. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = NEW_LINE(C)' -- --_Arguments_: -- C The argument shall be a scalar or array of the -- type `CHARACTER'. -- --_Return value_: -- Returns a CHARACTER scalar of length one with the new-line -- character of the same kind as parameter C. -- --_Example_: -- program newline -- implicit none -- write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.' -- end program newline -- -- --File: gfortran.info, Node: NINT, Next: NOT, Prev: NEW_LINE, Up: Intrinsic Procedures -- --7.164 `NINT' -- Nearest whole number --==================================== -- --_Description_: -- `NINT(X)' rounds its argument to the nearest whole number. -- --_Standard_: -- Fortran 77 and later, with KIND argument Fortran 90 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = NINT(X [, KIND])' -- --_Arguments_: -- X The type of the argument shall be `REAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- Returns A with the fractional portion of its magnitude eliminated -- by rounding to the nearest whole number and with its sign -- preserved, converted to an `INTEGER' of the default kind. -- --_Example_: -- program test_nint -- real(4) x4 -- real(8) x8 -- x4 = 1.234E0_4 -- x8 = 4.321_8 -- print *, nint(x4), idnint(x8) -- end program test_nint -- --_Specific names_: -- Name Argument Standard -- `IDNINT(X)' `REAL(8)' Fortran 95 and -- later -- --_See also_: -- *note CEILING::, *note FLOOR:: -- -- -- --File: gfortran.info, Node: NOT, Next: NULL, Prev: NINT, Up: Intrinsic Procedures -- --7.165 `NOT' -- Logical negation --=============================== -- --_Description_: -- `NOT' returns the bitwise boolean inverse of I. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = NOT(I)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- --_Return value_: -- The return type is `INTEGER', of the same kind as the argument. -- --_See also_: -- *note IAND::, *note IEOR::, *note IOR::, *note IBITS::, *note -- IBSET::, *note IBCLR:: -- -- -- --File: gfortran.info, Node: NULL, Next: OR, Prev: NOT, Up: Intrinsic Procedures -- --7.166 `NULL' -- Function that returns an disassociated pointer --============================================================== -- --_Description_: -- Returns a disassociated pointer. -- -- If MOLD is present, a dissassociated pointer of the same type is -- returned, otherwise the type is determined by context. -- -- In Fortran 95, MOLD is optional. Please note that Fortran 2003 -- includes cases where it is required. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `PTR => NULL([MOLD])' -- --_Arguments_: -- MOLD (Optional) shall be a pointer of any -- association status and of any type. -- --_Return value_: -- A disassociated pointer. -- --_Example_: -- REAL, POINTER, DIMENSION(:) :: VEC => NULL () -- --_See also_: -- *note ASSOCIATED:: -- -- --File: gfortran.info, Node: OR, Next: PACK, Prev: NULL, Up: Intrinsic Procedures -- --7.167 `OR' -- Bitwise logical OR --================================ -- --_Description_: -- Bitwise logical `OR'. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. For integer arguments, programmers should consider -- the use of the *note IOR:: intrinsic defined by the Fortran -- standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = OR(X, Y)' -- --_Arguments_: -- X The type shall be either a scalar `INTEGER' -- type or a scalar `LOGICAL' type. -- Y The type shall be the same as the type of X. -- --_Return value_: -- The return type is either a scalar `INTEGER' or a scalar -- `LOGICAL'. If the kind type parameters differ, then the smaller -- kind type is implicitly converted to larger kind, and the return -- has the larger kind. -- --_Example_: -- PROGRAM test_or -- LOGICAL :: T = .TRUE., F = .FALSE. -- INTEGER :: a, b -- DATA a / Z'F' /, b / Z'3' / -- -- WRITE (*,*) OR(T, T), OR(T, F), OR(F, T), OR(F, F) -- WRITE (*,*) OR(a, b) -- END PROGRAM -- --_See also_: -- Fortran 95 elemental function: *note IOR:: -- -- --File: gfortran.info, Node: PACK, Next: PERROR, Prev: OR, Up: Intrinsic Procedures -- --7.168 `PACK' -- Pack an array into an array of rank one --======================================================= -- --_Description_: -- Stores the elements of ARRAY in an array of rank one. -- -- The beginning of the resulting array is made up of elements whose -- MASK equals `TRUE'. Afterwards, positions are filled with elements -- taken from VECTOR. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = PACK(ARRAY, MASK[,VECTOR]' -- --_Arguments_: -- ARRAY Shall be an array of any type. -- MASK Shall be an array of type `LOGICAL' and of the -- same size as ARRAY. Alternatively, it may be a -- `LOGICAL' scalar. -- VECTOR (Optional) shall be an array of the same type -- as ARRAY and of rank one. If present, the -- number of elements in VECTOR shall be equal to -- or greater than the number of true elements in -- MASK. If MASK is scalar, the number of -- elements in VECTOR shall be equal to or -- greater than the number of elements in ARRAY. -- --_Return value_: -- The result is an array of rank one and the same type as that of -- ARRAY. If VECTOR is present, the result size is that of VECTOR, -- the number of `TRUE' values in MASK otherwise. -- --_Example_: -- Gathering nonzero elements from an array: -- PROGRAM test_pack_1 -- INTEGER :: m(6) -- m = (/ 1, 0, 0, 0, 5, 0 /) -- WRITE(*, FMT="(6(I0, ' '))") pack(m, m /= 0) ! "1 5" -- END PROGRAM -- -- Gathering nonzero elements from an array and appending elements -- from VECTOR: -- PROGRAM test_pack_2 -- INTEGER :: m(4) -- m = (/ 1, 0, 0, 2 /) -- WRITE(*, FMT="(4(I0, ' '))") pack(m, m /= 0, (/ 0, 0, 3, 4 /)) ! "1 2 3 4" -- END PROGRAM -- --_See also_: -- *note UNPACK:: -- -- --File: gfortran.info, Node: PERROR, Next: PRECISION, Prev: PACK, Up: Intrinsic Procedures -- --7.169 `PERROR' -- Print system error message --============================================ -- --_Description_: -- Prints (on the C `stderr' stream) a newline-terminated error -- message corresponding to the last system error. This is prefixed by -- STRING, a colon and a space. See `perror(3)'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL PERROR(STRING)' -- --_Arguments_: -- STRING A scalar of type `CHARACTER' and of the -- default kind. -- --_See also_: -- *note IERRNO:: -- -- --File: gfortran.info, Node: PRECISION, Next: PRESENT, Prev: PERROR, Up: Intrinsic Procedures -- --7.170 `PRECISION' -- Decimal precision of a real kind --===================================================== -- --_Description_: -- `PRECISION(X)' returns the decimal precision in the model of the -- type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = PRECISION(X)' -- --_Arguments_: -- X Shall be of type `REAL' or `COMPLEX'. -- --_Return value_: -- The return value is of type `INTEGER' and of the default integer -- kind. -- --_Example_: -- program prec_and_range -- real(kind=4) :: x(2) -- complex(kind=8) :: y -- -- print *, precision(x), range(x) -- print *, precision(y), range(y) -- end program prec_and_range -- -- --File: gfortran.info, Node: PRESENT, Next: PRODUCT, Prev: PRECISION, Up: Intrinsic Procedures -- --7.171 `PRESENT' -- Determine whether an optional dummy argument is specified --============================================================================ -- --_Description_: -- Determines whether an optional dummy argument is present. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = PRESENT(A)' -- --_Arguments_: -- A May be of any type and may be a pointer, -- scalar or array value, or a dummy procedure. -- It shall be the name of an optional dummy -- argument accessible within the current -- subroutine or function. -- --_Return value_: -- Returns either `TRUE' if the optional argument A is present, or -- `FALSE' otherwise. -- --_Example_: -- PROGRAM test_present -- WRITE(*,*) f(), f(42) ! "F T" -- CONTAINS -- LOGICAL FUNCTION f(x) -- INTEGER, INTENT(IN), OPTIONAL :: x -- f = PRESENT(x) -- END FUNCTION -- END PROGRAM -- -- --File: gfortran.info, Node: PRODUCT, Next: RADIX, Prev: PRESENT, Up: Intrinsic Procedures -- --7.172 `PRODUCT' -- Product of array elements --============================================ -- --_Description_: -- Multiplies the elements of ARRAY along dimension DIM if the -- corresponding element in MASK is `TRUE'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = PRODUCT(ARRAY[, MASK])' `RESULT = PRODUCT(ARRAY, DIM[, -- MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL' or -- `COMPLEX'. -- DIM (Optional) shall be a scalar of type `INTEGER' -- with a value in the range from 1 to n, where n -- equals the rank of ARRAY. -- MASK (Optional) shall be of type `LOGICAL' and -- either be a scalar or an array of the same -- shape as ARRAY. -- --_Return value_: -- The result is of the same type as ARRAY. -- -- If DIM is absent, a scalar with the product of all elements in -- ARRAY is returned. Otherwise, an array of rank n-1, where n equals -- the rank of ARRAY, and a shape similar to that of ARRAY with -- dimension DIM dropped is returned. -- --_Example_: -- PROGRAM test_product -- INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /) -- print *, PRODUCT(x) ! all elements, product = 120 -- print *, PRODUCT(x, MASK=MOD(x, 2)==1) ! odd elements, product = 15 -- END PROGRAM -- --_See also_: -- *note SUM:: -- -- --File: gfortran.info, Node: RADIX, Next: RANDOM_NUMBER, Prev: PRODUCT, Up: Intrinsic Procedures -- --7.173 `RADIX' -- Base of a model number --======================================= -- --_Description_: -- `RADIX(X)' returns the base of the model representing the entity X. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = RADIX(X)' -- --_Arguments_: -- X Shall be of type `INTEGER' or `REAL' -- --_Return value_: -- The return value is a scalar of type `INTEGER' and of the default -- integer kind. -- --_Example_: -- program test_radix -- print *, "The radix for the default integer kind is", radix(0) -- print *, "The radix for the default real kind is", radix(0.0) -- end program test_radix -- -- -- --File: gfortran.info, Node: RAN, Next: REAL, Prev: RANGE, Up: Intrinsic Procedures -- --7.174 `RAN' -- Real pseudo-random number --======================================== -- --_Description_: -- For compatibility with HP FORTRAN 77/iX, the `RAN' intrinsic is -- provided as an alias for `RAND'. See *note RAND:: for complete -- documentation. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_See also_: -- *note RAND::, *note RANDOM_NUMBER:: -- -- --File: gfortran.info, Node: RAND, Next: RANGE, Prev: RANDOM_SEED, Up: Intrinsic Procedures -- --7.175 `RAND' -- Real pseudo-random number --========================================= -- --_Description_: -- `RAND(FLAG)' returns a pseudo-random number from a uniform -- distribution between 0 and 1. If FLAG is 0, the next number in the -- current sequence is returned; if FLAG is 1, the generator is -- restarted by `CALL SRAND(0)'; if FLAG has any other value, it is -- used as a new seed with `SRAND'. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. It implements a simple modulo generator as provided -- by `g77'. For new code, one should consider the use of *note -- RANDOM_NUMBER:: as it implements a superior algorithm. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = RAND(FLAG)' -- --_Arguments_: -- FLAG Shall be a scalar `INTEGER' of kind 4. -- --_Return value_: -- The return value is of `REAL' type and the default kind. -- --_Example_: -- program test_rand -- integer,parameter :: seed = 86456 -- -- call srand(seed) -- print *, rand(), rand(), rand(), rand() -- print *, rand(seed), rand(), rand(), rand() -- end program test_rand -- --_See also_: -- *note SRAND::, *note RANDOM_NUMBER:: -- -- -- --File: gfortran.info, Node: RANDOM_NUMBER, Next: RANDOM_SEED, Prev: RADIX, Up: Intrinsic Procedures -- --7.176 `RANDOM_NUMBER' -- Pseudo-random number --============================================= -- --_Description_: -- Returns a single pseudorandom number or an array of pseudorandom -- numbers from the uniform distribution over the range 0 \leq x < 1. -- -- The runtime-library implements George Marsaglia's KISS (Keep It -- Simple Stupid) random number generator (RNG). This RNG combines: -- 1. The congruential generator x(n) = 69069 \cdot x(n-1) + -- 1327217885 with a period of 2^32, -- -- 2. A 3-shift shift-register generator with a period of 2^32 - 1, -- -- 3. Two 16-bit multiply-with-carry generators with a period of -- 597273182964842497 > 2^59. -- The overall period exceeds 2^123. -- -- Please note, this RNG is thread safe if used within OpenMP -- directives, i.e., its state will be consistent while called from -- multiple threads. However, the KISS generator does not create -- random numbers in parallel from multiple sources, but in sequence -- from a single source. If an OpenMP-enabled application heavily -- relies on random numbers, one should consider employing a -- dedicated parallel random number generator instead. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `RANDOM_NUMBER(HARVEST)' -- --_Arguments_: -- HARVEST Shall be a scalar or an array of type `REAL'. -- --_Example_: -- program test_random_number -- REAL :: r(5,5) -- CALL init_random_seed() ! see example of RANDOM_SEED -- CALL RANDOM_NUMBER(r) -- end program -- --_See also_: -- *note RANDOM_SEED:: -- -- --File: gfortran.info, Node: RANDOM_SEED, Next: RAND, Prev: RANDOM_NUMBER, Up: Intrinsic Procedures -- --7.177 `RANDOM_SEED' -- Initialize a pseudo-random number sequence --================================================================= -- --_Description_: -- Restarts or queries the state of the pseudorandom number generator -- used by `RANDOM_NUMBER'. -- -- If `RANDOM_SEED' is called without arguments, it is initialized to -- a default state. The example below shows how to initialize the -- random seed based on the system's time. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL RANDOM_SEED(SIZE, PUT, GET)' -- --_Arguments_: -- SIZE (Optional) Shall be a scalar and of type -- default `INTEGER', with `INTENT(OUT)'. It -- specifies the minimum size of the arrays used -- with the PUT and GET arguments. -- PUT (Optional) Shall be an array of type default -- `INTEGER' and rank one. It is `INTENT(IN)' and -- the size of the array must be larger than or -- equal to the number returned by the SIZE -- argument. -- GET (Optional) Shall be an array of type default -- `INTEGER' and rank one. It is `INTENT(OUT)' -- and the size of the array must be larger than -- or equal to the number returned by the SIZE -- argument. -- --_Example_: -- SUBROUTINE init_random_seed() -- INTEGER :: i, n, clock -- INTEGER, DIMENSION(:), ALLOCATABLE :: seed -- -- CALL RANDOM_SEED(size = n) -- ALLOCATE(seed(n)) -- -- CALL SYSTEM_CLOCK(COUNT=clock) -- -- seed = clock + 37 * (/ (i - 1, i = 1, n) /) -- CALL RANDOM_SEED(PUT = seed) -- -- DEALLOCATE(seed) -- END SUBROUTINE -- --_See also_: -- *note RANDOM_NUMBER:: -- -- --File: gfortran.info, Node: RANGE, Next: RAN, Prev: RAND, Up: Intrinsic Procedures -- --7.178 `RANGE' -- Decimal exponent range --======================================= -- --_Description_: -- `RANGE(X)' returns the decimal exponent range in the model of the -- type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = RANGE(X)' -- --_Arguments_: -- X Shall be of type `INTEGER', `REAL' or -- `COMPLEX'. -- --_Return value_: -- The return value is of type `INTEGER' and of the default integer -- kind. -- --_Example_: -- See `PRECISION' for an example. -- -- --File: gfortran.info, Node: REAL, Next: RENAME, Prev: RAN, Up: Intrinsic Procedures -- --7.179 `REAL' -- Convert to real type --==================================== -- --_Description_: -- `REAL(X [, KIND])' converts its argument X to a real type. The -- `REALPART(X)' function is provided for compatibility with `g77', -- and its use is strongly discouraged. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = REAL(X [, KIND])' -- `RESULT = REALPART(Z)' -- --_Arguments_: -- X Shall be `INTEGER', `REAL', or `COMPLEX'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- These functions return a `REAL' variable or array under the -- following rules: -- -- (A) -- `REAL(X)' is converted to a default real type if X is an -- integer or real variable. -- -- (B) -- `REAL(X)' is converted to a real type with the kind type -- parameter of X if X is a complex variable. -- -- (C) -- `REAL(X, KIND)' is converted to a real type with kind type -- parameter KIND if X is a complex, integer, or real variable. -- --_Example_: -- program test_real -- complex :: x = (1.0, 2.0) -- print *, real(x), real(x,8), realpart(x) -- end program test_real -- --_See also_: -- *note DBLE::, *note DFLOAT::, *note FLOAT:: -- -- -- --File: gfortran.info, Node: RENAME, Next: REPEAT, Prev: REAL, Up: Intrinsic Procedures -- --7.180 `RENAME' -- Rename a file --=============================== -- --_Description_: -- Renames a file from file PATH1 to PATH2. A null character -- (`CHAR(0)') can be used to mark the end of the names in PATH1 and -- PATH2; otherwise, trailing blanks in the file names are ignored. -- If the STATUS argument is supplied, it contains 0 on success or a -- nonzero error code upon return; see `rename(2)'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL RENAME(PATH1, PATH2 [, STATUS])' -- `STATUS = RENAME(PATH1, PATH2)' -- --_Arguments_: -- PATH1 Shall be of default `CHARACTER' type. -- PATH2 Shall be of default `CHARACTER' type. -- STATUS (Optional) Shall be of default `INTEGER' type. -- --_See also_: -- *note LINK:: -- -- -- --File: gfortran.info, Node: REPEAT, Next: RESHAPE, Prev: RENAME, Up: Intrinsic Procedures -- --7.181 `REPEAT' -- Repeated string concatenation --=============================================== -- --_Description_: -- Concatenates NCOPIES copies of a string. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = REPEAT(STRING, NCOPIES)' -- --_Arguments_: -- STRING Shall be scalar and of type `CHARACTER'. -- NCOPIES Shall be scalar and of type `INTEGER'. -- --_Return value_: -- A new scalar of type `CHARACTER' built up from NCOPIES copies of -- STRING. -- --_Example_: -- program test_repeat -- write(*,*) repeat("x", 5) ! "xxxxx" -- end program -- -- --File: gfortran.info, Node: RESHAPE, Next: RRSPACING, Prev: REPEAT, Up: Intrinsic Procedures -- --7.182 `RESHAPE' -- Function to reshape an array --=============================================== -- --_Description_: -- Reshapes SOURCE to correspond to SHAPE. If necessary, the new -- array may be padded with elements from PAD or permuted as defined -- by ORDER. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = RESHAPE(SOURCE, SHAPE[, PAD, ORDER])' -- --_Arguments_: -- SOURCE Shall be an array of any type. -- SHAPE Shall be of type `INTEGER' and an array of -- rank one. Its values must be positive or zero. -- PAD (Optional) shall be an array of the same type -- as SOURCE. -- ORDER (Optional) shall be of type `INTEGER' and an -- array of the same shape as SHAPE. Its values -- shall be a permutation of the numbers from 1 -- to n, where n is the size of SHAPE. If ORDER -- is absent, the natural ordering shall be -- assumed. -- --_Return value_: -- The result is an array of shape SHAPE with the same type as SOURCE. -- --_Example_: -- PROGRAM test_reshape -- INTEGER, DIMENSION(4) :: x -- WRITE(*,*) SHAPE(x) ! prints "4" -- WRITE(*,*) SHAPE(RESHAPE(x, (/2, 2/))) ! prints "2 2" -- END PROGRAM -- --_See also_: -- *note SHAPE:: -- -- --File: gfortran.info, Node: RRSPACING, Next: RSHIFT, Prev: RESHAPE, Up: Intrinsic Procedures -- --7.183 `RRSPACING' -- Reciprocal of the relative spacing --======================================================= -- --_Description_: -- `RRSPACING(X)' returns the reciprocal of the relative spacing of -- model numbers near X. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = RRSPACING(X)' -- --_Arguments_: -- X Shall be of type `REAL'. -- --_Return value_: -- The return value is of the same type and kind as X. The value -- returned is equal to `ABS(FRACTION(X)) * -- FLOAT(RADIX(X))**DIGITS(X)'. -- --_See also_: -- *note SPACING:: -- -- --File: gfortran.info, Node: RSHIFT, Next: SCALE, Prev: RRSPACING, Up: Intrinsic Procedures -- --7.184 `RSHIFT' -- Right shift bits --================================== -- --_Description_: -- `RSHIFT' returns a value corresponding to I with all of the bits -- shifted right by SHIFT places. If the absolute value of SHIFT is -- greater than `BIT_SIZE(I)', the value is undefined. Bits shifted -- out from the left end are lost; zeros are shifted in from the -- opposite end. -- -- This function has been superseded by the `ISHFT' intrinsic, which -- is standard in Fortran 95 and later. -- --_Standard_: -- GNU extension -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = RSHIFT(I, SHIFT)' -- --_Arguments_: -- I The type shall be `INTEGER'. -- SHIFT The type shall be `INTEGER'. -- --_Return value_: -- The return value is of type `INTEGER' and of the same kind as I. -- --_See also_: -- *note ISHFT::, *note ISHFTC::, *note LSHIFT:: -- -- -- --File: gfortran.info, Node: SCALE, Next: SCAN, Prev: RSHIFT, Up: Intrinsic Procedures -- --7.185 `SCALE' -- Scale a real value --=================================== -- --_Description_: -- `SCALE(X,I)' returns `X * RADIX(X)**I'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SCALE(X, I)' -- --_Arguments_: -- X The type of the argument shall be a `REAL'. -- I The type of the argument shall be a `INTEGER'. -- --_Return value_: -- The return value is of the same type and kind as X. Its value is -- `X * RADIX(X)**I'. -- --_Example_: -- program test_scale -- real :: x = 178.1387e-4 -- integer :: i = 5 -- print *, scale(x,i), x*radix(x)**i -- end program test_scale -- -- -- --File: gfortran.info, Node: SCAN, Next: SECNDS, Prev: SCALE, Up: Intrinsic Procedures -- --7.186 `SCAN' -- Scan a string for the presence of a set of characters --===================================================================== -- --_Description_: -- Scans a STRING for any of the characters in a SET of characters. -- -- If BACK is either absent or equals `FALSE', this function returns -- the position of the leftmost character of STRING that is in SET. -- If BACK equals `TRUE', the rightmost position is returned. If no -- character of SET is found in STRING, the result is zero. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SCAN(STRING, SET[, BACK [, KIND]])' -- --_Arguments_: -- STRING Shall be of type `CHARACTER'. -- SET Shall be of type `CHARACTER'. -- BACK (Optional) shall be of type `LOGICAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_Example_: -- PROGRAM test_scan -- WRITE(*,*) SCAN("FORTRAN", "AO") ! 2, found 'O' -- WRITE(*,*) SCAN("FORTRAN", "AO", .TRUE.) ! 6, found 'A' -- WRITE(*,*) SCAN("FORTRAN", "C++") ! 0, found none -- END PROGRAM -- --_See also_: -- *note INDEX intrinsic::, *note VERIFY:: -- -- --File: gfortran.info, Node: SECNDS, Next: SECOND, Prev: SCAN, Up: Intrinsic Procedures -- --7.187 `SECNDS' -- Time function --=============================== -- --_Description_: -- `SECNDS(X)' gets the time in seconds from the real-time system -- clock. X is a reference time, also in seconds. If this is zero, -- the time in seconds from midnight is returned. This function is -- non-standard and its use is discouraged. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = SECNDS (X)' -- --_Arguments_: -- T Shall be of type `REAL(4)'. -- X Shall be of type `REAL(4)'. -- --_Return value_: -- None -- --_Example_: -- program test_secnds -- integer :: i -- real(4) :: t1, t2 -- print *, secnds (0.0) ! seconds since midnight -- t1 = secnds (0.0) ! reference time -- do i = 1, 10000000 ! do something -- end do -- t2 = secnds (t1) ! elapsed time -- print *, "Something took ", t2, " seconds." -- end program test_secnds -- -- --File: gfortran.info, Node: SECOND, Next: SELECTED_CHAR_KIND, Prev: SECNDS, Up: Intrinsic Procedures -- --7.188 `SECOND' -- CPU time function --=================================== -- --_Description_: -- Returns a `REAL(4)' value representing the elapsed CPU time in -- seconds. This provides the same functionality as the standard -- `CPU_TIME' intrinsic, and is only included for backwards -- compatibility. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL SECOND(TIME)' -- `TIME = SECOND()' -- --_Arguments_: -- TIME Shall be of type `REAL(4)'. -- --_Return value_: -- In either syntax, TIME is set to the process's current runtime in -- seconds. -- --_See also_: -- *note CPU_TIME:: -- -- -- --File: gfortran.info, Node: SELECTED_CHAR_KIND, Next: SELECTED_INT_KIND, Prev: SECOND, Up: Intrinsic Procedures -- --7.189 `SELECTED_CHAR_KIND' -- Choose character kind --=================================================== -- --_Description_: -- `SELECTED_CHAR_KIND(NAME)' returns the kind value for the character -- set named NAME, if a character set with such a name is supported, -- or -1 otherwise. Currently, supported character sets include -- "ASCII" and "DEFAULT", which are equivalent. -- --_Standard_: -- Fortran 2003 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = SELECTED_CHAR_KIND(NAME)' -- --_Arguments_: -- NAME Shall be a scalar and of the default character -- type. -- --_Example_: -- program ascii_kind -- integer,parameter :: ascii = selected_char_kind("ascii") -- character(kind=ascii, len=26) :: s -- -- s = ascii_"abcdefghijklmnopqrstuvwxyz" -- print *, s -- end program ascii_kind -- -- --File: gfortran.info, Node: SELECTED_INT_KIND, Next: SELECTED_REAL_KIND, Prev: SELECTED_CHAR_KIND, Up: Intrinsic Procedures -- --7.190 `SELECTED_INT_KIND' -- Choose integer kind --================================================ -- --_Description_: -- `SELECTED_INT_KIND(I)' return the kind value of the smallest -- integer type that can represent all values ranging from -10^I -- (exclusive) to 10^I (exclusive). If there is no integer kind that -- accommodates this range, `SELECTED_INT_KIND' returns -1. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = SELECTED_INT_KIND(I)' -- --_Arguments_: -- I Shall be a scalar and of type `INTEGER'. -- --_Example_: -- program large_integers -- integer,parameter :: k5 = selected_int_kind(5) -- integer,parameter :: k15 = selected_int_kind(15) -- integer(kind=k5) :: i5 -- integer(kind=k15) :: i15 -- -- print *, huge(i5), huge(i15) -- -- ! The following inequalities are always true -- print *, huge(i5) >= 10_k5**5-1 -- print *, huge(i15) >= 10_k15**15-1 -- end program large_integers -- -- --File: gfortran.info, Node: SELECTED_REAL_KIND, Next: SET_EXPONENT, Prev: SELECTED_INT_KIND, Up: Intrinsic Procedures -- --7.191 `SELECTED_REAL_KIND' -- Choose real kind --============================================== -- --_Description_: -- `SELECTED_REAL_KIND(P,R)' returns the kind value of a real data -- type with decimal precision of at least `P' digits and exponent -- range greater at least `R'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = SELECTED_REAL_KIND(P, R)' -- --_Arguments_: -- P (Optional) shall be a scalar and of type -- `INTEGER'. -- R (Optional) shall be a scalar and of type -- `INTEGER'. -- At least one argument shall be present. -- --_Return value_: -- `SELECTED_REAL_KIND' returns the value of the kind type parameter -- of a real data type with decimal precision of at least `P' digits -- and a decimal exponent range of at least `R'. If more than one -- real data type meet the criteria, the kind of the data type with -- the smallest decimal precision is returned. If no real data type -- matches the criteria, the result is -- -1 if the processor does not support a real data type with a -- precision greater than or equal to `P' -- -- -2 if the processor does not support a real type with an exponent -- range greater than or equal to `R' -- -- -3 if neither is supported. -- --_Example_: -- program real_kinds -- integer,parameter :: p6 = selected_real_kind(6) -- integer,parameter :: p10r100 = selected_real_kind(10,100) -- integer,parameter :: r400 = selected_real_kind(r=400) -- real(kind=p6) :: x -- real(kind=p10r100) :: y -- real(kind=r400) :: z -- -- print *, precision(x), range(x) -- print *, precision(y), range(y) -- print *, precision(z), range(z) -- end program real_kinds -- -- --File: gfortran.info, Node: SET_EXPONENT, Next: SHAPE, Prev: SELECTED_REAL_KIND, Up: Intrinsic Procedures -- --7.192 `SET_EXPONENT' -- Set the exponent of the model --===================================================== -- --_Description_: -- `SET_EXPONENT(X, I)' returns the real number whose fractional part -- is that that of X and whose exponent part is I. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SET_EXPONENT(X, I)' -- --_Arguments_: -- X Shall be of type `REAL'. -- I Shall be of type `INTEGER'. -- --_Return value_: -- The return value is of the same type and kind as X. The real -- number whose fractional part is that that of X and whose exponent -- part if I is returned; it is `FRACTION(X) * RADIX(X)**I'. -- --_Example_: -- PROGRAM test_setexp -- REAL :: x = 178.1387e-4 -- INTEGER :: i = 17 -- PRINT *, SET_EXPONENT(x, i), FRACTION(x) * RADIX(x)**i -- END PROGRAM -- -- -- --File: gfortran.info, Node: SHAPE, Next: SIGN, Prev: SET_EXPONENT, Up: Intrinsic Procedures -- --7.193 `SHAPE' -- Determine the shape of an array --================================================ -- --_Description_: -- Determines the shape of an array. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = SHAPE(SOURCE)' -- --_Arguments_: -- SOURCE Shall be an array or scalar of any type. If -- SOURCE is a pointer it must be associated and -- allocatable arrays must be allocated. -- --_Return value_: -- An `INTEGER' array of rank one with as many elements as SOURCE has -- dimensions. The elements of the resulting array correspond to the -- extend of SOURCE along the respective dimensions. If SOURCE is a -- scalar, the result is the rank one array of size zero. -- --_Example_: -- PROGRAM test_shape -- INTEGER, DIMENSION(-1:1, -1:2) :: A -- WRITE(*,*) SHAPE(A) ! (/ 3, 4 /) -- WRITE(*,*) SIZE(SHAPE(42)) ! (/ /) -- END PROGRAM -- --_See also_: -- *note RESHAPE::, *note SIZE:: -- -- --File: gfortran.info, Node: SIGN, Next: SIGNAL, Prev: SHAPE, Up: Intrinsic Procedures -- --7.194 `SIGN' -- Sign copying function --===================================== -- --_Description_: -- `SIGN(A,B)' returns the value of A with the sign of B. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SIGN(A, B)' -- --_Arguments_: -- A Shall be of type `INTEGER' or `REAL' -- B Shall be of the same type and kind as A -- --_Return value_: -- The kind of the return value is that of A and B. If B\ge 0 then -- the result is `ABS(A)', else it is `-ABS(A)'. -- --_Example_: -- program test_sign -- print *, sign(-12,1) -- print *, sign(-12,0) -- print *, sign(-12,-1) -- -- print *, sign(-12.,1.) -- print *, sign(-12.,0.) -- print *, sign(-12.,-1.) -- end program test_sign -- --_Specific names_: -- Name Arguments Return type Standard -- `ISIGN(A,P)' `INTEGER(4)' `INTEGER(4)' f95, gnu -- `DSIGN(A,P)' `REAL(8)' `REAL(8)' f95, gnu -- -- --File: gfortran.info, Node: SIGNAL, Next: SIN, Prev: SIGN, Up: Intrinsic Procedures -- --7.195 `SIGNAL' -- Signal handling subroutine (or function) --========================================================== -- --_Description_: -- `SIGNAL(NUMBER, HANDLER [, STATUS])' causes external subroutine -- HANDLER to be executed with a single integer argument when signal -- NUMBER occurs. If HANDLER is an integer, it can be used to turn -- off handling of signal NUMBER or revert to its default action. -- See `signal(2)'. -- -- If `SIGNAL' is called as a subroutine and the STATUS argument is -- supplied, it is set to the value returned by `signal(2)'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL SIGNAL(NUMBER, HANDLER [, STATUS])' -- `STATUS = SIGNAL(NUMBER, HANDLER)' -- --_Arguments_: -- NUMBER Shall be a scalar integer, with `INTENT(IN)' -- HANDLER Signal handler (`INTEGER FUNCTION' or -- `SUBROUTINE') or dummy/global `INTEGER' scalar. -- `INTEGER'. It is `INTENT(IN)'. -- STATUS (Optional) STATUS shall be a scalar integer. -- It has `INTENT(OUT)'. -- --_Return value_: -- The `SIGNAL' function returns the value returned by `signal(2)'. -- --_Example_: -- program test_signal -- intrinsic signal -- external handler_print -- -- call signal (12, handler_print) -- call signal (10, 1) -- -- call sleep (30) -- end program test_signal -- -- --File: gfortran.info, Node: SIN, Next: SINH, Prev: SIGNAL, Up: Intrinsic Procedures -- --7.196 `SIN' -- Sine function --============================ -- --_Description_: -- `SIN(X)' computes the sine of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SIN(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value has same type and kind as X. -- --_Example_: -- program test_sin -- real :: x = 0.0 -- x = sin(x) -- end program test_sin -- --_Specific names_: -- Name Argument Return type Standard -- `DSIN(X)' `REAL(8) X' `REAL(8)' f95, gnu -- `CSIN(X)' `COMPLEX(4) `COMPLEX(4)' f95, gnu -- X' -- `ZSIN(X)' `COMPLEX(8) `COMPLEX(8)' f95, gnu -- X' -- `CDSIN(X)' `COMPLEX(8) `COMPLEX(8)' f95, gnu -- X' -- --_See also_: -- *note ASIN:: -- -- --File: gfortran.info, Node: SINH, Next: SIZE, Prev: SIN, Up: Intrinsic Procedures -- --7.197 `SINH' -- Hyperbolic sine function --======================================== -- --_Description_: -- `SINH(X)' computes the hyperbolic sine of X. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SINH(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL'. -- --_Example_: -- program test_sinh -- real(8) :: x = - 1.0_8 -- x = sinh(x) -- end program test_sinh -- --_Specific names_: -- Name Argument Return type Standard -- `DSINH(X)' `REAL(8) X' `REAL(8)' Fortran 95 and -- later -- --_See also_: -- *note ASINH:: -- -- --File: gfortran.info, Node: SIZE, Next: SIZEOF, Prev: SINH, Up: Intrinsic Procedures -- --7.198 `SIZE' -- Determine the size of an array --============================================== -- --_Description_: -- Determine the extent of ARRAY along a specified dimension DIM, or -- the total number of elements in ARRAY if DIM is absent. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = SIZE(ARRAY[, DIM [, KIND]])' -- --_Arguments_: -- ARRAY Shall be an array of any type. If ARRAY is a -- pointer it must be associated and allocatable -- arrays must be allocated. -- DIM (Optional) shall be a scalar of type `INTEGER' -- and its value shall be in the range from 1 to -- n, where n equals the rank of ARRAY. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_Example_: -- PROGRAM test_size -- WRITE(*,*) SIZE((/ 1, 2 /)) ! 2 -- END PROGRAM -- --_See also_: -- *note SHAPE::, *note RESHAPE:: -- -- --File: gfortran.info, Node: SIZEOF, Next: SLEEP, Prev: SIZE, Up: Intrinsic Procedures -- --7.199 `SIZEOF' -- Size in bytes of an expression --================================================ -- --_Description_: -- `SIZEOF(X)' calculates the number of bytes of storage the -- expression `X' occupies. -- --_Standard_: -- GNU extension -- --_Class_: -- Intrinsic function -- --_Syntax_: -- `N = SIZEOF(X)' -- --_Arguments_: -- X The argument shall be of any type, rank or -- shape. -- --_Return value_: -- The return value is of type integer and of the system-dependent -- kind C_SIZE_T (from the ISO_C_BINDING module). Its value is the -- number of bytes occupied by the argument. If the argument has the -- `POINTER' attribute, the number of bytes of the storage area -- pointed to is returned. If the argument is of a derived type with -- `POINTER' or `ALLOCATABLE' components, the return value doesn't -- account for the sizes of the data pointed to by these components. -- --_Example_: -- integer :: i -- real :: r, s(5) -- print *, (sizeof(s)/sizeof(r) == 5) -- end -- The example will print `.TRUE.' unless you are using a platform -- where default `REAL' variables are unusually padded. -- --_See also_: -- *note C_SIZEOF:: -- -- --File: gfortran.info, Node: SLEEP, Next: SNGL, Prev: SIZEOF, Up: Intrinsic Procedures -- --7.200 `SLEEP' -- Sleep for the specified number of seconds --========================================================== -- --_Description_: -- Calling this subroutine causes the process to pause for SECONDS -- seconds. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL SLEEP(SECONDS)' -- --_Arguments_: -- SECONDS The type shall be of default `INTEGER'. -- --_Example_: -- program test_sleep -- call sleep(5) -- end -- -- --File: gfortran.info, Node: SNGL, Next: SPACING, Prev: SLEEP, Up: Intrinsic Procedures -- --7.201 `SNGL' -- Convert double precision real to default real --============================================================= -- --_Description_: -- `SNGL(A)' converts the double precision real A to a default real -- value. This is an archaic form of `REAL' that is specific to one -- type for A. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SNGL(A)' -- --_Arguments_: -- A The type shall be a double precision `REAL'. -- --_Return value_: -- The return value is of type default `REAL'. -- --_See also_: -- *note DBLE:: -- -- --File: gfortran.info, Node: SPACING, Next: SPREAD, Prev: SNGL, Up: Intrinsic Procedures -- --7.202 `SPACING' -- Smallest distance between two numbers of a given type --======================================================================== -- --_Description_: -- Determines the distance between the argument X and the nearest -- adjacent number of the same type. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SPACING(X)' -- --_Arguments_: -- X Shall be of type `REAL'. -- --_Return value_: -- The result is of the same type as the input argument X. -- --_Example_: -- PROGRAM test_spacing -- INTEGER, PARAMETER :: SGL = SELECTED_REAL_KIND(p=6, r=37) -- INTEGER, PARAMETER :: DBL = SELECTED_REAL_KIND(p=13, r=200) -- -- WRITE(*,*) spacing(1.0_SGL) ! "1.1920929E-07" on i686 -- WRITE(*,*) spacing(1.0_DBL) ! "2.220446049250313E-016" on i686 -- END PROGRAM -- --_See also_: -- *note RRSPACING:: -- -- --File: gfortran.info, Node: SPREAD, Next: SQRT, Prev: SPACING, Up: Intrinsic Procedures -- --7.203 `SPREAD' -- Add a dimension to an array --============================================= -- --_Description_: -- Replicates a SOURCE array NCOPIES times along a specified -- dimension DIM. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = SPREAD(SOURCE, DIM, NCOPIES)' -- --_Arguments_: -- SOURCE Shall be a scalar or an array of any type and -- a rank less than seven. -- DIM Shall be a scalar of type `INTEGER' with a -- value in the range from 1 to n+1, where n -- equals the rank of SOURCE. -- NCOPIES Shall be a scalar of type `INTEGER'. -- --_Return value_: -- The result is an array of the same type as SOURCE and has rank n+1 -- where n equals the rank of SOURCE. -- --_Example_: -- PROGRAM test_spread -- INTEGER :: a = 1, b(2) = (/ 1, 2 /) -- WRITE(*,*) SPREAD(A, 1, 2) ! "1 1" -- WRITE(*,*) SPREAD(B, 1, 2) ! "1 1 2 2" -- END PROGRAM -- --_See also_: -- *note UNPACK:: -- -- --File: gfortran.info, Node: SQRT, Next: SRAND, Prev: SPREAD, Up: Intrinsic Procedures -- --7.204 `SQRT' -- Square-root function --==================================== -- --_Description_: -- `SQRT(X)' computes the square root of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = SQRT(X)' -- --_Arguments_: -- X The type shall be `REAL' or `COMPLEX'. -- --_Return value_: -- The return value is of type `REAL' or `COMPLEX'. The kind type -- parameter is the same as X. -- --_Example_: -- program test_sqrt -- real(8) :: x = 2.0_8 -- complex :: z = (1.0, 2.0) -- x = sqrt(x) -- z = sqrt(z) -- end program test_sqrt -- --_Specific names_: -- Name Argument Return type Standard -- `DSQRT(X)' `REAL(8) X' `REAL(8)' Fortran 95 and -- later -- `CSQRT(X)' `COMPLEX(4) `COMPLEX(4)' Fortran 95 and -- X' later -- `ZSQRT(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- `CDSQRT(X)' `COMPLEX(8) `COMPLEX(8)' GNU extension -- X' -- -- --File: gfortran.info, Node: SRAND, Next: STAT, Prev: SQRT, Up: Intrinsic Procedures -- --7.205 `SRAND' -- Reinitialize the random number generator --========================================================= -- --_Description_: -- `SRAND' reinitializes the pseudo-random number generator called by -- `RAND' and `IRAND'. The new seed used by the generator is -- specified by the required argument SEED. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL SRAND(SEED)' -- --_Arguments_: -- SEED Shall be a scalar `INTEGER(kind=4)'. -- --_Return value_: -- Does not return anything. -- --_Example_: -- See `RAND' and `IRAND' for examples. -- --_Notes_: -- The Fortran 2003 standard specifies the intrinsic `RANDOM_SEED' to -- initialize the pseudo-random numbers generator and `RANDOM_NUMBER' -- to generate pseudo-random numbers. Please note that in GNU -- Fortran, these two sets of intrinsics (`RAND', `IRAND' and `SRAND' -- on the one hand, `RANDOM_NUMBER' and `RANDOM_SEED' on the other -- hand) access two independent pseudo-random number generators. -- --_See also_: -- *note RAND::, *note RANDOM_SEED::, *note RANDOM_NUMBER:: -- -- -- --File: gfortran.info, Node: STAT, Next: SUM, Prev: SRAND, Up: Intrinsic Procedures -- --7.206 `STAT' -- Get file status --=============================== -- --_Description_: -- This function returns information about a file. No permissions are -- required on the file itself, but execute (search) permission is -- required on all of the directories in path that lead to the file. -- -- The elements that are obtained and stored in the array `BUFF': -- `buff(1)' Device ID -- `buff(2)' Inode number -- `buff(3)' File mode -- `buff(4)' Number of links -- `buff(5)' Owner's uid -- `buff(6)' Owner's gid -- `buff(7)' ID of device containing directory entry for -- file (0 if not available) -- `buff(8)' File size (bytes) -- `buff(9)' Last access time -- `buff(10)' Last modification time -- `buff(11)' Last file status change time -- `buff(12)' Preferred I/O block size (-1 if not available) -- `buff(13)' Number of blocks allocated (-1 if not -- available) -- -- Not all these elements are relevant on all systems. If an element -- is not relevant, it is returned as 0. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL STAT(FILE,BUFF[,STATUS])' -- --_Arguments_: -- FILE The type shall be `CHARACTER', of the default -- kind and a valid path within the file system. -- BUFF The type shall be `INTEGER(4), DIMENSION(13)'. -- STATUS (Optional) status flag of type `INTEGER(4)'. -- Returns 0 on success and a system specific -- error code otherwise. -- --_Example_: -- PROGRAM test_stat -- INTEGER, DIMENSION(13) :: buff -- INTEGER :: status -- -- CALL STAT("/etc/passwd", buff, status) -- -- IF (status == 0) THEN -- WRITE (*, FMT="('Device ID:', T30, I19)") buff(1) -- WRITE (*, FMT="('Inode number:', T30, I19)") buff(2) -- WRITE (*, FMT="('File mode (octal):', T30, O19)") buff(3) -- WRITE (*, FMT="('Number of links:', T30, I19)") buff(4) -- WRITE (*, FMT="('Owner''s uid:', T30, I19)") buff(5) -- WRITE (*, FMT="('Owner''s gid:', T30, I19)") buff(6) -- WRITE (*, FMT="('Device where located:', T30, I19)") buff(7) -- WRITE (*, FMT="('File size:', T30, I19)") buff(8) -- WRITE (*, FMT="('Last access time:', T30, A19)") CTIME(buff(9)) -- WRITE (*, FMT="('Last modification time', T30, A19)") CTIME(buff(10)) -- WRITE (*, FMT="('Last status change time:', T30, A19)") CTIME(buff(11)) -- WRITE (*, FMT="('Preferred block size:', T30, I19)") buff(12) -- WRITE (*, FMT="('No. of blocks allocated:', T30, I19)") buff(13) -- END IF -- END PROGRAM -- --_See also_: -- To stat an open file: *note FSTAT::, to stat a link: *note LSTAT:: -- -- --File: gfortran.info, Node: SUM, Next: SYMLNK, Prev: STAT, Up: Intrinsic Procedures -- --7.207 `SUM' -- Sum of array elements --==================================== -- --_Description_: -- Adds the elements of ARRAY along dimension DIM if the -- corresponding element in MASK is `TRUE'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = SUM(ARRAY[, MASK])' `RESULT = SUM(ARRAY, DIM[, MASK])' -- --_Arguments_: -- ARRAY Shall be an array of type `INTEGER', `REAL' or -- `COMPLEX'. -- DIM (Optional) shall be a scalar of type `INTEGER' -- with a value in the range from 1 to n, where n -- equals the rank of ARRAY. -- MASK (Optional) shall be of type `LOGICAL' and -- either be a scalar or an array of the same -- shape as ARRAY. -- --_Return value_: -- The result is of the same type as ARRAY. -- -- If DIM is absent, a scalar with the sum of all elements in ARRAY -- is returned. Otherwise, an array of rank n-1, where n equals the -- rank of ARRAY,and a shape similar to that of ARRAY with dimension -- DIM dropped is returned. -- --_Example_: -- PROGRAM test_sum -- INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /) -- print *, SUM(x) ! all elements, sum = 15 -- print *, SUM(x, MASK=MOD(x, 2)==1) ! odd elements, sum = 9 -- END PROGRAM -- --_See also_: -- *note PRODUCT:: -- -- --File: gfortran.info, Node: SYMLNK, Next: SYSTEM, Prev: SUM, Up: Intrinsic Procedures -- --7.208 `SYMLNK' -- Create a symbolic link --======================================== -- --_Description_: -- Makes a symbolic link from file PATH1 to PATH2. A null character -- (`CHAR(0)') can be used to mark the end of the names in PATH1 and -- PATH2; otherwise, trailing blanks in the file names are ignored. -- If the STATUS argument is supplied, it contains 0 on success or a -- nonzero error code upon return; see `symlink(2)'. If the system -- does not supply `symlink(2)', `ENOSYS' is returned. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL SYMLNK(PATH1, PATH2 [, STATUS])' -- `STATUS = SYMLNK(PATH1, PATH2)' -- --_Arguments_: -- PATH1 Shall be of default `CHARACTER' type. -- PATH2 Shall be of default `CHARACTER' type. -- STATUS (Optional) Shall be of default `INTEGER' type. -- --_See also_: -- *note LINK::, *note UNLINK:: -- -- -- --File: gfortran.info, Node: SYSTEM, Next: SYSTEM_CLOCK, Prev: SYMLNK, Up: Intrinsic Procedures -- --7.209 `SYSTEM' -- Execute a shell command --========================================= -- --_Description_: -- Passes the command COMMAND to a shell (see `system(3)'). If -- argument STATUS is present, it contains the value returned by -- `system(3)', which is presumably 0 if the shell command succeeded. -- Note that which shell is used to invoke the command is -- system-dependent and environment-dependent. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL SYSTEM(COMMAND [, STATUS])' -- `STATUS = SYSTEM(COMMAND)' -- --_Arguments_: -- COMMAND Shall be of default `CHARACTER' type. -- STATUS (Optional) Shall be of default `INTEGER' type. -- --_See also_: -- -- --File: gfortran.info, Node: SYSTEM_CLOCK, Next: TAN, Prev: SYSTEM, Up: Intrinsic Procedures -- --7.210 `SYSTEM_CLOCK' -- Time function --===================================== -- --_Description_: -- Determines the COUNT of milliseconds of wall clock time since the -- Epoch (00:00:00 UTC, January 1, 1970) modulo COUNT_MAX, COUNT_RATE -- determines the number of clock ticks per second. COUNT_RATE and -- COUNT_MAX are constant and specific to `gfortran'. -- -- If there is no clock, COUNT is set to `-HUGE(COUNT)', and -- COUNT_RATE and COUNT_MAX are set to zero -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])' -- --_Arguments_: -- --_Arguments_: -- COUNT (Optional) shall be a scalar of type default -- `INTEGER' with `INTENT(OUT)'. -- COUNT_RATE (Optional) shall be a scalar of type default -- `INTEGER' with `INTENT(OUT)'. -- COUNT_MAX (Optional) shall be a scalar of type default -- `INTEGER' with `INTENT(OUT)'. -- --_Example_: -- PROGRAM test_system_clock -- INTEGER :: count, count_rate, count_max -- CALL SYSTEM_CLOCK(count, count_rate, count_max) -- WRITE(*,*) count, count_rate, count_max -- END PROGRAM -- --_See also_: -- *note DATE_AND_TIME::, *note CPU_TIME:: -- -- --File: gfortran.info, Node: TAN, Next: TANH, Prev: SYSTEM_CLOCK, Up: Intrinsic Procedures -- --7.211 `TAN' -- Tangent function --=============================== -- --_Description_: -- `TAN(X)' computes the tangent of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = TAN(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL'. The kind type parameter is -- the same as X. -- --_Example_: -- program test_tan -- real(8) :: x = 0.165_8 -- x = tan(x) -- end program test_tan -- --_Specific names_: -- Name Argument Return type Standard -- `DTAN(X)' `REAL(8) X' `REAL(8)' Fortran 95 and -- later -- --_See also_: -- *note ATAN:: -- -- --File: gfortran.info, Node: TANH, Next: TIME, Prev: TAN, Up: Intrinsic Procedures -- --7.212 `TANH' -- Hyperbolic tangent function --=========================================== -- --_Description_: -- `TANH(X)' computes the hyperbolic tangent of X. -- --_Standard_: -- Fortran 77 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `X = TANH(X)' -- --_Arguments_: -- X The type shall be `REAL'. -- --_Return value_: -- The return value is of type `REAL' and lies in the range - 1 \leq -- tanh(x) \leq 1 . -- --_Example_: -- program test_tanh -- real(8) :: x = 2.1_8 -- x = tanh(x) -- end program test_tanh -- --_Specific names_: -- Name Argument Return type Standard -- `DTANH(X)' `REAL(8) X' `REAL(8)' Fortran 95 and -- later -- --_See also_: -- *note ATANH:: -- -- --File: gfortran.info, Node: TIME, Next: TIME8, Prev: TANH, Up: Intrinsic Procedures -- --7.213 `TIME' -- Time function --============================= -- --_Description_: -- Returns the current time encoded as an integer (in the manner of -- the UNIX function `time(3)'). This value is suitable for passing to -- `CTIME()', `GMTIME()', and `LTIME()'. -- -- This intrinsic is not fully portable, such as to systems with -- 32-bit `INTEGER' types but supporting times wider than 32 bits. -- Therefore, the values returned by this intrinsic might be, or -- become, negative, or numerically less than previous values, during -- a single run of the compiled program. -- -- See *note TIME8::, for information on a similar intrinsic that -- might be portable to more GNU Fortran implementations, though to -- fewer Fortran compilers. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = TIME()' -- --_Return value_: -- The return value is a scalar of type `INTEGER(4)'. -- --_See also_: -- *note CTIME::, *note GMTIME::, *note LTIME::, *note MCLOCK::, -- *note TIME8:: -- -- -- --File: gfortran.info, Node: TIME8, Next: TINY, Prev: TIME, Up: Intrinsic Procedures -- --7.214 `TIME8' -- Time function (64-bit) --======================================= -- --_Description_: -- Returns the current time encoded as an integer (in the manner of -- the UNIX function `time(3)'). This value is suitable for passing to -- `CTIME()', `GMTIME()', and `LTIME()'. -- -- _Warning:_ this intrinsic does not increase the range of the timing -- values over that returned by `time(3)'. On a system with a 32-bit -- `time(3)', `TIME8()' will return a 32-bit value, even though it is -- converted to a 64-bit `INTEGER(8)' value. That means overflows of -- the 32-bit value can still occur. Therefore, the values returned -- by this intrinsic might be or become negative or numerically less -- than previous values during a single run of the compiled program. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = TIME8()' -- --_Return value_: -- The return value is a scalar of type `INTEGER(8)'. -- --_See also_: -- *note CTIME::, *note GMTIME::, *note LTIME::, *note MCLOCK8::, -- *note TIME:: -- -- -- --File: gfortran.info, Node: TINY, Next: TRAILZ, Prev: TIME8, Up: Intrinsic Procedures -- --7.215 `TINY' -- Smallest positive number of a real kind --======================================================= -- --_Description_: -- `TINY(X)' returns the smallest positive (non zero) number in the -- model of the type of `X'. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = TINY(X)' -- --_Arguments_: -- X Shall be of type `REAL'. -- --_Return value_: -- The return value is of the same type and kind as X -- --_Example_: -- See `HUGE' for an example. -- -- --File: gfortran.info, Node: TRAILZ, Next: TRANSFER, Prev: TINY, Up: Intrinsic Procedures -- --7.216 `TRAILZ' -- Number of trailing zero bits of an integer --============================================================ -- --_Description_: -- `TRAILZ' returns the number of trailing zero bits of an integer. -- --_Standard_: -- Fortran 2008 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = TRAILZ(I)' -- --_Arguments_: -- I Shall be of type `INTEGER'. -- --_Return value_: -- The type of the return value is the default `INTEGER'. If all the -- bits of `I' are zero, the result value is `BIT_SIZE(I)'. -- --_Example_: -- PROGRAM test_trailz -- WRITE (*,*) TRAILZ(8) ! prints 3 -- END PROGRAM -- --_See also_: -- *note BIT_SIZE::, *note LEADZ:: -- -- --File: gfortran.info, Node: TRANSFER, Next: TRANSPOSE, Prev: TRAILZ, Up: Intrinsic Procedures -- --7.217 `TRANSFER' -- Transfer bit patterns --========================================= -- --_Description_: -- Interprets the bitwise representation of SOURCE in memory as if it -- is the representation of a variable or array of the same type and -- type parameters as MOLD. -- -- This is approximately equivalent to the C concept of _casting_ one -- type to another. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = TRANSFER(SOURCE, MOLD[, SIZE])' -- --_Arguments_: -- SOURCE Shall be a scalar or an array of any type. -- MOLD Shall be a scalar or an array of any type. -- SIZE (Optional) shall be a scalar of type `INTEGER'. -- --_Return value_: -- The result has the same type as MOLD, with the bit level -- representation of SOURCE. If SIZE is present, the result is a -- one-dimensional array of length SIZE. If SIZE is absent but MOLD -- is an array (of any size or shape), the result is a one- -- dimensional array of the minimum length needed to contain the -- entirety of the bitwise representation of SOURCE. If SIZE is -- absent and MOLD is a scalar, the result is a scalar. -- -- If the bitwise representation of the result is longer than that of -- SOURCE, then the leading bits of the result correspond to those of -- SOURCE and any trailing bits are filled arbitrarily. -- -- When the resulting bit representation does not correspond to a -- valid representation of a variable of the same type as MOLD, the -- results are undefined, and subsequent operations on the result -- cannot be guaranteed to produce sensible behavior. For example, -- it is possible to create `LOGICAL' variables for which `VAR' and -- `.NOT.VAR' both appear to be true. -- --_Example_: -- PROGRAM test_transfer -- integer :: x = 2143289344 -- print *, transfer(x, 1.0) ! prints "NaN" on i686 -- END PROGRAM -- -- --File: gfortran.info, Node: TRANSPOSE, Next: TRIM, Prev: TRANSFER, Up: Intrinsic Procedures -- --7.218 `TRANSPOSE' -- Transpose an array of rank two --=================================================== -- --_Description_: -- Transpose an array of rank two. Element (i, j) of the result has -- the value `MATRIX(j, i)', for all i, j. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = TRANSPOSE(MATRIX)' -- --_Arguments_: -- MATRIX Shall be an array of any type and have a rank -- of two. -- --_Return value_: -- The result has the same type as MATRIX, and has shape `(/ m, n /)' -- if MATRIX has shape `(/ n, m /)'. -- -- --File: gfortran.info, Node: TRIM, Next: TTYNAM, Prev: TRANSPOSE, Up: Intrinsic Procedures -- --7.219 `TRIM' -- Remove trailing blank characters of a string --============================================================ -- --_Description_: -- Removes trailing blank characters of a string. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = TRIM(STRING)' -- --_Arguments_: -- STRING Shall be a scalar of type `CHARACTER'. -- --_Return value_: -- A scalar of type `CHARACTER' which length is that of STRING less -- the number of trailing blanks. -- --_Example_: -- PROGRAM test_trim -- CHARACTER(len=10), PARAMETER :: s = "GFORTRAN " -- WRITE(*,*) LEN(s), LEN(TRIM(s)) ! "10 8", with/without trailing blanks -- END PROGRAM -- --_See also_: -- *note ADJUSTL::, *note ADJUSTR:: -- -- --File: gfortran.info, Node: TTYNAM, Next: UBOUND, Prev: TRIM, Up: Intrinsic Procedures -- --7.220 `TTYNAM' -- Get the name of a terminal device. --==================================================== -- --_Description_: -- Get the name of a terminal device. For more information, see -- `ttyname(3)'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL TTYNAM(UNIT, NAME)' -- `NAME = TTYNAM(UNIT)' -- --_Arguments_: -- UNIT Shall be a scalar `INTEGER'. -- NAME Shall be of type `CHARACTER'. -- --_Example_: -- PROGRAM test_ttynam -- INTEGER :: unit -- DO unit = 1, 10 -- IF (isatty(unit=unit)) write(*,*) ttynam(unit) -- END DO -- END PROGRAM -- --_See also_: -- *note ISATTY:: -- -- --File: gfortran.info, Node: UBOUND, Next: UMASK, Prev: TTYNAM, Up: Intrinsic Procedures -- --7.221 `UBOUND' -- Upper dimension bounds of an array --==================================================== -- --_Description_: -- Returns the upper bounds of an array, or a single upper bound -- along the DIM dimension. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Inquiry function -- --_Syntax_: -- `RESULT = UBOUND(ARRAY [, DIM [, KIND]])' -- --_Arguments_: -- ARRAY Shall be an array, of any type. -- DIM (Optional) Shall be a scalar `INTEGER'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. If DIM is -- absent, the result is an array of the upper bounds of ARRAY. If -- DIM is present, the result is a scalar corresponding to the upper -- bound of the array along that dimension. If ARRAY is an -- expression rather than a whole array or array structure component, -- or if it has a zero extent along the relevant dimension, the upper -- bound is taken to be the number of elements along the relevant -- dimension. -- --_See also_: -- *note LBOUND:: -- -- --File: gfortran.info, Node: UMASK, Next: UNLINK, Prev: UBOUND, Up: Intrinsic Procedures -- --7.222 `UMASK' -- Set the file creation mask --=========================================== -- --_Description_: -- Sets the file creation mask to MASK and returns the old value in -- argument OLD if it is supplied. See `umask(2)'. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine -- --_Syntax_: -- `CALL UMASK(MASK [, OLD])' -- --_Arguments_: -- MASK Shall be a scalar of type `INTEGER'. -- MASK (Optional) Shall be a scalar of type `INTEGER'. -- -- -- --File: gfortran.info, Node: UNLINK, Next: UNPACK, Prev: UMASK, Up: Intrinsic Procedures -- --7.223 `UNLINK' -- Remove a file from the file system --==================================================== -- --_Description_: -- Unlinks the file PATH. A null character (`CHAR(0)') can be used to -- mark the end of the name in PATH; otherwise, trailing blanks in -- the file name are ignored. If the STATUS argument is supplied, it -- contains 0 on success or a nonzero error code upon return; see -- `unlink(2)'. -- -- This intrinsic is provided in both subroutine and function forms; -- however, only one form can be used in any given program unit. -- --_Standard_: -- GNU extension -- --_Class_: -- Subroutine, function -- --_Syntax_: -- `CALL UNLINK(PATH [, STATUS])' -- `STATUS = UNLINK(PATH)' -- --_Arguments_: -- PATH Shall be of default `CHARACTER' type. -- STATUS (Optional) Shall be of default `INTEGER' type. -- --_See also_: -- *note LINK::, *note SYMLNK:: -- -- --File: gfortran.info, Node: UNPACK, Next: VERIFY, Prev: UNLINK, Up: Intrinsic Procedures -- --7.224 `UNPACK' -- Unpack an array of rank one into an array --=========================================================== -- --_Description_: -- Store the elements of VECTOR in an array of higher rank. -- --_Standard_: -- Fortran 95 and later -- --_Class_: -- Transformational function -- --_Syntax_: -- `RESULT = UNPACK(VECTOR, MASK, FIELD)' -- --_Arguments_: -- VECTOR Shall be an array of any type and rank one. It -- shall have at least as many elements as MASK -- has `TRUE' values. -- MASK Shall be an array of type `LOGICAL'. -- FIELD Shall be of the same type as VECTOR and have -- the same shape as MASK. -- --_Return value_: -- The resulting array corresponds to FIELD with `TRUE' elements of -- MASK replaced by values from VECTOR in array element order. -- --_Example_: -- PROGRAM test_unpack -- integer :: vector(2) = (/1,1/) -- logical :: mask(4) = (/ .TRUE., .FALSE., .FALSE., .TRUE. /) -- integer :: field(2,2) = 0, unity(2,2) -- -- ! result: unity matrix -- unity = unpack(vector, reshape(mask, (/2,2/)), field) -- END PROGRAM -- --_See also_: -- *note PACK::, *note SPREAD:: -- -- --File: gfortran.info, Node: VERIFY, Next: XOR, Prev: UNPACK, Up: Intrinsic Procedures -- --7.225 `VERIFY' -- Scan a string for the absence of a set of characters --====================================================================== -- --_Description_: -- Verifies that all the characters in a SET are present in a STRING. -- -- If BACK is either absent or equals `FALSE', this function returns -- the position of the leftmost character of STRING that is not in -- SET. If BACK equals `TRUE', the rightmost position is returned. If -- all characters of SET are found in STRING, the result is zero. -- --_Standard_: -- Fortran 95 and later, with KIND argument Fortran 2003 and later -- --_Class_: -- Elemental function -- --_Syntax_: -- `RESULT = VERIFY(STRING, SET[, BACK [, KIND]])' -- --_Arguments_: -- STRING Shall be of type `CHARACTER'. -- SET Shall be of type `CHARACTER'. -- BACK (Optional) shall be of type `LOGICAL'. -- KIND (Optional) An `INTEGER' initialization -- expression indicating the kind parameter of -- the result. -- --_Return value_: -- The return value is of type `INTEGER' and of kind KIND. If KIND is -- absent, the return value is of default integer kind. -- --_Example_: -- PROGRAM test_verify -- WRITE(*,*) VERIFY("FORTRAN", "AO") ! 1, found 'F' -- WRITE(*,*) VERIFY("FORTRAN", "FOO") ! 3, found 'R' -- WRITE(*,*) VERIFY("FORTRAN", "C++") ! 1, found 'F' -- WRITE(*,*) VERIFY("FORTRAN", "C++", .TRUE.) ! 7, found 'N' -- WRITE(*,*) VERIFY("FORTRAN", "FORTRAN") ! 0' found none -- END PROGRAM -- --_See also_: -- *note SCAN::, *note INDEX intrinsic:: -- -- --File: gfortran.info, Node: XOR, Prev: VERIFY, Up: Intrinsic Procedures -- --7.226 `XOR' -- Bitwise logical exclusive OR --=========================================== -- --_Description_: -- Bitwise logical exclusive or. -- -- This intrinsic routine is provided for backwards compatibility with -- GNU Fortran 77. For integer arguments, programmers should consider -- the use of the *note IEOR:: intrinsic defined by the Fortran -- standard. -- --_Standard_: -- GNU extension -- --_Class_: -- Function -- --_Syntax_: -- `RESULT = XOR(X, Y)' -- --_Arguments_: -- X The type shall be either a scalar `INTEGER' -- type or a scalar `LOGICAL' type. -- Y The type shall be the same as the type of I. -- --_Return value_: -- The return type is either a scalar `INTEGER' or a scalar -- `LOGICAL'. If the kind type parameters differ, then the smaller -- kind type is implicitly converted to larger kind, and the return -- has the larger kind. -- --_Example_: -- PROGRAM test_xor -- LOGICAL :: T = .TRUE., F = .FALSE. -- INTEGER :: a, b -- DATA a / Z'F' /, b / Z'3' / -- -- WRITE (*,*) XOR(T, T), XOR(T, F), XOR(F, T), XOR(F, F) -- WRITE (*,*) XOR(a, b) -- END PROGRAM -- --_See also_: -- Fortran 95 elemental function: *note IEOR:: -- -- --File: gfortran.info, Node: Intrinsic Modules, Next: Contributing, Prev: Intrinsic Procedures, Up: Top -- --8 Intrinsic Modules --******************* -- --8.1 `ISO_FORTRAN_ENV' --===================== -- --_Standard_: -- Fortran 2003 and later -- -- The `ISO_FORTRAN_ENV' module provides the following scalar --default-integer named constants: -- --`CHARACTER_STORAGE_SIZE': -- Size in bits of the character storage unit. -- --`ERROR_UNIT': -- Identifies the preconnected unit used for error reporting. -- --`FILE_STORAGE_SIZE': -- Size in bits of the file-storage unit. -- --`INPUT_UNIT': -- Identifies the preconnected unit identified by the asterisk (`*') -- in `READ' statement. -- --`IOSTAT_END': -- The value assigned to the variable passed to the IOSTAT= specifier -- of an input/output statement if an end-of-file condition occurred. -- --`IOSTAT_EOR': -- The value assigned to the variable passed to the IOSTAT= specifier -- of an input/output statement if an end-of-record condition -- occurred. -- --`NUMERIC_STORAGE_SIZE': -- The size in bits of the numeric storage unit. -- --`OUTPUT_UNIT': -- Identifies the preconnected unit identified by the asterisk (`*') -- in `WRITE' statement. -- --8.2 `ISO_C_BINDING' --=================== -- --_Standard_: -- Fortran 2003 and later, GNU extensions -- -- The following intrinsic procedures are provided by the module; their --definition can be found in the section Intrinsic Procedures of this --manual. -- --`C_ASSOCIATED' -- --`C_F_POINTER' -- --`C_F_PROCPOINTER' -- --`C_FUNLOC' -- --`C_LOC' -- -- The `ISO_C_BINDING' module provides the following named constants of --the type integer, which can be used as KIND type parameter. Note that --GNU Fortran currently does not support the `C_INT_FAST...' KIND type --parameters (marked by an asterisk (`*') in the list below). The --`C_INT_FAST...' parameters have therefore the value -2 and cannot be --used as KIND type parameter of the `INTEGER' type. -- -- In addition to the integer named constants required by the Fortran --2003 standard, GNU Fortran provides as an extension named constants for --the 128-bit integer types supported by the C compiler: `C_INT128_T, --C_INT_LEAST128_T, C_INT_FAST128_T'. -- --Fortran Named constant C type Extension --Type --`INTEGER' `C_INT' `int' --`INTEGER' `C_SHORT' `short int' --`INTEGER' `C_LONG' `long int' --`INTEGER' `C_LONG_LONG' `long long int' --`INTEGER' `C_SIGNED_CHAR' `signed char'/`unsigned -- char' --`INTEGER' `C_SIZE_T' `size_t' --`INTEGER' `C_INT8_T' `int8_t' --`INTEGER' `C_INT16_T' `int16_t' --`INTEGER' `C_INT32_T' `int32_t' --`INTEGER' `C_INT64_T' `int64_t' --`INTEGER' `C_INT128_T' `int128_t' Ext. --`INTEGER' `C_INT_LEAST8_T' `int_least8_t' --`INTEGER' `C_INT_LEAST16_T' `int_least16_t' --`INTEGER' `C_INT_LEAST32_T' `int_least32_t' --`INTEGER' `C_INT_LEAST64_T' `int_least64_t' --`INTEGER' `C_INT_LEAST128_T' `int_least128_t' Ext. --`INTEGER' `C_INT_FAST8_T'* `int_fast8_t' --`INTEGER' `C_INT_FAST16_T'* `int_fast16_t' --`INTEGER' `C_INT_FAST32_T'* `int_fast32_t' --`INTEGER' `C_INT_FAST64_T'* `int_fast64_t' --`INTEGER' `C_INT_FAST128_T'* `int_fast128_t' Ext. --`INTEGER' `C_INTMAX_T' `intmax_t' --`INTEGER' `C_INTPTR_T' `intptr_t' --`REAL' `C_FLOAT' `float' --`REAL' `C_DOUBLE' `double' --`REAL' `C_LONG_DOUBLE' `long double' --`COMPLEX' `C_FLOAT_COMPLEX' `float _Complex' --`COMPLEX' `C_DOUBLE_COMPLEX' `double _Complex' --`COMPLEX' `C_LONG_DOUBLE_COMPLEX' `long double _Complex' --`LOGICAL' `C_BOOL' `_Bool' --`CHARACTER' `C_CHAR' `char' -- -- Additionally, the following `(CHARACTER(KIND=C_CHAR))' are defined. -- --Name C definition Value --`C_NULL_CHAR' null character `'\0'' --`C_ALERT' alert `'\a'' --`C_BACKSPACE' backspace `'\b'' --`C_FORM_FEED' form feed `'\f'' --`C_NEW_LINE' new line `'\n'' --`C_CARRIAGE_RETURN'carriage return `'\r'' --`C_HORIZONTAL_TAB'horizontal tab `'\t'' --`C_VERTICAL_TAB'vertical tab `'\v'' -- --8.3 OpenMP Modules `OMP_LIB' and `OMP_LIB_KINDS' --================================================ -- --_Standard_: -- OpenMP Application Program Interface v3.0 -- -- The OpenMP Fortran runtime library routines are provided both in a --form of two Fortran 90 modules, named `OMP_LIB' and `OMP_LIB_KINDS', --and in a form of a Fortran `include' file named `omp_lib.h'. The --procedures provided by `OMP_LIB' can be found in the *note --Introduction: (libgomp)Top. manual, the named constants defined in the --`OMP_LIB_KINDS' module are listed below. -- -- For details refer to the actual OpenMP Application Program Interface --v3.0 (http://www.openmp.org/mp-documents/spec30.pdf). -- -- `OMP_LIB_KINDS' provides the following scalar default-integer named --constants: -- --`omp_integer_kind' -- --`omp_logical_kind' -- --`omp_lock_kind' -- --`omp_nest_lock_kind' -- --`omp_sched_kind' -- -- --File: gfortran.info, Node: Contributing, Next: Copying, Prev: Intrinsic Modules, Up: Top -- --Contributing --************ -- --Free software is only possible if people contribute to efforts to --create it. We're always in need of more people helping out with ideas --and comments, writing documentation and contributing code. -- -- If you want to contribute to GNU Fortran, have a look at the long --lists of projects you can take on. Some of these projects are small, --some of them are large; some are completely orthogonal to the rest of --what is happening on GNU Fortran, but others are "mainstream" projects --in need of enthusiastic hackers. All of these projects are important! --We'll eventually get around to the things here, but they are also --things doable by someone who is willing and able. -- --* Menu: -- --* Contributors:: --* Projects:: --* Proposed Extensions:: -- -- --File: gfortran.info, Node: Contributors, Next: Projects, Up: Contributing -- --Contributors to GNU Fortran --=========================== -- --Most of the parser was hand-crafted by _Andy Vaught_, who is also the --initiator of the whole project. Thanks Andy! Most of the interface --with GCC was written by _Paul Brook_. -- -- The following individuals have contributed code and/or ideas and --significant help to the GNU Fortran project (in alphabetical order): -- -- - Janne Blomqvist -- -- - Steven Bosscher -- -- - Paul Brook -- -- - Tobias Burnus -- -- - Franc,ois-Xavier Coudert -- -- - Bud Davis -- -- - Jerry DeLisle -- -- - Erik Edelmann -- -- - Bernhard Fischer -- -- - Daniel Franke -- -- - Richard Guenther -- -- - Richard Henderson -- -- - Katherine Holcomb -- -- - Jakub Jelinek -- -- - Niels Kristian Bech Jensen -- -- - Steven Johnson -- -- - Steven G. Kargl -- -- - Thomas Koenig -- -- - Asher Langton -- -- - H. J. Lu -- -- - Toon Moene -- -- - Brooks Moses -- -- - Andrew Pinski -- -- - Tim Prince -- -- - Christopher D. Rickett -- -- - Richard Sandiford -- -- - Tobias Schlu"ter -- -- - Roger Sayle -- -- - Paul Thomas -- -- - Andy Vaught -- -- - Feng Wang -- -- - Janus Weil -- -- The following people have contributed bug reports, smaller or larger --patches, and much needed feedback and encouragement for the GNU Fortran --project: -- -- - Bill Clodius -- -- - Dominique d'Humie`res -- -- - Kate Hedstrom -- -- - Erik Schnetter -- -- Many other individuals have helped debug, test and improve the GNU --Fortran compiler over the past few years, and we welcome you to do the --same! If you already have done so, and you would like to see your name --listed in the list above, please contact us. -- -- --File: gfortran.info, Node: Projects, Next: Proposed Extensions, Prev: Contributors, Up: Contributing -- --Projects --======== -- --_Help build the test suite_ -- Solicit more code for donation to the test suite: the more -- extensive the testsuite, the smaller the risk of breaking things -- in the future! We can keep code private on request. -- --_Bug hunting/squishing_ -- Find bugs and write more test cases! Test cases are especially very -- welcome, because it allows us to concentrate on fixing bugs -- instead of isolating them. Going through the bugzilla database at -- `http://gcc.gnu.org/bugzilla/' to reduce testcases posted there and -- add more information (for example, for which version does the -- testcase work, for which versions does it fail?) is also very -- helpful. -- -- -- --File: gfortran.info, Node: Proposed Extensions, Prev: Projects, Up: Contributing -- --Proposed Extensions --=================== -- --Here's a list of proposed extensions for the GNU Fortran compiler, in --no particular order. Most of these are necessary to be fully --compatible with existing Fortran compilers, but they are not part of --the official J3 Fortran 95 standard. -- --Compiler extensions: ---------------------- -- -- * User-specified alignment rules for structures. -- -- * Flag to generate `Makefile' info. -- -- * Automatically extend single precision constants to double. -- -- * Compile code that conserves memory by dynamically allocating -- common and module storage either on stack or heap. -- -- * Compile flag to generate code for array conformance checking -- (suggest -CC). -- -- * User control of symbol names (underscores, etc). -- -- * Compile setting for maximum size of stack frame size before -- spilling parts to static or heap. -- -- * Flag to force local variables into static space. -- -- * Flag to force local variables onto stack. -- --Environment Options --------------------- -- -- * Pluggable library modules for random numbers, linear algebra. LA -- should use BLAS calling conventions. -- -- * Environment variables controlling actions on arithmetic exceptions -- like overflow, underflow, precision loss--Generate NaN, abort, -- default. action. -- -- * Set precision for fp units that support it (i387). -- -- * Variable for setting fp rounding mode. -- -- * Variable to fill uninitialized variables with a user-defined bit -- pattern. -- -- * Environment variable controlling filename that is opened for that -- unit number. -- -- * Environment variable to clear/trash memory being freed. -- -- * Environment variable to control tracing of allocations and frees. -- -- * Environment variable to display allocated memory at normal program -- end. -- -- * Environment variable for filename for * IO-unit. -- -- * Environment variable for temporary file directory. -- -- * Environment variable forcing standard output to be line buffered -- (unix). -- -- -- --File: gfortran.info, Node: Copying, Next: GNU Free Documentation License, Prev: Contributing, Up: Top -- --GNU General Public License --************************** -- -- Version 3, 29 June 2007 -- -- Copyright (C) 2007 Free Software Foundation, Inc. `http://fsf.org/' -- -- Everyone is permitted to copy and distribute verbatim copies of this -- license document, but changing it is not allowed. -- --Preamble --======== -- --The GNU General Public License is a free, copyleft license for software --and other kinds of works. -- -- The licenses for most software and other practical works are designed --to take away your freedom to share and change the works. By contrast, --the GNU General Public License is intended to guarantee your freedom to --share and change all versions of a program-to make sure it remains free --software for all its users. We, the Free Software Foundation, use the --GNU General Public License for most of our software; it applies also to --any other work released this way by its authors. You can apply it to --your programs, too. -- -- When we speak of free software, we are referring to freedom, not --price. Our General Public Licenses are designed to make sure that you --have the freedom to distribute copies of free software (and charge for --them if you wish), that you receive source code or can get it if you --want it, that you can change the software or use pieces of it in new --free programs, and that you know you can do these things. -- -- To protect your rights, we need to prevent others from denying you --these rights or asking you to surrender the rights. Therefore, you --have certain responsibilities if you distribute copies of the software, --or if you modify it: responsibilities to respect the freedom of others. -- -- For example, if you distribute copies of such a program, whether --gratis or for a fee, you must pass on to the recipients the same --freedoms that you received. You must make sure that they, too, receive --or can get the source code. And you must show them these terms so they --know their rights. -- -- Developers that use the GNU GPL protect your rights with two steps: --(1) assert copyright on the software, and (2) offer you this License --giving you legal permission to copy, distribute and/or modify it. -- -- For the developers' and authors' protection, the GPL clearly explains --that there is no warranty for this free software. For both users' and --authors' sake, the GPL requires that modified versions be marked as --changed, so that their problems will not be attributed erroneously to --authors of previous versions. -- -- Some devices are designed to deny users access to install or run --modified versions of the software inside them, although the --manufacturer can do so. This is fundamentally incompatible with the --aim of protecting users' freedom to change the software. The --systematic pattern of such abuse occurs in the area of products for --individuals to use, which is precisely where it is most unacceptable. --Therefore, we have designed this version of the GPL to prohibit the --practice for those products. If such problems arise substantially in --other domains, we stand ready to extend this provision to those domains --in future versions of the GPL, as needed to protect the freedom of --users. -- -- Finally, every program is threatened constantly by software patents. --States should not allow patents to restrict development and use of --software on general-purpose computers, but in those that do, we wish to --avoid the special danger that patents applied to a free program could --make it effectively proprietary. To prevent this, the GPL assures that --patents cannot be used to render the program non-free. -- -- The precise terms and conditions for copying, distribution and --modification follow. -- --TERMS AND CONDITIONS --==================== -- -- 0. Definitions. -- -- "This License" refers to version 3 of the GNU General Public -- License. -- -- "Copyright" also means copyright-like laws that apply to other -- kinds of works, such as semiconductor masks. -- -- "The Program" refers to any copyrightable work licensed under this -- License. Each licensee is addressed as "you". "Licensees" and -- "recipients" may be individuals or organizations. -- -- To "modify" a work means to copy from or adapt all or part of the -- work in a fashion requiring copyright permission, other than the -- making of an exact copy. The resulting work is called a "modified -- version" of the earlier work or a work "based on" the earlier work. -- -- A "covered work" means either the unmodified Program or a work -- based on the Program. -- -- To "propagate" a work means to do anything with it that, without -- permission, would make you directly or secondarily liable for -- infringement under applicable copyright law, except executing it -- on a computer or modifying a private copy. Propagation includes -- copying, distribution (with or without modification), making -- available to the public, and in some countries other activities as -- well. -- -- To "convey" a work means any kind of propagation that enables other -- parties to make or receive copies. Mere interaction with a user -- through a computer network, with no transfer of a copy, is not -- conveying. -- -- An interactive user interface displays "Appropriate Legal Notices" -- to the extent that it includes a convenient and prominently visible -- feature that (1) displays an appropriate copyright notice, and (2) -- tells the user that there is no warranty for the work (except to -- the extent that warranties are provided), that licensees may -- convey the work under this License, and how to view a copy of this -- License. If the interface presents a list of user commands or -- options, such as a menu, a prominent item in the list meets this -- criterion. -- -- 1. Source Code. -- -- The "source code" for a work means the preferred form of the work -- for making modifications to it. "Object code" means any -- non-source form of a work. -- -- A "Standard Interface" means an interface that either is an -- official standard defined by a recognized standards body, or, in -- the case of interfaces specified for a particular programming -- language, one that is widely used among developers working in that -- language. -- -- The "System Libraries" of an executable work include anything, -- other than the work as a whole, that (a) is included in the normal -- form of packaging a Major Component, but which is not part of that -- Major Component, and (b) serves only to enable use of the work -- with that Major Component, or to implement a Standard Interface -- for which an implementation is available to the public in source -- code form. A "Major Component", in this context, means a major -- essential component (kernel, window system, and so on) of the -- specific operating system (if any) on which the executable work -- runs, or a compiler used to produce the work, or an object code -- interpreter used to run it. -- -- The "Corresponding Source" for a work in object code form means all -- the source code needed to generate, install, and (for an executable -- work) run the object code and to modify the work, including -- scripts to control those activities. However, it does not include -- the work's System Libraries, or general-purpose tools or generally -- available free programs which are used unmodified in performing -- those activities but which are not part of the work. For example, -- Corresponding Source includes interface definition files -- associated with source files for the work, and the source code for -- shared libraries and dynamically linked subprograms that the work -- is specifically designed to require, such as by intimate data -- communication or control flow between those subprograms and other -- parts of the work. -- -- The Corresponding Source need not include anything that users can -- regenerate automatically from other parts of the Corresponding -- Source. -- -- The Corresponding Source for a work in source code form is that -- same work. -- -- 2. Basic Permissions. -- -- All rights granted under this License are granted for the term of -- copyright on the Program, and are irrevocable provided the stated -- conditions are met. This License explicitly affirms your unlimited -- permission to run the unmodified Program. The output from running -- a covered work is covered by this License only if the output, -- given its content, constitutes a covered work. This License -- acknowledges your rights of fair use or other equivalent, as -- provided by copyright law. -- -- You may make, run and propagate covered works that you do not -- convey, without conditions so long as your license otherwise -- remains in force. You may convey covered works to others for the -- sole purpose of having them make modifications exclusively for -- you, or provide you with facilities for running those works, -- provided that you comply with the terms of this License in -- conveying all material for which you do not control copyright. -- Those thus making or running the covered works for you must do so -- exclusively on your behalf, under your direction and control, on -- terms that prohibit them from making any copies of your -- copyrighted material outside their relationship with you. -- -- Conveying under any other circumstances is permitted solely under -- the conditions stated below. Sublicensing is not allowed; section -- 10 makes it unnecessary. -- -- 3. Protecting Users' Legal Rights From Anti-Circumvention Law. -- -- No covered work shall be deemed part of an effective technological -- measure under any applicable law fulfilling obligations under -- article 11 of the WIPO copyright treaty adopted on 20 December -- 1996, or similar laws prohibiting or restricting circumvention of -- such measures. -- -- When you convey a covered work, you waive any legal power to forbid -- circumvention of technological measures to the extent such -- circumvention is effected by exercising rights under this License -- with respect to the covered work, and you disclaim any intention -- to limit operation or modification of the work as a means of -- enforcing, against the work's users, your or third parties' legal -- rights to forbid circumvention of technological measures. -- -- 4. Conveying Verbatim Copies. -- -- You may convey verbatim copies of the Program's source code as you -- receive it, in any medium, provided that you conspicuously and -- appropriately publish on each copy an appropriate copyright notice; -- keep intact all notices stating that this License and any -- non-permissive terms added in accord with section 7 apply to the -- code; keep intact all notices of the absence of any warranty; and -- give all recipients a copy of this License along with the Program. -- -- You may charge any price or no price for each copy that you convey, -- and you may offer support or warranty protection for a fee. -- -- 5. Conveying Modified Source Versions. -- -- You may convey a work based on the Program, or the modifications to -- produce it from the Program, in the form of source code under the -- terms of section 4, provided that you also meet all of these -- conditions: -- -- a. The work must carry prominent notices stating that you -- modified it, and giving a relevant date. -- -- b. The work must carry prominent notices stating that it is -- released under this License and any conditions added under -- section 7. This requirement modifies the requirement in -- section 4 to "keep intact all notices". -- -- c. You must license the entire work, as a whole, under this -- License to anyone who comes into possession of a copy. This -- License will therefore apply, along with any applicable -- section 7 additional terms, to the whole of the work, and all -- its parts, regardless of how they are packaged. This License -- gives no permission to license the work in any other way, but -- it does not invalidate such permission if you have separately -- received it. -- -- d. If the work has interactive user interfaces, each must display -- Appropriate Legal Notices; however, if the Program has -- interactive interfaces that do not display Appropriate Legal -- Notices, your work need not make them do so. -- -- A compilation of a covered work with other separate and independent -- works, which are not by their nature extensions of the covered -- work, and which are not combined with it such as to form a larger -- program, in or on a volume of a storage or distribution medium, is -- called an "aggregate" if the compilation and its resulting -- copyright are not used to limit the access or legal rights of the -- compilation's users beyond what the individual works permit. -- Inclusion of a covered work in an aggregate does not cause this -- License to apply to the other parts of the aggregate. -- -- 6. Conveying Non-Source Forms. -- -- You may convey a covered work in object code form under the terms -- of sections 4 and 5, provided that you also convey the -- machine-readable Corresponding Source under the terms of this -- License, in one of these ways: -- -- a. Convey the object code in, or embodied in, a physical product -- (including a physical distribution medium), accompanied by the -- Corresponding Source fixed on a durable physical medium -- customarily used for software interchange. -- -- b. Convey the object code in, or embodied in, a physical product -- (including a physical distribution medium), accompanied by a -- written offer, valid for at least three years and valid for -- as long as you offer spare parts or customer support for that -- product model, to give anyone who possesses the object code -- either (1) a copy of the Corresponding Source for all the -- software in the product that is covered by this License, on a -- durable physical medium customarily used for software -- interchange, for a price no more than your reasonable cost of -- physically performing this conveying of source, or (2) access -- to copy the Corresponding Source from a network server at no -- charge. -- -- c. Convey individual copies of the object code with a copy of -- the written offer to provide the Corresponding Source. This -- alternative is allowed only occasionally and noncommercially, -- and only if you received the object code with such an offer, -- in accord with subsection 6b. -- -- d. Convey the object code by offering access from a designated -- place (gratis or for a charge), and offer equivalent access -- to the Corresponding Source in the same way through the same -- place at no further charge. You need not require recipients -- to copy the Corresponding Source along with the object code. -- If the place to copy the object code is a network server, the -- Corresponding Source may be on a different server (operated -- by you or a third party) that supports equivalent copying -- facilities, provided you maintain clear directions next to -- the object code saying where to find the Corresponding Source. -- Regardless of what server hosts the Corresponding Source, you -- remain obligated to ensure that it is available for as long -- as needed to satisfy these requirements. -- -- e. Convey the object code using peer-to-peer transmission, -- provided you inform other peers where the object code and -- Corresponding Source of the work are being offered to the -- general public at no charge under subsection 6d. -- -- -- A separable portion of the object code, whose source code is -- excluded from the Corresponding Source as a System Library, need -- not be included in conveying the object code work. -- -- A "User Product" is either (1) a "consumer product", which means -- any tangible personal property which is normally used for personal, -- family, or household purposes, or (2) anything designed or sold for -- incorporation into a dwelling. In determining whether a product -- is a consumer product, doubtful cases shall be resolved in favor of -- coverage. For a particular product received by a particular user, -- "normally used" refers to a typical or common use of that class of -- product, regardless of the status of the particular user or of the -- way in which the particular user actually uses, or expects or is -- expected to use, the product. A product is a consumer product -- regardless of whether the product has substantial commercial, -- industrial or non-consumer uses, unless such uses represent the -- only significant mode of use of the product. -- -- "Installation Information" for a User Product means any methods, -- procedures, authorization keys, or other information required to -- install and execute modified versions of a covered work in that -- User Product from a modified version of its Corresponding Source. -- The information must suffice to ensure that the continued -- functioning of the modified object code is in no case prevented or -- interfered with solely because modification has been made. -- -- If you convey an object code work under this section in, or with, -- or specifically for use in, a User Product, and the conveying -- occurs as part of a transaction in which the right of possession -- and use of the User Product is transferred to the recipient in -- perpetuity or for a fixed term (regardless of how the transaction -- is characterized), the Corresponding Source conveyed under this -- section must be accompanied by the Installation Information. But -- this requirement does not apply if neither you nor any third party -- retains the ability to install modified object code on the User -- Product (for example, the work has been installed in ROM). -- -- The requirement to provide Installation Information does not -- include a requirement to continue to provide support service, -- warranty, or updates for a work that has been modified or -- installed by the recipient, or for the User Product in which it -- has been modified or installed. Access to a network may be denied -- when the modification itself materially and adversely affects the -- operation of the network or violates the rules and protocols for -- communication across the network. -- -- Corresponding Source conveyed, and Installation Information -- provided, in accord with this section must be in a format that is -- publicly documented (and with an implementation available to the -- public in source code form), and must require no special password -- or key for unpacking, reading or copying. -- -- 7. Additional Terms. -- -- "Additional permissions" are terms that supplement the terms of -- this License by making exceptions from one or more of its -- conditions. Additional permissions that are applicable to the -- entire Program shall be treated as though they were included in -- this License, to the extent that they are valid under applicable -- law. If additional permissions apply only to part of the Program, -- that part may be used separately under those permissions, but the -- entire Program remains governed by this License without regard to -- the additional permissions. -- -- When you convey a copy of a covered work, you may at your option -- remove any additional permissions from that copy, or from any part -- of it. (Additional permissions may be written to require their own -- removal in certain cases when you modify the work.) You may place -- additional permissions on material, added by you to a covered work, -- for which you have or can give appropriate copyright permission. -- -- Notwithstanding any other provision of this License, for material -- you add to a covered work, you may (if authorized by the copyright -- holders of that material) supplement the terms of this License -- with terms: -- -- a. Disclaiming warranty or limiting liability differently from -- the terms of sections 15 and 16 of this License; or -- -- b. Requiring preservation of specified reasonable legal notices -- or author attributions in that material or in the Appropriate -- Legal Notices displayed by works containing it; or -- -- c. Prohibiting misrepresentation of the origin of that material, -- or requiring that modified versions of such material be -- marked in reasonable ways as different from the original -- version; or -- -- d. Limiting the use for publicity purposes of names of licensors -- or authors of the material; or -- -- e. Declining to grant rights under trademark law for use of some -- trade names, trademarks, or service marks; or -- -- f. Requiring indemnification of licensors and authors of that -- material by anyone who conveys the material (or modified -- versions of it) with contractual assumptions of liability to -- the recipient, for any liability that these contractual -- assumptions directly impose on those licensors and authors. -- -- All other non-permissive additional terms are considered "further -- restrictions" within the meaning of section 10. If the Program as -- you received it, or any part of it, contains a notice stating that -- it is governed by this License along with a term that is a further -- restriction, you may remove that term. If a license document -- contains a further restriction but permits relicensing or -- conveying under this License, you may add to a covered work -- material governed by the terms of that license document, provided -- that the further restriction does not survive such relicensing or -- conveying. -- -- If you add terms to a covered work in accord with this section, you -- must place, in the relevant source files, a statement of the -- additional terms that apply to those files, or a notice indicating -- where to find the applicable terms. -- -- Additional terms, permissive or non-permissive, may be stated in -- the form of a separately written license, or stated as exceptions; -- the above requirements apply either way. -- -- 8. Termination. -- -- You may not propagate or modify a covered work except as expressly -- provided under this License. Any attempt otherwise to propagate or -- modify it is void, and will automatically terminate your rights -- under this License (including any patent licenses granted under -- the third paragraph of section 11). -- -- However, if you cease all violation of this License, then your -- license from a particular copyright holder is reinstated (a) -- provisionally, unless and until the copyright holder explicitly -- and finally terminates your license, and (b) permanently, if the -- copyright holder fails to notify you of the violation by some -- reasonable means prior to 60 days after the cessation. -- -- Moreover, your license from a particular copyright holder is -- reinstated permanently if the copyright holder notifies you of the -- violation by some reasonable means, this is the first time you have -- received notice of violation of this License (for any work) from -- that copyright holder, and you cure the violation prior to 30 days -- after your receipt of the notice. -- -- Termination of your rights under this section does not terminate -- the licenses of parties who have received copies or rights from -- you under this License. If your rights have been terminated and -- not permanently reinstated, you do not qualify to receive new -- licenses for the same material under section 10. -- -- 9. Acceptance Not Required for Having Copies. -- -- You are not required to accept this License in order to receive or -- run a copy of the Program. Ancillary propagation of a covered work -- occurring solely as a consequence of using peer-to-peer -- transmission to receive a copy likewise does not require -- acceptance. However, nothing other than this License grants you -- permission to propagate or modify any covered work. These actions -- infringe copyright if you do not accept this License. Therefore, -- by modifying or propagating a covered work, you indicate your -- acceptance of this License to do so. -- -- 10. Automatic Licensing of Downstream Recipients. -- -- Each time you convey a covered work, the recipient automatically -- receives a license from the original licensors, to run, modify and -- propagate that work, subject to this License. You are not -- responsible for enforcing compliance by third parties with this -- License. -- -- An "entity transaction" is a transaction transferring control of an -- organization, or substantially all assets of one, or subdividing an -- organization, or merging organizations. If propagation of a -- covered work results from an entity transaction, each party to that -- transaction who receives a copy of the work also receives whatever -- licenses to the work the party's predecessor in interest had or -- could give under the previous paragraph, plus a right to -- possession of the Corresponding Source of the work from the -- predecessor in interest, if the predecessor has it or can get it -- with reasonable efforts. -- -- You may not impose any further restrictions on the exercise of the -- rights granted or affirmed under this License. For example, you -- may not impose a license fee, royalty, or other charge for -- exercise of rights granted under this License, and you may not -- initiate litigation (including a cross-claim or counterclaim in a -- lawsuit) alleging that any patent claim is infringed by making, -- using, selling, offering for sale, or importing the Program or any -- portion of it. -- -- 11. Patents. -- -- A "contributor" is a copyright holder who authorizes use under this -- License of the Program or a work on which the Program is based. -- The work thus licensed is called the contributor's "contributor -- version". -- -- A contributor's "essential patent claims" are all patent claims -- owned or controlled by the contributor, whether already acquired or -- hereafter acquired, that would be infringed by some manner, -- permitted by this License, of making, using, or selling its -- contributor version, but do not include claims that would be -- infringed only as a consequence of further modification of the -- contributor version. For purposes of this definition, "control" -- includes the right to grant patent sublicenses in a manner -- consistent with the requirements of this License. -- -- Each contributor grants you a non-exclusive, worldwide, -- royalty-free patent license under the contributor's essential -- patent claims, to make, use, sell, offer for sale, import and -- otherwise run, modify and propagate the contents of its -- contributor version. -- -- In the following three paragraphs, a "patent license" is any -- express agreement or commitment, however denominated, not to -- enforce a patent (such as an express permission to practice a -- patent or covenant not to sue for patent infringement). To -- "grant" such a patent license to a party means to make such an -- agreement or commitment not to enforce a patent against the party. -- -- If you convey a covered work, knowingly relying on a patent -- license, and the Corresponding Source of the work is not available -- for anyone to copy, free of charge and under the terms of this -- License, through a publicly available network server or other -- readily accessible means, then you must either (1) cause the -- Corresponding Source to be so available, or (2) arrange to deprive -- yourself of the benefit of the patent license for this particular -- work, or (3) arrange, in a manner consistent with the requirements -- of this License, to extend the patent license to downstream -- recipients. "Knowingly relying" means you have actual knowledge -- that, but for the patent license, your conveying the covered work -- in a country, or your recipient's use of the covered work in a -- country, would infringe one or more identifiable patents in that -- country that you have reason to believe are valid. -- -- If, pursuant to or in connection with a single transaction or -- arrangement, you convey, or propagate by procuring conveyance of, a -- covered work, and grant a patent license to some of the parties -- receiving the covered work authorizing them to use, propagate, -- modify or convey a specific copy of the covered work, then the -- patent license you grant is automatically extended to all -- recipients of the covered work and works based on it. -- -- A patent license is "discriminatory" if it does not include within -- the scope of its coverage, prohibits the exercise of, or is -- conditioned on the non-exercise of one or more of the rights that -- are specifically granted under this License. You may not convey a -- covered work if you are a party to an arrangement with a third -- party that is in the business of distributing software, under -- which you make payment to the third party based on the extent of -- your activity of conveying the work, and under which the third -- party grants, to any of the parties who would receive the covered -- work from you, a discriminatory patent license (a) in connection -- with copies of the covered work conveyed by you (or copies made -- from those copies), or (b) primarily for and in connection with -- specific products or compilations that contain the covered work, -- unless you entered into that arrangement, or that patent license -- was granted, prior to 28 March 2007. -- -- Nothing in this License shall be construed as excluding or limiting -- any implied license or other defenses to infringement that may -- otherwise be available to you under applicable patent law. -- -- 12. No Surrender of Others' Freedom. -- -- If conditions are imposed on you (whether by court order, -- agreement or otherwise) that contradict the conditions of this -- License, they do not excuse you from the conditions of this -- License. If you cannot convey a covered work so as to satisfy -- simultaneously your obligations under this License and any other -- pertinent obligations, then as a consequence you may not convey it -- at all. For example, if you agree to terms that obligate you to -- collect a royalty for further conveying from those to whom you -- convey the Program, the only way you could satisfy both those -- terms and this License would be to refrain entirely from conveying -- the Program. -- -- 13. Use with the GNU Affero General Public License. -- -- Notwithstanding any other provision of this License, you have -- permission to link or combine any covered work with a work licensed -- under version 3 of the GNU Affero General Public License into a -- single combined work, and to convey the resulting work. The terms -- of this License will continue to apply to the part which is the -- covered work, but the special requirements of the GNU Affero -- General Public License, section 13, concerning interaction through -- a network will apply to the combination as such. -- -- 14. Revised Versions of this License. -- -- The Free Software Foundation may publish revised and/or new -- versions of the GNU General Public License from time to time. -- Such new versions will be similar in spirit to the present -- version, but may differ in detail to address new problems or -- concerns. -- -- Each version is given a distinguishing version number. If the -- Program specifies that a certain numbered version of the GNU -- General Public License "or any later version" applies to it, you -- have the option of following the terms and conditions either of -- that numbered version or of any later version published by the -- Free Software Foundation. If the Program does not specify a -- version number of the GNU General Public License, you may choose -- any version ever published by the Free Software Foundation. -- -- If the Program specifies that a proxy can decide which future -- versions of the GNU General Public License can be used, that -- proxy's public statement of acceptance of a version permanently -- authorizes you to choose that version for the Program. -- -- Later license versions may give you additional or different -- permissions. However, no additional obligations are imposed on any -- author or copyright holder as a result of your choosing to follow a -- later version. -- -- 15. Disclaimer of Warranty. -- -- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -- APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE -- COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" -- WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, -- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -- MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE -- RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. -- SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL -- NECESSARY SERVICING, REPAIR OR CORRECTION. -- -- 16. Limitation of Liability. -- -- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -- WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES -- AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU -- FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -- CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE -- THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA -- BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -- PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -- PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF -- THE POSSIBILITY OF SUCH DAMAGES. -- -- 17. Interpretation of Sections 15 and 16. -- -- If the disclaimer of warranty and limitation of liability provided -- above cannot be given local legal effect according to their terms, -- reviewing courts shall apply local law that most closely -- approximates an absolute waiver of all civil liability in -- connection with the Program, unless a warranty or assumption of -- liability accompanies a copy of the Program in return for a fee. -- -- --END OF TERMS AND CONDITIONS --=========================== -- --How to Apply These Terms to Your New Programs --============================================= -- --If you develop a new program, and you want it to be of the greatest --possible use to the public, the best way to achieve this is to make it --free software which everyone can redistribute and change under these --terms. -- -- To do so, attach the following notices to the program. It is safest --to attach them to the start of each source file to most effectively --state the exclusion of warranty; and each file should have at least the --"copyright" line and a pointer to where the full notice is found. -- -- ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES. -- Copyright (C) YEAR NAME OF AUTHOR -- -- This program is free software: you can redistribute it and/or modify -- it under the terms of the GNU General Public License as published by -- the Free Software Foundation, either version 3 of the License, or (at -- your option) any later version. -- -- This program is distributed in the hope that it will be useful, but -- WITHOUT ANY WARRANTY; without even the implied warranty of -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -- General Public License for more details. -- -- You should have received a copy of the GNU General Public License -- along with this program. If not, see `http://www.gnu.org/licenses/'. -- -- Also add information on how to contact you by electronic and paper --mail. -- -- If the program does terminal interaction, make it output a short --notice like this when it starts in an interactive mode: -- -- PROGRAM Copyright (C) YEAR NAME OF AUTHOR -- This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. -- This is free software, and you are welcome to redistribute it -- under certain conditions; type `show c' for details. -- -- The hypothetical commands `show w' and `show c' should show the --appropriate parts of the General Public License. Of course, your --program's commands might be different; for a GUI interface, you would --use an "about box". -- -- You should also get your employer (if you work as a programmer) or --school, if any, to sign a "copyright disclaimer" for the program, if --necessary. For more information on this, and how to apply and follow --the GNU GPL, see `http://www.gnu.org/licenses/'. -- -- The GNU General Public License does not permit incorporating your --program into proprietary programs. If your program is a subroutine --library, you may consider it more useful to permit linking proprietary --applications with the library. If this is what you want to do, use the --GNU Lesser General Public License instead of this License. But first, --please read `http://www.gnu.org/philosophy/why-not-lgpl.html'. -- -- --File: gfortran.info, Node: GNU Free Documentation License, Next: Funding, Prev: Copying, Up: Top -- --GNU Free Documentation License --****************************** -- -- Version 1.2, November 2002 -- -- Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. -- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA -- -- Everyone is permitted to copy and distribute verbatim copies -- of this license document, but changing it is not allowed. -- -- 0. PREAMBLE -- -- The purpose of this License is to make a manual, textbook, or other -- functional and useful document "free" in the sense of freedom: to -- assure everyone the effective freedom to copy and redistribute it, -- with or without modifying it, either commercially or -- noncommercially. Secondarily, this License preserves for the -- author and publisher a way to get credit for their work, while not -- being considered responsible for modifications made by others. -- -- This License is a kind of "copyleft", which means that derivative -- works of the document must themselves be free in the same sense. -- It complements the GNU General Public License, which is a copyleft -- license designed for free software. -- -- We have designed this License in order to use it for manuals for -- free software, because free software needs free documentation: a -- free program should come with manuals providing the same freedoms -- that the software does. But this License is not limited to -- software manuals; it can be used for any textual work, regardless -- of subject matter or whether it is published as a printed book. -- We recommend this License principally for works whose purpose is -- instruction or reference. -- -- 1. APPLICABILITY AND DEFINITIONS -- -- This License applies to any manual or other work, in any medium, -- that contains a notice placed by the copyright holder saying it -- can be distributed under the terms of this License. Such a notice -- grants a world-wide, royalty-free license, unlimited in duration, -- to use that work under the conditions stated herein. The -- "Document", below, refers to any such manual or work. Any member -- of the public is a licensee, and is addressed as "you". You -- accept the license if you copy, modify or distribute the work in a -- way requiring permission under copyright law. -- -- A "Modified Version" of the Document means any work containing the -- Document or a portion of it, either copied verbatim, or with -- modifications and/or translated into another language. -- -- A "Secondary Section" is a named appendix or a front-matter section -- of the Document that deals exclusively with the relationship of the -- publishers or authors of the Document to the Document's overall -- subject (or to related matters) and contains nothing that could -- fall directly within that overall subject. (Thus, if the Document -- is in part a textbook of mathematics, a Secondary Section may not -- explain any mathematics.) The relationship could be a matter of -- historical connection with the subject or with related matters, or -- of legal, commercial, philosophical, ethical or political position -- regarding them. -- -- The "Invariant Sections" are certain Secondary Sections whose -- titles are designated, as being those of Invariant Sections, in -- the notice that says that the Document is released under this -- License. If a section does not fit the above definition of -- Secondary then it is not allowed to be designated as Invariant. -- The Document may contain zero Invariant Sections. If the Document -- does not identify any Invariant Sections then there are none. -- -- The "Cover Texts" are certain short passages of text that are -- listed, as Front-Cover Texts or Back-Cover Texts, in the notice -- that says that the Document is released under this License. A -- Front-Cover Text may be at most 5 words, and a Back-Cover Text may -- be at most 25 words. -- -- A "Transparent" copy of the Document means a machine-readable copy, -- represented in a format whose specification is available to the -- general public, that is suitable for revising the document -- straightforwardly with generic text editors or (for images -- composed of pixels) generic paint programs or (for drawings) some -- widely available drawing editor, and that is suitable for input to -- text formatters or for automatic translation to a variety of -- formats suitable for input to text formatters. A copy made in an -- otherwise Transparent file format whose markup, or absence of -- markup, has been arranged to thwart or discourage subsequent -- modification by readers is not Transparent. An image format is -- not Transparent if used for any substantial amount of text. A -- copy that is not "Transparent" is called "Opaque". -- -- Examples of suitable formats for Transparent copies include plain -- ASCII without markup, Texinfo input format, LaTeX input format, -- SGML or XML using a publicly available DTD, and -- standard-conforming simple HTML, PostScript or PDF designed for -- human modification. Examples of transparent image formats include -- PNG, XCF and JPG. Opaque formats include proprietary formats that -- can be read and edited only by proprietary word processors, SGML or -- XML for which the DTD and/or processing tools are not generally -- available, and the machine-generated HTML, PostScript or PDF -- produced by some word processors for output purposes only. -- -- The "Title Page" means, for a printed book, the title page itself, -- plus such following pages as are needed to hold, legibly, the -- material this License requires to appear in the title page. For -- works in formats which do not have any title page as such, "Title -- Page" means the text near the most prominent appearance of the -- work's title, preceding the beginning of the body of the text. -- -- A section "Entitled XYZ" means a named subunit of the Document -- whose title either is precisely XYZ or contains XYZ in parentheses -- following text that translates XYZ in another language. (Here XYZ -- stands for a specific section name mentioned below, such as -- "Acknowledgements", "Dedications", "Endorsements", or "History".) -- To "Preserve the Title" of such a section when you modify the -- Document means that it remains a section "Entitled XYZ" according -- to this definition. -- -- The Document may include Warranty Disclaimers next to the notice -- which states that this License applies to the Document. These -- Warranty Disclaimers are considered to be included by reference in -- this License, but only as regards disclaiming warranties: any other -- implication that these Warranty Disclaimers may have is void and -- has no effect on the meaning of this License. -- -- 2. VERBATIM COPYING -- -- You may copy and distribute the Document in any medium, either -- commercially or noncommercially, provided that this License, the -- copyright notices, and the license notice saying this License -- applies to the Document are reproduced in all copies, and that you -- add no other conditions whatsoever to those of this License. You -- may not use technical measures to obstruct or control the reading -- or further copying of the copies you make or distribute. However, -- you may accept compensation in exchange for copies. If you -- distribute a large enough number of copies you must also follow -- the conditions in section 3. -- -- You may also lend copies, under the same conditions stated above, -- and you may publicly display copies. -- -- 3. COPYING IN QUANTITY -- -- If you publish printed copies (or copies in media that commonly -- have printed covers) of the Document, numbering more than 100, and -- the Document's license notice requires Cover Texts, you must -- enclose the copies in covers that carry, clearly and legibly, all -- these Cover Texts: Front-Cover Texts on the front cover, and -- Back-Cover Texts on the back cover. Both covers must also clearly -- and legibly identify you as the publisher of these copies. The -- front cover must present the full title with all words of the -- title equally prominent and visible. You may add other material -- on the covers in addition. Copying with changes limited to the -- covers, as long as they preserve the title of the Document and -- satisfy these conditions, can be treated as verbatim copying in -- other respects. -- -- If the required texts for either cover are too voluminous to fit -- legibly, you should put the first ones listed (as many as fit -- reasonably) on the actual cover, and continue the rest onto -- adjacent pages. -- -- If you publish or distribute Opaque copies of the Document -- numbering more than 100, you must either include a -- machine-readable Transparent copy along with each Opaque copy, or -- state in or with each Opaque copy a computer-network location from -- which the general network-using public has access to download -- using public-standard network protocols a complete Transparent -- copy of the Document, free of added material. If you use the -- latter option, you must take reasonably prudent steps, when you -- begin distribution of Opaque copies in quantity, to ensure that -- this Transparent copy will remain thus accessible at the stated -- location until at least one year after the last time you -- distribute an Opaque copy (directly or through your agents or -- retailers) of that edition to the public. -- -- It is requested, but not required, that you contact the authors of -- the Document well before redistributing any large number of -- copies, to give them a chance to provide you with an updated -- version of the Document. -- -- 4. MODIFICATIONS -- -- You may copy and distribute a Modified Version of the Document -- under the conditions of sections 2 and 3 above, provided that you -- release the Modified Version under precisely this License, with -- the Modified Version filling the role of the Document, thus -- licensing distribution and modification of the Modified Version to -- whoever possesses a copy of it. In addition, you must do these -- things in the Modified Version: -- -- A. Use in the Title Page (and on the covers, if any) a title -- distinct from that of the Document, and from those of -- previous versions (which should, if there were any, be listed -- in the History section of the Document). You may use the -- same title as a previous version if the original publisher of -- that version gives permission. -- -- B. List on the Title Page, as authors, one or more persons or -- entities responsible for authorship of the modifications in -- the Modified Version, together with at least five of the -- principal authors of the Document (all of its principal -- authors, if it has fewer than five), unless they release you -- from this requirement. -- -- C. State on the Title page the name of the publisher of the -- Modified Version, as the publisher. -- -- D. Preserve all the copyright notices of the Document. -- -- E. Add an appropriate copyright notice for your modifications -- adjacent to the other copyright notices. -- -- F. Include, immediately after the copyright notices, a license -- notice giving the public permission to use the Modified -- Version under the terms of this License, in the form shown in -- the Addendum below. -- -- G. Preserve in that license notice the full lists of Invariant -- Sections and required Cover Texts given in the Document's -- license notice. -- -- H. Include an unaltered copy of this License. -- -- I. Preserve the section Entitled "History", Preserve its Title, -- and add to it an item stating at least the title, year, new -- authors, and publisher of the Modified Version as given on -- the Title Page. If there is no section Entitled "History" in -- the Document, create one stating the title, year, authors, -- and publisher of the Document as given on its Title Page, -- then add an item describing the Modified Version as stated in -- the previous sentence. -- -- J. Preserve the network location, if any, given in the Document -- for public access to a Transparent copy of the Document, and -- likewise the network locations given in the Document for -- previous versions it was based on. These may be placed in -- the "History" section. You may omit a network location for a -- work that was published at least four years before the -- Document itself, or if the original publisher of the version -- it refers to gives permission. -- -- K. For any section Entitled "Acknowledgements" or "Dedications", -- Preserve the Title of the section, and preserve in the -- section all the substance and tone of each of the contributor -- acknowledgements and/or dedications given therein. -- -- L. Preserve all the Invariant Sections of the Document, -- unaltered in their text and in their titles. Section numbers -- or the equivalent are not considered part of the section -- titles. -- -- M. Delete any section Entitled "Endorsements". Such a section -- may not be included in the Modified Version. -- -- N. Do not retitle any existing section to be Entitled -- "Endorsements" or to conflict in title with any Invariant -- Section. -- -- O. Preserve any Warranty Disclaimers. -- -- If the Modified Version includes new front-matter sections or -- appendices that qualify as Secondary Sections and contain no -- material copied from the Document, you may at your option -- designate some or all of these sections as invariant. To do this, -- add their titles to the list of Invariant Sections in the Modified -- Version's license notice. These titles must be distinct from any -- other section titles. -- -- You may add a section Entitled "Endorsements", provided it contains -- nothing but endorsements of your Modified Version by various -- parties--for example, statements of peer review or that the text -- has been approved by an organization as the authoritative -- definition of a standard. -- -- You may add a passage of up to five words as a Front-Cover Text, -- and a passage of up to 25 words as a Back-Cover Text, to the end -- of the list of Cover Texts in the Modified Version. Only one -- passage of Front-Cover Text and one of Back-Cover Text may be -- added by (or through arrangements made by) any one entity. If the -- Document already includes a cover text for the same cover, -- previously added by you or by arrangement made by the same entity -- you are acting on behalf of, you may not add another; but you may -- replace the old one, on explicit permission from the previous -- publisher that added the old one. -- -- The author(s) and publisher(s) of the Document do not by this -- License give permission to use their names for publicity for or to -- assert or imply endorsement of any Modified Version. -- -- 5. COMBINING DOCUMENTS -- -- You may combine the Document with other documents released under -- this License, under the terms defined in section 4 above for -- modified versions, provided that you include in the combination -- all of the Invariant Sections of all of the original documents, -- unmodified, and list them all as Invariant Sections of your -- combined work in its license notice, and that you preserve all -- their Warranty Disclaimers. -- -- The combined work need only contain one copy of this License, and -- multiple identical Invariant Sections may be replaced with a single -- copy. If there are multiple Invariant Sections with the same name -- but different contents, make the title of each such section unique -- by adding at the end of it, in parentheses, the name of the -- original author or publisher of that section if known, or else a -- unique number. Make the same adjustment to the section titles in -- the list of Invariant Sections in the license notice of the -- combined work. -- -- In the combination, you must combine any sections Entitled -- "History" in the various original documents, forming one section -- Entitled "History"; likewise combine any sections Entitled -- "Acknowledgements", and any sections Entitled "Dedications". You -- must delete all sections Entitled "Endorsements." -- -- 6. COLLECTIONS OF DOCUMENTS -- -- You may make a collection consisting of the Document and other -- documents released under this License, and replace the individual -- copies of this License in the various documents with a single copy -- that is included in the collection, provided that you follow the -- rules of this License for verbatim copying of each of the -- documents in all other respects. -- -- You may extract a single document from such a collection, and -- distribute it individually under this License, provided you insert -- a copy of this License into the extracted document, and follow -- this License in all other respects regarding verbatim copying of -- that document. -- -- 7. AGGREGATION WITH INDEPENDENT WORKS -- -- A compilation of the Document or its derivatives with other -- separate and independent documents or works, in or on a volume of -- a storage or distribution medium, is called an "aggregate" if the -- copyright resulting from the compilation is not used to limit the -- legal rights of the compilation's users beyond what the individual -- works permit. When the Document is included in an aggregate, this -- License does not apply to the other works in the aggregate which -- are not themselves derivative works of the Document. -- -- If the Cover Text requirement of section 3 is applicable to these -- copies of the Document, then if the Document is less than one half -- of the entire aggregate, the Document's Cover Texts may be placed -- on covers that bracket the Document within the aggregate, or the -- electronic equivalent of covers if the Document is in electronic -- form. Otherwise they must appear on printed covers that bracket -- the whole aggregate. -- -- 8. TRANSLATION -- -- Translation is considered a kind of modification, so you may -- distribute translations of the Document under the terms of section -- 4. Replacing Invariant Sections with translations requires special -- permission from their copyright holders, but you may include -- translations of some or all Invariant Sections in addition to the -- original versions of these Invariant Sections. You may include a -- translation of this License, and all the license notices in the -- Document, and any Warranty Disclaimers, provided that you also -- include the original English version of this License and the -- original versions of those notices and disclaimers. In case of a -- disagreement between the translation and the original version of -- this License or a notice or disclaimer, the original version will -- prevail. -- -- If a section in the Document is Entitled "Acknowledgements", -- "Dedications", or "History", the requirement (section 4) to -- Preserve its Title (section 1) will typically require changing the -- actual title. -- -- 9. TERMINATION -- -- You may not copy, modify, sublicense, or distribute the Document -- except as expressly provided for under this License. Any other -- attempt to copy, modify, sublicense or distribute the Document is -- void, and will automatically terminate your rights under this -- License. However, parties who have received copies, or rights, -- from you under this License will not have their licenses -- terminated so long as such parties remain in full compliance. -- -- 10. FUTURE REVISIONS OF THIS LICENSE -- -- The Free Software Foundation may publish new, revised versions of -- the GNU Free Documentation License from time to time. Such new -- versions will be similar in spirit to the present version, but may -- differ in detail to address new problems or concerns. See -- `http://www.gnu.org/copyleft/'. -- -- Each version of the License is given a distinguishing version -- number. If the Document specifies that a particular numbered -- version of this License "or any later version" applies to it, you -- have the option of following the terms and conditions either of -- that specified version or of any later version that has been -- published (not as a draft) by the Free Software Foundation. If -- the Document does not specify a version number of this License, -- you may choose any version ever published (not as a draft) by the -- Free Software Foundation. -- --ADDENDUM: How to use this License for your documents --==================================================== -- --To use this License in a document you have written, include a copy of --the License in the document and put the following copyright and license --notices just after the title page: -- -- Copyright (C) YEAR YOUR NAME. -- Permission is granted to copy, distribute and/or modify this document -- under the terms of the GNU Free Documentation License, Version 1.2 -- or any later version published by the Free Software Foundation; -- with no Invariant Sections, no Front-Cover Texts, and no Back-Cover -- Texts. A copy of the license is included in the section entitled ``GNU -- Free Documentation License''. -- -- If you have Invariant Sections, Front-Cover Texts and Back-Cover --Texts, replace the "with...Texts." line with this: -- -- with the Invariant Sections being LIST THEIR TITLES, with -- the Front-Cover Texts being LIST, and with the Back-Cover Texts -- being LIST. -- -- If you have Invariant Sections without Cover Texts, or some other --combination of the three, merge those two alternatives to suit the --situation. -- -- If your document contains nontrivial examples of program code, we --recommend releasing these examples in parallel under your choice of --free software license, such as the GNU General Public License, to --permit their use in free software. -- -- --File: gfortran.info, Node: Funding, Next: Option Index, Prev: GNU Free Documentation License, Up: Top -- --Funding Free Software --********************* -- --If you want to have more free software a few years from now, it makes --sense for you to help encourage people to contribute funds for its --development. The most effective approach known is to encourage --commercial redistributors to donate. -- -- Users of free software systems can boost the pace of development by --encouraging for-a-fee distributors to donate part of their selling price --to free software developers--the Free Software Foundation, and others. -- -- The way to convince distributors to do this is to demand it and --expect it from them. So when you compare distributors, judge them --partly by how much they give to free software development. Show --distributors they must compete to be the one who gives the most. -- -- To make this approach work, you must insist on numbers that you can --compare, such as, "We will donate ten dollars to the Frobnitz project --for each disk sold." Don't be satisfied with a vague promise, such as --"A portion of the profits are donated," since it doesn't give a basis --for comparison. -- -- Even a precise fraction "of the profits from this disk" is not very --meaningful, since creative accounting and unrelated business decisions --can greatly alter what fraction of the sales price counts as profit. --If the price you pay is $50, ten percent of the profit is probably less --than a dollar; it might be a few cents, or nothing at all. -- -- Some redistributors do development work themselves. This is useful --too; but to keep everyone honest, you need to inquire how much they do, --and what kind. Some kinds of development make much more long-term --difference than others. For example, maintaining a separate version of --a program contributes very little; maintaining the standard version of a --program for the whole community contributes much. Easy new ports --contribute little, since someone else would surely do them; difficult --ports such as adding a new CPU to the GNU Compiler Collection --contribute more; major new features or packages contribute the most. -- -- By establishing the idea that supporting further development is "the --proper thing to do" when distributing free software for a fee, we can --assure a steady flow of resources into making more free software. -- -- Copyright (C) 1994 Free Software Foundation, Inc. -- Verbatim copying and redistribution of this section is permitted -- without royalty; alteration is not permitted. -- -- --File: gfortran.info, Node: Option Index, Next: Keyword Index, Prev: Funding, Up: Top -- --Option Index --************ -- --`gfortran''s command line options are indexed here without any initial --`-' or `--'. Where an option has both positive and negative forms (such --as -foption and -fno-option), relevant entries in the manual are --indexed under the most appropriate form; it may sometimes be useful to --look up both forms. -- -- --* Menu: -- --* A-PREDICATE=ANSWER: Preprocessing Options. -- (line 120) --* APREDICATE=ANSWER: Preprocessing Options. -- (line 114) --* backslash: Fortran Dialect Options. -- (line 59) --* C: Preprocessing Options. -- (line 123) --* CC: Preprocessing Options. -- (line 138) --* cpp: Preprocessing Options. -- (line 13) --* dD: Preprocessing Options. -- (line 35) --* dI: Preprocessing Options. -- (line 51) --* dM: Preprocessing Options. -- (line 26) --* dN: Preprocessing Options. -- (line 41) --* DNAME: Preprocessing Options. -- (line 153) --* DNAME=DEFINITION: Preprocessing Options. -- (line 156) --* dU: Preprocessing Options. -- (line 44) --* falign-commons: Code Gen Options. (line 255) --* fall-intrinsics: Fortran Dialect Options. -- (line 18) --* fbacktrace: Debugging Options. (line 31) --* fblas-matmul-limit: Code Gen Options. (line 214) --* fbounds-check: Code Gen Options. (line 130) --* fcheck-array-temporaries: Code Gen Options. (line 144) --* fconvert=CONVERSION: Runtime Options. (line 9) --* fcray-pointer: Fortran Dialect Options. -- (line 105) --* fd-lines-as-code: Fortran Dialect Options. -- (line 29) --* fd-lines-as-comments: Fortran Dialect Options. -- (line 29) --* fdefault-double-8: Fortran Dialect Options. -- (line 36) --* fdefault-integer-8: Fortran Dialect Options. -- (line 44) --* fdefault-real-8: Fortran Dialect Options. -- (line 49) --* fdollar-ok: Fortran Dialect Options. -- (line 56) --* fdump-core: Debugging Options. (line 38) --* fdump-parse-tree: Debugging Options. (line 10) --* fexternal-blas: Code Gen Options. (line 206) --* ff2c: Code Gen Options. (line 25) --* ffixed-line-length-N: Fortran Dialect Options. -- (line 76) --* ffpe-trap=LIST: Debugging Options. (line 14) --* ffree-form: Fortran Dialect Options. -- (line 12) --* ffree-line-length-N: Fortran Dialect Options. -- (line 89) --* fimplicit-none: Fortran Dialect Options. -- (line 100) --* finit-character: Code Gen Options. (line 238) --* finit-integer: Code Gen Options. (line 238) --* finit-local-zero: Code Gen Options. (line 238) --* finit-logical: Code Gen Options. (line 238) --* finit-real: Code Gen Options. (line 238) --* fintrinsic-modules-path DIR: Directory Options. (line 40) --* fmax-array-constructor: Code Gen Options. (line 152) --* fmax-errors=N: Error and Warning Options. -- (line 27) --* fmax-identifier-length=N: Fortran Dialect Options. -- (line 96) --* fmax-stack-var-size: Code Gen Options. (line 170) --* fmax-subrecord-length=LENGTH: Runtime Options. (line 36) --* fmodule-private: Fortran Dialect Options. -- (line 71) --* fno-automatic: Code Gen Options. (line 15) --* fno-fixed-form: Fortran Dialect Options. -- (line 12) --* fno-range-check: Runtime Options. (line 20) --* fno-underscoring: Code Gen Options. (line 54) --* fopenmp: Fortran Dialect Options. -- (line 109) --* fpack-derived: Code Gen Options. (line 184) --* fpp: Preprocessing Options. -- (line 13) --* frange-check: Fortran Dialect Options. -- (line 117) --* frecord-marker=LENGTH: Runtime Options. (line 28) --* frecursive: Code Gen Options. (line 225) --* frepack-arrays: Code Gen Options. (line 190) --* fsecond-underscore: Code Gen Options. (line 113) --* fshort-enums <1>: Fortran 2003 status. (line 20) --* fshort-enums: Code Gen Options. (line 200) --* fsign-zero: Runtime Options. (line 41) --* fsyntax-only: Error and Warning Options. -- (line 33) --* fworking-directory: Preprocessing Options. -- (line 55) --* H: Preprocessing Options. -- (line 176) --* IDIR: Directory Options. (line 14) --* idirafter DIR: Preprocessing Options. -- (line 70) --* imultilib DIR: Preprocessing Options. -- (line 77) --* iprefix PREFIX: Preprocessing Options. -- (line 81) --* iquote DIR: Preprocessing Options. -- (line 90) --* isysroot DIR: Preprocessing Options. -- (line 86) --* isystem DIR: Preprocessing Options. -- (line 97) --* JDIR: Directory Options. (line 31) --* MDIR: Directory Options. (line 31) --* nostdinc: Preprocessing Options. -- (line 105) --* P: Preprocessing Options. -- (line 181) --* pedantic: Error and Warning Options. -- (line 38) --* pedantic-errors: Error and Warning Options. -- (line 57) --* static-libgfortran: Link Options. (line 11) --* std=STD option: Fortran Dialect Options. -- (line 129) --* UNAME: Preprocessing Options. -- (line 187) --* undef: Preprocessing Options. -- (line 110) --* Waliasing: Error and Warning Options. -- (line 68) --* Walign-commons: Error and Warning Options. -- (line 165) --* Wall: Error and Warning Options. -- (line 61) --* Wampersand: Error and Warning Options. -- (line 85) --* Warray-temporaries: Error and Warning Options. -- (line 93) --* Wcharacter-truncation: Error and Warning Options. -- (line 98) --* Wconversion: Error and Warning Options. -- (line 104) --* Werror: Error and Warning Options. -- (line 171) --* Wimplicit-interface: Error and Warning Options. -- (line 107) --* Wintrinsic-shadow: Error and Warning Options. -- (line 152) --* Wintrinsics-std: Error and Warning Options. -- (line 113) --* Wline-truncation: Error and Warning Options. -- (line 101) --* Wsurprising: Error and Warning Options. -- (line 120) --* Wtabs: Error and Warning Options. -- (line 140) --* Wunderflow: Error and Warning Options. -- (line 148) --* Wunused-parameter: Error and Warning Options. -- (line 158) -- -- --File: gfortran.info, Node: Keyword Index, Prev: Option Index, Up: Top -- --Keyword Index --************* -- -- --* Menu: -- --* $: Fortran Dialect Options. -- (line 56) --* %LOC: Argument list functions. -- (line 6) --* %REF: Argument list functions. -- (line 6) --* %VAL: Argument list functions. -- (line 6) --* &: Error and Warning Options. -- (line 85) --* [...]: Fortran 2003 status. (line 13) --* ABORT: ABORT. (line 6) --* ABS: ABS. (line 6) --* absolute value: ABS. (line 6) --* ACCESS: ACCESS. (line 6) --* ACCESS='STREAM' I/O: Fortran 2003 status. (line 32) --* ACHAR: ACHAR. (line 6) --* ACOS: ACOS. (line 6) --* ACOSH: ACOSH. (line 6) --* adjust string <1>: ADJUSTR. (line 6) --* adjust string: ADJUSTL. (line 6) --* ADJUSTL: ADJUSTL. (line 6) --* ADJUSTR: ADJUSTR. (line 6) --* AIMAG: AIMAG. (line 6) --* AINT: AINT. (line 6) --* ALARM: ALARM. (line 6) --* ALGAMA: LOG_GAMMA. (line 6) --* aliasing: Error and Warning Options. -- (line 68) --* alignment of COMMON blocks <1>: Code Gen Options. (line 255) --* alignment of COMMON blocks: Error and Warning Options. -- (line 165) --* ALL: ALL. (line 6) --* all warnings: Error and Warning Options. -- (line 61) --* ALLOCATABLE components of derived types: Fortran 2003 status. -- (line 30) --* ALLOCATABLE dummy arguments: Fortran 2003 status. (line 26) --* ALLOCATABLE function results: Fortran 2003 status. (line 28) --* ALLOCATED: ALLOCATED. (line 6) --* allocation, moving: MOVE_ALLOC. (line 6) --* allocation, status: ALLOCATED. (line 6) --* ALOG: LOG. (line 6) --* ALOG10: LOG10. (line 6) --* AMAX0: MAX. (line 6) --* AMAX1: MAX. (line 6) --* AMIN0: MIN. (line 6) --* AMIN1: MIN. (line 6) --* AMOD: MOD. (line 6) --* AND: AND. (line 6) --* ANINT: ANINT. (line 6) --* ANY: ANY. (line 6) --* area hyperbolic cosine: ACOSH. (line 6) --* area hyperbolic sine: ASINH. (line 6) --* area hyperbolic tangent: ATANH. (line 6) --* argument list functions: Argument list functions. -- (line 6) --* arguments, to program <1>: IARGC. (line 6) --* arguments, to program <2>: GET_COMMAND_ARGUMENT. -- (line 6) --* arguments, to program <3>: GET_COMMAND. (line 6) --* arguments, to program <4>: GETARG. (line 6) --* arguments, to program: COMMAND_ARGUMENT_COUNT. -- (line 6) --* array, add elements: SUM. (line 6) --* array, apply condition <1>: ANY. (line 6) --* array, apply condition: ALL. (line 6) --* array, bounds checking: Code Gen Options. (line 130) --* array, change dimensions: RESHAPE. (line 6) --* array, combine arrays: MERGE. (line 6) --* array, condition testing <1>: ANY. (line 6) --* array, condition testing: ALL. (line 6) --* array, conditionally add elements: SUM. (line 6) --* array, conditionally count elements: COUNT. (line 6) --* array, conditionally multiply elements: PRODUCT. (line 6) --* array, constructors: Fortran 2003 status. (line 13) --* array, count elements: SIZE. (line 6) --* array, duplicate dimensions: SPREAD. (line 6) --* array, duplicate elements: SPREAD. (line 6) --* array, element counting: COUNT. (line 6) --* array, gather elements: PACK. (line 6) --* array, increase dimension <1>: UNPACK. (line 6) --* array, increase dimension: SPREAD. (line 6) --* array, indices of type real: Real array indices. (line 6) --* array, location of maximum element: MAXLOC. (line 6) --* array, location of minimum element: MINLOC. (line 6) --* array, lower bound: LBOUND. (line 6) --* array, maximum value: MAXVAL. (line 6) --* array, merge arrays: MERGE. (line 6) --* array, minimum value: MINVAL. (line 6) --* array, multiply elements: PRODUCT. (line 6) --* array, number of elements <1>: SIZE. (line 6) --* array, number of elements: COUNT. (line 6) --* array, packing: PACK. (line 6) --* array, permutation: CSHIFT. (line 6) --* array, product: PRODUCT. (line 6) --* array, reduce dimension: PACK. (line 6) --* array, rotate: CSHIFT. (line 6) --* array, scatter elements: UNPACK. (line 6) --* array, shape: SHAPE. (line 6) --* array, shift: EOSHIFT. (line 6) --* array, shift circularly: CSHIFT. (line 6) --* array, size: SIZE. (line 6) --* array, sum: SUM. (line 6) --* array, transmogrify: RESHAPE. (line 6) --* array, transpose: TRANSPOSE. (line 6) --* array, unpacking: UNPACK. (line 6) --* array, upper bound: UBOUND. (line 6) --* ASCII collating sequence <1>: IACHAR. (line 6) --* ASCII collating sequence: ACHAR. (line 6) --* ASIN: ASIN. (line 6) --* ASINH <1>: ATANH. (line 6) --* ASINH: ASINH. (line 6) --* ASSOCIATED: ASSOCIATED. (line 6) --* association status: ASSOCIATED. (line 6) --* association status, C pointer: C_ASSOCIATED. (line 6) --* ATAN: ATAN. (line 6) --* ATAN2: ATAN2. (line 6) --* Authors: Contributors. (line 6) --* backslash: Fortran Dialect Options. -- (line 59) --* backtrace: Debugging Options. (line 31) --* BESJ0: BESSEL_J0. (line 6) --* BESJ1: BESSEL_J1. (line 6) --* BESJN: BESSEL_JN. (line 6) --* Bessel function, first kind <1>: BESSEL_JN. (line 6) --* Bessel function, first kind <2>: BESSEL_J1. (line 6) --* Bessel function, first kind: BESSEL_J0. (line 6) --* Bessel function, second kind <1>: BESSEL_YN. (line 6) --* Bessel function, second kind <2>: BESSEL_Y1. (line 6) --* Bessel function, second kind: BESSEL_Y0. (line 6) --* BESSEL_J0: BESSEL_J0. (line 6) --* BESSEL_J1: BESSEL_J1. (line 6) --* BESSEL_JN: BESSEL_JN. (line 6) --* BESSEL_Y0: BESSEL_Y0. (line 6) --* BESSEL_Y1: BESSEL_Y1. (line 6) --* BESSEL_YN: BESSEL_YN. (line 6) --* BESY0: BESSEL_Y0. (line 6) --* BESY1: BESSEL_Y1. (line 6) --* BESYN: BESSEL_YN. (line 6) --* BIT_SIZE: BIT_SIZE. (line 6) --* bits, clear: IBCLR. (line 6) --* bits, extract: IBITS. (line 6) --* bits, get: IBITS. (line 6) --* bits, move <1>: TRANSFER. (line 6) --* bits, move: MVBITS. (line 6) --* bits, negate: NOT. (line 6) --* bits, number of: BIT_SIZE. (line 6) --* bits, set: IBSET. (line 6) --* bits, shift: ISHFT. (line 6) --* bits, shift circular: ISHFTC. (line 6) --* bits, shift left: LSHIFT. (line 6) --* bits, shift right: RSHIFT. (line 6) --* bits, testing: BTEST. (line 6) --* bits, unset: IBCLR. (line 6) --* bitwise logical and <1>: IAND. (line 6) --* bitwise logical and: AND. (line 6) --* bitwise logical exclusive or <1>: XOR. (line 6) --* bitwise logical exclusive or: IEOR. (line 6) --* bitwise logical not: NOT. (line 6) --* bitwise logical or <1>: OR. (line 6) --* bitwise logical or: IOR. (line 6) --* bounds checking: Code Gen Options. (line 130) --* BOZ literal constants: BOZ literal constants. -- (line 6) --* BTEST: BTEST. (line 6) --* C_ASSOCIATED: C_ASSOCIATED. (line 6) --* C_F_POINTER: C_F_POINTER. (line 6) --* C_F_PROCPOINTER: C_F_PROCPOINTER. (line 6) --* C_FUNLOC: C_FUNLOC. (line 6) --* C_LOC: C_LOC. (line 6) --* C_SIZEOF: C_SIZEOF. (line 6) --* CABS: ABS. (line 6) --* calling convention: Code Gen Options. (line 25) --* CCOS: COS. (line 6) --* CDABS: ABS. (line 6) --* CDCOS: COS. (line 6) --* CDEXP: EXP. (line 6) --* CDLOG: LOG. (line 6) --* CDSIN: SIN. (line 6) --* CDSQRT: SQRT. (line 6) --* ceiling: CEILING. (line 6) --* CEILING: CEILING. (line 6) --* ceiling: ANINT. (line 6) --* CEXP: EXP. (line 6) --* CHAR: CHAR. (line 6) --* character kind: SELECTED_CHAR_KIND. (line 6) --* character set: Fortran Dialect Options. -- (line 56) --* CHDIR: CHDIR. (line 6) --* checking array temporaries: Code Gen Options. (line 144) --* checking subscripts: Code Gen Options. (line 130) --* CHMOD: CHMOD. (line 6) --* clock ticks <1>: SYSTEM_CLOCK. (line 6) --* clock ticks <2>: MCLOCK8. (line 6) --* clock ticks: MCLOCK. (line 6) --* CLOG: LOG. (line 6) --* CMPLX: CMPLX. (line 6) --* code generation, conventions: Code Gen Options. (line 6) --* collating sequence, ASCII <1>: IACHAR. (line 6) --* collating sequence, ASCII: ACHAR. (line 6) --* command options: Invoking GNU Fortran. -- (line 6) --* command-line arguments <1>: IARGC. (line 6) --* command-line arguments <2>: GET_COMMAND_ARGUMENT. -- (line 6) --* command-line arguments <3>: GET_COMMAND. (line 6) --* command-line arguments <4>: GETARG. (line 6) --* command-line arguments: COMMAND_ARGUMENT_COUNT. -- (line 6) --* command-line arguments, number of <1>: IARGC. (line 6) --* command-line arguments, number of: COMMAND_ARGUMENT_COUNT. -- (line 6) --* COMMAND_ARGUMENT_COUNT: COMMAND_ARGUMENT_COUNT. -- (line 6) --* COMPLEX: COMPLEX. (line 6) --* complex conjugate: CONJG. (line 6) --* complex numbers, conversion to <1>: DCMPLX. (line 6) --* complex numbers, conversion to <2>: COMPLEX. (line 6) --* complex numbers, conversion to: CMPLX. (line 6) --* complex numbers, imaginary part: AIMAG. (line 6) --* complex numbers, real part <1>: REAL. (line 6) --* complex numbers, real part: DREAL. (line 6) --* Conditional compilation: Preprocessing and conditional compilation. -- (line 6) --* CONJG: CONJG. (line 6) --* Contributing: Contributing. (line 6) --* Contributors: Contributors. (line 6) --* conversion: Error and Warning Options. -- (line 104) --* conversion, to character: CHAR. (line 6) --* conversion, to complex <1>: DCMPLX. (line 6) --* conversion, to complex <2>: COMPLEX. (line 6) --* conversion, to complex: CMPLX. (line 6) --* conversion, to integer <1>: LONG. (line 6) --* conversion, to integer <2>: INT8. (line 6) --* conversion, to integer <3>: INT2. (line 6) --* conversion, to integer <4>: INT. (line 6) --* conversion, to integer <5>: ICHAR. (line 6) --* conversion, to integer <6>: IACHAR. (line 6) --* conversion, to integer: Implicitly convert LOGICAL and INTEGER values. -- (line 6) --* conversion, to logical <1>: LOGICAL. (line 6) --* conversion, to logical: Implicitly convert LOGICAL and INTEGER values. -- (line 6) --* conversion, to real <1>: SNGL. (line 6) --* conversion, to real <2>: REAL. (line 6) --* conversion, to real <3>: FLOAT. (line 6) --* conversion, to real <4>: DFLOAT. (line 6) --* conversion, to real: DBLE. (line 6) --* conversion, to string: CTIME. (line 6) --* CONVERT specifier: CONVERT specifier. (line 6) --* core, dump <1>: ABORT. (line 6) --* core, dump: Debugging Options. (line 38) --* COS: COS. (line 6) --* COSH: COSH. (line 6) --* cosine: COS. (line 6) --* cosine, hyperbolic: COSH. (line 6) --* cosine, hyperbolic, inverse: ACOSH. (line 6) --* cosine, inverse: ACOS. (line 6) --* COUNT: COUNT. (line 6) --* CPP <1>: Preprocessing Options. -- (line 6) --* CPP: Preprocessing and conditional compilation. -- (line 6) --* CPU_TIME: CPU_TIME. (line 6) --* Credits: Contributors. (line 6) --* CSHIFT: CSHIFT. (line 6) --* CSIN: SIN. (line 6) --* CSQRT: SQRT. (line 6) --* CTIME: CTIME. (line 6) --* current date <1>: IDATE. (line 6) --* current date <2>: FDATE. (line 6) --* current date: DATE_AND_TIME. (line 6) --* current time <1>: TIME8. (line 6) --* current time <2>: TIME. (line 6) --* current time <3>: ITIME. (line 6) --* current time <4>: FDATE. (line 6) --* current time: DATE_AND_TIME. (line 6) --* DABS: ABS. (line 6) --* DACOS: ACOS. (line 6) --* DACOSH: ACOSH. (line 6) --* DASIN: ASIN. (line 6) --* DASINH <1>: ATANH. (line 6) --* DASINH: ASINH. (line 6) --* DATAN: ATAN. (line 6) --* DATAN2: ATAN2. (line 6) --* date, current <1>: IDATE. (line 6) --* date, current <2>: FDATE. (line 6) --* date, current: DATE_AND_TIME. (line 6) --* DATE_AND_TIME: DATE_AND_TIME. (line 6) --* DBESJ0: BESSEL_J0. (line 6) --* DBESJ1: BESSEL_J1. (line 6) --* DBESJN: BESSEL_JN. (line 6) --* DBESY0: BESSEL_Y0. (line 6) --* DBESY1: BESSEL_Y1. (line 6) --* DBESYN: BESSEL_YN. (line 6) --* DBLE: DBLE. (line 6) --* DCMPLX: DCMPLX. (line 6) --* DCONJG: CONJG. (line 6) --* DCOS: COS. (line 6) --* DCOSH: COSH. (line 6) --* DDIM: DIM. (line 6) --* debugging information options: Debugging Options. (line 6) --* debugging, preprocessor: Preprocessing Options. -- (line 26) --* DECODE: ENCODE and DECODE statements. -- (line 6) --* delayed execution <1>: SLEEP. (line 6) --* delayed execution: ALARM. (line 6) --* DEXP: EXP. (line 6) --* DFLOAT: DFLOAT. (line 6) --* DGAMMA: GAMMA. (line 6) --* dialect options: Fortran Dialect Options. -- (line 6) --* DIGITS: DIGITS. (line 6) --* DIM: DIM. (line 6) --* DIMAG: AIMAG. (line 6) --* DINT: AINT. (line 6) --* directive, INCLUDE: Directory Options. (line 6) --* directory, options: Directory Options. (line 6) --* directory, search paths for inclusion: Directory Options. (line 14) --* division, modulo: MODULO. (line 6) --* division, remainder: MOD. (line 6) --* DLGAMA: LOG_GAMMA. (line 6) --* DLOG: LOG. (line 6) --* DLOG10: LOG10. (line 6) --* DMAX1: MAX. (line 6) --* DMIN1: MIN. (line 6) --* DMOD: MOD. (line 6) --* DNINT: ANINT. (line 6) --* dot product: DOT_PRODUCT. (line 6) --* DOT_PRODUCT: DOT_PRODUCT. (line 6) --* DPROD: DPROD. (line 6) --* DREAL: DREAL. (line 6) --* DSIGN: SIGN. (line 6) --* DSIN: SIN. (line 6) --* DSINH: SINH. (line 6) --* DSQRT: SQRT. (line 6) --* DTAN: TAN. (line 6) --* DTANH: TANH. (line 6) --* DTIME: DTIME. (line 6) --* elapsed time <1>: SECOND. (line 6) --* elapsed time <2>: SECNDS. (line 6) --* elapsed time: DTIME. (line 6) --* ENCODE: ENCODE and DECODE statements. -- (line 6) --* ENUM statement: Fortran 2003 status. (line 20) --* ENUMERATOR statement: Fortran 2003 status. (line 20) --* environment variable <1>: GET_ENVIRONMENT_VARIABLE. -- (line 6) --* environment variable <2>: GETENV. (line 6) --* environment variable <3>: Runtime. (line 6) --* environment variable: Environment Variables. -- (line 6) --* EOSHIFT: EOSHIFT. (line 6) --* EPSILON: EPSILON. (line 6) --* ERF: ERF. (line 6) --* ERFC: ERFC. (line 6) --* ERFC_SCALED: ERFC_SCALED. (line 6) --* error function: ERF. (line 6) --* error function, complementary: ERFC. (line 6) --* error function, complementary, exponentially-scaled: ERFC_SCALED. -- (line 6) --* errors, limiting: Error and Warning Options. -- (line 27) --* escape characters: Fortran Dialect Options. -- (line 59) --* ETIME: ETIME. (line 6) --* Euclidean distance: HYPOT. (line 6) --* EXIT: EXIT. (line 6) --* EXP: EXP. (line 6) --* EXPONENT: EXPONENT. (line 6) --* exponential function: EXP. (line 6) --* exponential function, inverse <1>: LOG10. (line 6) --* exponential function, inverse: LOG. (line 6) --* expression size <1>: SIZEOF. (line 6) --* expression size: C_SIZEOF. (line 6) --* extensions: Extensions. (line 6) --* extensions, implemented: Extensions implemented in GNU Fortran. -- (line 6) --* extensions, not implemented: Extensions not implemented in GNU Fortran. -- (line 6) --* f2c calling convention: Code Gen Options. (line 25) --* Factorial function: GAMMA. (line 6) --* FDATE: FDATE. (line 6) --* FDL, GNU Free Documentation License: GNU Free Documentation License. -- (line 6) --* FGET: FGET. (line 6) --* FGETC: FGETC. (line 6) --* file format, fixed: Fortran Dialect Options. -- (line 12) --* file format, free: Fortran Dialect Options. -- (line 12) --* file operation, file number: FNUM. (line 6) --* file operation, flush: FLUSH. (line 6) --* file operation, position <1>: FTELL. (line 6) --* file operation, position: FSEEK. (line 6) --* file operation, read character <1>: FGETC. (line 6) --* file operation, read character: FGET. (line 6) --* file operation, seek: FSEEK. (line 6) --* file operation, write character <1>: FPUTC. (line 6) --* file operation, write character: FPUT. (line 6) --* file system, access mode: ACCESS. (line 6) --* file system, change access mode: CHMOD. (line 6) --* file system, create link <1>: SYMLNK. (line 6) --* file system, create link: LINK. (line 6) --* file system, file creation mask: UMASK. (line 6) --* file system, file status <1>: STAT. (line 6) --* file system, file status <2>: LSTAT. (line 6) --* file system, file status: FSTAT. (line 6) --* file system, hard link: LINK. (line 6) --* file system, remove file: UNLINK. (line 6) --* file system, rename file: RENAME. (line 6) --* file system, soft link: SYMLNK. (line 6) --* FLOAT: FLOAT. (line 6) --* floating point, exponent: EXPONENT. (line 6) --* floating point, fraction: FRACTION. (line 6) --* floating point, nearest different: NEAREST. (line 6) --* floating point, relative spacing <1>: SPACING. (line 6) --* floating point, relative spacing: RRSPACING. (line 6) --* floating point, scale: SCALE. (line 6) --* floating point, set exponent: SET_EXPONENT. (line 6) --* floor: FLOOR. (line 6) --* FLOOR: FLOOR. (line 6) --* floor: AINT. (line 6) --* FLUSH: FLUSH. (line 6) --* FLUSH statement: Fortran 2003 status. (line 16) --* FNUM: FNUM. (line 6) --* Fortran 77: GNU Fortran and G77. (line 6) --* FPP: Preprocessing and conditional compilation. -- (line 6) --* FPUT: FPUT. (line 6) --* FPUTC: FPUTC. (line 6) --* FRACTION: FRACTION. (line 6) --* FREE: FREE. (line 6) --* FSEEK: FSEEK. (line 6) --* FSTAT: FSTAT. (line 6) --* FTELL: FTELL. (line 6) --* g77: GNU Fortran and G77. (line 6) --* g77 calling convention: Code Gen Options. (line 25) --* GAMMA: GAMMA. (line 6) --* Gamma function: GAMMA. (line 6) --* Gamma function, logarithm of: LOG_GAMMA. (line 6) --* GCC: GNU Fortran and GCC. (line 6) --* GERROR: GERROR. (line 6) --* GET_COMMAND: GET_COMMAND. (line 6) --* GET_COMMAND_ARGUMENT: GET_COMMAND_ARGUMENT. -- (line 6) --* GET_ENVIRONMENT_VARIABLE: GET_ENVIRONMENT_VARIABLE. -- (line 6) --* GETARG: GETARG. (line 6) --* GETCWD: GETCWD. (line 6) --* GETENV: GETENV. (line 6) --* GETGID: GETGID. (line 6) --* GETLOG: GETLOG. (line 6) --* GETPID: GETPID. (line 6) --* GETUID: GETUID. (line 6) --* GMTIME: GMTIME. (line 6) --* GNU Compiler Collection: GNU Fortran and GCC. (line 6) --* GNU Fortran command options: Invoking GNU Fortran. -- (line 6) --* Hollerith constants: Hollerith constants support. -- (line 6) --* HOSTNM: HOSTNM. (line 6) --* HUGE: HUGE. (line 6) --* hyperbolic arccosine: ACOSH. (line 6) --* hyperbolic arcsine: ASINH. (line 6) --* hyperbolic arctangent: ATANH. (line 6) --* hyperbolic cosine: COSH. (line 6) --* hyperbolic function, cosine: COSH. (line 6) --* hyperbolic function, cosine, inverse: ACOSH. (line 6) --* hyperbolic function, sine: SINH. (line 6) --* hyperbolic function, sine, inverse: ASINH. (line 6) --* hyperbolic function, tangent: TANH. (line 6) --* hyperbolic function, tangent, inverse: ATANH. (line 6) --* hyperbolic sine: SINH. (line 6) --* hyperbolic tangent: TANH. (line 6) --* HYPOT: HYPOT. (line 6) --* I/O item lists: I/O item lists. (line 6) --* IABS: ABS. (line 6) --* IACHAR: IACHAR. (line 6) --* IAND: IAND. (line 6) --* IARGC: IARGC. (line 6) --* IBCLR: IBCLR. (line 6) --* IBITS: IBITS. (line 6) --* IBSET: IBSET. (line 6) --* ICHAR: ICHAR. (line 6) --* IDATE: IDATE. (line 6) --* IDIM: DIM. (line 6) --* IDINT: INT. (line 6) --* IDNINT: NINT. (line 6) --* IEEE, ISNAN: ISNAN. (line 6) --* IEOR: IEOR. (line 6) --* IERRNO: IERRNO. (line 6) --* IFIX: INT. (line 6) --* IMAG: AIMAG. (line 6) --* IMAGPART: AIMAG. (line 6) --* IMPORT statement: Fortran 2003 status. (line 43) --* INCLUDE directive: Directory Options. (line 6) --* inclusion, directory search paths for: Directory Options. (line 14) --* INDEX: INDEX intrinsic. (line 6) --* INT: INT. (line 6) --* INT2: INT2. (line 6) --* INT8: INT8. (line 6) --* integer kind: SELECTED_INT_KIND. (line 6) --* intrinsic: Error and Warning Options. -- (line 152) --* intrinsic Modules: Intrinsic Modules. (line 6) --* intrinsic procedures: Intrinsic Procedures. -- (line 6) --* Introduction: Top. (line 6) --* IOMSG= specifier: Fortran 2003 status. (line 18) --* IOR: IOR. (line 6) --* IOSTAT, end of file: IS_IOSTAT_END. (line 6) --* IOSTAT, end of record: IS_IOSTAT_EOR. (line 6) --* IRAND: IRAND. (line 6) --* IS_IOSTAT_END: IS_IOSTAT_END. (line 6) --* IS_IOSTAT_EOR: IS_IOSTAT_EOR. (line 6) --* ISATTY: ISATTY. (line 6) --* ISHFT: ISHFT. (line 6) --* ISHFTC: ISHFTC. (line 6) --* ISIGN: SIGN. (line 6) --* ISNAN: ISNAN. (line 6) --* ISO C Bindings: Fortran 2003 status. (line 52) --* ISO_FORTRAN_ENV statement: Fortran 2003 status. (line 46) --* ITIME: ITIME. (line 6) --* KILL: KILL. (line 6) --* kind: KIND. (line 6) --* KIND: KIND. (line 6) --* kind: KIND Type Parameters. -- (line 6) --* kind, character: SELECTED_CHAR_KIND. (line 6) --* kind, integer: SELECTED_INT_KIND. (line 6) --* kind, old-style: Old-style kind specifications. -- (line 6) --* kind, real: SELECTED_REAL_KIND. (line 6) --* language, dialect options: Fortran Dialect Options. -- (line 6) --* LBOUND: LBOUND. (line 6) --* LEADZ: LEADZ. (line 6) --* LEN: LEN. (line 6) --* LEN_TRIM: LEN_TRIM. (line 6) --* lexical comparison of strings <1>: LLT. (line 6) --* lexical comparison of strings <2>: LLE. (line 6) --* lexical comparison of strings <3>: LGT. (line 6) --* lexical comparison of strings: LGE. (line 6) --* LGAMMA: LOG_GAMMA. (line 6) --* LGE: LGE. (line 6) --* LGT: LGT. (line 6) --* libf2c calling convention: Code Gen Options. (line 25) --* limits, largest number: HUGE. (line 6) --* limits, smallest number: TINY. (line 6) --* LINK: LINK. (line 6) --* linking, static: Link Options. (line 6) --* LLE: LLE. (line 6) --* LLT: LLT. (line 6) --* LNBLNK: LNBLNK. (line 6) --* LOC: LOC. (line 6) --* location of a variable in memory: LOC. (line 6) --* LOG: LOG. (line 6) --* LOG10: LOG10. (line 6) --* LOG_GAMMA: LOG_GAMMA. (line 6) --* logarithmic function <1>: LOG10. (line 6) --* logarithmic function: LOG. (line 6) --* logarithmic function, inverse: EXP. (line 6) --* LOGICAL: LOGICAL. (line 6) --* logical and, bitwise <1>: IAND. (line 6) --* logical and, bitwise: AND. (line 6) --* logical exclusive or, bitwise <1>: XOR. (line 6) --* logical exclusive or, bitwise: IEOR. (line 6) --* logical not, bitwise: NOT. (line 6) --* logical or, bitwise <1>: OR. (line 6) --* logical or, bitwise: IOR. (line 6) --* login name: GETLOG. (line 6) --* LONG: LONG. (line 6) --* LSHIFT: LSHIFT. (line 6) --* LSTAT: LSTAT. (line 6) --* LTIME: LTIME. (line 6) --* MALLOC: MALLOC. (line 6) --* MATMUL: MATMUL. (line 6) --* matrix multiplication: MATMUL. (line 6) --* matrix, transpose: TRANSPOSE. (line 6) --* MAX: MAX. (line 6) --* MAX0: MAX. (line 6) --* MAX1: MAX. (line 6) --* MAXEXPONENT: MAXEXPONENT. (line 6) --* maximum value <1>: MAXVAL. (line 6) --* maximum value: MAX. (line 6) --* MAXLOC: MAXLOC. (line 6) --* MAXVAL: MAXVAL. (line 6) --* MCLOCK: MCLOCK. (line 6) --* MCLOCK8: MCLOCK8. (line 6) --* MERGE: MERGE. (line 6) --* messages, error: Error and Warning Options. -- (line 6) --* messages, warning: Error and Warning Options. -- (line 6) --* MIN: MIN. (line 6) --* MIN0: MIN. (line 6) --* MIN1: MIN. (line 6) --* MINEXPONENT: MINEXPONENT. (line 6) --* minimum value <1>: MINVAL. (line 6) --* minimum value: MIN. (line 6) --* MINLOC: MINLOC. (line 6) --* MINVAL: MINVAL. (line 6) --* MOD: MOD. (line 6) --* model representation, base: RADIX. (line 6) --* model representation, epsilon: EPSILON. (line 6) --* model representation, largest number: HUGE. (line 6) --* model representation, maximum exponent: MAXEXPONENT. (line 6) --* model representation, minimum exponent: MINEXPONENT. (line 6) --* model representation, precision: PRECISION. (line 6) --* model representation, radix: RADIX. (line 6) --* model representation, range: RANGE. (line 6) --* model representation, significant digits: DIGITS. (line 6) --* model representation, smallest number: TINY. (line 6) --* module entities: Fortran Dialect Options. -- (line 71) --* module search path: Directory Options. (line 14) --* modulo: MODULO. (line 6) --* MODULO: MODULO. (line 6) --* MOVE_ALLOC: MOVE_ALLOC. (line 6) --* moving allocation: MOVE_ALLOC. (line 6) --* multiply array elements: PRODUCT. (line 6) --* MVBITS: MVBITS. (line 6) --* Namelist: Extensions to namelist. -- (line 6) --* NEAREST: NEAREST. (line 6) --* NEW_LINE: NEW_LINE. (line 6) --* newline: NEW_LINE. (line 6) --* NINT: NINT. (line 6) --* NOT: NOT. (line 6) --* NULL: NULL. (line 6) --* OpenMP <1>: OpenMP. (line 6) --* OpenMP: Fortran Dialect Options. -- (line 109) --* operators, unary: Unary operators. (line 6) --* options, code generation: Code Gen Options. (line 6) --* options, debugging: Debugging Options. (line 6) --* options, dialect: Fortran Dialect Options. -- (line 6) --* options, directory search: Directory Options. (line 6) --* options, errors: Error and Warning Options. -- (line 6) --* options, fortran dialect: Fortran Dialect Options. -- (line 12) --* options, gfortran command: Invoking GNU Fortran. -- (line 6) --* options, linking: Link Options. (line 6) --* options, negative forms: Invoking GNU Fortran. -- (line 13) --* options, preprocessor: Preprocessing Options. -- (line 6) --* options, run-time: Code Gen Options. (line 6) --* options, runtime: Runtime Options. (line 6) --* options, warnings: Error and Warning Options. -- (line 6) --* OR: OR. (line 6) --* output, newline: NEW_LINE. (line 6) --* PACK: PACK. (line 6) --* paths, search: Directory Options. (line 14) --* PERROR: PERROR. (line 6) --* pointer, C address of pointers: C_F_PROCPOINTER. (line 6) --* pointer, C address of procedures: C_FUNLOC. (line 6) --* pointer, C association status: C_ASSOCIATED. (line 6) --* pointer, convert C to Fortran: C_F_POINTER. (line 6) --* pointer, cray <1>: MALLOC. (line 6) --* pointer, cray: FREE. (line 6) --* pointer, Cray: Cray pointers. (line 6) --* pointer, disassociated: NULL. (line 6) --* pointer, status <1>: NULL. (line 6) --* pointer, status: ASSOCIATED. (line 6) --* positive difference: DIM. (line 6) --* PRECISION: PRECISION. (line 6) --* Preprocessing: Preprocessing and conditional compilation. -- (line 6) --* preprocessing, assertation: Preprocessing Options. -- (line 114) --* preprocessing, define macros: Preprocessing Options. -- (line 153) --* preprocessing, include path: Preprocessing Options. -- (line 70) --* preprocessing, keep comments: Preprocessing Options. -- (line 123) --* preprocessing, no linemarkers: Preprocessing Options. -- (line 181) --* preprocessing, undefine macros: Preprocessing Options. -- (line 187) --* preprocessor: Preprocessing Options. -- (line 6) --* preprocessor, debugging: Preprocessing Options. -- (line 26) --* preprocessor, disable: Preprocessing Options. -- (line 13) --* preprocessor, enable: Preprocessing Options. -- (line 13) --* preprocessor, include file handling: Preprocessing and conditional compilation. -- (line 6) --* preprocessor, working directory: Preprocessing Options. -- (line 55) --* PRESENT: PRESENT. (line 6) --* private: Fortran Dialect Options. -- (line 71) --* procedure pointer, convert C to Fortran: C_LOC. (line 6) --* process id: GETPID. (line 6) --* PRODUCT: PRODUCT. (line 6) --* product, double-precision: DPROD. (line 6) --* product, matrix: MATMUL. (line 6) --* product, vector: DOT_PRODUCT. (line 6) --* program termination: EXIT. (line 6) --* program termination, with core dump: ABORT. (line 6) --* PROTECTED statement: Fortran 2003 status. (line 37) --* RADIX: RADIX. (line 6) --* RAN: RAN. (line 6) --* RAND: RAND. (line 6) --* random number generation <1>: RANDOM_NUMBER. (line 6) --* random number generation <2>: RAND. (line 6) --* random number generation <3>: RAN. (line 6) --* random number generation: IRAND. (line 6) --* random number generation, seeding <1>: SRAND. (line 6) --* random number generation, seeding: RANDOM_SEED. (line 6) --* RANDOM_NUMBER: RANDOM_NUMBER. (line 6) --* RANDOM_SEED: RANDOM_SEED. (line 6) --* RANGE: RANGE. (line 6) --* range checking: Code Gen Options. (line 130) --* read character, stream mode <1>: FGETC. (line 6) --* read character, stream mode: FGET. (line 6) --* REAL: REAL. (line 6) --* real kind: SELECTED_REAL_KIND. (line 6) --* real number, exponent: EXPONENT. (line 6) --* real number, fraction: FRACTION. (line 6) --* real number, nearest different: NEAREST. (line 6) --* real number, relative spacing <1>: SPACING. (line 6) --* real number, relative spacing: RRSPACING. (line 6) --* real number, scale: SCALE. (line 6) --* real number, set exponent: SET_EXPONENT. (line 6) --* REALPART: REAL. (line 6) --* RECORD: STRUCTURE and RECORD. -- (line 6) --* remainder: MOD. (line 6) --* RENAME: RENAME. (line 6) --* repacking arrays: Code Gen Options. (line 190) --* REPEAT: REPEAT. (line 6) --* RESHAPE: RESHAPE. (line 6) --* root: SQRT. (line 6) --* rounding, ceiling <1>: CEILING. (line 6) --* rounding, ceiling: ANINT. (line 6) --* rounding, floor <1>: FLOOR. (line 6) --* rounding, floor: AINT. (line 6) --* rounding, nearest whole number: NINT. (line 6) --* RRSPACING: RRSPACING. (line 6) --* RSHIFT: RSHIFT. (line 6) --* SAVE statement: Code Gen Options. (line 15) --* SCALE: SCALE. (line 6) --* SCAN: SCAN. (line 6) --* search path: Directory Options. (line 6) --* search paths, for included files: Directory Options. (line 14) --* SECNDS: SECNDS. (line 6) --* SECOND: SECOND. (line 6) --* seeding a random number generator <1>: SRAND. (line 6) --* seeding a random number generator: RANDOM_SEED. (line 6) --* SELECTED_CHAR_KIND: SELECTED_CHAR_KIND. (line 6) --* SELECTED_INT_KIND: SELECTED_INT_KIND. (line 6) --* SELECTED_REAL_KIND: SELECTED_REAL_KIND. (line 6) --* SET_EXPONENT: SET_EXPONENT. (line 6) --* SHAPE: SHAPE. (line 6) --* SHORT: INT2. (line 6) --* SIGN: SIGN. (line 6) --* sign copying: SIGN. (line 6) --* SIGNAL: SIGNAL. (line 6) --* SIN: SIN. (line 6) --* sine: SIN. (line 6) --* sine, hyperbolic: SINH. (line 6) --* sine, hyperbolic, inverse: ASINH. (line 6) --* sine, inverse: ASIN. (line 6) --* SINH: SINH. (line 6) --* SIZE: SIZE. (line 6) --* size of a variable, in bits: BIT_SIZE. (line 6) --* size of an expression <1>: SIZEOF. (line 6) --* size of an expression: C_SIZEOF. (line 6) --* SIZEOF: SIZEOF. (line 6) --* SLEEP: SLEEP. (line 6) --* SNGL: SNGL. (line 6) --* SPACING: SPACING. (line 6) --* SPREAD: SPREAD. (line 6) --* SQRT: SQRT. (line 6) --* square-root: SQRT. (line 6) --* SRAND: SRAND. (line 6) --* Standards: Standards. (line 6) --* STAT: STAT. (line 6) --* statement, ENUM: Fortran 2003 status. (line 20) --* statement, ENUMERATOR: Fortran 2003 status. (line 20) --* statement, FLUSH: Fortran 2003 status. (line 16) --* statement, IMPORT: Fortran 2003 status. (line 43) --* statement, ISO_FORTRAN_ENV: Fortran 2003 status. (line 46) --* statement, PROTECTED: Fortran 2003 status. (line 37) --* statement, SAVE: Code Gen Options. (line 15) --* statement, USE, INTRINSIC: Fortran 2003 status. (line 46) --* statement, VALUE: Fortran 2003 status. (line 39) --* statement, VOLATILE: Fortran 2003 status. (line 41) --* STREAM I/O: Fortran 2003 status. (line 32) --* stream mode, read character <1>: FGETC. (line 6) --* stream mode, read character: FGET. (line 6) --* stream mode, write character <1>: FPUTC. (line 6) --* stream mode, write character: FPUT. (line 6) --* string, adjust left: ADJUSTL. (line 6) --* string, adjust right: ADJUSTR. (line 6) --* string, comparison <1>: LLT. (line 6) --* string, comparison <2>: LLE. (line 6) --* string, comparison <3>: LGT. (line 6) --* string, comparison: LGE. (line 6) --* string, concatenate: REPEAT. (line 6) --* string, find missing set: VERIFY. (line 6) --* string, find non-blank character: LNBLNK. (line 6) --* string, find subset: SCAN. (line 6) --* string, find substring: INDEX intrinsic. (line 6) --* string, length: LEN. (line 6) --* string, length, without trailing whitespace: LEN_TRIM. (line 6) --* string, remove trailing whitespace: TRIM. (line 6) --* string, repeat: REPEAT. (line 6) --* STRUCTURE: STRUCTURE and RECORD. -- (line 6) --* structure packing: Code Gen Options. (line 184) --* subscript checking: Code Gen Options. (line 130) --* substring position: INDEX intrinsic. (line 6) --* SUM: SUM. (line 6) --* sum array elements: SUM. (line 6) --* suppressing warnings: Error and Warning Options. -- (line 6) --* symbol names: Fortran Dialect Options. -- (line 56) --* symbol names, transforming: Code Gen Options. (line 54) --* symbol names, underscores: Code Gen Options. (line 54) --* SYMLNK: SYMLNK. (line 6) --* syntax checking: Error and Warning Options. -- (line 33) --* SYSTEM: SYSTEM. (line 6) --* system, error handling <1>: PERROR. (line 6) --* system, error handling <2>: IERRNO. (line 6) --* system, error handling: GERROR. (line 6) --* system, group id: GETGID. (line 6) --* system, host name: HOSTNM. (line 6) --* system, login name: GETLOG. (line 6) --* system, process id: GETPID. (line 6) --* system, signal handling: SIGNAL. (line 6) --* system, system call: SYSTEM. (line 6) --* system, terminal <1>: TTYNAM. (line 6) --* system, terminal: ISATTY. (line 6) --* system, user id: GETUID. (line 6) --* system, working directory <1>: GETCWD. (line 6) --* system, working directory: CHDIR. (line 6) --* SYSTEM_CLOCK: SYSTEM_CLOCK. (line 6) --* tabulators: Error and Warning Options. -- (line 140) --* TAN: TAN. (line 6) --* tangent: TAN. (line 6) --* tangent, hyperbolic: TANH. (line 6) --* tangent, hyperbolic, inverse: ATANH. (line 6) --* tangent, inverse <1>: ATAN2. (line 6) --* tangent, inverse: ATAN. (line 6) --* TANH: TANH. (line 6) --* terminate program: EXIT. (line 6) --* terminate program, with core dump: ABORT. (line 6) --* TIME: TIME. (line 6) --* time, clock ticks <1>: SYSTEM_CLOCK. (line 6) --* time, clock ticks <2>: MCLOCK8. (line 6) --* time, clock ticks: MCLOCK. (line 6) --* time, conversion to GMT info: GMTIME. (line 6) --* time, conversion to local time info: LTIME. (line 6) --* time, conversion to string: CTIME. (line 6) --* time, current <1>: TIME8. (line 6) --* time, current <2>: TIME. (line 6) --* time, current <3>: ITIME. (line 6) --* time, current <4>: FDATE. (line 6) --* time, current: DATE_AND_TIME. (line 6) --* time, elapsed <1>: SECOND. (line 6) --* time, elapsed <2>: SECNDS. (line 6) --* time, elapsed <3>: ETIME. (line 6) --* time, elapsed <4>: DTIME. (line 6) --* time, elapsed: CPU_TIME. (line 6) --* TIME8: TIME8. (line 6) --* TINY: TINY. (line 6) --* TR 15581: Fortran 2003 status. (line 25) --* trace: Debugging Options. (line 31) --* TRAILZ: TRAILZ. (line 6) --* TRANSFER: TRANSFER. (line 6) --* transforming symbol names: Code Gen Options. (line 54) --* transpose: TRANSPOSE. (line 6) --* TRANSPOSE: TRANSPOSE. (line 6) --* trigonometric function, cosine: COS. (line 6) --* trigonometric function, cosine, inverse: ACOS. (line 6) --* trigonometric function, sine: SIN. (line 6) --* trigonometric function, sine, inverse: ASIN. (line 6) --* trigonometric function, tangent: TAN. (line 6) --* trigonometric function, tangent, inverse <1>: ATAN2. (line 6) --* trigonometric function, tangent, inverse: ATAN. (line 6) --* TRIM: TRIM. (line 6) --* TTYNAM: TTYNAM. (line 6) --* type cast: TRANSFER. (line 6) --* UBOUND: UBOUND. (line 6) --* UMASK: UMASK. (line 6) --* underflow: Error and Warning Options. -- (line 148) --* underscore: Code Gen Options. (line 54) --* UNLINK: UNLINK. (line 6) --* UNPACK: UNPACK. (line 6) --* unused parameter: Error and Warning Options. -- (line 158) --* USE, INTRINSIC statement: Fortran 2003 status. (line 46) --* user id: GETUID. (line 6) --* VALUE statement: Fortran 2003 status. (line 39) --* vector product: DOT_PRODUCT. (line 6) --* VERIFY: VERIFY. (line 6) --* VOLATILE statement: Fortran 2003 status. (line 41) --* warnings, aliasing: Error and Warning Options. -- (line 68) --* warnings, alignment of COMMON blocks: Error and Warning Options. -- (line 165) --* warnings, all: Error and Warning Options. -- (line 61) --* warnings, ampersand: Error and Warning Options. -- (line 85) --* warnings, array temporaries: Error and Warning Options. -- (line 93) --* warnings, character truncation: Error and Warning Options. -- (line 98) --* warnings, conversion: Error and Warning Options. -- (line 104) --* warnings, implicit interface: Error and Warning Options. -- (line 107) --* warnings, intrinsic: Error and Warning Options. -- (line 152) --* warnings, intrinsics of other standards: Error and Warning Options. -- (line 113) --* warnings, line truncation: Error and Warning Options. -- (line 101) --* warnings, non-standard intrinsics: Error and Warning Options. -- (line 113) --* warnings, suppressing: Error and Warning Options. -- (line 6) --* warnings, suspicious code: Error and Warning Options. -- (line 120) --* warnings, tabs: Error and Warning Options. -- (line 140) --* warnings, to errors: Error and Warning Options. -- (line 171) --* warnings, underflow: Error and Warning Options. -- (line 148) --* warnings, unused parameter: Error and Warning Options. -- (line 158) --* write character, stream mode <1>: FPUTC. (line 6) --* write character, stream mode: FPUT. (line 6) --* XOR: XOR. (line 6) --* ZABS: ABS. (line 6) --* ZCOS: COS. (line 6) --* zero bits <1>: TRAILZ. (line 6) --* zero bits: LEADZ. (line 6) --* ZEXP: EXP. (line 6) --* ZLOG: LOG. (line 6) --* ZSIN: SIN. (line 6) --* ZSQRT: SQRT. (line 6) -- -- -- --Tag Table: --Node: Top1990 --Node: Introduction3305 --Node: About GNU Fortran4052 --Node: GNU Fortran and GCC8080 --Node: Preprocessing and conditional compilation10192 --Node: GNU Fortran and G7711833 --Node: Project Status12406 --Node: Standards14921 --Node: Invoking GNU Fortran16132 --Node: Option Summary17855 --Node: Fortran Dialect Options21343 --Node: Preprocessing Options28153 --Node: Error and Warning Options36279 --Node: Debugging Options43706 --Node: Directory Options45869 --Node: Link Options47384 --Node: Runtime Options48008 --Node: Code Gen Options50088 --Node: Environment Variables62313 --Node: Runtime62918 --Node: GFORTRAN_STDIN_UNIT64146 --Node: GFORTRAN_STDOUT_UNIT64513 --Node: GFORTRAN_STDERR_UNIT64914 --Node: GFORTRAN_USE_STDERR65312 --Node: GFORTRAN_TMPDIR65757 --Node: GFORTRAN_UNBUFFERED_ALL66198 --Node: GFORTRAN_UNBUFFERED_PRECONNECTED66721 --Node: GFORTRAN_SHOW_LOCUS67363 --Node: GFORTRAN_OPTIONAL_PLUS67857 --Node: GFORTRAN_DEFAULT_RECL68332 --Node: GFORTRAN_LIST_SEPARATOR68823 --Node: GFORTRAN_CONVERT_UNIT69432 --Node: GFORTRAN_ERROR_DUMPCORE72294 --Node: GFORTRAN_ERROR_BACKTRACE72841 --Node: Fortran 2003 and 2008 status73392 --Node: Fortran 2003 status73632 --Node: Fortran 2008 status75323 --Node: Compiler Characteristics76292 --Node: KIND Type Parameters76630 --Node: Extensions77557 --Node: Extensions implemented in GNU Fortran78156 --Node: Old-style kind specifications79490 --Node: Old-style variable initialization80596 --Node: Extensions to namelist81908 --Node: X format descriptor without count field83904 --Node: Commas in FORMAT specifications84431 --Node: Missing period in FORMAT specifications84948 --Node: I/O item lists85510 --Node: BOZ literal constants85899 --Node: Real array indices88468 --Node: Unary operators88765 --Node: Implicitly convert LOGICAL and INTEGER values89179 --Node: Hollerith constants support90139 --Node: Cray pointers91911 --Node: CONVERT specifier97321 --Node: OpenMP99319 --Node: Argument list functions101574 --Node: Extensions not implemented in GNU Fortran103168 --Node: STRUCTURE and RECORD104020 --Node: ENCODE and DECODE statements106076 --Node: Intrinsic Procedures107394 --Node: Introduction to Intrinsics121084 --Node: ABORT123436 --Node: ABS124193 --Node: ACCESS125695 --Node: ACHAR127616 --Node: ACOS128817 --Node: ACOSH129815 --Node: ADJUSTL130692 --Node: ADJUSTR131633 --Node: AIMAG132580 --Node: AINT133900 --Node: ALARM135372 --Node: ALL137006 --Node: ALLOCATED138924 --Node: AND139805 --Node: ANINT141102 --Node: ANY142465 --Node: ASIN144395 --Node: ASINH145407 --Node: ASSOCIATED146289 --Node: ATAN149294 --Node: ATAN2150183 --Node: ATANH151527 --Node: BESSEL_J0152407 --Node: BESSEL_J1153451 --Node: BESSEL_JN154503 --Node: BESSEL_Y0155670 --Node: BESSEL_Y1156670 --Node: BESSEL_YN157670 --Node: BIT_SIZE158887 --Node: BTEST159716 --Node: C_ASSOCIATED160604 --Node: C_FUNLOC161813 --Node: C_F_PROCPOINTER163182 --Node: C_F_POINTER164811 --Node: C_LOC166229 --Node: C_SIZEOF167346 --Node: CEILING168699 --Node: CHAR169704 --Node: CHDIR170768 --Node: CHMOD171936 --Node: CMPLX173731 --Node: COMMAND_ARGUMENT_COUNT175195 --Node: COMPLEX176102 --Node: CONJG177245 --Node: COS178255 --Node: COSH179526 --Node: COUNT180495 --Node: CPU_TIME182351 --Node: CSHIFT183705 --Node: CTIME185361 --Node: DATE_AND_TIME186620 --Node: DBLE189081 --Node: DCMPLX189905 --Node: DFLOAT191099 --Node: DIGITS191793 --Node: DIM192759 --Node: DOT_PRODUCT193902 --Node: DPROD195558 --Node: DREAL196284 --Node: DTIME196948 --Node: EOSHIFT199754 --Node: EPSILON201827 --Node: ERF202553 --Node: ERFC203327 --Node: ERFC_SCALED204131 --Node: ETIME204823 --Node: EXIT207054 --Node: EXP207913 --Node: EXPONENT209071 --Node: FDATE209821 --Node: FLOAT211096 --Node: FGET211810 --Node: FGETC213604 --Node: FLOOR215372 --Node: FLUSH216356 --Node: FNUM216994 --Node: FPUT217716 --Node: FPUTC219317 --Node: FRACTION221057 --Node: FREE221958 --Node: FSEEK222795 --Node: FSTAT225089 --Node: FTELL226129 --Node: GAMMA227107 --Node: GERROR228148 --Node: GETARG228867 --Node: GET_COMMAND230631 --Node: GET_COMMAND_ARGUMENT231577 --Node: GETCWD233545 --Node: GETENV234491 --Node: GET_ENVIRONMENT_VARIABLE235713 --Node: GETGID237413 --Node: GETLOG237948 --Node: GETPID238806 --Node: GETUID239534 --Node: GMTIME240048 --Node: HOSTNM241537 --Node: HUGE242453 --Node: HYPOT243172 --Node: IACHAR243992 --Node: IAND245172 --Node: IARGC246159 --Node: IBCLR247182 --Node: IBITS247843 --Node: IBSET248758 --Node: ICHAR249414 --Node: IDATE251395 --Node: IEOR252422 --Node: IERRNO253298 --Node: INDEX intrinsic253853 --Node: INT255199 --Node: INT2256786 --Node: INT8257551 --Node: IOR258263 --Node: IRAND259113 --Node: IS_IOSTAT_END260465 --Node: IS_IOSTAT_EOR261560 --Node: ISATTY262685 --Node: ISHFT263468 --Node: ISHFTC264448 --Node: ISNAN265664 --Node: ITIME266412 --Node: KILL267437 --Node: KIND268310 --Node: LBOUND269155 --Node: LEADZ270467 --Node: LEN271271 --Node: LEN_TRIM272362 --Node: LGE273350 --Node: LGT274663 --Node: LINK275940 --Node: LLE276975 --Node: LLT278279 --Node: LNBLNK279549 --Node: LOC280325 --Node: LOG281056 --Node: LOG10282347 --Node: LOG_GAMMA283319 --Node: LOGICAL284407 --Node: LONG285211 --Node: LSHIFT285967 --Node: LSTAT286921 --Node: LTIME288075 --Node: MALLOC289490 --Node: MATMUL290950 --Node: MAX292040 --Node: MAXEXPONENT293539 --Node: MAXLOC294355 --Node: MAXVAL296404 --Node: MCLOCK298067 --Node: MCLOCK8299070 --Node: MERGE300284 --Node: MIN301026 --Node: MINEXPONENT302522 --Node: MINLOC303152 --Node: MINVAL305201 --Node: MOD306883 --Node: MODULO308375 --Node: MOVE_ALLOC309589 --Node: MVBITS310613 --Node: NEAREST311672 --Node: NEW_LINE312795 --Node: NINT313566 --Node: NOT314834 --Node: NULL315417 --Node: OR316315 --Node: PACK317593 --Node: PERROR319585 --Node: PRECISION320207 --Node: PRESENT321033 --Node: PRODUCT322139 --Node: RADIX323664 --Node: RAN324441 --Node: RAND324897 --Node: RANDOM_NUMBER326232 --Node: RANDOM_SEED327950 --Node: RANGE329833 --Node: REAL330457 --Node: RENAME331899 --Node: REPEAT332918 --Node: RESHAPE333644 --Node: RRSPACING335113 --Node: RSHIFT335806 --Node: SCALE336768 --Node: SCAN337542 --Node: SECNDS339092 --Node: SECOND340180 --Node: SELECTED_CHAR_KIND341056 --Node: SELECTED_INT_KIND342053 --Node: SELECTED_REAL_KIND343228 --Node: SET_EXPONENT345167 --Node: SHAPE346163 --Node: SIGN347276 --Node: SIGNAL348359 --Node: SIN349856 --Node: SINH350898 --Node: SIZE351710 --Node: SIZEOF353018 --Node: SLEEP354312 --Node: SNGL354869 --Node: SPACING355540 --Node: SPREAD356552 --Node: SQRT357697 --Node: SRAND358936 --Node: STAT360104 --Node: SUM363216 --Node: SYMLNK364685 --Node: SYSTEM365817 --Node: SYSTEM_CLOCK366765 --Node: TAN368109 --Node: TANH368945 --Node: TIME369812 --Node: TIME8370916 --Node: TINY372053 --Node: TRAILZ372653 --Node: TRANSFER373438 --Node: TRANSPOSE375472 --Node: TRIM376159 --Node: TTYNAM377016 --Node: UBOUND377931 --Node: UMASK379300 --Node: UNLINK379855 --Node: UNPACK380832 --Node: VERIFY382120 --Node: XOR383836 --Node: Intrinsic Modules385144 --Node: Contributing390935 --Node: Contributors391787 --Node: Projects393410 --Node: Proposed Extensions394213 --Node: Copying396264 --Node: GNU Free Documentation License433828 --Node: Funding456240 --Node: Option Index458765 --Node: Keyword Index470647 -- --End Tag Table diff -Nur a/gcc/function.c b/gcc/function.c --- a/gcc/function.c 2009-07-11 21:06:26.000000000 +0200 +++ b/gcc/function.c 2010-01-25 09:50:29.135686643 +0100 |