8253 lines
199 KiB
Plaintext
8253 lines
199 KiB
Plaintext
@ignore
|
|
Copyright (C) 2005, 2006
|
|
Free Software Foundation, Inc.
|
|
This is part of the GNU Fortran manual.
|
|
For copying conditions, see the file gfortran.texi.
|
|
|
|
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 ``GNU General Public License'' and ``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 gfdl(7) man page.
|
|
|
|
|
|
Some basic guidelines for editing this document:
|
|
|
|
(1) The intrinsic procedures are to be listed in alphabetical order.
|
|
(2) The generic name is to be use.
|
|
(3) The specific names are included in the function index and in a
|
|
table at the end of the node (See ABS entry).
|
|
(4) Try to maintain the same style for each entry.
|
|
|
|
|
|
@end ignore
|
|
|
|
@tex
|
|
\gdef\acos{\mathop{\rm acos}\nolimits}
|
|
\gdef\asin{\mathop{\rm asin}\nolimits}
|
|
\gdef\atan{\mathop{\rm atan}\nolimits}
|
|
\gdef\acosh{\mathop{\rm acosh}\nolimits}
|
|
\gdef\asinh{\mathop{\rm asinh}\nolimits}
|
|
\gdef\atanh{\mathop{\rm atanh}\nolimits}
|
|
@end tex
|
|
|
|
|
|
@node Intrinsic Procedures
|
|
@chapter Intrinsic Procedures
|
|
@cindex Intrinsic Procedures
|
|
|
|
This portion of the document is incomplete and undergoing massive expansion
|
|
and editing. All contributions and corrections are strongly encouraged.
|
|
|
|
Implemented intrinsics are fully functional and available to the user to apply.
|
|
Some intrinsics have documentation yet to be completed as indicated by 'documentation pending'.
|
|
|
|
@comment Missing intrinsics (double check with #19292)
|
|
@comment - MClock
|
|
@comment - Short
|
|
|
|
@menu
|
|
* Introduction: Introduction
|
|
* @code{ABORT}: ABORT, Abort the program
|
|
* @code{ABS}: ABS, Absolute value
|
|
* @code{ACCESS}: ACCESS, Checks file access modes
|
|
* @code{ACHAR}: ACHAR, Character in @acronym{ASCII} collating sequence
|
|
* @code{ACOS}: ACOS, Arccosine function
|
|
* @code{ACOSH}: ACOSH, Hyperbolic arccosine function
|
|
* @code{ADJUSTL}: ADJUSTL, Left adjust a string
|
|
* @code{ADJUSTR}: ADJUSTR, Right adjust a string
|
|
* @code{AIMAG}: AIMAG, Imaginary part of complex number
|
|
* @code{AINT}: AINT, Truncate to a whole number
|
|
* @code{ALARM}: ALARM, Set an alarm clock
|
|
* @code{ALL}: ALL, Determine if all values are true
|
|
* @code{ALLOCATED}: ALLOCATED, Status of allocatable entity
|
|
* @code{AND}: AND, Bitwise logical AND
|
|
* @code{ANINT}: ANINT, Nearest whole number
|
|
* @code{ANY}: ANY, Determine if any values are true
|
|
* @code{ASIN}: ASIN, Arcsine function
|
|
* @code{ASINH}: ASINH, Hyperbolic arcsine function
|
|
* @code{ASSOCIATED}: ASSOCIATED, Status of a pointer or pointer/target pair
|
|
* @code{ATAN}: ATAN, Arctangent function
|
|
* @code{ATAN2}: ATAN2, Arctangent function
|
|
* @code{ATANH}: ATANH, Hyperbolic arctangent function
|
|
* @code{BESJ0}: BESJ0, Bessel function of the first kind of order 0
|
|
* @code{BESJ1}: BESJ1, Bessel function of the first kind of order 1
|
|
* @code{BESJN}: BESJN, Bessel function of the first kind
|
|
* @code{BESY0}: BESY0, Bessel function of the second kind of order 0
|
|
* @code{BESY1}: BESY1, Bessel function of the second kind of order 1
|
|
* @code{BESYN}: BESYN, Bessel function of the second kind
|
|
* @code{BIT_SIZE}: BIT_SIZE, Bit size inquiry function
|
|
* @code{BTEST}: BTEST, Bit test function
|
|
* @code{CEILING}: CEILING, Integer ceiling function
|
|
* @code{CHAR}: CHAR, Integer-to-character conversion function
|
|
* @code{CHDIR}: CHDIR, Change working directory
|
|
* @code{CHMOD}: CHMOD, Change access permissions of files
|
|
* @code{CMPLX}: CMPLX, Complex conversion function
|
|
* @code{COMMAND_ARGUMENT_COUNT}: COMMAND_ARGUMENT_COUNT, Get number of command line arguments
|
|
* @code{CONJG}: CONJG, Complex conjugate function
|
|
* @code{COS}: COS, Cosine function
|
|
* @code{COSH}: COSH, Hyperbolic cosine function
|
|
* @code{COUNT}: COUNT, Count occurrences of TRUE in an array
|
|
* @code{CPU_TIME}: CPU_TIME, CPU time subroutine
|
|
* @code{CSHIFT}: CSHIFT, Circular array shift function
|
|
* @code{CTIME}: CTIME, Subroutine (or function) to convert a time into a string
|
|
* @code{DATE_AND_TIME}: DATE_AND_TIME, Date and time subroutine
|
|
* @code{DBLE}: DBLE, Double precision conversion function
|
|
* @code{DCMPLX}: DCMPLX, Double complex conversion function
|
|
* @code{DFLOAT}: DFLOAT, Double precision conversion function
|
|
* @code{DIGITS}: DIGITS, Significant digits function
|
|
* @code{DIM}: DIM, Dim function
|
|
* @code{DOT_PRODUCT}: DOT_PRODUCT, Dot product function
|
|
* @code{DPROD}: DPROD, Double product function
|
|
* @code{DREAL}: DREAL, Double real part function
|
|
* @code{DTIME}: DTIME, Execution time subroutine (or function)
|
|
* @code{EOSHIFT}: EOSHIFT, End-off shift function
|
|
* @code{EPSILON}: EPSILON, Epsilon function
|
|
* @code{ERF}: ERF, Error function
|
|
* @code{ERFC}: ERFC, Complementary error function
|
|
* @code{ETIME}: ETIME, Execution time subroutine (or function)
|
|
* @code{EXIT}: EXIT, Exit the program with status.
|
|
* @code{EXP}: EXP, Exponential function
|
|
* @code{EXPONENT}: EXPONENT, Exponent function
|
|
* @code{FDATE}: FDATE, Subroutine (or function) to get the current time as a string
|
|
* @code{FGET}: FGET, Read a single character in stream mode from stdin
|
|
* @code{FGETC}: FGETC, Read a single character in stream mode
|
|
* @code{FLOAT}: FLOAT, Convert integer to default real
|
|
* @code{FLOOR}: FLOOR, Integer floor function
|
|
* @code{FLUSH}: FLUSH, Flush I/O unit(s)
|
|
* @code{FNUM}: FNUM, File number function
|
|
* @code{FPUT}: FPUT, Write a single character in stream mode to stdout
|
|
* @code{FPUTC}: FPUTC, Write a single character in stream mode
|
|
* @code{FRACTION}: FRACTION, Fractional part of the model representation
|
|
* @code{FREE}: FREE, Memory de-allocation subroutine
|
|
* @code{FSEEK}: FSEEK, Low level file positioning subroutine
|
|
* @code{FSTAT}: FSTAT, Get file status
|
|
* @code{FTELL}: FTELL, Current stream position
|
|
* @code{GETARG}: GETARG, Get command line arguments
|
|
* @code{GET_COMMAND}: GET_COMMAND, Get the entire command line
|
|
* @code{GET_COMMAND_ARGUMENT}: GET_COMMAND_ARGUMENT, Get command line arguments
|
|
* @code{GETCWD}: GETCWD, Get current working directory
|
|
* @code{GETENV}: GETENV, Get an environmental variable
|
|
* @code{GET_ENVIRONMENT_VARIABLE}: GET_ENVIRONMENT_VARIABLE, Get an environmental variable
|
|
* @code{GETGID}: GETGID, Group ID function
|
|
* @code{GETLOG}: GETLOG, Get login name
|
|
* @code{GETPID}: GETPID, Process ID function
|
|
* @code{GETUID}: GETUID, User ID function
|
|
* @code{GMTIME}: GMTIME, Convert time to GMT info
|
|
* @code{HOSTNM}: HOSTNM, Get system host name
|
|
* @code{HUGE}: HUGE, Largest number of a kind
|
|
* @code{IACHAR}: IACHAR, Code in @acronym{ASCII} collating sequence
|
|
* @code{IAND}: IAND, Bitwise logical and
|
|
* @code{IARGC}: IARGC, Get the number of command line arguments
|
|
* @code{IBCLR}: IBCLR, Clear bit
|
|
* @code{IBITS}: IBITS, Bit extraction
|
|
* @code{IBSET}: IBSET, Set bit
|
|
* @code{ICHAR}: ICHAR, Character-to-integer conversion function
|
|
* @code{IDATE}: IDATE, Current local time (day/month/year)
|
|
* @code{IEOR}: IEOR, Bitwise logical exclusive or
|
|
* @code{IERRNO}: IERRNO, Function to get the last system error number
|
|
* @code{INDEX}: INDEX, Position of a substring within a string
|
|
* @code{INT}: INT, Convert to integer type
|
|
* @code{IOR}: IOR, Bitwise logical or
|
|
* @code{IRAND}: IRAND, Integer pseudo-random number
|
|
* @code{ISHFT}: ISHFT, Shift bits
|
|
* @code{ISHFTC}: ISHFTC, Shift bits circularly
|
|
* @code{ITIME}: ITIME, Current local time (hour/minutes/seconds)
|
|
* @code{KILL}: KILL, Send a signal to a process
|
|
* @code{KIND}: KIND, Kind of an entity
|
|
* @code{LBOUND}: LBOUND, Lower dimension bounds of an array
|
|
* @code{LEN}: LEN, Length of a character entity
|
|
* @code{LEN_TRIM}: LEN_TRIM, Length of a character entity without trailing blank characters
|
|
* @code{LGE}: LGE, Lexical greater than or equal
|
|
* @code{LGT}: LGT, Lexical greater than
|
|
* @code{LINK}: LINK, Create a hard link
|
|
* @code{LLE}: LLE, Lexical less than or equal
|
|
* @code{LLT}: LLT, Lexical less than
|
|
* @code{LNBLNK}: LNBLNK, Index of the last non-blank character in a string
|
|
* @code{LOC}: LOC, Returns the address of a variable
|
|
* @code{LOG}: LOG, Logarithm function
|
|
* @code{LOG10}: LOG10, Base 10 logarithm function
|
|
* @code{LOGICAL}: LOGICAL, Convert to logical type
|
|
* @code{LSHIFT}: LSHIFT, Left shift bits
|
|
* @code{LSTAT}: LSTAT, Get file status
|
|
* @code{LTIME}: LTIME, Convert time to local time info
|
|
* @code{MALLOC}: MALLOC, Dynamic memory allocation function
|
|
* @code{MATMUL}: MATMUL, matrix multiplication
|
|
* @code{MAX}: MAX, Maximum value of an argument list
|
|
* @code{MAXEXPONENT}: MAXEXPONENT, Maximum exponent of a real kind
|
|
* @code{MAXLOC}: MAXLOC, Location of the maximum value within an array
|
|
* @code{MAXVAL}: MAXVAL, Maximum value of an array
|
|
* @code{MERGE}: MERGE, Merge arrays
|
|
* @code{MIN}: MIN, Minimum value of an argument list
|
|
* @code{MINEXPONENT}: MINEXPONENT, Minimum exponent of a real kind
|
|
* @code{MINLOC}: MINLOC, Location of the minimum value within an array
|
|
* @code{MINVAL}: MINVAL, Minimum value of an array
|
|
* @code{MOD}: MOD, Remainder function
|
|
* @code{MODULO}: MODULO, Modulo function
|
|
* @code{MOVE_ALLOC}: MOVE_ALLOC, Move allocation from one object to another
|
|
* @code{MVBITS}: MVBITS, Move bits from one integer to another
|
|
* @code{NEAREST}: NEAREST, Nearest representable number
|
|
* @code{NEW_LINE}: NEW_LINE, New line character
|
|
* @code{NINT}: NINT, Nearest whole number
|
|
* @code{NOT}: NOT, Logical negation
|
|
* @code{NULL}: NULL, Function that returns an disassociated pointer
|
|
* @code{OR}: OR, Bitwise logical OR
|
|
* @code{PACK}: PACK, Pack an array into an array of rank one
|
|
* @code{PERROR}: PERROR, Print system error message
|
|
* @code{PRECISION}: PRECISION, Decimal precision of a real kind
|
|
* @code{PRESENT}: PRESENT, Determine whether an optional argument is specified
|
|
* @code{PRODUCT}: PRODUCT, Product of array elements
|
|
* @code{RADIX}: RADIX, Base of a data model
|
|
* @code{RANDOM_NUMBER}: RANDOM_NUMBER, Pseudo-random number
|
|
* @code{RANDOM_SEED}: RANDOM_SEED, Initialize a pseudo-random number sequence
|
|
* @code{RAND}: RAND, Real pseudo-random number
|
|
* @code{RANGE}: RANGE, Decimal exponent range of a real kind
|
|
* @code{RAN}: RAN, Real pseudo-random number
|
|
* @code{REAL}: REAL, Convert to real type
|
|
* @code{RENAME}: RENAME, Rename a file
|
|
* @code{REPEAT}: REPEAT, Repeated string concatenation
|
|
* @code{RESHAPE}: RESHAPE, Function to reshape an array
|
|
* @code{RRSPACING}: RRSPACING, Reciprocal of the relative spacing
|
|
* @code{RSHIFT}: RSHIFT, Right shift bits
|
|
* @code{SCALE}: SCALE, Scale a real value
|
|
* @code{SCAN}: SCAN, Scan a string for the presence of a set of characters
|
|
* @code{SECNDS}: SECNDS, Time function
|
|
@comment * @code{SECOND}: SECOND, (?)
|
|
@comment * @code{SECONDS}: SECONDS, (?)
|
|
* @code{SELECTED_INT_KIND}: SELECTED_INT_KIND, Choose integer kind
|
|
* @code{SELECTED_REAL_KIND}: SELECTED_REAL_KIND, Choose real kind
|
|
* @code{SET_EXPONENT}: SET_EXPONENT, Set the exponent of the model
|
|
* @code{SHAPE}: SHAPE, Determine the shape of an array
|
|
* @code{SIGN}: SIGN, Sign copying function
|
|
* @code{SIGNAL}: SIGNAL, Signal handling subroutine (or function)
|
|
* @code{SIN}: SIN, Sine function
|
|
* @code{SINH}: SINH, Hyperbolic sine function
|
|
* @code{SIZE}: SIZE, Function to determine the size of an array
|
|
* @code{SNGL}: SNGL, Convert double precision real to default real
|
|
* @code{SPACING}: SPACING, Smallest distance between two numbers of a given type
|
|
* @code{SPREAD}: SPREAD, Add a dimension to an array
|
|
* @code{SQRT}: SQRT, Square-root function
|
|
* @code{SRAND}: SRAND, Reinitialize the random number generator
|
|
* @code{STAT}: STAT, Get file status
|
|
* @code{SUM}: SUM, Sum of array elements
|
|
* @code{SYMLNK}: SYMLNK, Create a symbolic link
|
|
* @code{SYSTEM}: SYSTEM, Execute a shell command
|
|
* @code{SYSTEM_CLOCK}: SYSTEM_CLOCK, Time function
|
|
* @code{TAN}: TAN, Tangent function
|
|
* @code{TANH}: TANH, Hyperbolic tangent function
|
|
* @code{TIME}: TIME, Time function
|
|
* @code{TINY}: TINY, Smallest positive number of a real kind
|
|
* @code{TRANSFER}: TRANSFER, Transfer bit patterns
|
|
* @code{TRANSPOSE}: TRANSPOSE, Transpose an array of rank two
|
|
* @code{TRIM}: TRIM, Function to remove trailing blank characters of a string
|
|
* @code{UBOUND}: UBOUND, Upper dimension bounds of an array
|
|
* @code{UMASK}: UMASK, Set the file creation mask
|
|
* @code{UNLINK}: UNLINK, Remove a file from the file system
|
|
* @code{UNMASK}: UNMASK, (?)
|
|
* @code{UNPACK}: UNPACK, Unpack an array of rank one into an array
|
|
* @code{VERIFY}: VERIFY, Scan a string for the absence of a set of characters
|
|
* @code{XOR}: XOR, Bitwise logical exclusive or
|
|
@end menu
|
|
|
|
@node Introduction
|
|
@section Introduction to intrinsic procedures
|
|
|
|
GNU Fortran provides a rich set of intrinsic procedures that includes all
|
|
the intrinsic procedures required by the Fortran 95 standard, a set of
|
|
intrinsic procedures for backwards compatibility with Gnu Fortran 77
|
|
(i.e., @command{g77}), and a small selection of intrinsic procedures
|
|
from the Fortran 2003 standard. Any description here, which conflicts with a
|
|
description in either the Fortran 95 standard or the Fortran 2003 standard,
|
|
is unintentional and the standard(s) should be considered authoritative.
|
|
|
|
The enumeration of the @code{KIND} type parameter is processor defined in
|
|
the Fortran 95 standard. GNU Fortran defines the default integer type and
|
|
default real type by @code{INTEGER(KIND=4)} and @code{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 @command{gfortran}, this kind type parameter is @code{KIND=8}.
|
|
Hence, @code{REAL(KIND=8)} and @code{DOUBLE PRECISION} are equivalent.
|
|
In the description of generic intrinsic procedures, the kind type parameter
|
|
will be specified by @code{KIND=*}, and in the description of specific
|
|
names for an intrinsic procedure the kind type parameter will be explicitly
|
|
given (e.g., @code{REAL(KIND=4)} or @code{REAL(KIND=8)}). Finally, for
|
|
brevity the optional @code{KIND=} syntax will be omitted.
|
|
|
|
Many of the intrinsics 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 @option{-std=f95} and @option{-std=gnu} options,
|
|
which can be used to restrict the set of intrinsic procedures to a
|
|
given standard. By default, @command{gfortran} sets the @option{-std=gnu}
|
|
option, and so all intrinsic procedures described here are accepted. There
|
|
is one caveat. For a select group of intrinsic procedures, @command{g77}
|
|
implemented both a function and a subroutine. Both classes
|
|
have been implemented in @command{gfortran} for backwards compatibility
|
|
with @command{g77}. It is noted here that these functions and subroutines
|
|
cannot be intermixed in a given subprogram. In the descriptions that follow,
|
|
the applicable option(s) is noted.
|
|
|
|
|
|
|
|
@node ABORT
|
|
@section @code{ABORT} --- Abort the program
|
|
@findex @code{ABORT} intrinsic
|
|
@cindex abort
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ABORT} causes immediate termination of the program. On operating
|
|
systems that support a core dump, @code{ABORT} will produce a core dump,
|
|
which is suitable for debugging purposes.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL ABORT}
|
|
|
|
@item @emph{Return value}:
|
|
Does not return.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_abort
|
|
integer :: i = 1, j = 2
|
|
if (i /= j) call abort
|
|
end program test_abort
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{EXIT}, @ref{KILL}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node ABS
|
|
@section @code{ABS} --- Absolute value
|
|
@findex @code{ABS} intrinsic
|
|
@findex @code{CABS} intrinsic
|
|
@findex @code{DABS} intrinsic
|
|
@findex @code{IABS} intrinsic
|
|
@findex @code{ZABS} intrinsic
|
|
@findex @code{CDABS} intrinsic
|
|
@cindex absolute value
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ABS(X)} computes the absolute value of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later, has overloads that are GNU extensions
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ABS(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be an @code{INTEGER(*)},
|
|
@code{REAL(*)}, or @code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and
|
|
kind as the argument except the return value is @code{REAL(*)} for a
|
|
@code{COMPLEX(*)} argument.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{CABS(Z)} @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)} @tab F77 and later
|
|
@item @code{DABS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@item @code{IABS(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later
|
|
@item @code{ZABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@item @code{CDABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
@node ACCESS
|
|
@section @code{ACCESS} --- Checks file access modes
|
|
@findex @code{ACCESS}
|
|
@cindex file system functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ACCESS(NAME, MODE)} checks whether the file @var{NAME}
|
|
exists, is readable, writable or executable. Except for the
|
|
executable check, @code{ACCESS} can be replaced by
|
|
Fortran 95's @code{INQUIRE}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = ACCESS(NAME, MODE)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{NAME} @tab Scalar @code{CHARACTER} with the file name.
|
|
Tailing blank are ignored unless the character @code{achar(0)} is
|
|
present, then all characters up to and excluding @code{achar(0)} are
|
|
used as file name.
|
|
@item @var{MODE} @tab Scalar @code{CHARACTER} with the file access mode,
|
|
may be any concatenation of @code{"r"} (readable), @code{"w"} (writable)
|
|
and @code{"x"} (executable), or @code{" "} to check for existance.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Returns a scalar @code{INTEGER}, which is @code{0} if the file is
|
|
accessable in the given mode; otherwise or if an invalid argument
|
|
has been given for @code{MODE} the value @code{1} is returned.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
@node ACHAR
|
|
@section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence
|
|
@findex @code{ACHAR} intrinsic
|
|
@cindex @acronym{ASCII} collating sequence
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ACHAR(I)} returns the character located at position @code{I}
|
|
in the @acronym{ASCII} collating sequence.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = ACHAR(I)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{CHARACTER} with a length of one. The
|
|
kind type parameter is the same as @code{KIND('A')}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_achar
|
|
character c
|
|
c = achar(32)
|
|
end program test_achar
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node ACOS
|
|
@section @code{ACOS} --- Arccosine function
|
|
@findex @code{ACOS} intrinsic
|
|
@findex @code{DACOS} intrinsic
|
|
@cindex trigonometric functions (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ACOS(X)} computes the arccosine of @var{X} (inverse of @code{COS(X)}).
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ACOS(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
|
|
less than one.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{ 0 \leq \acos(x) \leq \pi}. The kind type parameter
|
|
is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_acos
|
|
real(8) :: x = 0.866_8
|
|
x = acos(x)
|
|
end program test_acos
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DACOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{COS}
|
|
|
|
@end table
|
|
|
|
|
|
@node ACOSH
|
|
@section @code{ACOSH} --- Hyperbolic arccosine function
|
|
@findex @code{ACOSH} intrinsic
|
|
@cindex hyperbolic arccosine
|
|
@cindex hyperbolic cosine (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ACOSH(X)} computes the area hyperbolic cosine of @var{X} (inverse of @code{COSH(X)}).
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ACOSH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
|
|
greater or equal to one.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{0 \leq \acosh (x) \leq \infty}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_acosh
|
|
REAL(8), DIMENSION(3) :: x = (/ 1.0, 2.0, 3.0 /)
|
|
WRITE (*,*) ACOSH(x)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{COSH}
|
|
@end table
|
|
|
|
|
|
|
|
@node ADJUSTL
|
|
@section @code{ADJUSTL} --- Left adjust a string
|
|
@findex @code{ADJUSTL} intrinsic
|
|
@cindex adjust string
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ADJUSTL(STR)} will left adjust a string by removing leading spaces.
|
|
Spaces are inserted at the end of the string as needed.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{STR = ADJUSTL(STR)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{STR} @tab The type shall be @code{CHARACTER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{CHARACTER} where leading spaces
|
|
are removed and the same number of spaces are inserted on the end
|
|
of @var{STR}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_adjustl
|
|
character(len=20) :: str = ' gfortran'
|
|
str = adjustl(str)
|
|
print *, str
|
|
end program test_adjustl
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node ADJUSTR
|
|
@section @code{ADJUSTR} --- Right adjust a string
|
|
@findex @code{ADJUSTR} intrinsic
|
|
@cindex adjust string
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ADJUSTR(STR)} will right adjust a string by removing trailing spaces.
|
|
Spaces are inserted at the start of the string as needed.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{STR = ADJUSTR(STR)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{STR} @tab The type shall be @code{CHARACTER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{CHARACTER} where trailing spaces
|
|
are removed and the same number of spaces are inserted at the start
|
|
of @var{STR}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_adjustr
|
|
character(len=20) :: str = 'gfortran'
|
|
str = adjustr(str)
|
|
print *, str
|
|
end program test_adjustr
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node AIMAG
|
|
@section @code{AIMAG} --- Imaginary part of complex number
|
|
@findex @code{AIMAG} intrinsic
|
|
@findex @code{DIMAG} intrinsic
|
|
@findex @code{IMAG} intrinsic
|
|
@findex @code{IMAGPART} intrinsic
|
|
@cindex Imaginary part
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{AIMAG(Z)} yields the imaginary part of complex argument @code{Z}.
|
|
The @code{IMAG(Z)} and @code{IMAGPART(Z)} intrinsic functions are provided
|
|
for compatibility with @command{g77}, and their use in new code is
|
|
strongly discouraged.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later, has overloads that are GNU extensions
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = AIMAG(Z)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{Z} @tab The type of the argument shall be @code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type real with the
|
|
kind type parameter of the argument.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DIMAG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{REAL(8)} @tab GNU extension
|
|
@item @code{IMAG(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab GNU extension
|
|
@item @code{IMAGPART(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node AINT
|
|
@section @code{AINT} --- Truncate to a whole number
|
|
@findex @code{AINT} intrinsic
|
|
@findex @code{DINT} intrinsic
|
|
@cindex whole number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{AINT(X [, KIND])} truncates its argument to a whole number.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = AINT(X)}
|
|
@code{X = AINT(X, KIND)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be @code{REAL(*)}.
|
|
@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
|
|
initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type real with the kind type parameter of the
|
|
argument if the optional @var{KIND} is absent; otherwise, the kind
|
|
type parameter will be given by @var{KIND}. If the magnitude of
|
|
@var{X} is less than one, then @code{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 @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node ALARM
|
|
@section @code{ALARM} --- Execute a routine after a given delay
|
|
@findex @code{ALARM} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ALARM(SECONDS, HANDLER [, STATUS])} causes external subroutine @var{HANDLER}
|
|
to be executed after a delay of @var{SECONDS} by using @code{alarm(1)} to
|
|
set up a signal and @code{signal(2)} to catch it. If @var{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.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL ALARM(SECONDS, HANDLER)}
|
|
@code{CALL ALARM(SECONDS, HANDLER, STATUS)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{SECONDS} @tab The type of the argument shall be a scalar
|
|
@code{INTEGER}. It is @code{INTENT(IN)}.
|
|
@item @var{HANDLER} @tab Signal handler (@code{INTEGER FUNCTION} or
|
|
@code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
|
|
@code{INTEGER}. It is @code{INTENT(IN)}.
|
|
@item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar
|
|
@code{INTEGER} variable. It is @code{INTENT(OUT)}.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_alarm
|
|
external handler_print
|
|
integer i
|
|
call alarm (3, handler_print, i)
|
|
print *, i
|
|
call sleep(10)
|
|
end program test_alarm
|
|
@end smallexample
|
|
This will cause the external routine @var{handler_print} to be called
|
|
after 3 seconds.
|
|
@end table
|
|
|
|
|
|
|
|
@node ALL
|
|
@section @code{ALL} --- All values in @var{MASK} along @var{DIM} are true
|
|
@findex @code{ALL} intrinsic
|
|
@cindex true values
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ALL(MASK [, DIM])} determines if all the values are true in @var{MASK}
|
|
in the array along dimension @var{DIM}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{L = ALL(MASK)}
|
|
@code{L = ALL(MASK, DIM)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
|
|
it shall not be scalar.
|
|
@item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer
|
|
with a value that lies between one and the rank of @var{MASK}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
@code{ALL(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
|
|
the kind type parameter is the same as the kind type parameter of
|
|
@var{MASK}. If @var{DIM} is present, then @code{ALL(MASK, DIM)} returns
|
|
an array with the rank of @var{MASK} minus 1. The shape is determined from
|
|
the shape of @var{MASK} where the @var{DIM} dimension is elided.
|
|
|
|
@table @asis
|
|
@item (A)
|
|
@code{ALL(MASK)} is true if all elements of @var{MASK} are true.
|
|
It also is true if @var{MASK} has zero size; otherwise, it is false.
|
|
@item (B)
|
|
If the rank of @var{MASK} is one, then @code{ALL(MASK,DIM)} is equivalent
|
|
to @code{ALL(MASK)}. If the rank is greater than one, then @code{ALL(MASK,DIM)}
|
|
is determined by applying @code{ALL} to the array sections.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node ALLOCATED
|
|
@section @code{ALLOCATED} --- Status of an allocatable entity
|
|
@findex @code{ALLOCATED} intrinsic
|
|
@cindex allocation status
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ALLOCATED(X)} checks the status of whether @var{X} is allocated.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{L = ALLOCATED(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The argument shall be an @code{ALLOCATABLE} array.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar @code{LOGICAL} with the default logical
|
|
kind type parameter. If @var{X} is allocated, @code{ALLOCATED(X)}
|
|
is @code{.TRUE.}; otherwise, it returns the @code{.TRUE.}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_allocated
|
|
integer :: i = 4
|
|
real(4), allocatable :: x(:)
|
|
if (allocated(x) .eqv. .false.) allocate(x(i))
|
|
end program test_allocated
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
@node AND
|
|
@section @code{AND} --- Bitwise logical AND
|
|
@findex @code{AND} intrinsic
|
|
@cindex bit operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Bitwise logical @code{AND}.
|
|
|
|
This intrinsic routine is provided for backwards compatibility with
|
|
GNU Fortran 77. For integer arguments, programmers should consider
|
|
the use of the @ref{IAND} intrinsic defined by the Fortran standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{RESULT = AND(X, Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return type is either @code{INTEGER(*)} or @code{LOGICAL} after
|
|
cross-promotion of the arguments.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
F95 elemental function: @ref{IAND}
|
|
@end table
|
|
|
|
|
|
|
|
@node ANINT
|
|
@section @code{ANINT} --- Nearest whole number
|
|
@findex @code{ANINT} intrinsic
|
|
@findex @code{DNINT} intrinsic
|
|
@cindex whole number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ANINT(X [, KIND])} rounds its argument to the nearest whole number.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ANINT(X)}
|
|
@code{X = ANINT(X, KIND)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be @code{REAL(*)}.
|
|
@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
|
|
initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type real with the kind type parameter of the
|
|
argument if the optional @var{KIND} is absent; otherwise, the kind
|
|
type parameter will be given by @var{KIND}. If @var{X} is greater than
|
|
zero, then @code{ANINT(X)} returns @code{AINT(X+0.5)}. If @var{X} is
|
|
less than or equal to zero, then it returns @code{AINT(X-0.5)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DNINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node ANY
|
|
@section @code{ANY} --- Any value in @var{MASK} along @var{DIM} is true
|
|
@findex @code{ANY} intrinsic
|
|
@cindex true values
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ANY(MASK [, DIM])} determines if any of the values in the logical array
|
|
@var{MASK} along dimension @var{DIM} are @code{.TRUE.}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{L = ANY(MASK)}
|
|
@code{L = ANY(MASK, DIM)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
|
|
it shall not be scalar.
|
|
@item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer
|
|
with a value that lies between one and the rank of @var{MASK}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
@code{ANY(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
|
|
the kind type parameter is the same as the kind type parameter of
|
|
@var{MASK}. If @var{DIM} is present, then @code{ANY(MASK, DIM)} returns
|
|
an array with the rank of @var{MASK} minus 1. The shape is determined from
|
|
the shape of @var{MASK} where the @var{DIM} dimension is elided.
|
|
|
|
@table @asis
|
|
@item (A)
|
|
@code{ANY(MASK)} is true if any element of @var{MASK} is true;
|
|
otherwise, it is false. It also is false if @var{MASK} has zero size.
|
|
@item (B)
|
|
If the rank of @var{MASK} is one, then @code{ANY(MASK,DIM)} is equivalent
|
|
to @code{ANY(MASK)}. If the rank is greater than one, then @code{ANY(MASK,DIM)}
|
|
is determined by applying @code{ANY} to the array sections.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node ASIN
|
|
@section @code{ASIN} --- Arcsine function
|
|
@findex @code{ASIN} intrinsic
|
|
@findex @code{DASIN} intrinsic
|
|
@cindex trigonometric functions (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ASIN(X)} computes the arcsine of its @var{X} (inverse of @code{SIN(X)}).
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ASIN(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and a magnitude that is
|
|
less than one.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{-\pi / 2 \leq \asin (x) \leq \pi / 2}. The kind type
|
|
parameter is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_asin
|
|
real(8) :: x = 0.866_8
|
|
x = asin(x)
|
|
end program test_asin
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DASIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{SIN}
|
|
|
|
@end table
|
|
|
|
|
|
@node ASINH
|
|
@section @code{ASINH} --- Hyperbolic arcsine function
|
|
@findex @code{ASINH} intrinsic
|
|
@cindex hyperbolic arcsine
|
|
@cindex hyperbolic sine (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ASINH(X)} computes the area hyperbolic sine of @var{X} (inverse of @code{SINH(X)}).
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ASINH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, with @var{X} a real number.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{-\infty \leq \asinh (x) \leq \infty}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_asinh
|
|
REAL(8), DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
|
|
WRITE (*,*) ASINH(x)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{SINH}
|
|
@end table
|
|
|
|
|
|
|
|
@node ASSOCIATED
|
|
@section @code{ASSOCIATED} --- Status of a pointer or pointer/target pair
|
|
@findex @code{ASSOCIATED} intrinsic
|
|
@cindex pointer status
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ASSOCIATED(PTR [, TGT])} determines the status of the pointer @var{PTR}
|
|
or if @var{PTR} is associated with the target @var{TGT}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{L = ASSOCIATED(PTR)}
|
|
@code{L = ASSOCIATED(PTR [, TGT])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{PTR} @tab @var{PTR} shall have the @code{POINTER} attribute and
|
|
it can be of any type.
|
|
@item @var{TGT} @tab (Optional) @var{TGT} shall be a @code{POINTER} or
|
|
a @code{TARGET}. It must have the same type, kind type parameter, and
|
|
array rank as @var{PTR}.
|
|
@end multitable
|
|
The status of neither @var{PTR} nor @var{TGT} can be undefined.
|
|
|
|
@item @emph{Return value}:
|
|
@code{ASSOCIATED(PTR)} returns a scalar value of type @code{LOGICAL(4)}.
|
|
There are several cases:
|
|
@table @asis
|
|
@item (A) If the optional @var{TGT} is not present, then @code{ASSOCIATED(PTR)}
|
|
is true if @var{PTR} is associated with a target; otherwise, it returns false.
|
|
@item (B) If @var{TGT} is present and a scalar target, the result is true if
|
|
@var{TGT}
|
|
is not a 0 sized storage sequence and the target associated with @var{PTR}
|
|
occupies the same storage units. If @var{PTR} is disassociated, then the
|
|
result is false.
|
|
@item (C) If @var{TGT} is present and an array target, the result is true if
|
|
@var{TGT} and @var{PTR} have the same shape, are not 0 sized arrays, are
|
|
arrays whose elements are not 0 sized storage sequences, and @var{TGT} and
|
|
@var{PTR} occupy the same storage units in array element order.
|
|
As in case(B), the result is false, if @var{PTR} is disassociated.
|
|
@item (D) If @var{TGT} is present and an scalar pointer, the result is true if
|
|
target associated with @var{PTR} and the target associated with @var{TGT}
|
|
are not 0 sized storage sequences and occupy the same storage units.
|
|
The result is false, if either @var{TGT} or @var{PTR} is disassociated.
|
|
@item (E) If @var{TGT} is present and an array pointer, the result is true if
|
|
target associated with @var{PTR} and the target associated with @var{TGT}
|
|
have the same shape, are not 0 sized arrays, are arrays whose elements are
|
|
not 0 sized storage sequences, and @var{TGT} and @var{PTR} occupy the same
|
|
storage units in array element order.
|
|
The result is false, if either @var{TGT} or @var{PTR} is disassociated.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{NULL}
|
|
@end table
|
|
|
|
|
|
|
|
@node ATAN
|
|
@section @code{ATAN} --- Arctangent function
|
|
@findex @code{ATAN} intrinsic
|
|
@findex @code{DATAN} intrinsic
|
|
@cindex trigonometric functions (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ATAN(X)} computes the arctangent of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ATAN(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{ - \pi / 2 \leq \atan (x) \leq \pi / 2}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_atan
|
|
real(8) :: x = 2.866_8
|
|
x = atan(x)
|
|
end program test_atan
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DATAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{TAN}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node ATAN2
|
|
@section @code{ATAN2} --- Arctangent function
|
|
@findex @code{ATAN2} intrinsic
|
|
@findex @code{DATAN2} intrinsic
|
|
@cindex trigonometric functions (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ATAN2(Y,X)} computes the arctangent of the complex number @math{X + i Y}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ATAN2(Y,X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{Y} @tab The type shall be @code{REAL(*)}.
|
|
@item @var{X} @tab The type and kind type parameter shall be the same as @var{Y}.
|
|
If @var{Y} is zero, then @var{X} must be nonzero.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value has the same type and kind type parameter as @var{Y}.
|
|
It is the principal value of the complex number @math{X + i Y}. If
|
|
@var{X} is nonzero, then it lies in the range @math{-\pi \le \atan (x) \leq \pi}.
|
|
The sign is positive if @var{Y} is positive. If @var{Y} is zero, then
|
|
the return value is zero if @var{X} is positive and @math{\pi} if @var{X}
|
|
is negative. Finally, if @var{X} is zero, then the magnitude of the result
|
|
is @math{\pi/2}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_atan2
|
|
real(4) :: x = 1.e0_4, y = 0.5e0_4
|
|
x = atan2(y,x)
|
|
end program test_atan2
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DATAN2(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node ATANH
|
|
@section @code{ATANH} --- Hyperbolic arctangent function
|
|
@findex @code{ASINH} intrinsic
|
|
@cindex hyperbolic arctangent
|
|
@cindex hyperbolic tangent (inverse)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ATANH(X)} computes the area hyperbolic sine of @var{X} (inverse of @code{TANH(X)}).
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ATANH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is less than or equal to one.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{-\infty \leq \atanh(x) \leq \infty}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_atanh
|
|
REAL, DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
|
|
WRITE (*,*) ATANH(x)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{TANH}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node BESJ0
|
|
@section @code{BESJ0} --- Bessel function of the first kind of order 0
|
|
@findex @code{BESJ0} intrinsic
|
|
@findex @code{DBESJ0} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESJ0(X)} computes the Bessel function of the first kind of order 0
|
|
of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = BESJ0(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{ - 0.4027... \leq Bessel (0,x) \leq 1}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besj0
|
|
real(8) :: x = 0.0_8
|
|
x = besj0(x)
|
|
end program test_besj0
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESJ0(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BESJ1
|
|
@section @code{BESJ1} --- Bessel function of the first kind of order 1
|
|
@findex @code{BESJ1} intrinsic
|
|
@findex @code{DBESJ1} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESJ1(X)} computes the Bessel function of the first kind of order 1
|
|
of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = BESJ1(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{ - 0.5818... \leq Bessel (0,x) \leq 0.5818 }.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besj1
|
|
real(8) :: x = 1.0_8
|
|
x = besj1(x)
|
|
end program test_besj1
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESJ1(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BESJN
|
|
@section @code{BESJN} --- Bessel function of the first kind
|
|
@findex @code{BESJN} intrinsic
|
|
@findex @code{DBESJN} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESJN(N, X)} computes the Bessel function of the first kind of order
|
|
@var{N} of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = BESJN(N, X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besjn
|
|
real(8) :: x = 1.0_8
|
|
x = besjn(5,x)
|
|
end program test_besjn
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESJN(X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)} @tab GNU extension
|
|
@item @tab @code{REAL(8) X} @tab @tab
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BESY0
|
|
@section @code{BESY0} --- Bessel function of the second kind of order 0
|
|
@findex @code{BESY0} intrinsic
|
|
@findex @code{DBESY0} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESY0(X)} computes the Bessel function of the second kind of order 0
|
|
of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = BESY0(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besy0
|
|
real(8) :: x = 0.0_8
|
|
x = besy0(x)
|
|
end program test_besy0
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESY0(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BESY1
|
|
@section @code{BESY1} --- Bessel function of the second kind of order 1
|
|
@findex @code{BESY1} intrinsic
|
|
@findex @code{DBESY1} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESY1(X)} computes the Bessel function of the second kind of order 1
|
|
of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = BESY1(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besy1
|
|
real(8) :: x = 1.0_8
|
|
x = besy1(x)
|
|
end program test_besy1
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESY1(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BESYN
|
|
@section @code{BESYN} --- Bessel function of the second kind
|
|
@findex @code{BESYN} intrinsic
|
|
@findex @code{DBESYN} intrinsic
|
|
@cindex Bessel
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BESYN(N, X)} computes the Bessel function of the second kind of order
|
|
@var{N} of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = BESYN(N, X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_besyn
|
|
real(8) :: x = 1.0_8
|
|
x = besyn(5,x)
|
|
end program test_besyn
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DBESYN(N,X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)} @tab GNU extension
|
|
@item @tab @code{REAL(8) X} @tab @tab
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node BIT_SIZE
|
|
@section @code{BIT_SIZE} --- Bit size inquiry function
|
|
@findex @code{BIT_SIZE} intrinsic
|
|
@cindex bit_size
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BIT_SIZE(I)} returns the number of bits (integer precision plus sign bit)
|
|
represented by the type of @var{I}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = BIT_SIZE(I)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(*)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_bit_size
|
|
integer :: i = 123
|
|
integer :: size
|
|
size = bit_size(i)
|
|
print *, size
|
|
end program test_bit_size
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node BTEST
|
|
@section @code{BTEST} --- Bit test function
|
|
@findex @code{BTEST} intrinsic
|
|
@cindex bit operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{BTEST(I,POS)} returns logical @code{.TRUE.} if the bit at @var{POS}
|
|
in @var{I} is set.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = BTEST(I,POS)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab The type shall be @code{INTEGER(*)}.
|
|
@item @var{POS} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{LOGICAL}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node CEILING
|
|
@section @code{CEILING} --- Integer ceiling function
|
|
@findex @code{CEILING} intrinsic
|
|
@cindex CEILING
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CEILING(X)} returns the least integer greater than or equal to @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = CEILING(X[,KIND])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@item @var{KIND} @tab (Optional) scalar integer initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(KIND)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FLOOR}, @ref{NINT}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node CHAR
|
|
@section @code{CHAR} --- Character conversion function
|
|
@findex @code{CHAR} intrinsic
|
|
@cindex conversion function (character)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CHAR(I,[KIND])} returns the character represented by the integer @var{I}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = CHAR(I[,KIND])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab The type shall be @code{INTEGER(*)}.
|
|
@item @var{KIND} @tab Optional scaler integer initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{CHARACTER(1)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_char
|
|
integer :: i = 74
|
|
character(1) :: c
|
|
c = char(i)
|
|
print *, i, c ! returns 'J'
|
|
end program test_char
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{ACHAR}, @ref{ICHAR}, @ref{IACHAR}
|
|
|
|
@end table
|
|
|
|
|
|
@node CHDIR
|
|
@section @code{CHDIR} --- Change working directory
|
|
@findex @code{CHDIR} intrinsic
|
|
@cindex file system functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Change current working directory to a specified @var{PATH}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL chdir(PATH[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{PATH} @tab The type shall be @code{CHARACTER(*)} and shall specify a valid path within the file system.
|
|
@item @var{STATUS} @tab (Optional) status flag. Returns 0 on success,
|
|
a system specific and non-zero error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_chdir
|
|
CHARACTER(len=255) :: path
|
|
CALL getcwd(path)
|
|
WRITE(*,*) TRIM(path)
|
|
CALL chdir("/tmp")
|
|
CALL getcwd(path)
|
|
WRITE(*,*) TRIM(path)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{GETCWD}
|
|
@end table
|
|
|
|
|
|
|
|
@node CHMOD
|
|
@section @code{CHMOD} --- Change access permissions of files
|
|
@findex @code{CHMOD}
|
|
@cindex file system functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CHMOD} changes the permissions of a file. This function invokes
|
|
@code{/bin/chmod} and might therefore not work on all platforms.
|
|
@code{CHMOD} as an intrinsic function is not implemented in GNU Fortran.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CHMOD(NAME, MODE[, STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{NAME} @tab Scalar @code{CHARACTER} with the file name.
|
|
Trailing blanks are ignored unless the character @code{achar(0)} is
|
|
present, then all characters up to and excluding @code{achar(0)} are
|
|
used as the file name.
|
|
|
|
@item @var{MODE} @tab Scalar @code{CHARACTER} giving the file permission.
|
|
@var{MODE} uses the same syntax as the @var{MODE} argument of
|
|
@code{/bin/chmod}.
|
|
|
|
@item @var{STATUS} @tab (optional) scalar @code{INTEGER}, which is
|
|
@code{0} on success and non-zero otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program chmod_test
|
|
implicit none
|
|
integer :: status
|
|
call chmod('test.dat','u+x',status)
|
|
print *, 'Status: ', status
|
|
end program chmod_test
|
|
@end smallexample
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
@node CMPLX
|
|
@section @code{CMPLX} --- Complex conversion function
|
|
@findex @code{CMPLX} intrinsic
|
|
@cindex CMPLX
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CMPLX(X[,Y[,KIND]])} returns a complex number where @var{X} is converted to
|
|
the real component. If @var{Y} is present it is converted to the imaginary
|
|
component. If @var{Y} is not present then the imaginary component is set to
|
|
0.0. If @var{X} is complex then @var{Y} must not be present.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = CMPLX(X[,Y[,KIND]])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
|
|
@item @var{Y} @tab Optional, allowed if @var{X} is not @code{COMPLEX(*)}. May be @code{INTEGER(*)} or @code{REAL(*)}.
|
|
@item @var{KIND} @tab Optional scaler integer initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{COMPLEX(*)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_cmplx
|
|
integer :: i = 42
|
|
real :: x = 3.14
|
|
complex :: z
|
|
z = cmplx(i, x)
|
|
print *, z, cmplx(x)
|
|
end program test_cmplx
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node COMMAND_ARGUMENT_COUNT
|
|
@section @code{COMMAND_ARGUMENT_COUNT} --- Get number of command line arguments
|
|
@findex @code{COMMAND_ARGUMENT_COUNT} intrinsic
|
|
@cindex command line arguments
|
|
@cindex getopt
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{COMMAND_ARGUMENT_COUNT()} returns the number of arguments passed on the
|
|
command line when the containing program was invoked.
|
|
|
|
@item @emph{Standard}:
|
|
F2003
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = COMMAND_ARGUMENT_COUNT()}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item None
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(4)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_command_argument_count
|
|
integer :: count
|
|
count = command_argument_count()
|
|
print *, count
|
|
end program test_command_argument_count
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}
|
|
@end table
|
|
|
|
@node CONJG
|
|
@section @code{CONJG} --- Complex conjugate function
|
|
@findex @code{CONJG} intrinsic
|
|
@findex @code{DCONJG} intrinsic
|
|
@cindex complex conjugate
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CONJG(Z)} returns the conjugate of @var{Z}. If @var{Z} is @code{(x, y)}
|
|
then the result is @code{(x, -y)}
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later, has overloads that are GNU extensions
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Z = CONJG(Z)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{Z} @tab The type shall be @code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{COMPLEX(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DCONJG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node COS
|
|
@section @code{COS} --- Cosine function
|
|
@findex @code{COS} intrinsic
|
|
@findex @code{DCOS} intrinsic
|
|
@findex @code{ZCOS} intrinsic
|
|
@findex @code{CDCOS} intrinsic
|
|
@cindex trigonometric functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{COS(X)} computes the cosine of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later, has overloads that are GNU extensions
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = COS(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it lies in the
|
|
range @math{ -1 \leq \cos (x) \leq 1}. The kind type
|
|
parameter is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_cos
|
|
real :: x = 0.0
|
|
x = cos(x)
|
|
end program test_cos
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DCOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@item @code{CCOS(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F77 and later
|
|
@item @code{ZCOS(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@item @code{CDCOS(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{ACOS}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node COSH
|
|
@section @code{COSH} --- Hyperbolic cosine function
|
|
@findex @code{COSH} intrinsic
|
|
@findex @code{DCOSH} intrinsic
|
|
@cindex hyperbolic cosine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{COSH(X)} computes the hyperbolic cosine of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = COSH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and it is positive
|
|
(@math{ \cosh (x) \geq 0 }.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_cosh
|
|
real(8) :: x = 1.0_8
|
|
x = cosh(x)
|
|
end program test_cosh
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DCOSH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
Inverse function: @ref{ACOSH}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node COUNT
|
|
@section @code{COUNT} --- Count function
|
|
@findex @code{COUNT} intrinsic
|
|
@cindex count
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{COUNT(MASK[,DIM])} counts the number of @code{.TRUE.} elements of
|
|
@var{MASK} along the dimension of @var{DIM}. If @var{DIM} is omitted it is
|
|
taken to be @code{1}. @var{DIM} is a scaler of type @code{INTEGER} in the
|
|
range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{MASK}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = COUNT(MASK[,DIM])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{MASK} @tab The type shall be @code{LOGICAL}.
|
|
@item @var{DIM} @tab The type shall be @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} with rank equal to that of
|
|
@var{MASK}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node CPU_TIME
|
|
@section @code{CPU_TIME} --- CPU elapsed time in seconds
|
|
@findex @code{CPU_TIME} intrinsic
|
|
@cindex CPU_TIME
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Returns a @code{REAL} value representing the elapsed CPU time in seconds. This
|
|
is useful for testing segments of code to determine execution time.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CPU_TIME(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL} with @code{INTENT(OUT)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
None
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node CSHIFT
|
|
@section @code{CSHIFT} --- Circular shift function
|
|
@findex @code{CSHIFT} intrinsic
|
|
@cindex bit manipulation
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CSHIFT(ARRAY, SHIFT[,DIM])} performs a circular shift on elements of
|
|
@var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is omitted it is
|
|
taken to be @code{1}. @var{DIM} is a scaler of type @code{INTEGER} in the
|
|
range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{ARRAY}.
|
|
If the rank of @var{ARRAY} is one, then all elements of @var{ARRAY} are shifted
|
|
by @var{SHIFT} places. If rank is greater than one, then all complete rank one
|
|
sections of @var{ARRAY} along the given dimension are shifted. Elements
|
|
shifted out one end of each rank one section are shifted back in the other end.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{A = CSHIFT(A, SHIFT[,DIM])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{ARRAY} @tab May be any type, not scaler.
|
|
@item @var{SHIFT} @tab The type shall be @code{INTEGER}.
|
|
@item @var{DIM} @tab The type shall be @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Returns an array of same type and rank as the @var{ARRAY} argument.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
@node CTIME
|
|
@section @code{CTIME} --- Convert a time into a string
|
|
@findex @code{CTIME} intrinsic
|
|
@cindex ctime subroutine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{CTIME(T,S)} converts @var{T}, a system time value, such as returned
|
|
by @code{TIME8()}, to a string of the form @samp{Sat Aug 19 18:13:14
|
|
1995}, and returns that string into @var{S}.
|
|
|
|
If @code{CTIME} is invoked as a function, it can not be invoked as a
|
|
subroutine, and vice versa.
|
|
|
|
@var{T} is an @code{INTENT(IN)} @code{INTEGER(KIND=8)} variable.
|
|
@var{S} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .80
|
|
@item @code{CALL CTIME(T,S)}.
|
|
@item @code{S = CTIME(T)}, (not recommended).
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{S}@tab The type shall be of type @code{CHARACTER}.
|
|
@item @var{T}@tab The type shall be of type @code{INTEGER(KIND=8)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The converted date and time as a string.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
@node DATE_AND_TIME
|
|
@section @code{DATE_AND_TIME} --- Date and time subroutine
|
|
@findex @code{DATE_AND_TIME} intrinsic
|
|
@cindex DATE_AND_TIME
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DATE_AND_TIME(DATE, TIME, ZONE, VALUES)} gets the corresponding date and
|
|
time information from the real-time system clock. @var{DATE} is
|
|
@code{INTENT(OUT)} and has form ccyymmdd. @var{TIME} is @code{INTENT(OUT)} and
|
|
has form hhmmss.sss. @var{ZONE} is @code{INTENT(OUT)} and has form (+-)hhmm,
|
|
representing the difference with respect to Coordinated Universal Time (UTC).
|
|
Unavailable time and date parameters return blanks.
|
|
|
|
@var{VALUES} is @code{INTENT(OUT)} and provides the following:
|
|
|
|
@multitable @columnfractions .15 .30 .60
|
|
@item @tab @code{VALUE(1)}: @tab The year
|
|
@item @tab @code{VALUE(2)}: @tab The month
|
|
@item @tab @code{VALUE(3)}: @tab The day of the month
|
|
@item @tab @code{VALUE(4)}: @tab Time difference with UTC in minutes
|
|
@item @tab @code{VALUE(5)}: @tab The hour of the day
|
|
@item @tab @code{VALUE(6)}: @tab The minutes of the hour
|
|
@item @tab @code{VALUE(7)}: @tab The seconds of the minute
|
|
@item @tab @code{VALUE(8)}: @tab The milliseconds of the second
|
|
@end multitable
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{DATE} @tab (Optional) The type shall be @code{CHARACTER(8)} or larger.
|
|
@item @var{TIME} @tab (Optional) The type shall be @code{CHARACTER(10)} or larger.
|
|
@item @var{ZONE} @tab (Optional) The type shall be @code{CHARACTER(5)} or larger.
|
|
@item @var{VALUES}@tab (Optional) The type shall be @code{INTEGER(8)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
None
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node DBLE
|
|
@section @code{DBLE} --- Double conversion function
|
|
@findex @code{DBLE} intrinsic
|
|
@cindex double conversion
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DBLE(X)} Converts @var{X} to double precision real type.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = DBLE(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type double precision real.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{DFLOAT}, @ref{FLOAT}, @ref{REAL}
|
|
@end table
|
|
|
|
|
|
|
|
@node DCMPLX
|
|
@section @code{DCMPLX} --- Double complex conversion function
|
|
@findex @code{DCMPLX} intrinsic
|
|
@cindex DCMPLX
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DCMPLX(X [,Y])} returns a double complex number where @var{X} is
|
|
converted to the real component. If @var{Y} is present it is converted to the
|
|
imaginary component. If @var{Y} is not present then the imaginary component is
|
|
set to 0.0. If @var{X} is complex then @var{Y} must not be present.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = DCMPLX(X)}
|
|
@code{C = DCMPLX(X,Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
|
|
@item @var{Y} @tab Optional if @var{X} is not @code{COMPLEX(*)}. May be @code{INTEGER(*)} or @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{COMPLEX(8)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node DFLOAT
|
|
@section @code{DFLOAT} --- Double conversion function
|
|
@findex @code{DFLOAT} intrinsic
|
|
@cindex double float conversion
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DFLOAT(X)} Converts @var{X} to double precision real type.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = DFLOAT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type double precision real.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_dfloat
|
|
integer :: i = 5
|
|
print *, dfloat(i)
|
|
end program test_dfloat
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{DBLE}, @ref{FLOAT}, @ref{REAL}
|
|
@end table
|
|
|
|
|
|
|
|
@node DIGITS
|
|
@section @code{DIGITS} --- Significant digits function
|
|
@findex @code{DIGITS} intrinsic
|
|
@cindex digits, significant
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DIGITS(X)} returns the number of significant digits of the internal model
|
|
representation of @var{X}. For example, on a system using a 32-bit
|
|
floating point representation, a default real number would likely return 24.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = DIGITS(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node DIM
|
|
@section @code{DIM} --- Dim function
|
|
@findex @code{DIM} intrinsic
|
|
@findex @code{IDIM} intrinsic
|
|
@findex @code{DDIM} intrinsic
|
|
@cindex dim
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DIM(X,Y)} returns the difference @code{X-Y} if the result is positive;
|
|
otherwise returns zero.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = DIM(X,Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{INTEGER(*)} or @code{REAL(*)}
|
|
@item @var{Y} @tab The type shall be the same type and kind as @var{X}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(*)} or @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{IDIM(X,Y)} @tab @code{INTEGER(4) X,Y} @tab @code{INTEGER(4)} @tab F77 and later
|
|
@item @code{DDIM(X,Y)} @tab @code{REAL(8) X,Y} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node DOT_PRODUCT
|
|
@section @code{DOT_PRODUCT} --- Dot product function
|
|
@findex @code{DOT_PRODUCT} intrinsic
|
|
@cindex Dot product
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DOT_PRODUCT(X,Y)} computes the dot product multiplication of two vectors
|
|
@var{X} and @var{Y}. The two vectors may be either numeric or logical
|
|
and must be arrays of rank one and of equal size. If the vectors are
|
|
@code{INTEGER(*)} or @code{REAL(*)}, the result is @code{SUM(X*Y)}. If the
|
|
vectors are @code{COMPLEX(*)}, the result is @code{SUM(CONJG(X)*Y)}. If the
|
|
vectors are @code{LOGICAL}, the result is @code{ANY(X.AND.Y)}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{S = DOT_PRODUCT(X,Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
|
|
@item @var{Y} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
If the arguments are numeric, the return value is a scaler of numeric type,
|
|
@code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}. If the arguments are
|
|
@code{LOGICAL}, the return value is @code{.TRUE.} or @code{.FALSE.}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node DPROD
|
|
@section @code{DPROD} --- Double product function
|
|
@findex @code{DPROD} intrinsic
|
|
@cindex Double product
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DPROD(X,Y)} returns the product @code{X*Y}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{D = DPROD(X,Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL}.
|
|
@item @var{Y} @tab The type shall be @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(8)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_dprod
|
|
integer :: i
|
|
real :: x = 5.2
|
|
real :: y = 2.3
|
|
real(8) :: d
|
|
d = dprod(x,y)
|
|
print *, d
|
|
end program test_dprod
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node DREAL
|
|
@section @code{DREAL} --- Double real part function
|
|
@findex @code{DREAL} intrinsic
|
|
@cindex Double real part
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DREAL(Z)} returns the real part of complex variable @var{Z}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{D = DREAL(Z)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{Z} @tab The type shall be @code{COMPLEX(8)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(8)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_dreal
|
|
complex(8) :: z = (1.3_8,7.2_8)
|
|
print *, dreal(z)
|
|
end program test_dreal
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{AIMAG}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node DTIME
|
|
@section @code{DTIME} --- Execution time subroutine (or function)
|
|
@findex @code{DTIME} intrinsic
|
|
@cindex dtime subroutine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{DTIME(TARRAY, RESULT)} initially returns the number of seconds of runtime
|
|
since the start of the process's execution in @var{RESULT}. @var{TARRAY}
|
|
returns the user and system components of this time in @code{TARRAY(1)} and
|
|
@code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{TARRAY(1) +
|
|
TARRAY(2)}.
|
|
|
|
Subsequent invocations of @code{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.
|
|
|
|
If @code{DTIME} is invoked as a function, it can not be invoked as a
|
|
subroutine, and vice versa.
|
|
|
|
@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
|
|
|
|
@multitable @columnfractions .15 .30 .60
|
|
@item @tab @code{TARRAY(1)}: @tab User time in seconds.
|
|
@item @tab @code{TARRAY(2)}: @tab System time in seconds.
|
|
@item @tab @code{RESULT}: @tab Run time since start in seconds.
|
|
@end multitable
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .80
|
|
@item @code{CALL DTIME(TARRAY, RESULT)}.
|
|
@item @code{RESULT = DTIME(TARRAY)}, (not recommended).
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
|
|
@item @var{RESULT}@tab The type shall be @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Elapsed time in seconds since the start of program execution.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node EOSHIFT
|
|
@section @code{EOSHIFT} --- End-off shift function
|
|
@findex @code{EOSHIFT} intrinsic
|
|
@cindex bit manipulation
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{EOSHIFT(ARRAY, SHIFT[,BOUNDARY, DIM])} performs an end-off shift on
|
|
elements of @var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is
|
|
omitted it is taken to be @code{1}. @var{DIM} is a scaler of type
|
|
@code{INTEGER} in the range of @math{1 /leq DIM /leq n)} where @math{n} is the
|
|
rank of @var{ARRAY}. If the rank of @var{ARRAY} is one, then all elements of
|
|
@var{ARRAY} are shifted by @var{SHIFT} places. If rank is greater than one,
|
|
then all complete rank one sections of @var{ARRAY} along the given dimension are
|
|
shifted. Elements shifted out one end of each rank one section are dropped. If
|
|
@var{BOUNDARY} is present then the corresponding value of from @var{BOUNDARY}
|
|
is copied back in the other end. If @var{BOUNDARY} is not present then the
|
|
following are copied in depending on the type of @var{ARRAY}.
|
|
|
|
@multitable @columnfractions .15 .80
|
|
@item @emph{Array Type} @tab @emph{Boundary Value}
|
|
@item Numeric @tab 0 of the type and kind of @var{ARRAY}.
|
|
@item Logical @tab @code{.FALSE.}.
|
|
@item Character(@var{len}) @tab @var{len} blanks.
|
|
@end multitable
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{A = EOSHIFT(A, SHIFT[,BOUNDARY, DIM])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{ARRAY} @tab May be any type, not scaler.
|
|
@item @var{SHIFT} @tab The type shall be @code{INTEGER}.
|
|
@item @var{BOUNDARY} @tab Same type as @var{ARRAY}.
|
|
@item @var{DIM} @tab The type shall be @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Returns an array of same type and rank as the @var{ARRAY} argument.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node EPSILON
|
|
@section @code{EPSILON} --- Epsilon function
|
|
@findex @code{EPSILON} intrinsic
|
|
@cindex epsilon, significant
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{EPSILON(X)} returns a nearly negligible number relative to @code{1}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = EPSILON(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of same type as the argument.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_epsilon
|
|
real :: x = 3.143
|
|
real(8) :: y = 2.33
|
|
print *, EPSILON(x)
|
|
print *, EPSILON(y)
|
|
end program test_epsilon
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node ERF
|
|
@section @code{ERF} --- Error function
|
|
@findex @code{ERF} intrinsic
|
|
@cindex error function
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ERF(X)} computes the error function of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU Extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ERF(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)} and it is positive
|
|
(@math{ - 1 \leq erf (x) \leq 1 }.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_erf
|
|
real(8) :: x = 0.17_8
|
|
x = erf(x)
|
|
end program test_erf
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DERF(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node ERFC
|
|
@section @code{ERFC} --- Error function
|
|
@findex @code{ERFC} intrinsic
|
|
@cindex error function
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ERFC(X)} computes the complementary error function of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = ERFC(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{REAL(*)} and it is positive
|
|
(@math{ 0 \leq erfc (x) \leq 2 }.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_erfc
|
|
real(8) :: x = 0.17_8
|
|
x = erfc(x)
|
|
end program test_erfc
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DERFC(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node ETIME
|
|
@section @code{ETIME} --- Execution time subroutine (or function)
|
|
@findex @code{ETIME} intrinsic
|
|
@cindex time functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ETIME(TARRAY, RESULT)} returns the number of seconds of runtime
|
|
since the start of the process's execution in @var{RESULT}. @var{TARRAY}
|
|
returns the user and system components of this time in @code{TARRAY(1)} and
|
|
@code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{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.
|
|
|
|
If @code{ETIME} is invoked as a function, it can not be invoked as a
|
|
subroutine, and vice versa.
|
|
|
|
@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
|
|
|
|
@multitable @columnfractions .15 .30 .60
|
|
@item @tab @code{TARRAY(1)}: @tab User time in seconds.
|
|
@item @tab @code{TARRAY(2)}: @tab System time in seconds.
|
|
@item @tab @code{RESULT}: @tab Run time since start in seconds.
|
|
@end multitable
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .8
|
|
@item @code{CALL ETIME(TARRAY, RESULT)}.
|
|
@item @code{RESULT = ETIME(TARRAY)}, (not recommended).
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
|
|
@item @var{RESULT}@tab The type shall be @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Elapsed time in seconds since the start of program execution.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{CPU_TIME}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node EXIT
|
|
@section @code{EXIT} --- Exit the program with status.
|
|
@findex @code{EXIT}
|
|
@cindex exit
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{EXIT} causes immediate termination of the program with status. If status
|
|
is omitted it returns the canonical @emph{success} for the system. All Fortran
|
|
I/O units are closed.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL EXIT([STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{STATUS} @tab The type of the argument shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
@code{STATUS} is passed to the parent process on exit.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_exit
|
|
integer :: STATUS = 0
|
|
print *, 'This program is going to exit.'
|
|
call EXIT(STATUS)
|
|
end program test_exit
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{ABORT}, @ref{KILL}
|
|
@end table
|
|
|
|
|
|
|
|
@node EXP
|
|
@section @code{EXP} --- Exponential function
|
|
@findex @code{EXP} intrinsic
|
|
@findex @code{DEXP} intrinsic
|
|
@findex @code{ZEXP} intrinsic
|
|
@findex @code{CDEXP} intrinsic
|
|
@cindex exponential
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{EXP(X)} computes the base @math{e} exponential of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later, has overloads that are GNU extensions
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = EXP(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value has same type and kind as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_exp
|
|
real :: x = 1.0
|
|
x = exp(x)
|
|
end program test_exp
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DEXP(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@item @code{CEXP(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F77 and later
|
|
@item @code{ZEXP(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@item @code{CDEXP(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node EXPONENT
|
|
@section @code{EXPONENT} --- Exponent function
|
|
@findex @code{EXPONENT} intrinsic
|
|
@cindex exponent function
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{EXPONENT(X)} returns the value of the exponent part of @var{X}. If @var{X}
|
|
is zero the value returned is zero.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = EXPONENT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type default @code{INTEGER}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_exponent
|
|
real :: x = 1.0
|
|
integer :: i
|
|
i = exponent(x)
|
|
print *, i
|
|
print *, exponent(0.0)
|
|
end program test_exponent
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
@node FDATE
|
|
@section @code{FDATE} --- Get the current time as a string
|
|
@findex @code{FDATE} intrinsic
|
|
@cindex fdate subroutine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FDATE(DATE)} returns the current date (using the same format as
|
|
@code{CTIME}) in @var{DATE}. It is equivalent to @code{CALL CTIME(DATE,
|
|
TIME8())}.
|
|
|
|
If @code{FDATE} is invoked as a function, it can not be invoked as a
|
|
subroutine, and vice versa.
|
|
|
|
@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .80
|
|
@item @code{CALL FDATE(DATE)}.
|
|
@item @code{DATE = FDATE()}, (not recommended).
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{DATE}@tab The type shall be of type @code{CHARACTER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The current date and time as a string.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
@node FLOAT
|
|
|
|
@section @code{FLOAT} --- Convert integer to default real
|
|
@findex @code{FLOAT} intrinsic
|
|
@cindex conversion function (float)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FLOAT(I)} converts the integer @var{I} to a default real value.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = FLOAT(I)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type default @code{REAL}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_float
|
|
integer :: i = 1
|
|
if (float(i) /= 1.) call abort
|
|
end program test_float
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{DBLE}, @ref{DFLOAT}, @ref{REAL}
|
|
@end table
|
|
|
|
|
|
|
|
@node FGET
|
|
@section @code{FGET} --- Read a single character in stream mode from stdin
|
|
@findex @code{FGET} intrinsic
|
|
@cindex file operations
|
|
@cindex stream operations
|
|
|
|
@table @asis
|
|
@item @emph{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 routine is provided for backwards compatibility with
|
|
@command{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 @ref{Fortran 2003 status}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL fget(C[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{C} @tab The type shall be @code{CHARACTER}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success,
|
|
-1 on end-of-file and a system specific positive error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FGETC}, @ref{FPUT}, @ref{FPUTC}
|
|
@end table
|
|
|
|
|
|
@node FGETC
|
|
@section @code{FGETC} --- Read a single character in stream mode
|
|
@findex @code{FGETC} intrinsic
|
|
@cindex file operations
|
|
@cindex stream operations
|
|
|
|
@table @asis
|
|
@item @emph{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 routine is provided for backwards compatibility with
|
|
@command{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 @ref{Fortran 2003 status}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL fgetc(UNIT,C[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{UNIT} @tab The type shall be @code{INTEGER}.
|
|
@item @var{C} @tab The type shall be @code{CHARACTER}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success,
|
|
-1 on end-of-file and a system specific positive error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FGET}, @ref{FPUT}, @ref{FPUTC}
|
|
@end table
|
|
|
|
|
|
|
|
@node FLOOR
|
|
@section @code{FLOOR} --- Integer floor function
|
|
@findex @code{FLOOR} intrinsic
|
|
@cindex floor
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FLOOR(X)} returns the greatest integer less than or equal to @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = FLOOR(X[,KIND])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@item @var{KIND} @tab Optional scaler integer initialization expression.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(KIND)}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{CEILING}, @ref{NINT}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node FLUSH
|
|
@section @code{FLUSH} --- Flush I/O unit(s)
|
|
@findex @code{FLUSH}
|
|
@cindex flush
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Flushes Fortran unit(s) currently open for output. Without the optional
|
|
argument, all units are flushed, otherwise just the unit specified.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL FLUSH(UNIT)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{UNIT} @tab (Optional) The type shall be @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Note}:
|
|
Beginning with the Fortran 2003 standard, there is a @code{FLUSH}
|
|
statement that should be preferred over the @code{FLUSH} intrinsic.
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node FNUM
|
|
@section @code{FNUM} --- File number function
|
|
@findex @code{FNUM} intrinsic
|
|
@cindex fnum
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FNUM(UNIT)} returns the POSIX file descriptor number corresponding to the
|
|
open Fortran I/O unit @code{UNIT}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = FNUM(UNIT)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{UNIT} @tab The type shall be @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_fnum
|
|
integer :: i
|
|
open (unit=10, status = "scratch")
|
|
i = fnum(10)
|
|
print *, i
|
|
close (10)
|
|
end program test_fnum
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node FPUT
|
|
@section @code{FPUT} --- Write a single character in stream mode to stdout
|
|
@findex @code{FPUT} intrinsic
|
|
@cindex file operations
|
|
@cindex stream operations
|
|
|
|
@table @asis
|
|
@item @emph{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 routine is provided for backwards compatibility with
|
|
@command{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 @ref{Fortran 2003 status}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL fput(C[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{C} @tab The type shall be @code{CHARACTER}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success,
|
|
-1 on end-of-file and a system specific positive error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_fput
|
|
CHARACTER(len=*) :: str = "gfortran"
|
|
INTEGER :: i
|
|
DO i = 1, len_trim(str)
|
|
CALL fput(str(i:i))
|
|
END DO
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FPUTC}, @ref{FGET}, @ref{FGETC}
|
|
@end table
|
|
|
|
|
|
|
|
@node FPUTC
|
|
@section @code{FPUTC} --- Write a single character in stream mode
|
|
@findex @code{FPUTC} intrinsic
|
|
@cindex file operations
|
|
@cindex stream operations
|
|
|
|
@table @asis
|
|
@item @emph{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 routine is provided for backwards compatibility with
|
|
@command{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 @ref{Fortran 2003 status}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL fputc(UNIT,C[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{UNIT} @tab The type shall be @code{INTEGER}.
|
|
@item @var{C} @tab The type shall be @code{CHARACTER}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success,
|
|
-1 on end-of-file and a system specific positive error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_fputc
|
|
CHARACTER(len=*) :: 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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FPUT}, @ref{FGET}, @ref{FGETC}
|
|
@end table
|
|
|
|
|
|
|
|
@node FRACTION
|
|
@section @code{FRACTION} --- Fractional part of the model representation
|
|
@findex @code{FRACTION} intrinsic
|
|
@cindex fractional part
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FRACTION(X)} returns the fractional part of the model
|
|
representation of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = FRACTION(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be a @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as the argument.
|
|
The fractional part of the model representation of @code{X} is returned;
|
|
it is @code{X * RADIX(X)**(-EXPONENT(X))}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_fraction
|
|
real :: x
|
|
x = 178.1387e-4
|
|
print *, fraction(x), x * radix(x)**(-exponent(x))
|
|
end program test_fraction
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node FREE
|
|
@section @code{FREE} --- Frees memory
|
|
@findex @code{FREE} intrinsic
|
|
@cindex FREE
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Frees memory previously allocated by @code{MALLOC()}. The @code{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
|
|
@code{DEALLOCATE}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{FREE(PTR)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{PTR} @tab The type shall be @code{INTEGER}. It represents the
|
|
location of the memory that should be de-allocated.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
None
|
|
|
|
@item @emph{Example}:
|
|
See @code{MALLOC} for an example.
|
|
|
|
@item @emph{See also}:
|
|
@ref{MALLOC}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node FSTAT
|
|
@section @code{FSTAT} --- Get file status
|
|
@findex @code{FSTAT} intrinsic
|
|
@cindex file system operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{FSTAT} is identical to @ref{STAT}, except that information about an
|
|
already opened file is obtained.
|
|
|
|
The elements in @code{BUFF} are the same as described by @ref{STAT}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL fstat(UNIT,BUFF[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{UNIT} @tab An open I/O unit number of type @code{INTEGER}.
|
|
@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0
|
|
on success and a system specific error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
See @ref{STAT} for an example.
|
|
|
|
@item @emph{See also}:
|
|
To stat a link: @ref{LSTAT}, to stat a file: @ref{STAT}
|
|
@end table
|
|
|
|
|
|
|
|
@node FSEEK
|
|
@section @code{FSEEK} --- Low level file positioning subroutine
|
|
@findex @code{FSEEK}
|
|
@cindex file system functions
|
|
|
|
Not yet implemented in GNU Fortran.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@uref{http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19292, g77 features lacking in gfortran}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node FTELL
|
|
@section @code{FTELL} --- Current stream position
|
|
@findex @code{FTELL} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{FSEEK}
|
|
@end table
|
|
|
|
|
|
|
|
@node GETARG
|
|
@section @code{GETARG} --- Get command line arguments
|
|
@findex @code{GETARG} intrinsic
|
|
@cindex command line arguments
|
|
@cindex getopt
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Retrieve the @var{N}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 @ref{GET_COMMAND_ARGUMENT} intrinsic defined by the Fortran 2003
|
|
standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL GETARG(N,ARG)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{N} @tab Shall of type @code{INTEGER(4)}, @math{@var{N} \geq 0}
|
|
@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
After @code{GETARG} returns, the @var{ARG} argument holds the @var{N}th
|
|
command line argument. If @var{ARG} can not hold the argument, it is
|
|
truncated to fit the length of @var{ARG}. If there are less than @var{N}
|
|
arguments specified at the command line, @var{ARG} will be filled with blanks.
|
|
If @math{@var{N} = 0}, @var{ARG} is set to the name of the program (on systems
|
|
that support this feature).
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_getarg
|
|
INTEGER :: i
|
|
CHARACTER(len=32) :: arg
|
|
|
|
DO i = 1, iargc()
|
|
CALL getarg(i, arg)
|
|
WRITE (*,*) arg
|
|
END DO
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
GNU Fortran 77 compatibility function: @ref{IARGC}
|
|
|
|
F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT}
|
|
@end table
|
|
|
|
|
|
|
|
@node GET_COMMAND
|
|
@section @code{GET_COMMAND} --- Get the entire command line
|
|
@findex @code{GET_COMMAND} intrinsic
|
|
@cindex command line arguments
|
|
@cindex getopt
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Retrieve the entire command line that was used to invoke the program.
|
|
|
|
@item @emph{Standard}:
|
|
F2003
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL GET_COMMAND(CMD)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{CMD} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Stores the entire command line that was used to invoke the program in @var{ARG}.
|
|
If @var{ARG} is not large enough, the command will be truncated.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_get_command
|
|
CHARACTER(len=255) :: cmd
|
|
CALL get_command(cmd)
|
|
WRITE (*,*) TRIM(cmd)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT}
|
|
@end table
|
|
|
|
|
|
|
|
@node GET_COMMAND_ARGUMENT
|
|
@section @code{GET_COMMAND_ARGUMENT} --- Get command line arguments
|
|
@findex @code{GET_COMMAND_ARGUMENT} intrinsic
|
|
@cindex command line arguments
|
|
@cindex getopt
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Retrieve the @var{N}th argument that was passed on the
|
|
command line when the containing program was invoked.
|
|
|
|
@item @emph{Standard}:
|
|
F2003
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL GET_COMMAND_ARGUMENT(N,ARG)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{N} @tab Shall of type @code{INTEGER(4)}, @math{@var{N} \geq 0}
|
|
@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
After @code{GET_COMMAND_ARGUMENT} returns, the @var{ARG} argument holds the
|
|
@var{N}th command line argument. If @var{ARG} can not hold the argument, it is
|
|
truncated to fit the length of @var{ARG}. If there are less than @var{N}
|
|
arguments specified at the command line, @var{ARG} will be filled with blanks.
|
|
If @math{@var{N} = 0}, @var{ARG} is set to the name of the program (on systems
|
|
that support this feature).
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{GET_COMMAND}, @ref{COMMAND_ARGUMENT_COUNT}
|
|
@end table
|
|
|
|
|
|
|
|
@node GETCWD
|
|
@section @code{GETCWD} --- Get current working directory
|
|
@findex @code{GETCWD} intrinsic
|
|
@cindex file system functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Get current working directory.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine.
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL getcwd(CWD[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{CWD} @tab The type shall be @code{CHARACTER(*)}.
|
|
@item @var{STATUS} @tab (Optional) status flag. Returns 0 on success,
|
|
a system specific and non-zero error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_getcwd
|
|
CHARACTER(len=255) :: cwd
|
|
CALL getcwd(cwd)
|
|
WRITE(*,*) TRIM(cwd)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{CHDIR}
|
|
@end table
|
|
|
|
|
|
|
|
@node GETENV
|
|
@section @code{GETENV} --- Get an environmental variable
|
|
@findex @code{GETENV} intrinsic
|
|
@cindex environment variable
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Get the @var{VALUE} of the environmental variable @var{ENVVAR}.
|
|
|
|
This intrinsic routine is provided for backwards compatibility with
|
|
GNU Fortran 77. In new code, programmers should consider the use of
|
|
the @ref{GET_ENVIRONMENT_VARIABLE} intrinsic defined by the Fortran
|
|
2003 standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL GETENV(ENVVAR,VALUE)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Stores the value of @var{ENVVAR} in @var{VALUE}. If @var{VALUE} is
|
|
not large enough to hold the data, it is truncated. If @var{ENVVAR}
|
|
is not set, @var{VALUE} will be filled with blanks.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_getenv
|
|
CHARACTER(len=255) :: homedir
|
|
CALL getenv("HOME", homedir)
|
|
WRITE (*,*) TRIM(homedir)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{GET_ENVIRONMENT_VARIABLE}
|
|
@end table
|
|
|
|
|
|
|
|
@node GET_ENVIRONMENT_VARIABLE
|
|
@section @code{GET_ENVIRONMENT_VARIABLE} --- Get an environmental variable
|
|
@findex @code{GET_ENVIRONMENT_VARIABLE} intrinsic
|
|
@cindex environment variable
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Get the @var{VALUE} of the environmental variable @var{ENVVAR}.
|
|
|
|
@item @emph{Standard}:
|
|
F2003
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL GET_ENVIRONMENT_VARIABLE(ENVVAR,VALUE)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Stores the value of @var{ENVVAR} in @var{VALUE}. If @var{VALUE} is
|
|
not large enough to hold the data, it is truncated. If @var{ENVVAR}
|
|
is not set, @var{VALUE} will be filled with blanks.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_getenv
|
|
CHARACTER(len=255) :: homedir
|
|
CALL get_environment_variable("HOME", homedir)
|
|
WRITE (*,*) TRIM(homedir)
|
|
END PROGRAM
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node GETGID
|
|
@section @code{GETGID} --- Group ID function
|
|
@findex @code{GETGID} intrinsic
|
|
@cindex GETGID
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Returns the numerical group ID of the current process.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = GETGID()}
|
|
|
|
@item @emph{Return value}:
|
|
The return value of @code{GETGID} is an @code{INTEGER} of the default
|
|
kind.
|
|
|
|
|
|
@item @emph{Example}:
|
|
See @code{GETPID} for an example.
|
|
|
|
@item @emph{See also}:
|
|
@ref{GETPID}
|
|
@end table
|
|
|
|
|
|
|
|
@node GETLOG
|
|
@section @code{GETLOG} --- Get login name
|
|
@findex @code{GETLOG} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node GETPID
|
|
@section @code{GETPID} --- Process ID function
|
|
@findex @code{GETPID} intrinsic
|
|
@cindex GETPID
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Returns the numerical process identifier of the current process.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = GETPID()}
|
|
|
|
@item @emph{Return value}:
|
|
The return value of @code{GETPID} is an @code{INTEGER} of the default
|
|
kind.
|
|
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node GETUID
|
|
@section @code{GETUID} --- User ID function
|
|
@findex @code{GETUID} intrinsic
|
|
@cindex GETUID
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Returns the numerical user ID of the current process.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{GETUID()}
|
|
|
|
@item @emph{Return value}:
|
|
The return value of @code{GETUID} is an @code{INTEGER} of the default
|
|
kind.
|
|
|
|
|
|
@item @emph{Example}:
|
|
See @code{GETPID} for an example.
|
|
|
|
@item @emph{See also}:
|
|
@ref{GETPID}
|
|
@end table
|
|
|
|
|
|
|
|
@node GMTIME
|
|
@section @code{GMTIME} --- Convert time to GMT info
|
|
@findex @code{GMTIME}
|
|
@cindex time function
|
|
|
|
Not yet implemented in GNU Fortran.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node HOSTNM
|
|
@section @code{HOSTNM} --- Get system host name
|
|
@findex @code{HOSTNM} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
@node HUGE
|
|
@section @code{HUGE} --- Largest number of a kind
|
|
@findex @code{HUGE} intrinsic
|
|
@cindex huge
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{HUGE(X)} returns the largest number that is not an infinity in
|
|
the model of the type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = HUGE(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL} or @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as @var{X}
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node IACHAR
|
|
@section @code{IACHAR} --- Code in @acronym{ASCII} collating sequence
|
|
@findex @code{IACHAR} intrinsic
|
|
@cindex @acronym{ASCII} collating sequence
|
|
@cindex conversion function (character)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{IACHAR(C)} returns the code for the @acronym{ASCII} character
|
|
in the first character position of @code{C}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = IACHAR(C)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_iachar
|
|
integer i
|
|
i = iachar(' ')
|
|
end program test_iachar
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{CHAR},@ref{ICHAR}
|
|
|
|
@end table
|
|
|
|
|
|
@node IAND
|
|
@section @code{IAND} --- Bitwise logical and
|
|
@findex @code{IAND} intrinsic
|
|
@cindex bit operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Bitwise logical @code{AND}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{RESULT = IAND(X, Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{INTEGER(*)}.
|
|
@item @var{Y} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return type is @code{INTEGER(*)} after cross-promotion of the arguments.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
PROGRAM test_iand
|
|
INTEGER :: a, b
|
|
DATA a / Z'F' /, b / Z'3' /
|
|
WRITE (*,*) IAND(a, b)
|
|
END PROGRAM
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{IOR}, @ref{IEOR}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
|
|
@end table
|
|
|
|
|
|
|
|
@node IARGC
|
|
@section @code{IARGC} --- Get the number of command line arguments
|
|
@findex @code{IARGC} intrinsic
|
|
@cindex command line arguments
|
|
@cindex getopt
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{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 @ref{COMMAND_ARGUMENT_COUNT} intrinsic defined by the Fortran 2003
|
|
standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental Function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = IARGC()}
|
|
|
|
@item @emph{Arguments}:
|
|
None.
|
|
|
|
@item @emph{Return value}:
|
|
The number of command line arguments, type @code{INTEGER(4)}.
|
|
|
|
@item @emph{Example}:
|
|
See @ref{GETARG}
|
|
|
|
@item @emph{See also}:
|
|
GNU Fortran 77 compatibility subroutine: @ref{GETARG}
|
|
|
|
F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT}
|
|
@end table
|
|
|
|
|
|
|
|
@node IBCLR
|
|
@section @code{IBCLR} --- Clear bit
|
|
@findex @code{IBCLR} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{IBITS}, @ref{IBSET}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node IBITS
|
|
@section @code{IBITS} --- Bit extraction
|
|
@findex @code{IBITS} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@ref{IBCLR}, @ref{IBSET}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node IBSET
|
|
@section @code{IBSET} --- Set bit
|
|
@findex @code{IBSET} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{IBCLR}, @ref{IBITS}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node ICHAR
|
|
@section @code{ICHAR} --- Character-to-integer conversion function
|
|
@findex @code{ICHAR} intrinsic
|
|
@cindex conversion function (character)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{ICHAR(C)} returns the code for the character in the first character
|
|
position of @code{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.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = ICHAR(C)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_ichar
|
|
integer i
|
|
i = ichar(' ')
|
|
end program test_ichar
|
|
@end smallexample
|
|
|
|
@item @emph{Note}:
|
|
No intrinsic exists to convert a printable character string to a numerical
|
|
value. For example, there is no intrinsic that, given the @code{CHARACTER}
|
|
value 154, returns an @code{INTEGER} or @code{REAL} value with the
|
|
value 154.
|
|
|
|
Instead, you can use internal-file I/O to do this kind of conversion. For
|
|
example:
|
|
@smallexample
|
|
program read_val
|
|
integer value
|
|
character(len=10) string
|
|
|
|
string = '154'
|
|
read (string,'(I10)') value
|
|
print *, value
|
|
end program read_val
|
|
@end smallexample
|
|
@end table
|
|
|
|
@node IDATE
|
|
@section @code{IDATE} --- Get current local time subroutine (day/month/year)
|
|
@findex @code{IDATE} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{IDATE(TARRAY)} Fills @var{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 @var{TARRAY}, respectively.
|
|
The year has four significant digits.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL IDATE(TARRAY)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{TARRAY} @tab The type shall be @code{INTEGER, DIMENSION(3)} and
|
|
the kind shall be the default integer kind.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Does not return.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_idate
|
|
integer, dimension(3) :: tarray
|
|
call idate(tarray)
|
|
print *, tarray(1)
|
|
print *, tarray(2)
|
|
print *, tarray(3)
|
|
end program test_idate
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node IEOR
|
|
@section @code{IEOR} --- Bitwise logical exclusive or
|
|
@findex @code{IEOR} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{IOR}, @ref{IAND}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node IERRNO
|
|
@section @code{IERRNO} --- Get the last system error number
|
|
@findex @code{IERRNO} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{PERROR}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node INDEX
|
|
@section @code{INDEX} --- Position of a substring within a string
|
|
@findex @code{INDEX} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node INT
|
|
@section @code{INT} --- Convert to integer type
|
|
@findex @code{INT} intrinsic
|
|
@findex @code{IFIX} intrinsic
|
|
@findex @code{IDINT} intrinsic
|
|
@cindex conversion function (integer)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Convert to integer type
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .30 .80
|
|
@item @code{X = INT(X)}
|
|
@item @code{X = INT(X, KIND)}
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{INTEGER(*)}, @code{REAL(*)} or @code{COMPLEX(*)}
|
|
@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
These functions return a @code{INTEGER(*)} variable or array under
|
|
the following rules:
|
|
|
|
@table @asis
|
|
@item (A)
|
|
If @var{X} is of type @code{INTEGER(*)}, @code{INT(X) = X}
|
|
@item (B)
|
|
If @var{X} is of type @code{REAL(*)} and @math{|X| < 1} @code{INT(X)} equals @var{0}.
|
|
If @math{|X| \geq 1}, then @code{INT(X)} equals the largest integer that does not exceed
|
|
the range of @var{X} and whose sign is the same as the sign of @var{X}.
|
|
@item (C)
|
|
If @var{X} is of type @code{COMPLEX(*)}, rule B is applied to the real part of X.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_int
|
|
integer :: i = 42
|
|
complex :: z = (-3.7, 1.0)
|
|
print *, int(i)
|
|
print *, int(z), int(z,8)
|
|
end program
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{IFIX(X)} @tab @code{REAL(4) X} @tab @code{INTEGER} @tab F77 and later
|
|
@item @code{IDINT(X)} @tab @code{REAL(8) X} @tab @code{INTEGER} @tab F77 and later
|
|
@end multitable
|
|
|
|
@comment @item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node IOR
|
|
@section @code{IOR} --- Bitwise logical or
|
|
@findex @code{IOR} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{IEOR}, @ref{IAND}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node IRAND
|
|
@section @code{IRAND} --- Integer pseudo-random number
|
|
@findex @code{IRAND} intrinsic
|
|
@cindex random number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{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 @var{FLAG} is 0, the next number
|
|
in the current sequence is returned; if @var{FLAG} is 1, the generator
|
|
is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
|
|
it is used as a new seed with @code{SRAND}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = IRAND(FLAG)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{FLAG} @tab shall be a scalar @code{INTEGER} of kind 4.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of @code{INTEGER(kind=4)} type.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node ISHFT
|
|
@section @code{ISHFT} --- Shift bits
|
|
@findex @code{ISHFT} intrinsic
|
|
@cindex bit manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{ISHFTC}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node ISHFTC
|
|
@section @code{ISHFTC} --- Shift bits circularly
|
|
@findex @code{ISHFTC} intrinsic
|
|
@cindex bit manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{ISHFT}
|
|
@end table
|
|
|
|
|
|
|
|
@node ITIME
|
|
@section @code{ITIME} --- Get current local time subroutine (hour/minutes/seconds)
|
|
@findex @code{ITIME} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{IDATE(TARRAY)} Fills @var{TARRAY} 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 @var{TARRAY},
|
|
respectively.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL ITIME(TARRAY)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{TARRAY} @tab The type shall be @code{INTEGER, DIMENSION(3)}
|
|
and the kind shall be the default integer kind.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Does not return.
|
|
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_itime
|
|
integer, dimension(3) :: tarray
|
|
call itime(tarray)
|
|
print *, tarray(1)
|
|
print *, tarray(2)
|
|
print *, tarray(3)
|
|
end program test_itime
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node KILL
|
|
@section @code{KILL} --- Send a signal to a process
|
|
@findex @code{KILL} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{ABORT}, @ref{EXIT}
|
|
@end table
|
|
|
|
|
|
|
|
@node KIND
|
|
@section @code{KIND} --- Kind of an entity
|
|
@findex @code{KIND} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{KIND(X)} returns the kind value of the entity @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{K = KIND(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab Shall be of type @code{LOGICAL}, @code{INTEGER},
|
|
@code{REAL}, @code{COMPLEX} or @code{CHARACTER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{INTEGER} and of the default
|
|
integer kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node LBOUND
|
|
@section @code{LBOUND} --- Lower dimension bounds of an array
|
|
@findex @code{LBOUND} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{UBOUND}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LEN
|
|
@section @code{LEN} --- Length of a character entity
|
|
@findex @code{LEN} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LEN_TRIM}, @ref{ADJUSTL}, @ref{ADJUSTR}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LEN_TRIM
|
|
@section @code{LEN_TRIM} --- Length of a character entity without trailing blank characters
|
|
@findex @code{LEN_TRIM} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LEN}, @ref{ADJUSTL}, @ref{ADJUSTR}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LGE
|
|
@section @code{LGE} --- Lexical greater than or equal
|
|
@findex @code{LGE} intrinsic
|
|
@cindex comparison (lexical)
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LGT}, @ref{LLE}, @ref{LLT}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LGT
|
|
@section @code{LGT} --- Lexical greater than
|
|
@findex @code{LGT} intrinsic
|
|
@cindex comparison (lexical)
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LGE}, @ref{LLE}, @ref{LLT}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LINK
|
|
@section @code{LINK} --- Create a hard link
|
|
@findex @code{LINK} intrinsic
|
|
@cindex file system operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{UNLINK}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LLE
|
|
@section @code{LLE} --- Lexical less than or equal
|
|
@findex @code{LLE} intrinsic
|
|
@cindex comparison (lexical)
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LGE}, @ref{LGT}, @ref{LLT}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LLT
|
|
@section @code{LLT} --- Lexical less than
|
|
@findex @code{LLT} intrinsic
|
|
@cindex comparison (lexical)
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LGE}, @ref{LGT}, @ref{LLE}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LNBLNK
|
|
@section @code{LNBLNK} --- Index of the last non-blank character in a string
|
|
@findex @code{LNBLNK} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{INDEX}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LOC
|
|
@section @code{LOC} --- Returns the address of a variable
|
|
@findex @code{LOC} intrinsic
|
|
@cindex loc
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{LOC(X)} returns the address of @var{X} as an integer.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = LOC(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab Variable of any type.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(n)}, where @code{n} is the
|
|
size (in bytes) of a memory address on the target machine.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_loc
|
|
integer :: i
|
|
real :: r
|
|
i = loc(r)
|
|
print *, i
|
|
end program test_loc
|
|
@end smallexample
|
|
@end table
|
|
|
|
@node LOG
|
|
@section @code{LOG} --- Logarithm function
|
|
@findex @code{LOG} intrinsic
|
|
@findex @code{ALOG} intrinsic
|
|
@findex @code{DLOG} intrinsic
|
|
@findex @code{CLOG} intrinsic
|
|
@findex @code{ZLOG} intrinsic
|
|
@findex @code{CDLOG} intrinsic
|
|
@cindex logarithm
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{LOG(X)} computes the logarithm of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = LOG(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
|
|
The kind type parameter is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{ALOG(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab f95, gnu
|
|
@item @code{DLOG(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
|
|
@item @code{CLOG(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab f95, gnu
|
|
@item @code{ZLOG(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
|
|
@item @code{CDLOG(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node LOG10
|
|
@section @code{LOG10} --- Base 10 logarithm function
|
|
@findex @code{LOG10} intrinsic
|
|
@findex @code{ALOG10} intrinsic
|
|
@findex @code{DLOG10} intrinsic
|
|
@cindex logarithm
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{LOG10(X)} computes the base 10 logarithm of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = LOG10(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
|
|
The kind type parameter is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_log10
|
|
real(8) :: x = 10.0_8
|
|
x = log10(x)
|
|
end program test_log10
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{ALOG10(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F95 and later
|
|
@item @code{DLOG10(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
@node LOGICAL
|
|
@section @code{LOGICAL} --- Convert to logical type
|
|
@findex @code{LOGICAL} intrinsic
|
|
@cindex conversion function (logical)
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node LSHIFT
|
|
@section @code{LSHIFT} --- Left shift bits
|
|
@findex @code{LSHIFT}
|
|
@cindex bit manipulation
|
|
|
|
Not yet implemented in GNU Fortran.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
@node LSTAT
|
|
@section @code{LSTAT} --- Get file status
|
|
@findex @code{LSTAT} intrinsic
|
|
@cindex file system operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{LSTAT} is identical to @ref{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 @code{BUFF} are the same as described by @ref{STAT}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL LSTAT(FILE,BUFF[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{FILE} @tab The type shall be @code{CHARACTER(*)}, a valid path within the file system.
|
|
@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0
|
|
on success and a system specific error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
See @ref{STAT} for an example.
|
|
|
|
@item @emph{See also}:
|
|
To stat an open file: @ref{FSTAT}, to stat a file: @ref{STAT}
|
|
@end table
|
|
|
|
|
|
|
|
@node LTIME
|
|
@section @code{LTIME} --- Convert time to local time info
|
|
@findex @code{LTIME}
|
|
@cindex time function
|
|
|
|
Not yet implemented in GNU Fortran.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node MALLOC
|
|
@section @code{MALLOC} --- Allocate dynamic memory
|
|
@findex @code{MALLOC} intrinsic
|
|
@cindex MALLOC
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MALLOC(SIZE)} allocates @var{SIZE} bytes of dynamic memory and
|
|
returns the address of the allocated memory. The @code{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
|
|
@code{ALLOCATE}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{PTR = MALLOC(SIZE)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{SIZE} @tab The type shall be @code{INTEGER(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER(K)}, with @var{K} such that
|
|
variables of type @code{INTEGER(K)} have the same size as
|
|
C pointers (@code{sizeof(void *)}).
|
|
|
|
@item @emph{Example}:
|
|
The following example demonstrates the use of @code{MALLOC} and
|
|
@code{FREE} with Cray pointers. This example is intended to run on
|
|
32-bit systems, where the default integer kind is suitable to store
|
|
pointers; on 64-bit systems, ptr_x would need to be declared as
|
|
@code{integer(kind=8)}.
|
|
|
|
@smallexample
|
|
program test_malloc
|
|
integer i
|
|
integer ptr_x
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{FREE}
|
|
@end table
|
|
|
|
|
|
@node MATMUL
|
|
@section @code{MATMUL} --- matrix multiplication
|
|
@findex @code{MATMUL} intrinsic
|
|
@cindex matrix operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
@node MAX
|
|
@section @code{MAX} --- Maximum value of an argument list
|
|
@findex @code{MAX} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{MAX0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later
|
|
@item @code{AMAX0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MAX(X))} @tab F77 and later
|
|
@item @code{MAX1(X)} @tab @code{REAL(*) X} @tab @code{INT(MAX(X))} @tab F77 and later
|
|
@item @code{AMAX1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F77 and later
|
|
@item @code{DMAX1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{MAXLOC} @ref{MAXVAL}
|
|
@end table
|
|
|
|
|
|
@node MAXEXPONENT
|
|
@section @code{MAXEXPONENT} --- Maximum exponent of a real kind
|
|
@findex @code{MAXEXPONENT} intrinsic
|
|
@cindex MAXEXPONENT
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MAXEXPONENT(X)} returns the maximum exponent in the model of the
|
|
type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = MAXEXPONENT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program exponents
|
|
real(kind=4) :: x
|
|
real(kind=8) :: y
|
|
|
|
print *, minexponent(x), maxexponent(x)
|
|
print *, minexponent(y), maxexponent(y)
|
|
end program exponents
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
@node MAXLOC
|
|
@section @code{MAXLOC} --- Location of the maximum value within an array
|
|
@findex @code{MAXLOC} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{MAX}, @ref{MAXVAL}
|
|
@end table
|
|
|
|
|
|
|
|
@node MAXVAL
|
|
@section @code{MAXVAL} --- Maximum value of an array
|
|
@findex @code{MAXVAL} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{MAX}, @ref{MAXLOC}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node MERGE
|
|
@section @code{MERGE} --- Merge arrays
|
|
@findex @code{MERGE} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
@node MIN
|
|
@section @code{MIN} --- Minimum value of an argument list
|
|
@findex @code{MIN} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{MIN0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later
|
|
@item @code{AMIN0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MIN(X))} @tab F77 and later
|
|
@item @code{MIN1(X)} @tab @code{REAL(*) X} @tab @code{INT(MIN(X))} @tab F77 and later
|
|
@item @code{AMIN1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F77 and later
|
|
@item @code{DMIN1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{MINLOC}, @ref{MINVAL}
|
|
@end table
|
|
|
|
@node MINEXPONENT
|
|
@section @code{MINEXPONENT} --- Minimum exponent of a real kind
|
|
@findex @code{MINEXPONENT} intrinsic
|
|
@cindex MINEXPONENT
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MINEXPONENT(X)} returns the minimum exponent in the model of the
|
|
type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = MINEXPONENT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
See @code{MAXEXPONENT} for an example.
|
|
@end table
|
|
|
|
|
|
@node MINLOC
|
|
@section @code{MINLOC} --- Location of the minimum value within an array
|
|
@findex @code{MINLOC} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{MIN}, @ref{MINVAL}
|
|
|
|
@end table
|
|
|
|
|
|
@node MINVAL
|
|
@section @code{MINVAL} --- Minimum value of an array
|
|
@findex @code{MINVAL} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{MIN}, @ref{MINLOC}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node MOD
|
|
@section @code{MOD} --- Remainder function
|
|
@findex @code{MOD} intrinsic
|
|
@findex @code{AMOD} intrinsic
|
|
@findex @code{DMOD} intrinsic
|
|
@cindex remainder
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MOD(A,P)} computes the remainder of the division of A by P. It is
|
|
calculated as @code{A - (INT(A/P) * P)}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = MOD(A,P)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{A} @tab shall be a scalar of type @code{INTEGER} or @code{REAL}
|
|
@item @var{P} @tab shall be a scalar of the same type as @var{A} and not
|
|
equal to zero
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The kind of the return value is the result of cross-promoting
|
|
the kinds of the arguments.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Arguments @tab Return type @tab Standard
|
|
@item @code{AMOD(A,P)} @tab @code{REAL(4)} @tab @code{REAL(4)} @tab F95 and later
|
|
@item @code{DMOD(A,P)} @tab @code{REAL(8)} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node MODULO
|
|
@section @code{MODULO} --- Modulo function
|
|
@findex @code{MODULO} intrinsic
|
|
@cindex modulo
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MODULO(A,P)} computes the @var{A} modulo @var{P}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = MODULO(A,P)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{A} @tab shall be a scalar of type @code{INTEGER} or @code{REAL}
|
|
@item @var{P} @tab shall be a scalar of the same type and kind as @var{A}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The type and kind of the result are those of the arguments.
|
|
@table @asis
|
|
@item If @var{A} and @var{P} are of type @code{INTEGER}:
|
|
@code{MODULO(A,P)} has the value @var{R} such that @code{A=Q*P+R}, where
|
|
@var{Q} is an integer and @var{R} is between 0 (inclusive) and @var{P}
|
|
(exclusive).
|
|
@item If @var{A} and @var{P} are of type @code{REAL}:
|
|
@code{MODULO(A,P)} has the value of @code{A - FLOOR (A / P) * P}.
|
|
@end table
|
|
In all cases, if @var{P} is zero the result is processor-dependent.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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 test_mod
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node MVBITS
|
|
@section @code{MVBITS} --- Move bits from one integer to another
|
|
@findex @code{MVBITS} intrinsic
|
|
@cindex bit operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node MOVE_ALLOC
|
|
@section @code{MOVE_ALLOC} --- Move allocation from one object to another
|
|
@findex @code{MOVE_ALLOC} intrinsic
|
|
@cindex MOVE_ALLOC
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{MOVE_ALLOC(SRC, DEST)} moves the allocation from @var{SRC} to
|
|
@var{DEST}. @var{SRC} will become deallocated in the process.
|
|
|
|
@item @emph{Standard}:
|
|
F2003 and later
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL MOVE_ALLOC(SRC, DEST)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{SRC} @tab @code{ALLOCATABLE}, @code{INTENT(INOUT)}, may be of any type and kind.
|
|
@item @var{DEST} @tab @code{ALLOCATABLE}, @code{INTENT(OUT)}, shall be of the same type, kind and rank as @var{SRC}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
None
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node NEAREST
|
|
@section @code{NEAREST} --- Nearest representable number
|
|
@findex @code{NEAREST} intrinsic
|
|
@cindex processor-representable number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{NEAREST(X, S)} returns the processor-representable number nearest
|
|
to @code{X} in the direction indicated by the sign of @code{S}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = NEAREST(X, S)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@item @var{S} @tab (Optional) shall be of type @code{REAL} and
|
|
not equal to zero.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type as @code{X}. If @code{S} is
|
|
positive, @code{NEAREST} returns the processor-representable number
|
|
greater than @code{X} and nearest to it. If @code{S} is negative,
|
|
@code{NEAREST} returns the processor-representable number smaller than
|
|
@code{X} and nearest to it.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node NEW_LINE
|
|
@section @code{NEW_LINE} --- New line character
|
|
@findex @code{NEW_LINE} intrinsic
|
|
@findex @code{NEW_LINE} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{NEW_LINE(C)} returns the new-line character
|
|
|
|
@item @emph{Standard}:
|
|
F2003 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{C = NEW_LINE(C)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{C} @tab The argument shall be a scalar or array of the
|
|
type @code{CHARACTER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Returns a @var{CHARACTER} scalar of length one with the new-line character of
|
|
the same kind as parameter @var{C}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program newline
|
|
implicit none
|
|
write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.'
|
|
end program newline
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node NINT
|
|
@section @code{NINT} --- Nearest whole number
|
|
@findex @code{NINT} intrinsic
|
|
@findex @code{IDNINT} intrinsic
|
|
@cindex whole number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{NINT(X)} rounds its argument to the nearest whole number.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = NINT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Returns @var{A} with the fractional portion of its magnitude eliminated by
|
|
rounding to the nearest whole number and with its sign preserved,
|
|
converted to an @code{INTEGER} of the default kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .33 .33 .33
|
|
@item Name @tab Argument @tab Standard
|
|
@item @code{IDNINT(X)} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{CEILING}, @ref{FLOOR}
|
|
|
|
@end table
|
|
|
|
|
|
@node NOT
|
|
@section @code{NOT} --- Logical negation
|
|
@findex @code{NOT} intrinsic
|
|
@cindex logical operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node NULL
|
|
@section @code{NULL} --- Function that returns an disassociated pointer
|
|
@findex @code{NULL} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{ASSOCIATED}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node OR
|
|
@section @code{OR} --- Bitwise logical OR
|
|
@findex @code{OR} intrinsic
|
|
@cindex bit operations
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
Bitwise logical @code{OR}.
|
|
|
|
This intrinsic routine is provided for backwards compatibility with
|
|
GNU Fortran 77. For integer arguments, programmers should consider
|
|
the use of the @ref{IOR} intrinsic defined by the Fortran standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{RESULT = OR(X, Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return type is either @code{INTEGER(*)} or @code{LOGICAL}
|
|
after cross-promotion of the arguments.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
F95 elemental function: @ref{IOR}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node PACK
|
|
@section @code{PACK} --- Pack an array into an array of rank one
|
|
@findex @code{PACK} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@ref{UNPACK}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node PERROR
|
|
@section @code{PERROR} --- Print system error message
|
|
@findex @code{PERROR} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@ref{IERRNO}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node PRECISION
|
|
@section @code{PRECISION} --- Decimal precision of a real kind
|
|
@findex @code{PRECISION} intrinsic
|
|
@cindex PRECISION
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{PRECISION(X)} returns the decimal precision in the model of the
|
|
type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = PRECISION(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL} or @code{COMPLEX}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node PRESENT
|
|
@section @code{PRESENT} --- Determine whether an optional argument is specified
|
|
@findex @code{PRESENT} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node PRODUCT
|
|
@section @code{PRODUCT} --- Product of array elements
|
|
@findex @code{PRODUCT} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@ref{SUM}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node RADIX
|
|
@section @code{RADIX} --- Base of a model number
|
|
@findex @code{RADIX} intrinsic
|
|
@cindex base
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{RADIX(X)} returns the base of the model representing the entity @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{R = RADIX(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab Shall be of type @code{INTEGER} or @code{REAL}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is a scalar of type @code{INTEGER} and of the default
|
|
integer kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node RANDOM_NUMBER
|
|
@section @code{RANDOM_NUMBER} --- Pseudo-random number
|
|
@findex @code{RANDOM_NUMBER} intrinsic
|
|
@cindex random numbers
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{RANDOM_SEED}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node RANDOM_SEED
|
|
@section @code{RANDOM_SEED} --- Initialize a pseudo-random number sequence
|
|
@findex @code{RANDOM_SEED} intrinsic
|
|
@cindex random numbers
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{RANDOM_NUMBER}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node RAND
|
|
@section @code{RAND} --- Real pseudo-random number
|
|
@findex @code{RAND} intrinsic
|
|
@findex @code{RAN} intrinsic
|
|
@cindex random number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{RAND(FLAG)} returns a pseudo-random number from a uniform
|
|
distribution between 0 and 1. If @var{FLAG} is 0, the next number
|
|
in the current sequence is returned; if @var{FLAG} is 1, the generator
|
|
is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
|
|
it is used as a new seed with @code{SRAND}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = RAND(FLAG)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{FLAG} @tab shall be a scalar @code{INTEGER} of kind 4.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of @code{REAL} type and the default kind.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Note}:
|
|
For compatibility with HP FORTRAN 77/iX, the @code{RAN} intrinsic is
|
|
provided as an alias for @code{RAND}.
|
|
|
|
@item @emph{See also}:
|
|
@ref{SRAND}, @ref{RANDOM_NUMBER}
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node RANGE
|
|
@section @code{RANGE} --- Decimal exponent range of a real kind
|
|
@findex @code{RANGE} intrinsic
|
|
@cindex RANGE
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{RANGE(X)} returns the decimal exponent range in the model of the
|
|
type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{I = RANGE(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL} or @code{COMPLEX}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{INTEGER} and of the default integer
|
|
kind.
|
|
|
|
@item @emph{Example}:
|
|
See @code{PRECISION} for an example.
|
|
@end table
|
|
|
|
|
|
|
|
@node RAN
|
|
@section @code{RAN} --- Real pseudo-random number
|
|
@findex @code{RAN} intrinsic
|
|
@cindex random number
|
|
|
|
@table @asis
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{See also}:
|
|
@ref{RAND}, @ref{RANDOM_NUMBER}
|
|
@end table
|
|
|
|
|
|
|
|
@node REAL
|
|
@section @code{REAL} --- Convert to real type
|
|
@findex @code{REAL} intrinsic
|
|
@findex @code{REALPART} intrinsic
|
|
@cindex true values
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{REAL(X [, KIND])} converts its argument @var{X} to a real type. The
|
|
@code{REALPART(X)} function is provided for compatibility with @command{g77},
|
|
and its use is strongly discouraged.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .30 .80
|
|
@item @code{X = REAL(X)}
|
|
@item @code{X = REAL(X, KIND)}
|
|
@item @code{X = REALPART(Z)}
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be @code{INTEGER(*)}, @code{REAL(*)}, or
|
|
@code{COMPLEX(*)}.
|
|
@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
These functions return a @code{REAL(*)} variable or array under
|
|
the following rules:
|
|
|
|
@table @asis
|
|
@item (A)
|
|
@code{REAL(X)} is converted to a default real type if @var{X} is an
|
|
integer or real variable.
|
|
@item (B)
|
|
@code{REAL(X)} is converted to a real type with the kind type parameter
|
|
of @var{X} if @var{X} is a complex variable.
|
|
@item (C)
|
|
@code{REAL(X, KIND)} is converted to a real type with kind type
|
|
parameter @var{KIND} if @var{X} is a complex, integer, or real
|
|
variable.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_real
|
|
complex :: x = (1.0, 2.0)
|
|
print *, real(x), real(x,8), realpart(x)
|
|
end program test_real
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
@ref{DBLE}, @ref{DFLOAT}, @ref{FLOAT}
|
|
|
|
@end table
|
|
|
|
|
|
@node RENAME
|
|
@section @code{RENAME} --- Rename a file
|
|
@findex @code{RENAME} intrinsic
|
|
@cindex file system operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node REPEAT
|
|
@section @code{REPEAT} --- Repeated string concatenation
|
|
@findex @code{REPEAT} intrinsic
|
|
@cindex string manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node RESHAPE
|
|
@section @code{RESHAPE} --- Function to reshape an array
|
|
@findex @code{RESHAPE} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{SHAPE}
|
|
@end table
|
|
|
|
|
|
|
|
@node RRSPACING
|
|
@section @code{RRSPACING} --- Reciprocal of the relative spacing
|
|
@findex @code{RRSPACING} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{RRSPACING(X)} returns the reciprocal of the relative spacing of
|
|
model numbers near @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = RRSPACING(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as @var{X}.
|
|
The value returned is equal to
|
|
@code{ABS(FRACTION(X)) * FLOAT(RADIX(X))**DIGITS(X)}.
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node RSHIFT
|
|
@section @code{RSHIFT} --- Right shift bits
|
|
@findex @code{RSHIFT}
|
|
@cindex bit manipulation
|
|
|
|
Not yet implemented in GNU Fortran.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node SCALE
|
|
@section @code{SCALE} --- Scale a real value
|
|
@findex @code{SCALE} intrinsic
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SCALE(X,I)} returns @code{X * RADIX(X)**I}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = SCALE(X, I)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type of the argument shall be a @code{REAL}.
|
|
@item @var{I} @tab The type of the argument shall be a @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as @var{X}.
|
|
Its value is @code{X * RADIX(X)**I}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_scale
|
|
real :: x = 178.1387e-4
|
|
integer :: i = 5
|
|
print *, scale(x,i), x*radix(x)**i
|
|
end program test_scale
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
@node SCAN
|
|
@section @code{SCAN} --- Scan a string for the presence of a set of characters
|
|
@findex @code{SCAN} intrinsic
|
|
@cindex string manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SECNDS
|
|
@section @code{SECNDS} --- Time function
|
|
@findex @code{SECNDS} intrinsic
|
|
@cindex SECNDS
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SECNDS(X)} gets the time in seconds from the real-time system clock.
|
|
@var{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.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{T = SECNDS (X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item Name @tab Type
|
|
@item @var{T} @tab REAL(4)
|
|
@item @var{X} @tab REAL(4)
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
None
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_secnds
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node SELECTED_INT_KIND
|
|
@section @code{SELECTED_INT_KIND} --- Choose integer kind
|
|
@findex @code{SELECTED_INT_KIND} intrinsic
|
|
@cindex integer kind
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SELECTED_INT_KIND(I)} return the kind value of the smallest integer
|
|
type that can represent all values ranging from @math{-10^I} (exclusive)
|
|
to @math{10^I} (exclusive). If there is no integer kind that accommodates
|
|
this range, @code{SELECTED_INT_KIND} returns @math{-1}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .30 .80
|
|
@item @code{J = SELECTED_INT_KIND(I)}
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{I} @tab shall be a scalar and of type @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node SELECTED_REAL_KIND
|
|
@section @code{SELECTED_REAL_KIND} --- Choose real kind
|
|
@findex @code{SELECTED_REAL_KIND} intrinsic
|
|
@cindex real kind
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SELECTED_REAL_KIND(P,R)} return the kind value of a real data type
|
|
with decimal precision greater of at least @code{P} digits and exponent
|
|
range greater at least @code{R}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .30 .80
|
|
@item @code{I = SELECTED_REAL_KIND(P,R)}
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{P} @tab (Optional) shall be a scalar and of type @code{INTEGER}.
|
|
@item @var{R} @tab (Optional) shall be a scalar and of type @code{INTEGER}.
|
|
@end multitable
|
|
At least one argument shall be present.
|
|
|
|
@item @emph{Return value}:
|
|
|
|
@code{SELECTED_REAL_KIND} returns the value of the kind type parameter of
|
|
a real data type with decimal precision of at least @code{P} digits and a
|
|
decimal exponent range of at least @code{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
|
|
@table @asis
|
|
@item -1 if the processor does not support a real data type with a
|
|
precision greater than or equal to @code{P}
|
|
@item -2 if the processor does not support a real type with an exponent
|
|
range greater than or equal to @code{R}
|
|
@item -3 if neither is supported.
|
|
@end table
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
@node SET_EXPONENT
|
|
@section @code{SET_EXPONENT} --- Set the exponent of the model
|
|
@findex @code{SET_EXPONENT} intrinsic
|
|
@cindex exponent
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SET_EXPONENT(X, I)} returns the real number whose fractional part
|
|
is that that of @var{X} and whose exponent part if @var{I}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = SET_EXPONENT(X, I)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@item @var{I} @tab shall be of type @code{INTEGER}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as @var{X}.
|
|
The real number whose fractional part
|
|
is that that of @var{X} and whose exponent part if @var{I} is returned;
|
|
it is @code{FRACTION(X) * RADIX(X)**I}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_setexp
|
|
real :: x = 178.1387e-4
|
|
integer :: i = 17
|
|
print *, set_exponent(x), fraction(x) * radix(x)**i
|
|
end program test_setexp
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
|
|
|
|
@node SHAPE
|
|
@section @code{SHAPE} --- Determine the shape of an array
|
|
@findex @code{SHAPE} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{RESHAPE}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SIGN
|
|
@section @code{SIGN} --- Sign copying function
|
|
@findex @code{SIGN} intrinsic
|
|
@findex @code{ISIGN} intrinsic
|
|
@findex @code{DSIGN} intrinsic
|
|
@cindex sign copying
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SIGN(A,B)} returns the value of @var{A} with the sign of @var{B}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = SIGN(A,B)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{A} @tab shall be a scalar of type @code{INTEGER} or @code{REAL}
|
|
@item @var{B} @tab shall be a scalar of the same type and kind as @var{A}
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The kind of the return value is that of @var{A} and @var{B}.
|
|
If @math{B\ge 0} then the result is @code{ABS(A)}, else
|
|
it is @code{-ABS(A)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Arguments @tab Return type @tab Standard
|
|
@item @code{ISIGN(A,P)} @tab @code{INTEGER(4)} @tab @code{INTEGER(4)} @tab f95, gnu
|
|
@item @code{DSIGN(A,P)} @tab @code{REAL(8)} @tab @code{REAL(8)} @tab f95, gnu
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node SIGNAL
|
|
@section @code{SIGNAL} --- Signal handling subroutine (or function)
|
|
@findex @code{SIGNAL} intrinsic
|
|
@cindex SIGNAL subroutine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SIGNAL(NUMBER, HANDLER [, STATUS])} causes external subroutine
|
|
@var{HANDLER} to be executed with a single integer argument when signal
|
|
@var{NUMBER} occurs. If @var{HANDLER} is an integer, it can be used to
|
|
turn off handling of signal @var{NUMBER} or revert to its default
|
|
action. See @code{signal(2)}.
|
|
|
|
If @code{SIGNAL} is called as a subroutine and the @var{STATUS} argument
|
|
is supplied, it is set to the value returned by @code{signal(2)}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
subroutine, non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@multitable @columnfractions .30 .80
|
|
@item @code{CALL ALARM(NUMBER, HANDLER)}
|
|
@item @code{CALL ALARM(NUMBER, HANDLER, STATUS)}
|
|
@item @code{STATUS = ALARM(NUMBER, HANDLER)}
|
|
@end multitable
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{NUMBER} @tab shall be a scalar integer, with @code{INTENT(IN)}
|
|
@item @var{HANDLER}@tab Signal handler (@code{INTEGER FUNCTION} or
|
|
@code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
|
|
@code{INTEGER}. It is @code{INTENT(IN)}.
|
|
@item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar
|
|
integer. It has @code{INTENT(OUT)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The @code{SIGNAL} functions returns the value returned by @code{signal(2)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_signal
|
|
intrinsic signal
|
|
external handler_print
|
|
|
|
call signal (12, handler_print)
|
|
call signal (10, 1)
|
|
|
|
call sleep (30)
|
|
end program test_signal
|
|
@end smallexample
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SIN
|
|
@section @code{SIN} --- Sine function
|
|
@findex @code{SIN} intrinsic
|
|
@findex @code{DSIN} intrinsic
|
|
@findex @code{ZSIN} intrinsic
|
|
@findex @code{CDSIN} intrinsic
|
|
@cindex trigonometric functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SIN(X)} computes the sine of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = SIN(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value has same type and kind as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_sin
|
|
real :: x = 0.0
|
|
x = sin(x)
|
|
end program test_sin
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DSIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
|
|
@item @code{CSIN(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab f95, gnu
|
|
@item @code{ZSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
|
|
@item @code{CDSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{ASIN}
|
|
@end table
|
|
|
|
|
|
|
|
@node SINH
|
|
@section @code{SINH} --- Hyperbolic sine function
|
|
@findex @code{SINH} intrinsic
|
|
@findex @code{DSINH} intrinsic
|
|
@cindex hyperbolic sine
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SINH(X)} computes the hyperbolic sine of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = SINH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_sinh
|
|
real(8) :: x = - 1.0_8
|
|
x = sinh(x)
|
|
end program test_sinh
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DSINH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{ASINH}
|
|
@end table
|
|
|
|
|
|
|
|
@node SIZE
|
|
@section @code{SIZE} --- Determine the size of an array
|
|
@findex @code{SIZE} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
@node SNGL
|
|
@section @code{SNGL} --- Convert double precision real to default real
|
|
@findex @code{SNGL} intrinsic
|
|
@cindex conversion function (real)
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SNGL(A)} converts the double precision real @var{A}
|
|
to a default real value. This is an archaic form of @code{REAL}
|
|
that is specific to one type for @var{A}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = SNGL(A)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{A} @tab The type shall be a double precision @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type default @code{REAL}.
|
|
|
|
@item @emph{See also}:
|
|
@ref{DBLE}
|
|
@end table
|
|
|
|
|
|
|
|
@node SPACING
|
|
@section @code{SPACING} --- Smallest distance between two numbers of a given type
|
|
@findex @code{SPACING} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SPREAD
|
|
@section @code{SPREAD} --- Add a dimension to an array
|
|
@findex @code{SPREAD} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SQRT
|
|
@section @code{SQRT} --- Square-root function
|
|
@findex @code{SQRT} intrinsic
|
|
@findex @code{DSQRT} intrinsic
|
|
@findex @code{CSQRT} intrinsic
|
|
@findex @code{ZSQRT} intrinsic
|
|
@findex @code{CDSQRT} intrinsic
|
|
@cindex square-root
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SQRT(X)} computes the square root of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = SQRT(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)} or
|
|
@code{COMPLEX(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
|
|
The kind type parameter is the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DSQRT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later
|
|
@item @code{CSQRT(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F95 and later
|
|
@item @code{ZSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
|
|
@end multitable
|
|
@end table
|
|
|
|
|
|
|
|
@node SRAND
|
|
@section @code{SRAND} --- Reinitialize the random number generator
|
|
@findex @code{SRAND} intrinsic
|
|
@cindex random number
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{SRAND} reinitializes the pseudo-random number generator
|
|
called by @code{RAND} and @code{IRAND}. The new seed used by the
|
|
generator is specified by the required argument @var{SEED}.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL SRAND(SEED)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{SEED} @tab shall be a scalar @code{INTEGER(kind=4)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
Does not return.
|
|
|
|
@item @emph{Example}:
|
|
See @code{RAND} and @code{IRAND} for examples.
|
|
|
|
@item @emph{Notes}:
|
|
The Fortran 2003 standard specifies the intrinsic @code{RANDOM_SEED} to
|
|
initialize the pseudo-random numbers generator and @code{RANDOM_NUMBER}
|
|
to generate pseudo-random numbers. Please note that in
|
|
GNU Fortran, these two sets of intrinsics (@code{RAND},
|
|
@code{IRAND} and @code{SRAND} on the one hand, @code{RANDOM_NUMBER} and
|
|
@code{RANDOM_SEED} on the other hand) access two independent
|
|
pseudo-random number generators.
|
|
|
|
@item @emph{See also}:
|
|
@ref{RAND}, @ref{RANDOM_SEED}, @ref{RANDOM_NUMBER}
|
|
|
|
@end table
|
|
|
|
|
|
@node STAT
|
|
@section @code{STAT} --- Get file status
|
|
@findex @code{STAT} intrinsic
|
|
@cindex file system operations
|
|
|
|
@table @asis
|
|
@item @emph{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 @code{BUFF}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @code{buff(1)} @tab Device ID
|
|
@item @code{buff(2)} @tab Inode number
|
|
@item @code{buff(3)} @tab File mode
|
|
@item @code{buff(4)} @tab Number of links
|
|
@item @code{buff(5)} @tab Owner's uid
|
|
@item @code{buff(6)} @tab Owner's gid
|
|
@item @code{buff(7)} @tab ID of device containing directory entry for file (0 if not available)
|
|
@item @code{buff(8)} @tab File size (bytes)
|
|
@item @code{buff(9)} @tab Last access time
|
|
@item @code{buff(10)} @tab Last modification time
|
|
@item @code{buff(11)} @tab Last file status change time
|
|
@item @code{buff(12)} @tab Preferred I/O block size (-1 if not available)
|
|
@item @code{buff(13)} @tab Number of blocks allocated (-1 if not available)
|
|
@end multitable
|
|
|
|
Not all these elements are relevant on all systems.
|
|
If an element is not relevant, it is returned as 0.
|
|
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@code{CALL STAT(FILE,BUFF[,STATUS])}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{FILE} @tab The type shall be @code{CHARACTER(*)}, a valid path within the file system.
|
|
@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}.
|
|
@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0
|
|
on success and a system specific error code otherwise.
|
|
@end multitable
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
To stat an open file: @ref{FSTAT}, to stat a link: @ref{LSTAT}
|
|
@end table
|
|
|
|
|
|
|
|
@node SUM
|
|
@section @code{SUM} --- Sum of array elements
|
|
@findex @code{SUM} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@ref{PRODUCT}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SYMLNK
|
|
@section @code{SYMLNK} --- Create a symbolic link
|
|
@findex @code{SYMLNK} intrinsic
|
|
@cindex file system operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
@item @emph{Class}:
|
|
GNU extension
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SYSTEM
|
|
@section @code{SYSTEM} --- Execute a shell command
|
|
@findex @code{SYSTEM} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node SYSTEM_CLOCK
|
|
@section @code{SYSTEM_CLOCK} --- Time function
|
|
@findex @code{SYSTEM_CLOCK} intrinsic
|
|
@cindex time functions
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
@node TAN
|
|
@section @code{TAN} --- Tangent function
|
|
@findex @code{TAN} intrinsic
|
|
@findex @code{DTAN} intrinsic
|
|
@cindex trigonometric functions
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{TAN(X)} computes the tangent of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = TAN(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)}. The kind type parameter is
|
|
the same as @var{X}.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_tan
|
|
real(8) :: x = 0.165_8
|
|
x = tan(x)
|
|
end program test_tan
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DTAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{ATAN}
|
|
@end table
|
|
|
|
|
|
|
|
@node TANH
|
|
@section @code{TANH} --- Hyperbolic tangent function
|
|
@findex @code{TANH} intrinsic
|
|
@findex @code{DTANH} intrinsic
|
|
@cindex hyperbolic tangent
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{TANH(X)} computes the hyperbolic tangent of @var{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F77 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{X = TANH(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be @code{REAL(*)}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of type @code{REAL(*)} and lies in the range
|
|
@math{ - 1 \leq tanh(x) \leq 1 }.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
program test_tanh
|
|
real(8) :: x = 2.1_8
|
|
x = tanh(x)
|
|
end program test_tanh
|
|
@end smallexample
|
|
|
|
@item @emph{Specific names}:
|
|
@multitable @columnfractions .20 .20 .20 .40
|
|
@item Name @tab Argument @tab Return type @tab Standard
|
|
@item @code{DTANH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later
|
|
@end multitable
|
|
|
|
@item @emph{See also}:
|
|
@ref{ATANH}
|
|
@end table
|
|
|
|
|
|
|
|
@node TIME
|
|
@section @code{TIME} --- Time function
|
|
@findex @code{TIME} intrinsic
|
|
@cindex time functions
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
@node TINY
|
|
@section @code{TINY} --- Smallest positive number of a real kind
|
|
@findex @code{TINY} intrinsic
|
|
@cindex tiny
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@code{TINY(X)} returns the smallest positive (non zero) number
|
|
in the model of the type of @code{X}.
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{Y = TINY(X)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab shall be of type @code{REAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return value is of the same type and kind as @var{X}
|
|
|
|
@item @emph{Example}:
|
|
See @code{HUGE} for an example.
|
|
@end table
|
|
|
|
|
|
|
|
@node TRANSFER
|
|
@section @code{TRANSFER} --- Transfer bit patterns
|
|
@findex @code{TRANSFER} intrinsic
|
|
@cindex bit manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node TRANSPOSE
|
|
@section @code{TRANSPOSE} --- Transpose an array of rank two
|
|
@findex @code{TRANSPOSE} intrinsic
|
|
@cindex matrix manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node TRIM
|
|
@section @code{TRIM} --- Function to remove trailing blank characters of a string
|
|
@findex @code{TRIM} intrinsic
|
|
@cindex string manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node UBOUND
|
|
@section @code{UBOUND} --- Upper dimension bounds of an array
|
|
@findex @code{UBOUND} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Inquiry function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LBOUND}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node UMASK
|
|
@section @code{UMASK} --- Set the file creation mask
|
|
@findex @code{UMASK} intrinsic
|
|
@cindex file system operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node UNLINK
|
|
@section @code{UNLINK} --- Remove a file from the file system
|
|
@findex @code{UNLINK} intrinsic
|
|
@cindex file system operations
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Subroutine
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{LINK}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node UNMASK
|
|
@section @code{UNMASK} --- (?)
|
|
@findex @code{UNMASK} intrinsic
|
|
@cindex undocumented intrinsic
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
@item @emph{Class}:
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node UNPACK
|
|
@section @code{UNPACK} --- Unpack an array of rank one into an array
|
|
@findex @code{UNPACK} intrinsic
|
|
@cindex array manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Transformational function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
|
|
@item @emph{See also}:
|
|
@ref{PACK}
|
|
@end table
|
|
|
|
|
|
|
|
|
|
@node VERIFY
|
|
@section @code{VERIFY} --- Scan a string for the absence of a set of characters
|
|
@findex @code{VERIFY} intrinsic
|
|
@cindex string manipulation
|
|
|
|
Intrinsic implemented, documentation pending.
|
|
|
|
@table @asis
|
|
@item @emph{Description}:
|
|
@item @emph{Standard}:
|
|
F95 and later
|
|
|
|
@item @emph{Class}:
|
|
Elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@item @emph{Arguments}:
|
|
@item @emph{Return value}:
|
|
@item @emph{Example}:
|
|
@item @emph{Specific names}:
|
|
@item @emph{See also}:
|
|
@end table
|
|
|
|
|
|
@node XOR
|
|
@section @code{XOR} --- Bitwise logical exclusive OR
|
|
@findex @code{XOR} intrinsic
|
|
@cindex bit operations
|
|
|
|
@table @asis
|
|
@item @emph{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 @ref{IEOR} intrinsic defined by the Fortran standard.
|
|
|
|
@item @emph{Standard}:
|
|
GNU extension
|
|
|
|
@item @emph{Class}:
|
|
Non-elemental function
|
|
|
|
@item @emph{Syntax}:
|
|
@code{RESULT = XOR(X, Y)}
|
|
|
|
@item @emph{Arguments}:
|
|
@multitable @columnfractions .15 .80
|
|
@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
|
|
@end multitable
|
|
|
|
@item @emph{Return value}:
|
|
The return type is either @code{INTEGER(*)} or @code{LOGICAL}
|
|
after cross-promotion of the arguments.
|
|
|
|
@item @emph{Example}:
|
|
@smallexample
|
|
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
|
|
@end smallexample
|
|
|
|
@item @emph{See also}:
|
|
F95 elemental function: @ref{IEOR}
|
|
@end table
|
|
|
|
|