gcc/fortran/intrinsic.texi

   1 @ignore
   2 Copyright (C) 2005
   3 Free Software Foundation, Inc.
   4 This is part of the GFORTRAN manual.
   5 For copying conditions, see the file gfortran.texi.
   6
   7 Permission is granted to copy, distribute and/or modify this document
   8 under the terms of the GNU Free Documentation License, Version 1.2 or
   9 any later version published by the Free Software Foundation; with the
  10 Invariant Sections being ``GNU General Public License'' and ``Funding
  11 Free Software'', the Front-Cover texts being (a) (see below), and with
  12 the Back-Cover Texts being (b) (see below).  A copy of the license is
  13 included in the gfdl(7) man page.
  14
  15
  16 Some basic guidelines for editing this document:
  17
  18   (1) The intrinsic procedures are to be listed in alphabetical order.
  19   (2) The generic name is to be use.
  20   (3) The specific names are included in the function index and in a
  21       table at the end of the node (See ABS entry).
  22   (4) Try to maintain the same style for each entry.
  23
  24
  25 @end ignore
  26
  27 @node Intrinsic Procedures
  28 @chapter Intrinsic Procedures
  29 @cindex Intrinsic Procedures
  30
  31 This portion of the document is incomplete and undergoing massive expansion
  32 and editing.  All contributions and corrections are strongly encouraged.
  33
  34 @menu
  35 * Introduction:         Introduction
  36 * @code{ABORT}:         ABORT,     Abort the program
  37 * @code{ABS}:           ABS,       Absolute value
  38 * @code{ACHAR}:         ACHAR,     Character in @acronym{ASCII} collating sequence
  39 * @code{ACOS}:          ACOS,      Arc cosine function
  40 * @code{ADJUSTL}:       ADJUSTL,   Left adjust a string
  41 * @code{ADJUSTR}:       ADJUSTR,   Right adjust a string
  42 * @code{AIMAG}:         AIMAG,     Imaginary part of complex number
  43 * @code{AINT}:          AINT,      Truncate to a whole number
  44 * @code{ALARM}:         ALARM,     Set an alarm clock
  45 * @code{ALL}:           ALL,       Determine if all values are true
  46 * @code{ALLOCATED}:     ALLOCATED, Status of allocatable entity
  47 * @code{ANINT}:         ANINT,     Nearest whole number
  48 * @code{ANY}:           ANY,       Determine if any values are true
  49 * @code{ASIN}:          ASIN,      Arcsine function
  50 * @code{ASSOCIATED}:    ASSOCIATED, Status of a pointer or pointer/target pair
  51 * @code{ATAN}:          ATAN,      Arctangent function
  52 * @code{ATAN2}:         ATAN2,     Arctangent function
  53 * @code{BESJ0}:         BESJ0,     Bessel function of the first kind of order 0
  54 * @code{BESJ1}:         BESJ1,     Bessel function of the first kind of order 1
  55 * @code{BESJN}:         BESJN,     Bessel function of the first kind
  56 * @code{BESY0}:         BESY0,     Bessel function of the second kind of order 0
  57 * @code{BESY1}:         BESY1,     Bessel function of the second kind of order 1
  58 * @code{BESYN}:         BESYN,     Bessel function of the second kind
  59 * @code{BIT_SIZE}:      BIT_SIZE,  Bit size inquiry function
  60 * @code{BTEST}:         BTEST,     Bit test function
  61 * @code{CEILING}:       CEILING,   Integer ceiling function
  62 * @code{CHAR}:          CHAR,      Character conversion function
  63 * @code{CMPLX}:         CMPLX,     Complex conversion function
  64 * @code{COMMAND_ARGUMENT_COUNT}: COMMAND_ARGUMENT_COUNT,  Command line argument count
  65 * @code{CONJG}:         CONJG,     Complex conjugate function
  66 * @code{COS}:           COS,       Cosine function
  67 * @code{COSH}:          COSH,      Hyperbolic cosine function
  68 * @code{COUNT}:         COUNT,     Count occurrences of .TRUE. in an array
  69 * @code{CPU_TIME}:      CPU_TIME,  CPU time subroutine
  70 * @code{CSHIFT}:        CSHIFT,    Circular array shift function
  71 * @code{CTIME}:         CTIME,     Subroutine (or function) to convert a time into a string
  72 * @code{DATE_AND_TIME}: DATE_AND_TIME, Date and time subroutine
  73 * @code{DBLE}:          DBLE,      Double precision conversion function
  74 * @code{DCMPLX}:        DCMPLX,    Double complex conversion function
  75 * @code{DFLOAT}:        DFLOAT,    Double precision conversion function
  76 * @code{DIGITS}:        DIGITS,    Significant digits function
  77 * @code{DIM}:           DIM,       Dim function
  78 * @code{DOT_PRODUCT}:   DOT_PRODUCT, Dot product function
  79 * @code{DPROD}:         DPROD,     Double product function
  80 * @code{DREAL}:         DREAL,     Double real part function
  81 * @code{DTIME}:         DTIME,     Execution time subroutine (or function)
  82 * @code{EOSHIFT}:       EOSHIFT,   End-off shift function
  83 * @code{EPSILON}:       EPSILON,   Epsilon function
  84 * @code{ERF}:           ERF,       Error function
  85 * @code{ERFC}:          ERFC,      Complementary error function
  86 * @code{ETIME}:         ETIME,     Execution time subroutine (or function)
  87 * @code{EXIT}:          EXIT,      Exit the program with status.
  88 * @code{EXP}:           EXP,       Exponential function
  89 * @code{EXPONENT}:      EXPONENT,  Exponent function
  90 * @code{FDATE}:         FDATE,     Subroutine (or function) to get the current time as a string
  91 * @code{FLOAT}:         FLOAT,     Convert integer to default real
  92 * @code{FLOOR}:         FLOOR,     Integer floor function
  93 * @code{FNUM}:          FNUM,      File number function
  94 * @code{FREE}:          FREE,      Memory de-allocation subroutine
  95 * @code{LOC}:           LOC,       Returns the address of a variable
  96 * @code{LOG}:           LOG,       Logarithm function
  97 * @code{LOG10}:         LOG10,     Base 10 logarithm function
  98 * @code{MALLOC}:        MALLOC,    Dynamic memory allocation function
  99 * @code{REAL}:          REAL,      Convert to real type
 100 * @code{SECNDS}:        SECNDS,    Time function
 101 * @code{SIGNAL}:        SIGNAL,    Signal handling subroutine (or function)
 102 * @code{SIN}:           SIN,       Sine function
 103 * @code{SINH}:          SINH,      Hyperbolic sine function
 104 * @code{SQRT}:          SQRT,      Square-root function
 105 * @code{TAN}:           TAN,       Tangent function
 106 * @code{TANH}:          TANH,      Hyperbolic tangent function
 107 @end menu
 108
 109 @node Introduction
 110 @section Introduction to intrinsic procedures
 111
 112 Gfortran provides a rich set of intrinsic procedures that includes all
 113 the intrinsic procedures required by the Fortran 95 standard, a set of
 114 intrinsic procedures for backwards compatibility with Gnu Fortran 77
 115 (i.e., @command{g77}), and a small selection of intrinsic procedures
 116 from the Fortran 2003 standard.  Any description here, which conflicts with a
 117 description in either the Fortran 95 standard or the Fortran 2003 standard,
 118 is unintentional and the standard(s) should be considered authoritative.
 119
 120 The enumeration of the @code{KIND} type parameter is processor defined in
 121 the Fortran 95 standard.  Gfortran defines the default integer type and
 122 default real type by @code{INTEGER(KIND=4)} and @code{REAL(KIND=4)},
 123 respectively.  The standard mandates that both data types shall have
 124 another kind, which have more precision.  On typical target architectures
 125 supported by @command{gfortran}, this kind type parameter is @code{KIND=8}.
 126 Hence, @code{REAL(KIND=8)} and @code{DOUBLE PRECISION} are equivalent.
 127 In the description of generic intrinsic procedures, the kind type parameter
 128 will be specified by @code{KIND=*}, and in the description of specific
 129 names for an intrinsic procedure the kind type parameter will be explicitly
 130 given (e.g., @code{REAL(KIND=4)} or @code{REAL(KIND=8)}).  Finally, for
 131 brevity the optional @code{KIND=} syntax will be omitted.
 132
 133 Many of the intrinsics procedures take one or more optional arguments.
 134 This document follows the convention used in the Fortran 95 standard,
 135 and denotes such arguments by square brackets.
 136
 137 @command{Gfortran} offers the @option{-std=f95} and @option{-std=gnu} options,
 138 which can be used to restrict the set of intrinsic procedures to a
 139 given standard.  By default, @command{gfortran} sets the @option{-std=gnu}
 140 option, and so all intrinsic procedures described here are accepted.  There
 141 is one caveat.  For a select group of intrinsic procedures, @command{g77}
 142 implemented both a function and a subroutine.  Both classes
 143 have been implemented in @command{gfortran} for backwards compatibility
 144 with @command{g77}.  It is noted here that these functions and subroutines
 145 cannot be intermixed in a given subprogram.  In the descriptions that follow,
 146 the applicable option(s) is noted.
 147
 148
 149
 150 @node ABORT
 151 @section @code{ABORT} --- Abort the program
 152 @findex @code{ABORT}
 153 @cindex abort
 154
 155 @table @asis
 156 @item @emph{Description}:
 157 @code{ABORT} causes immediate termination of the program.  On operating
 158 systems that support a core dump, @code{ABORT} will produce a core dump,
 159 which is suitable for debugging purposes.
 160
 161 @item @emph{Option}:
 162 gnu
 163
 164 @item @emph{Class}:
 165 non-elemental subroutine
 166
 167 @item @emph{Syntax}:
 168 @code{CALL ABORT}
 169
 170 @item @emph{Return value}:
 171 Does not return.
 172
 173 @item @emph{Example}:
 174 @smallexample
 175 program test_abort
 176   integer :: i = 1, j = 2
 177   if (i /= j) call abort
 178 end program test_abort
 179 @end smallexample
 180 @end table
 181
 182
 183
 184 @node ABS
 185 @section @code{ABS} --- Absolute value
 186 @findex @code{ABS} intrinsic
 187 @findex @code{CABS} intrinsic
 188 @findex @code{DABS} intrinsic
 189 @findex @code{IABS} intrinsic
 190 @findex @code{ZABS} intrinsic
 191 @findex @code{CDABS} intrinsic
 192 @cindex absolute value
 193
 194 @table @asis
 195 @item @emph{Description}:
 196 @code{ABS(X)} computes the absolute value of @code{X}.
 197
 198 @item @emph{Option}:
 199 f95, gnu
 200
 201 @item @emph{Class}:
 202 elemental function
 203
 204 @item @emph{Syntax}:
 205 @code{X = ABS(X)}
 206
 207 @item @emph{Arguments}:
 208 @multitable @columnfractions .15 .80
 209 @item @var{X} @tab The type of the argument shall be an @code{INTEGER(*)},
 210 @code{REAL(*)}, or @code{COMPLEX(*)}.
 211 @end multitable
 212
 213 @item @emph{Return value}:
 214 The return value is of the same type and
 215 kind as the argument except the return value is @code{REAL(*)} for a
 216 @code{COMPLEX(*)} argument.
 217
 218 @item @emph{Example}:
 219 @smallexample
 220 program test_abs
 221   integer :: i = -1
 222   real :: x = -1.e0
 223   complex :: z = (-1.e0,0.e0)
 224   i = abs(i)
 225   x = abs(x)
 226   x = abs(z)
 227 end program test_abs
 228 @end smallexample
 229
 230 @item @emph{Specific names}:
 231 @multitable @columnfractions .24 .24 .24 .24
 232 @item Name            @tab Argument            @tab Return type       @tab Option
 233 @item @code{CABS(Z)}  @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)}    @tab f95, gnu
 234 @item @code{DABS(X)}  @tab @code{REAL(8)    X} @tab @code{REAL(8)}    @tab f95, gnu
 235 @item @code{IABS(I)}  @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab f95, gnu
 236 @item @code{ZABS(Z)}  @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
 237 @item @code{CDABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
 238 @end multitable
 239 @end table
 240
 241
 242
 243 @node ACHAR
 244 @section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence
 245 @findex @code{ACHAR} intrinsic
 246 @cindex @acronym{ASCII} collating sequence
 247
 248 @table @asis
 249 @item @emph{Description}:
 250 @code{ACHAR(I)} returns the character located at position @code{I}
 251 in the @acronym{ASCII} collating sequence.
 252
 253 @item @emph{Option}:
 254 f95, gnu
 255
 256 @item @emph{Class}:
 257 elemental function
 258
 259 @item @emph{Syntax}:
 260 @code{C = ACHAR(I)}
 261
 262 @item @emph{Arguments}:
 263 @multitable @columnfractions .15 .80
 264 @item @var{I} @tab The type shall be @code{INTEGER(*)}.
 265 @end multitable
 266
 267 @item @emph{Return value}:
 268 The return value is of type @code{CHARACTER} with a length of one.  The
 269 kind type parameter is the same as  @code{KIND('A')}.
 270
 271 @item @emph{Example}:
 272 @smallexample
 273 program test_achar
 274   character c
 275   c = achar(32)
 276 end program test_achar
 277 @end smallexample
 278 @end table
 279
 280
 281
 282 @node ACOS
 283 @section @code{ACOS} --- Arc cosine function
 284 @findex @code{ACOS} intrinsic
 285 @findex @code{DACOS} intrinsic
 286 @cindex arc cosine
 287
 288 @table @asis
 289 @item @emph{Description}:
 290 @code{ACOS(X)} computes the arc cosine of @var{X}.
 291
 292 @item @emph{Option}:
 293 f95, gnu
 294
 295 @item @emph{Class}:
 296 elemental function
 297
 298 @item @emph{Syntax}:
 299 @code{X = ACOS(X)}
 300
 301 @item @emph{Arguments}:
 302 @multitable @columnfractions .15 .80
 303 @item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
 304 less than one.
 305 @end multitable
 306
 307 @item @emph{Return value}:
 308 The return value is of type @code{REAL(*)} and it lies in the
 309 range @math{ 0 \leq \arccos (x) \leq \pi}.  The kind type
 310 parameter is the same as @var{X}.
 311
 312 @item @emph{Example}:
 313 @smallexample
 314 program test_acos
 315   real(8) :: x = 0.866_8
 316   x = achar(x)
 317 end program test_acos
 318 @end smallexample
 319
 320 @item @emph{Specific names}:
 321 @multitable @columnfractions .24 .24 .24 .24
 322 @item Name            @tab Argument          @tab Return type       @tab Option
 323 @item @code{DACOS(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 324 @end multitable
 325 @end table
 326
 327
 328
 329 @node ADJUSTL
 330 @section @code{ADJUSTL} --- Left adjust a string
 331 @findex @code{ADJUSTL} intrinsic
 332 @cindex adjust string
 333
 334 @table @asis
 335 @item @emph{Description}:
 336 @code{ADJUSTL(STR)} will left adjust a string by removing leading spaces.
 337 Spaces are inserted at the end of the string as needed.
 338
 339 @item @emph{Option}:
 340 f95, gnu
 341
 342 @item @emph{Class}:
 343 elemental function
 344
 345 @item @emph{Syntax}:
 346 @code{STR = ADJUSTL(STR)}
 347
 348 @item @emph{Arguments}:
 349 @multitable @columnfractions .15 .80
 350 @item @var{STR} @tab The type shall be @code{CHARACTER}.
 351 @end multitable
 352
 353 @item @emph{Return value}:
 354 The return value is of type @code{CHARACTER} where leading spaces
 355 are removed and the same number of spaces are inserted on the end
 356 of @var{STR}.
 357
 358 @item @emph{Example}:
 359 @smallexample
 360 program test_adjustl
 361   character(len=20) :: str = '   gfortran'
 362   str = adjustl(str)
 363   print *, str
 364 end program test_adjustl
 365 @end smallexample
 366 @end table
 367
 368
 369
 370 @node ADJUSTR
 371 @section @code{ADJUSTR} --- Right adjust a string
 372 @findex @code{ADJUSTR} intrinsic
 373 @cindex adjust string
 374
 375 @table @asis
 376 @item @emph{Description}:
 377 @code{ADJUSTR(STR)} will right adjust a string by removing trailing spaces.
 378 Spaces are inserted at the start of the string as needed.
 379
 380 @item @emph{Option}:
 381 f95, gnu
 382
 383 @item @emph{Class}:
 384 elemental function
 385
 386 @item @emph{Syntax}:
 387 @code{STR = ADJUSTR(STR)}
 388
 389 @item @emph{Arguments}:
 390 @multitable @columnfractions .15 .80
 391 @item @var{STR} @tab The type shall be @code{CHARACTER}.
 392 @end multitable
 393
 394 @item @emph{Return value}:
 395 The return value is of type @code{CHARACTER} where trailing spaces
 396 are removed and the same number of spaces are inserted at the start
 397 of @var{STR}.
 398
 399 @item @emph{Example}:
 400 @smallexample
 401 program test_adjustr
 402   character(len=20) :: str = 'gfortran'
 403   str = adjustr(str)
 404   print *, str
 405 end program test_adjustr
 406 @end smallexample
 407 @end table
 408
 409
 410
 411 @node AIMAG
 412 @section @code{AIMAG} --- Imaginary part of complex number
 413 @findex @code{AIMAG} intrinsic
 414 @findex @code{DIMAG} intrinsic
 415 @findex @code{IMAG} intrinsic
 416 @findex @code{IMAGPART} intrinsic
 417 @cindex Imaginary part
 418
 419 @table @asis
 420 @item @emph{Description}:
 421 @code{AIMAG(Z)} yields the imaginary part of complex argument @code{Z}.
 422 The @code{IMAG(Z)} and @code{IMAGPART(Z)} intrinsic functions are provided
 423 for compatibility with @command{g77}, and their use in new code is
 424 strongly discouraged.
 425
 426 @item @emph{Option}:
 427 f95, gnu
 428
 429 @item @emph{Class}:
 430 elemental function
 431
 432 @item @emph{Syntax}:
 433 @code{X = AIMAG(Z)}
 434
 435 @item @emph{Arguments}:
 436 @multitable @columnfractions .15 .80
 437 @item @var{Z} @tab The type of the argument shall be @code{COMPLEX(*)}.
 438 @end multitable
 439
 440 @item @emph{Return value}:
 441 The return value is of type real with the
 442 kind type parameter of the argument.
 443
 444 @item @emph{Example}:
 445 @smallexample
 446 program test_aimag
 447   complex(4) z4
 448   complex(8) z8
 449   z4 = cmplx(1.e0_4, 0.e0_4)
 450   z8 = cmplx(0.e0_8, 1.e0_8)
 451   print *, aimag(z4), dimag(z8)
 452 end program test_aimag
 453 @end smallexample
 454
 455 @item @emph{Specific names}:
 456 @multitable @columnfractions .24 .24 .24 .24
 457 @item Name            @tab Argument            @tab Return type       @tab Option
 458 @item @code{DIMAG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{REAL(8)}    @tab f95, gnu
 459 @item @code{IMAG(Z)}  @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)}    @tab gnu
 460 @item @code{IMAGPART(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab gnu
 461 @end multitable
 462 @end table
 463
 464
 465
 466 @node AINT
 467 @section @code{AINT} --- Imaginary part of complex number
 468 @findex @code{AINT} intrinsic
 469 @findex @code{DINT} intrinsic
 470 @cindex whole number
 471
 472 @table @asis
 473 @item @emph{Description}:
 474 @code{AINT(X [, KIND])} truncates its argument to a whole number.
 475
 476 @item @emph{Option}:
 477 f95, gnu
 478
 479 @item @emph{Class}:
 480 elemental function
 481
 482 @item @emph{Syntax}:
 483 @code{X = AINT(X)}
 484 @code{X = AINT(X, KIND)}
 485
 486 @item @emph{Arguments}:
 487 @multitable @columnfractions .15 .80
 488 @item @var{X}    @tab The type of the argument shall be @code{REAL(*)}.
 489 @item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
 490 initialization expression.
 491 @end multitable
 492
 493 @item @emph{Return value}:
 494 The return value is of type real with the kind type parameter of the
 495 argument if the optional @var{KIND} is absent; otherwise, the kind
 496 type parameter will be given by @var{KIND}.  If the magnitude of
 497 @var{X} is less than one, then @code{AINT(X)} returns zero.  If the
 498 magnitude is equal to or greater than one, then it returns the largest
 499 whole number that does not exceed its magnitude.  The sign is the same
 500 as the sign of @var{X}.
 501
 502 @item @emph{Example}:
 503 @smallexample
 504 program test_aint
 505   real(4) x4
 506   real(8) x8
 507   x4 = 1.234E0_4
 508   x8 = 4.321_8
 509   print *, aint(x4), dint(x8)
 510   x8 = aint(x4,8)
 511 end program test_aint
 512 @end smallexample
 513
 514 @item @emph{Specific names}:
 515 @multitable @columnfractions .24 .24 .24 .24
 516 @item Name           @tab Argument         @tab Return type      @tab Option
 517 @item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
 518 @end multitable
 519 @end table
 520
 521
 522
 523 @node ALARM
 524 @section @code{ALARM} --- Execute a routine after a given delay
 525 @findex @code{ALARM} intrinsic
 526
 527 @table @asis
 528 @item @emph{Description}:
 529 @code{ALARM(SECONDS [, STATUS])} causes external subroutine @var{HANDLER}
 530 to be executed after a delay of @var{SECONDS} by using @code{alarm(1)} to
 531 set up a signal and @code{signal(2)} to catch it. If @var{STATUS} is
 532 supplied, it will be returned with the number of seconds remaining until
 533 any previously scheduled alarm was due to be delivered, or zero if there
 534 was no previously scheduled alarm.
 535
 536 @item @emph{Option}:
 537 gnu
 538
 539 @item @emph{Class}:
 540 subroutine
 541
 542 @item @emph{Syntax}:
 543 @code{CALL ALARM(SECONDS, HANDLER)}
 544 @code{CALL ALARM(SECONDS, HANDLER, STATUS)}
 545
 546 @item @emph{Arguments}:
 547 @multitable @columnfractions .15 .80
 548 @item @var{SECONDS} @tab The type of the argument shall be a scalar
 549 @code{INTEGER}. It is @code{INTENT(IN)}.
 550 @item @var{HANDLER} @tab Signal handler (@code{INTEGER FUNCTION} or
 551 @code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
 552 @code{INTEGER}. It is @code{INTENT(IN)}.
 553 @item @var{STATUS}  @tab (Optional) @var{STATUS} shall be a scalar
 554 @code{INTEGER} variable. It is @code{INTENT(OUT)}.
 555 @end multitable
 556
 557 @item @emph{Example}:
 558 @smallexample
 559 program test_alarm
 560   external handler_print
 561   integer i
 562   call alarm (3, handler_print, i)
 563   print *, i
 564   call sleep(10)
 565 end program test_alarm
 566 @end smallexample
 567 This will cause the external routine @var{handler_print} to be called
 568 after 3 seconds.
 569 @end table
 570
 571
 572
 573 @node ALL
 574 @section @code{ALL} --- All values in @var{MASK} along @var{DIM} are true
 575 @findex @code{ALL} intrinsic
 576 @cindex true values
 577
 578 @table @asis
 579 @item @emph{Description}:
 580 @code{ALL(MASK [, DIM])} determines if all the values are true in @var{MASK}
 581 in the array along dimension @var{DIM}.
 582
 583 @item @emph{Option}:
 584 f95, gnu
 585
 586 @item @emph{Class}:
 587 transformational function
 588
 589 @item @emph{Syntax}:
 590 @code{L = ALL(MASK)}
 591 @code{L = ALL(MASK, DIM)}
 592
 593 @item @emph{Arguments}:
 594 @multitable @columnfractions .15 .80
 595 @item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
 596 it shall not be scalar.
 597 @item @var{DIM}  @tab (Optional) @var{DIM} shall be a scalar integer
 598 with a value that lies between one and the rank of @var{MASK}.
 599 @end multitable
 600
 601 @item @emph{Return value}:
 602 @code{ALL(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
 603 the kind type parameter is the same as the kind type parameter of
 604 @var{MASK}.  If @var{DIM} is present, then @code{ALL(MASK, DIM)} returns
 605 an array with the rank of @var{MASK} minus 1.  The shape is determined from
 606 the shape of @var{MASK} where the @var{DIM} dimension is elided.
 607
 608 @table @asis
 609 @item (A)
 610 @code{ALL(MASK)} is true if all elements of @var{MASK} are true.
 611 It also is true if @var{MASK} has zero size; otherwise, it is false.
 612 @item (B)
 613 If the rank of @var{MASK} is one, then @code{ALL(MASK,DIM)} is equivalent
 614 to @code{ALL(MASK)}.  If the rank is greater than one, then @code{ALL(MASK,DIM)}
 615 is determined by applying @code{ALL} to the array sections.
 616 @end table
 617
 618 @item @emph{Example}:
 619 @smallexample
 620 program test_all
 621   logical l
 622   l = all((/.true., .true., .true./))
 623   print *, l
 624   call section
 625   contains
 626     subroutine section
 627       integer a(2,3), b(2,3)
 628       a = 1
 629       b = 1
 630       b(2,2) = 2
 631       print *, all(a .eq. b, 1)
 632       print *, all(a .eq. b, 2)
 633     end subroutine section
 634 end program test_all
 635 @end smallexample
 636 @end table
 637
 638
 639
 640 @node ALLOCATED
 641 @section @code{ALLOCATED} --- Status of an allocatable entity
 642 @findex @code{ALLOCATED} intrinsic
 643 @cindex allocation status
 644
 645 @table @asis
 646 @item @emph{Description}:
 647 @code{ALLOCATED(X)} checks the status of whether @var{X} is allocated.
 648
 649 @item @emph{Option}:
 650 f95, gnu
 651
 652 @item @emph{Class}:
 653 inquiry function
 654
 655 @item @emph{Syntax}:
 656 @code{L = ALLOCATED(X)}
 657
 658 @item @emph{Arguments}:
 659 @multitable @columnfractions .15 .80
 660 @item @var{X}    @tab The argument shall be an @code{ALLOCATABLE} array.
 661 @end multitable
 662
 663 @item @emph{Return value}:
 664 The return value is a scalar @code{LOGICAL} with the default logical
 665 kind type parameter.  If @var{X} is allocated, @code{ALLOCATED(X)}
 666 is @code{.TRUE.}; otherwise, it returns the @code{.TRUE.}
 667
 668 @item @emph{Example}:
 669 @smallexample
 670 program test_allocated
 671   integer :: i = 4
 672   real(4), allocatable :: x(:)
 673   if (allocated(x) .eqv. .false.) allocate(x(i)
 674 end program test_allocated
 675 @end smallexample
 676 @end table
 677
 678
 679
 680 @node ANINT
 681 @section @code{ANINT} --- Imaginary part of complex number
 682 @findex @code{ANINT} intrinsic
 683 @findex @code{DNINT} intrinsic
 684 @cindex whole number
 685
 686 @table @asis
 687 @item @emph{Description}:
 688 @code{ANINT(X [, KIND])} rounds its argument to the nearest whole number.
 689
 690 @item @emph{Option}:
 691 f95, gnu
 692
 693 @item @emph{Class}:
 694 elemental function
 695
 696 @item @emph{Syntax}:
 697 @code{X = ANINT(X)}
 698 @code{X = ANINT(X, KIND)}
 699
 700 @item @emph{Arguments}:
 701 @multitable @columnfractions .15 .80
 702 @item @var{X}    @tab The type of the argument shall be @code{REAL(*)}.
 703 @item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
 704 initialization expression.
 705 @end multitable
 706
 707 @item @emph{Return value}:
 708 The return value is of type real with the kind type parameter of the
 709 argument if the optional @var{KIND} is absent; otherwise, the kind
 710 type parameter will be given by @var{KIND}.  If @var{X} is greater than
 711 zero, then @code{ANINT(X)} returns @code{AINT(X+0.5)}.  If @var{X} is
 712 less than or equal to zero, then return @code{AINT(X-0.5)}.
 713
 714 @item @emph{Example}:
 715 @smallexample
 716 program test_anint
 717   real(4) x4
 718   real(8) x8
 719   x4 = 1.234E0_4
 720   x8 = 4.321_8
 721   print *, anint(x4), dnint(x8)
 722   x8 = anint(x4,8)
 723 end program test_anint
 724 @end smallexample
 725
 726 @item @emph{Specific names}:
 727 @multitable @columnfractions .24 .24 .24 .24
 728 @item Name            @tab Argument         @tab Return type      @tab Option
 729 @item @code{DNINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
 730 @end multitable
 731 @end table
 732
 733
 734
 735 @node ANY
 736 @section @code{ANY} --- Any value in @var{MASK} along @var{DIM} is true
 737 @findex @code{ANY} intrinsic
 738 @cindex true values
 739
 740 @table @asis
 741 @item @emph{Description}:
 742 @code{ANY(MASK [, DIM])} determines if any of the values in the logical array
 743 @var{MASK} along dimension @var{DIM} are @code{.TRUE.}.
 744
 745 @item @emph{Option}:
 746 f95, gnu
 747
 748 @item @emph{Class}:
 749 transformational function
 750
 751 @item @emph{Syntax}:
 752 @code{L = ANY(MASK)}
 753 @code{L = ANY(MASK, DIM)}
 754
 755 @item @emph{Arguments}:
 756 @multitable @columnfractions .15 .80
 757 @item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
 758 it shall not be scalar.
 759 @item @var{DIM}  @tab (Optional) @var{DIM} shall be a scalar integer
 760 with a value that lies between one and the rank of @var{MASK}.
 761 @end multitable
 762
 763 @item @emph{Return value}:
 764 @code{ANY(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
 765 the kind type parameter is the same as the kind type parameter of
 766 @var{MASK}.  If @var{DIM} is present, then @code{ANY(MASK, DIM)} returns
 767 an array with the rank of @var{MASK} minus 1.  The shape is determined from
 768 the shape of @var{MASK} where the @var{DIM} dimension is elided.
 769
 770 @table @asis
 771 @item (A)
 772 @code{ANY(MASK)} is true if any element of @var{MASK} is true;
 773 otherwise, it is false.  It also is false if @var{MASK} has zero size.
 774 @item (B)
 775 If the rank of @var{MASK} is one, then @code{ANY(MASK,DIM)} is equivalent
 776 to @code{ANY(MASK)}.  If the rank is greater than one, then @code{ANY(MASK,DIM)}
 777 is determined by applying @code{ANY} to the array sections.
 778 @end table
 779
 780 @item @emph{Example}:
 781 @smallexample
 782 program test_any
 783   logical l
 784   l = any((/.true., .true., .true./))
 785   print *, l
 786   call section
 787   contains
 788     subroutine section
 789       integer a(2,3), b(2,3)
 790       a = 1
 791       b = 1
 792       b(2,2) = 2
 793       print *, any(a .eq. b, 1)
 794       print *, any(a .eq. b, 2)
 795     end subroutine section
 796 end program test_any
 797 @end smallexample
 798 @end table
 799
 800
 801
 802 @node ASIN
 803 @section @code{ASIN} --- Arcsine function
 804 @findex @code{ASIN} intrinsic
 805 @findex @code{DASIN} intrinsic
 806 @cindex arcsine
 807
 808 @table @asis
 809 @item @emph{Description}:
 810 @code{ASIN(X)} computes the arcsine of its @var{X}.
 811
 812 @item @emph{Option}:
 813 f95, gnu
 814
 815 @item @emph{Class}:
 816 elemental function
 817
 818 @item @emph{Syntax}:
 819 @code{X = ASIN(X)}
 820
 821 @item @emph{Arguments}:
 822 @multitable @columnfractions .15 .80
 823 @item @var{X} @tab The type shall be @code{REAL(*)}, and a magnitude that is
 824 less than one.
 825 @end multitable
 826
 827 @item @emph{Return value}:
 828 The return value is of type @code{REAL(*)} and it lies in the
 829 range @math{-\pi / 2 \leq \arccos (x) \leq \pi / 2}.  The kind type
 830 parameter is the same as @var{X}.
 831
 832 @item @emph{Example}:
 833 @smallexample
 834 program test_asin
 835   real(8) :: x = 0.866_8
 836   x = asin(x)
 837 end program test_asin
 838 @end smallexample
 839
 840 @item @emph{Specific names}:
 841 @multitable @columnfractions .24 .24 .24 .24
 842 @item Name            @tab Argument          @tab Return type       @tab Option
 843 @item @code{DASIN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 844 @end multitable
 845 @end table
 846
 847
 848
 849 @node ASSOCIATED
 850 @section @code{ASSOCIATED} --- Status of a pointer or pointer/target pair
 851 @findex @code{ASSOCIATED} intrinsic
 852 @cindex pointer status
 853
 854 @table @asis
 855 @item @emph{Description}:
 856 @code{ASSOCIATED(PTR [, TGT])} determines the status of the pointer @var{PTR}
 857 or if @var{PTR} is associated with the target @var{TGT}.
 858
 859 @item @emph{Option}:
 860 f95, gnu
 861
 862 @item @emph{Class}:
 863 inquiry function
 864
 865 @item @emph{Syntax}:
 866 @code{L = ASSOCIATED(PTR)}
 867 @code{L = ASSOCIATED(PTR [, TGT])}
 868
 869 @item @emph{Arguments}:
 870 @multitable @columnfractions .15 .80
 871 @item @var{PTR} @tab @var{PTR} shall have the @code{POINTER} attribute and
 872 it can be of any type.
 873 @item @var{TGT} @tab (Optional) @var{TGT} shall be a @code{POINTER} or
 874 a @code{TARGET}.  It must have the same type, kind type parameter, and
 875 array rank as @var{PTR}.
 876 @end multitable
 877 The status of neither @var{PTR} nor @var{TGT} can be undefined.
 878
 879 @item @emph{Return value}:
 880 @code{ASSOCIATED(PTR)} returns a scalar value of type @code{LOGICAL(4)}.
 881 There are several cases:
 882 @table @asis
 883 @item (A) If the optional @var{TGT} is not present, then @code{ASSOCIATED(PTR)}
 884 is true if @var{PTR} is associated with a target; otherwise, it returns false.
 885 @item (B) If @var{TGT} is present and a scalar target, the result is true if
 886 @var{TGT}
 887 is not a 0 sized storage sequence and the target associated with @var{PTR}
 888 occupies the same storage units.  If @var{PTR} is disassociated, then the
 889 result is false.
 890 @item (C) If @var{TGT} is present and an array target, the result is true if
 891 @var{TGT} and @var{PTR} have the same shape, are not 0 sized arrays, are
 892 arrays whose elements are not 0 sized storage sequences, and @var{TGT} and
 893 @var{PTR} occupy the same storage units in array element order.
 894 As in case(B), the result is false, if @var{PTR} is disassociated.
 895 @item (D) If @var{TGT} is present and an scalar pointer, the result is true if
 896 target associated with @var{PTR} and the target associated with @var{TGT}
 897 are not 0 sized storage sequences and occupy the same storage units.
 898 The result is false, if either @var{TGT} or @var{PTR} is disassociated.
 899 @item (E) If @var{TGT} is present and an array pointer, the result is true if
 900 target associated with @var{PTR} and the target associated with @var{TGT}
 901 have the same shape, are not 0 sized arrays, are arrays whose elements are
 902 not 0 sized storage sequences, and @var{TGT} and @var{PTR} occupy the same
 903 storage units in array element order.
 904 The result is false, if either @var{TGT} or @var{PTR} is disassociated.
 905 @end table
 906
 907 @item @emph{Example}:
 908 @smallexample
 909 program test_associated
 910    implicit none
 911    real, target  :: tgt(2) = (/1., 2./)
 912    real, pointer :: ptr(:)
 913    ptr => tgt
 914    if (associated(ptr)     .eqv. .false.) call abort
 915    if (associated(ptr,tgt) .eqv. .false.) call abort
 916 end program test_associated
 917 @end smallexample
 918 @end table
 919
 920
 921
 922 @node ATAN
 923 @section @code{ATAN} --- Arctangent function
 924 @findex @code{ATAN} intrinsic
 925 @findex @code{DATAN} intrinsic
 926 @cindex arctangent
 927
 928 @table @asis
 929 @item @emph{Description}:
 930 @code{ATAN(X)} computes the arctangent of @var{X}.
 931
 932 @item @emph{Option}:
 933 f95, gnu
 934
 935 @item @emph{Class}:
 936 elemental function
 937
 938 @item @emph{Syntax}:
 939 @code{X = ATAN(X)}
 940
 941 @item @emph{Arguments}:
 942 @multitable @columnfractions .15 .80
 943 @item @var{X} @tab The type shall be @code{REAL(*)}.
 944 @end multitable
 945
 946 @item @emph{Return value}:
 947 The return value is of type @code{REAL(*)} and it lies in the
 948 range @math{ - \pi / 2 \leq \arcsin (x) \leq \pi / 2}.
 949
 950 @item @emph{Example}:
 951 @smallexample
 952 program test_atan
 953   real(8) :: x = 2.866_8
 954   x = atan(x)
 955 end program test_atan
 956 @end smallexample
 957
 958 @item @emph{Specific names}:
 959 @multitable @columnfractions .24 .24 .24 .24
 960 @item Name            @tab Argument          @tab Return type       @tab Option
 961 @item @code{DATAN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 962 @end multitable
 963 @end table
 964
 965
 966
 967 @node ATAN2
 968 @section @code{ATAN2} --- Arctangent function
 969 @findex @code{ATAN2} intrinsic
 970 @findex @code{DATAN2} intrinsic
 971 @cindex arctangent
 972
 973 @table @asis
 974 @item @emph{Description}:
 975 @code{ATAN2(Y,X)} computes the arctangent of the complex number @math{X + i Y}.
 976
 977 @item @emph{Option}:
 978 f95, gnu
 979
 980 @item @emph{Class}:
 981 elemental function
 982
 983 @item @emph{Syntax}:
 984 @code{X = ATAN2(Y,X)}
 985
 986 @item @emph{Arguments}:
 987 @multitable @columnfractions .15 .80
 988 @item @var{Y} @tab The type shall be @code{REAL(*)}.
 989 @item @var{X} @tab The type and kind type parameter shall be the same as @var{Y}.
 990 If @var{Y} is zero, then @var{X} must be nonzero.
 991 @end multitable
 992
 993 @item @emph{Return value}:
 994 The return value has the same type and kind type parameter as @var{Y}.
 995 It is the principle value of the complex number @math{X + i Y}.  If
 996 @var{X} is nonzero, then it lies in the range @math{-\pi \le \arccos (x) \leq \pi}.
 997 The sign is positive if @var{Y} is positive.  If @var{Y} is zero, then
 998 the return value is zero if @var{X} is positive and @math{\pi} if @var{X}
 999 is negative.  Finally, if @var{X} is zero, then the magnitude of the result
1000 is @math{\pi/2}.
1001
1002 @item @emph{Example}:
1003 @smallexample
1004 program test_atan2
1005   real(4) :: x = 1.e0_4, y = 0.5e0_4
1006   x = atan2(y,x)
1007 end program test_atan2
1008 @end smallexample
1009
1010 @item @emph{Specific names}:
1011 @multitable @columnfractions .24 .24 .24 .24
1012 @item Name            @tab Argument          @tab Return type    @tab Option
1013 @item @code{DATAN2(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
1014 @end multitable
1015 @end table
1016
1017
1018
1019 @node BESJ0
1020 @section @code{BESJ0} --- Bessel function of the first kind of order 0
1021 @findex @code{BESJ0} intrinsic
1022 @findex @code{DBESJ0} intrinsic
1023 @cindex Bessel
1024
1025 @table @asis
1026 @item @emph{Description}:
1027 @code{BESJ0(X)} computes the Bessel function of the first kind of order 0
1028 of @var{X}.
1029
1030 @item @emph{Option}:
1031 gnu
1032
1033 @item @emph{Class}:
1034 elemental function
1035
1036 @item @emph{Syntax}:
1037 @code{X = BESJ0(X)}
1038
1039 @item @emph{Arguments}:
1040 @multitable @columnfractions .15 .80
1041 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1042 @end multitable
1043
1044 @item @emph{Return value}:
1045 The return value is of type @code{REAL(*)} and it lies in the
1046 range @math{ - 0.4027... \leq Bessel (0,x) \leq 1}.
1047
1048 @item @emph{Example}:
1049 @smallexample
1050 program test_besj0
1051   real(8) :: x = 0.0_8
1052   x = besj0(x)
1053 end program test_besj0
1054 @end smallexample
1055
1056 @item @emph{Specific names}:
1057 @multitable @columnfractions .24 .24 .24 .24
1058 @item Name            @tab Argument          @tab Return type       @tab Option
1059 @item @code{DBESJ0(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1060 @end multitable
1061 @end table
1062
1063
1064
1065 @node BESJ1
1066 @section @code{BESJ1} --- Bessel function of the first kind of order 1
1067 @findex @code{BESJ1} intrinsic
1068 @findex @code{DBESJ1} intrinsic
1069 @cindex Bessel
1070
1071 @table @asis
1072 @item @emph{Description}:
1073 @code{BESJ1(X)} computes the Bessel function of the first kind of order 1
1074 of @var{X}.
1075
1076 @item @emph{Option}:
1077 gnu
1078
1079 @item @emph{Class}:
1080 elemental function
1081
1082 @item @emph{Syntax}:
1083 @code{X = BESJ1(X)}
1084
1085 @item @emph{Arguments}:
1086 @multitable @columnfractions .15 .80
1087 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1088 @end multitable
1089
1090 @item @emph{Return value}:
1091 The return value is of type @code{REAL(*)} and it lies in the
1092 range @math{ - 0.5818... \leq Bessel (0,x) \leq 0.5818 }.
1093
1094 @item @emph{Example}:
1095 @smallexample
1096 program test_besj1
1097   real(8) :: x = 1.0_8
1098   x = besj1(x)
1099 end program test_besj1
1100 @end smallexample
1101
1102 @item @emph{Specific names}:
1103 @multitable @columnfractions .24 .24 .24 .24
1104 @item Name            @tab Argument          @tab Return type       @tab Option
1105 @item @code{DBESJ1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1106 @end multitable
1107 @end table
1108
1109
1110
1111 @node BESJN
1112 @section @code{BESJN} --- Bessel function of the first kind
1113 @findex @code{BESJN} intrinsic
1114 @findex @code{DBESJN} intrinsic
1115 @cindex Bessel
1116
1117 @table @asis
1118 @item @emph{Description}:
1119 @code{BESJN(N, X)} computes the Bessel function of the first kind of order
1120 @var{N} of @var{X}.
1121
1122 @item @emph{Option}:
1123 gnu
1124
1125 @item @emph{Class}:
1126 elemental function
1127
1128 @item @emph{Syntax}:
1129 @code{Y = BESJN(N, X)}
1130
1131 @item @emph{Arguments}:
1132 @multitable @columnfractions .15 .80
1133 @item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
1134 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1135 @end multitable
1136
1137 @item @emph{Return value}:
1138 The return value is a scalar of type @code{REAL(*)}.
1139
1140 @item @emph{Example}:
1141 @smallexample
1142 program test_besjn
1143   real(8) :: x = 1.0_8
1144   x = besjn(5,x)
1145 end program test_besjn
1146 @end smallexample
1147
1148 @item @emph{Specific names}:
1149 @multitable @columnfractions .24 .24 .24 .24
1150 @item Name             @tab Argument            @tab Return type       @tab Option
1151 @item @code{DBESJN(X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}    @tab gnu
1152 @item                  @tab @code{REAL(8) X}    @tab                   @tab
1153 @end multitable
1154 @end table
1155
1156
1157
1158 @node BESY0
1159 @section @code{BESY0} --- Bessel function of the second kind of order 0
1160 @findex @code{BESY0} intrinsic
1161 @findex @code{DBESY0} intrinsic
1162 @cindex Bessel
1163
1164 @table @asis
1165 @item @emph{Description}:
1166 @code{BESY0(X)} computes the Bessel function of the second kind of order 0
1167 of @var{X}.
1168
1169 @item @emph{Option}:
1170 gnu
1171
1172 @item @emph{Class}:
1173 elemental function
1174
1175 @item @emph{Syntax}:
1176 @code{X = BESY0(X)}
1177
1178 @item @emph{Arguments}:
1179 @multitable @columnfractions .15 .80
1180 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1181 @end multitable
1182
1183 @item @emph{Return value}:
1184 The return value is a scalar of type @code{REAL(*)}.
1185
1186 @item @emph{Example}:
1187 @smallexample
1188 program test_besy0
1189   real(8) :: x = 0.0_8
1190   x = besy0(x)
1191 end program test_besy0
1192 @end smallexample
1193
1194 @item @emph{Specific names}:
1195 @multitable @columnfractions .24 .24 .24 .24
1196 @item Name            @tab Argument          @tab Return type       @tab Option
1197 @item @code{DBESY0(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1198 @end multitable
1199 @end table
1200
1201
1202
1203 @node BESY1
1204 @section @code{BESY1} --- Bessel function of the second kind of order 1
1205 @findex @code{BESY1} intrinsic
1206 @findex @code{DBESY1} intrinsic
1207 @cindex Bessel
1208
1209 @table @asis
1210 @item @emph{Description}:
1211 @code{BESY1(X)} computes the Bessel function of the second kind of order 1
1212 of @var{X}.
1213
1214 @item @emph{Option}:
1215 gnu
1216
1217 @item @emph{Class}:
1218 elemental function
1219
1220 @item @emph{Syntax}:
1221 @code{X = BESY1(X)}
1222
1223 @item @emph{Arguments}:
1224 @multitable @columnfractions .15 .80
1225 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1226 @end multitable
1227
1228 @item @emph{Return value}:
1229 The return value is a scalar of type @code{REAL(*)}.
1230
1231 @item @emph{Example}:
1232 @smallexample
1233 program test_besy1
1234   real(8) :: x = 1.0_8
1235   x = besy1(x)
1236 end program test_besy1
1237 @end smallexample
1238
1239 @item @emph{Specific names}:
1240 @multitable @columnfractions .24 .24 .24 .24
1241 @item Name            @tab Argument          @tab Return type       @tab Option
1242 @item @code{DBESY1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1243 @end multitable
1244 @end table
1245
1246
1247
1248 @node BESYN
1249 @section @code{BESYN} --- Bessel function of the second kind
1250 @findex @code{BESYN} intrinsic
1251 @findex @code{DBESYN} intrinsic
1252 @cindex Bessel
1253
1254 @table @asis
1255 @item @emph{Description}:
1256 @code{BESYN(N, X)} computes the Bessel function of the second kind of order
1257 @var{N} of @var{X}.
1258
1259 @item @emph{Option}:
1260 gnu
1261
1262 @item @emph{Class}:
1263 elemental function
1264
1265 @item @emph{Syntax}:
1266 @code{Y = BESYN(N, X)}
1267
1268 @item @emph{Arguments}:
1269 @multitable @columnfractions .15 .80
1270 @item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
1271 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
1272 @end multitable
1273
1274 @item @emph{Return value}:
1275 The return value is a scalar of type @code{REAL(*)}.
1276
1277 @item @emph{Example}:
1278 @smallexample
1279 program test_besyn
1280   real(8) :: x = 1.0_8
1281   x = besyn(5,x)
1282 end program test_besyn
1283 @end smallexample
1284
1285 @item @emph{Specific names}:
1286 @multitable @columnfractions .24 .24 .24 .24
1287 @item Name               @tab Argument            @tab Return type     @tab Option
1288 @item @code{DBESYN(N,X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}  @tab gnu
1289 @item                    @tab @code{REAL(8)    X} @tab                 @tab
1290 @end multitable
1291 @end table
1292
1293
1294
1295 @node BIT_SIZE
1296 @section @code{BIT_SIZE} --- Bit size inquiry function
1297 @findex @code{BIT_SIZE} intrinsic
1298 @cindex bit_size
1299
1300 @table @asis
1301 @item @emph{Description}:
1302 @code{BIT_SIZE(I)} returns the number of bits (integer precision plus sign bit)
1303 represented by the type of @var{I}.
1304
1305 @item @emph{Option}:
1306 f95, gnu
1307
1308 @item @emph{Class}:
1309 elemental function
1310
1311 @item @emph{Syntax}:
1312 @code{I = BIT_SIZE(I)}
1313
1314 @item @emph{Arguments}:
1315 @multitable @columnfractions .15 .80
1316 @item @var{I} @tab The type shall be @code{INTEGER(*)}.
1317 @end multitable
1318
1319 @item @emph{Return value}:
1320 The return value is of type @code{INTEGER(*)}
1321
1322 @item @emph{Example}:
1323 @smallexample
1324 program test_bit_size
1325     integer :: i = 123
1326     integer :: size
1327     size = bit_size(i)
1328     print *, size
1329 end program test_bit_size
1330 @end smallexample
1331 @end table
1332
1333
1334
1335 @node BTEST
1336 @section @code{BTEST} --- Bit test function
1337 @findex @code{BTEST} intrinsic
1338 @cindex BTEST
1339
1340 @table @asis
1341 @item @emph{Description}:
1342 @code{BTEST(I,POS)} returns logical @code{.TRUE.} if the bit at @var{POS}
1343 in @var{I} is set.
1344
1345 @item @emph{Option}:
1346 f95, gnu
1347
1348 @item @emph{Class}:
1349 elemental function
1350
1351 @item @emph{Syntax}:
1352 @code{I = BTEST(I,POS)}
1353
1354 @item @emph{Arguments}:
1355 @multitable @columnfractions .15 .80
1356 @item @var{I} @tab The type shall be @code{INTEGER(*)}.
1357 @item @var{POS} @tab The type shall be @code{INTEGER(*)}.
1358 @end multitable
1359
1360 @item @emph{Return value}:
1361 The return value is of type @code{LOGICAL}
1362
1363 @item @emph{Example}:
1364 @smallexample
1365 program test_btest
1366     integer :: i = 32768 + 1024 + 64
1367     integer :: pos
1368     logical :: bool
1369     do pos=0,16
1370         bool = btest(i, pos)
1371         print *, pos, bool
1372     end do
1373 end program test_btest
1374 @end smallexample
1375 @end table
1376
1377
1378
1379 @node CEILING
1380 @section @code{CEILING} --- Integer ceiling function
1381 @findex @code{CEILING} intrinsic
1382 @cindex CEILING
1383
1384 @table @asis
1385 @item @emph{Description}:
1386 @code{CEILING(X)} returns the least integer greater than or equal to @var{X}.
1387
1388 @item @emph{Option}:
1389 f95, gnu
1390
1391 @item @emph{Class}:
1392 elemental function
1393
1394 @item @emph{Syntax}:
1395 @code{I = CEILING(X[,KIND])}
1396
1397 @item @emph{Arguments}:
1398 @multitable @columnfractions .15 .80
1399 @item @var{X} @tab The type shall be @code{REAL(*)}.
1400 @item @var{KIND} @tab Optional scaler integer initialization expression.
1401 @end multitable
1402
1403 @item @emph{Return value}:
1404 The return value is of type @code{INTEGER(KIND)}
1405
1406 @item @emph{Example}:
1407 @smallexample
1408 program test_ceiling
1409     real :: x = 63.29
1410     real :: y = -63.59
1411     print *, ceiling(x) ! returns 64
1412     print *, ceiling(y) ! returns -63
1413 end program test_ceiling
1414 @end smallexample
1415 @end table
1416
1417
1418
1419 @node CHAR
1420 @section @code{CHAR} --- Character conversion function
1421 @findex @code{CHAR} intrinsic
1422 @cindex CHAR
1423
1424 @table @asis
1425 @item @emph{Description}:
1426 @code{CHAR(I,[KIND])} returns the character represented by the integer @var{I}.
1427
1428 @item @emph{Option}:
1429 f95, gnu
1430
1431 @item @emph{Class}:
1432 elemental function
1433
1434 @item @emph{Syntax}:
1435 @code{C = CHAR(I[,KIND])}
1436
1437 @item @emph{Arguments}:
1438 @multitable @columnfractions .15 .80
1439 @item @var{I} @tab The type shall be @code{INTEGER(*)}.
1440 @item @var{KIND} @tab Optional scaler integer initialization expression.
1441 @end multitable
1442
1443 @item @emph{Return value}:
1444 The return value is of type @code{CHARACTER(1)}
1445
1446 @item @emph{Example}:
1447 @smallexample
1448 program test_char
1449     integer :: i = 74
1450     character(1) :: c
1451     c = char(i)
1452     print *, i, c ! returns 'J'
1453 end program test_char
1454 @end smallexample
1455 @end table
1456
1457
1458
1459 @node CMPLX
1460 @section @code{CMPLX} --- Complex conversion function
1461 @findex @code{CMPLX} intrinsic
1462 @cindex CMPLX
1463
1464 @table @asis
1465 @item @emph{Description}:
1466 @code{CMPLX(X,[Y,KIND])} returns a complex number where @var{X} is converted to
1467 the real component.  If @var{Y} is present it is converted to the imaginary
1468 component.  If @var{Y} is not present then the imaginary component is set to
1469 0.0.  If @var{X} is complex then @var{Y} must not be present.
1470
1471 @item @emph{Option}:
1472 f95, gnu
1473
1474 @item @emph{Class}:
1475 elemental function
1476
1477 @item @emph{Syntax}:
1478 @code{C = CMPLX(X[,Y,KIND])}
1479
1480 @item @emph{Arguments}:
1481 @multitable @columnfractions .15 .80
1482 @item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
1483 @item @var{Y} @tab Optional, allowed if @var{X} is not @code{COMPLEX(*)}.  May be @code{INTEGER(*)} or @code{REAL(*)}.
1484 @item @var{KIND} @tab Optional scaler integer initialization expression.
1485 @end multitable
1486
1487 @item @emph{Return value}:
1488 The return value is of type @code{COMPLEX(*)}
1489
1490 @item @emph{Example}:
1491 @smallexample
1492 program test_cmplx
1493     integer :: i = 42
1494     real :: x = 3.14
1495     complex :: z
1496     z = cmplx(i, x)
1497     print *, z, cmplx(x)
1498 end program test_cmplx
1499 @end smallexample
1500 @end table
1501
1502
1503
1504 @node COMMAND_ARGUMENT_COUNT
1505 @section @code{COMMAND_ARGUMENT_COUNT} --- Argument count function
1506 @findex @code{COMMAND_ARGUMENT_COUNT} intrinsic
1507 @cindex command argument count
1508
1509 @table @asis
1510 @item @emph{Description}:
1511 @code{COMMAND_ARGUMENT_COUNT()} returns the number of arguments passed on the
1512 command line when the containing program was invoked.
1513
1514 @item @emph{Option}:
1515 f2003, gnu
1516
1517 @item @emph{Class}:
1518 non-elemental function
1519
1520 @item @emph{Syntax}:
1521 @code{I = COMMAND_ARGUMENT_COUNT()}
1522
1523 @item @emph{Arguments}:
1524 @multitable @columnfractions .15 .80
1525 @item None
1526 @end multitable
1527
1528 @item @emph{Return value}:
1529 The return value is of type @code{INTEGER(4)}
1530
1531 @item @emph{Example}:
1532 @smallexample
1533 program test_command_argument_count
1534     integer :: count
1535     count = command_argument_count()
1536     print *, count
1537 end program test_command_argument_count
1538 @end smallexample
1539 @end table
1540
1541
1542
1543 @node CONJG
1544 @section @code{CONJG} --- Complex conjugate function
1545 @findex @code{CONJG} intrinsic
1546 @findex @code{DCONJG} intrinsic
1547 @cindex complex conjugate
1548 @table @asis
1549 @item @emph{Description}:
1550 @code{CONJG(Z)} returns the conjugate of @var{Z}.  If @var{Z} is @code{(x, y)}
1551 then the result is @code{(x, -y)}
1552
1553 @item @emph{Option}:
1554 f95, gnu
1555
1556 @item @emph{Class}:
1557 elemental function
1558
1559 @item @emph{Syntax}:
1560 @code{Z = CONJG(Z)}
1561
1562 @item @emph{Arguments}:
1563 @multitable @columnfractions .15 .80
1564 @item @var{Z} @tab The type shall be @code{COMPLEX(*)}.
1565 @end multitable
1566
1567 @item @emph{Return value}:
1568 The return value is of type @code{COMPLEX(*)}.
1569
1570 @item @emph{Example}:
1571 @smallexample
1572 program test_conjg
1573     complex :: z = (2.0, 3.0)
1574     complex(8) :: dz = (2.71_8, -3.14_8)
1575     z= conjg(z)
1576     print *, z
1577     dz = dconjg(dz)
1578     print *, dz
1579 end program test_conjg
1580 @end smallexample
1581
1582 @item @emph{Specific names}:
1583 @multitable @columnfractions .24 .24 .24 .24
1584 @item Name             @tab Argument             @tab Return type          @tab Option
1585 @item @code{DCONJG(Z)} @tab @code{COMPLEX(8) Z}  @tab @code{COMPLEX(8)}    @tab gnu
1586 @end multitable
1587 @end table
1588
1589
1590
1591 @node COS
1592 @section @code{COS} --- Cosine function
1593 @findex @code{COS} intrinsic
1594 @findex @code{DCOS} intrinsic
1595 @findex @code{ZCOS} intrinsic
1596 @findex @code{CDCOS} intrinsic
1597 @cindex cosine
1598
1599 @table @asis
1600 @item @emph{Description}:
1601 @code{COS(X)} computes the cosine of @var{X}.
1602
1603 @item @emph{Option}:
1604 f95, gnu
1605
1606 @item @emph{Class}:
1607 elemental function
1608
1609 @item @emph{Syntax}:
1610 @code{X = COS(X)}
1611
1612 @item @emph{Arguments}:
1613 @multitable @columnfractions .15 .80
1614 @item @var{X} @tab The type shall be @code{REAL(*)} or
1615 @code{COMPLEX(*)}.
1616 @end multitable
1617
1618 @item @emph{Return value}:
1619 The return value has the same type and kind as @var{X}.
1620
1621 @item @emph{Example}:
1622 @smallexample
1623 program test_cos
1624   real :: x = 0.0
1625   x = cos(x)
1626 end program test_cos
1627 @end smallexample
1628
1629 @item @emph{Specific names}:
1630 @multitable @columnfractions .24 .24 .24 .24
1631 @item Name            @tab Argument          @tab Return type     @tab Option
1632 @item @code{DCOS(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}  @tab f95, gnu
1633 @item @code{CCOS(X)}@tab @code{COMPLEX(4) X}@tab @code{COMPLEX(4)}@tab f95, gnu
1634 @item @code{ZCOS(X)}@tab @code{COMPLEX(8) X}@tab @code{COMPLEX(8)}@tab f95, gnu
1635 @item @code{CDCOS(X)}@tab @code{COMPLEX(8) X}@tab @code{COMPLEX(8)}@tab f95, gnu
1636 @end multitable
1637 @end table
1638
1639
1640
1641 @node COSH
1642 @section @code{COSH} --- Hyperbolic cosine function
1643 @findex @code{COSH} intrinsic
1644 @findex @code{DCOSH} intrinsic
1645 @cindex hyperbolic cosine
1646
1647 @table @asis
1648 @item @emph{Description}:
1649 @code{COSH(X)} computes the hyperbolic cosine of @var{X}.
1650
1651 @item @emph{Option}:
1652 f95, gnu
1653
1654 @item @emph{Class}:
1655 elemental function
1656
1657 @item @emph{Syntax}:
1658 @code{X = COSH(X)}
1659
1660 @item @emph{Arguments}:
1661 @multitable @columnfractions .15 .80
1662 @item @var{X} @tab The type shall be @code{REAL(*)}.
1663 @end multitable
1664
1665 @item @emph{Return value}:
1666 The return value is of type @code{REAL(*)} and it is positive
1667 (@math{ \cosh (x) \geq 0 }.
1668
1669 @item @emph{Example}:
1670 @smallexample
1671 program test_cosh
1672   real(8) :: x = 1.0_8
1673   x = cosh(x)
1674 end program test_cosh
1675 @end smallexample
1676
1677 @item @emph{Specific names}:
1678 @multitable @columnfractions .24 .24 .24 .24
1679 @item Name            @tab Argument          @tab Return type       @tab Option
1680 @item @code{DCOSH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1681 @end multitable
1682 @end table
1683
1684
1685
1686 @node COUNT
1687 @section @code{COUNT} --- Count function
1688 @findex @code{COUNT} intrinsic
1689 @cindex count
1690
1691 @table @asis
1692 @item @emph{Description}:
1693 @code{COUNT(MASK[,DIM])} counts the number of @code{.TRUE.} elements of
1694 @var{MASK} along the dimension of @var{DIM}.  If @var{DIM} is omitted it is
1695 taken to be @code{1}.  @var{DIM} is a scaler of type @code{INTEGER} in the
1696 range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{MASK}.
1697
1698 @item @emph{Option}:
1699 f95, gnu
1700
1701 @item @emph{Class}:
1702 transformational function
1703
1704 @item @emph{Syntax}:
1705 @code{I = COUNT(MASK[,DIM])}
1706
1707 @item @emph{Arguments}:
1708 @multitable @columnfractions .15 .80
1709 @item @var{MASK} @tab The type shall be @code{LOGICAL}.
1710 @item @var{DIM}  @tab The type shall be @code{INTEGER}.
1711 @end multitable
1712
1713 @item @emph{Return value}:
1714 The return value is of type @code{INTEGER} with rank equal to that of
1715 @var{MASK}.
1716
1717 @item @emph{Example}:
1718 @smallexample
1719 program test_count
1720     integer, dimension(2,3) :: a, b
1721     logical, dimension(2,3) :: mask
1722     a = reshape( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /))
1723     b = reshape( (/ 0, 7, 3, 4, 5, 8 /), (/ 2, 3 /))
1724     print '(3i3)', a(1,:)
1725     print '(3i3)', a(2,:)
1726     print *
1727     print '(3i3)', b(1,:)
1728     print '(3i3)', b(2,:)
1729     print *
1730     mask = a.ne.b
1731     print '(3l3)', mask(1,:)
1732     print '(3l3)', mask(2,:)
1733     print *
1734     print '(3i3)', count(mask)
1735     print *
1736     print '(3i3)', count(mask, 1)
1737     print *
1738     print '(3i3)', count(mask, 2)
1739 end program test_count
1740 @end smallexample
1741 @end table
1742
1743
1744
1745 @node CPU_TIME
1746 @section @code{CPU_TIME} --- CPU elapsed time in seconds
1747 @findex @code{CPU_TIME} intrinsic
1748 @cindex CPU_TIME
1749
1750 @table @asis
1751 @item @emph{Description}:
1752 Returns a @code{REAL} value representing the elapsed CPU time in seconds.  This
1753 is useful for testing segments of code to determine execution time.
1754
1755 @item @emph{Option}:
1756 f95, gnu
1757
1758 @item @emph{Class}:
1759 subroutine
1760
1761 @item @emph{Syntax}:
1762 @code{CPU_TIME(X)}
1763
1764 @item @emph{Arguments}:
1765 @multitable @columnfractions .15 .80
1766 @item @var{X} @tab The type shall be @code{REAL} with @code{INTENT(OUT)}.
1767 @end multitable
1768
1769 @item @emph{Return value}:
1770 None
1771
1772 @item @emph{Example}:
1773 @smallexample
1774 program test_cpu_time
1775     real :: start, finish
1776     call cpu_time(start)
1777         ! put code to test here
1778     call cpu_time(finish)
1779     print '("Time = ",f6.3," seconds.")',finish-start
1780 end program test_cpu_time
1781 @end smallexample
1782 @end table
1783
1784
1785
1786 @node CSHIFT
1787 @section @code{CSHIFT} --- Circular shift function
1788 @findex @code{CSHIFT} intrinsic
1789 @cindex cshift intrinsic
1790
1791 @table @asis
1792 @item @emph{Description}:
1793 @code{CSHIFT(ARRAY, SHIFT[,DIM])} performs a circular shift on elements of
1794 @var{ARRAY} along the dimension of @var{DIM}.  If @var{DIM} is omitted it is
1795 taken to be @code{1}.  @var{DIM} is a scaler of type @code{INTEGER} in the
1796 range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{ARRAY}.
1797 If the rank of @var{ARRAY} is one, then all elements of @var{ARRAY} are shifted
1798 by @var{SHIFT} places.  If rank is greater than one, then all complete rank one
1799 sections of @var{ARRAY} along the given dimension are shifted.  Elements
1800 shifted out one end of each rank one section are shifted back in the other end.
1801
1802 @item @emph{Option}:
1803 f95, gnu
1804
1805 @item @emph{Class}:
1806 transformational function
1807
1808 @item @emph{Syntax}:
1809 @code{A = CSHIFT(A, SHIFT[,DIM])}
1810
1811 @item @emph{Arguments}:
1812 @multitable @columnfractions .15 .80
1813 @item @var{ARRAY}  @tab May be any type, not scaler.
1814 @item @var{SHIFT}  @tab The type shall be @code{INTEGER}.
1815 @item @var{DIM}    @tab The type shall be @code{INTEGER}.
1816 @end multitable
1817
1818 @item @emph{Return value}:
1819 Returns an array of same type and rank as the @var{ARRAY} argument.
1820
1821 @item @emph{Example}:
1822 @smallexample
1823 program test_cshift
1824     integer, dimension(3,3) :: a
1825     a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
1826     print '(3i3)', a(1,:)
1827     print '(3i3)', a(2,:)
1828     print '(3i3)', a(3,:)
1829     a = cshift(a, SHIFT=(/1, 2, -1/), DIM=2)
1830     print *
1831     print '(3i3)', a(1,:)
1832     print '(3i3)', a(2,:)
1833     print '(3i3)', a(3,:)
1834 end program test_cshift
1835 @end smallexample
1836 @end table
1837
1838
1839 @node CTIME
1840 @section @code{CTIME} --- Convert a time into a string
1841 @findex @code{CTIME} intrinsic
1842 @cindex ctime subroutine
1843
1844 @table @asis
1845 @item @emph{Description}:
1846 @code{CTIME(T,S)} converts @var{T}, a system time value, such as returned
1847 by @code{TIME8()}, to a string of the form @samp{Sat Aug 19 18:13:14
1848 1995}, and returns that string into @var{S}.
1849
1850 If @code{CTIME} is invoked as a function, it can not be invoked as a
1851 subroutine, and vice versa.
1852
1853 @var{T} is an @code{INTENT(IN)} @code{INTEGER(KIND=8)} variable.
1854 @var{S} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
1855
1856 @item @emph{Option}:
1857 gnu
1858
1859 @item @emph{Class}:
1860 subroutine
1861
1862 @item @emph{Syntax}:
1863 @multitable @columnfractions .80
1864 @item @code{CALL CTIME(T,S)}.
1865 @item @code{S = CTIME(T)}, (not recommended).
1866 @end multitable
1867
1868 @item @emph{Arguments}:
1869 @multitable @columnfractions .15 .80
1870 @item @var{S}@tab The type shall be of type @code{CHARACTER}.
1871 @item @var{T}@tab The type shall be of type @code{INTEGER(KIND=8)}.
1872 @end multitable
1873
1874 @item @emph{Return value}:
1875 The converted date and time as a string.
1876
1877 @item @emph{Example}:
1878 @smallexample
1879 program test_ctime
1880     integer(8) :: i
1881     character(len=30) :: date
1882     i = time8()
1883
1884     ! Do something, main part of the program
1885
1886     call ctime(i,date)
1887     print *, 'Program was started on ', date
1888 end program test_ctime
1889 @end smallexample
1890 @end table
1891
1892 @node DATE_AND_TIME
1893 @section @code{DATE_AND_TIME} --- Date and time subroutine
1894 @findex @code{DATE_AND_TIME} intrinsic
1895 @cindex DATE_AND_TIME
1896
1897 @table @asis
1898 @item @emph{Description}:
1899 @code{DATE_AND_TIME(DATE, TIME, ZONE, VALUES)} gets the corresponding date and
1900 time information from the real-time system clock.  @var{DATE} is
1901 @code{INTENT(OUT)} and has form ccyymmdd.  @var{TIME} is @code{INTENT(OUT)} and
1902 has form hhmmss.sss.  @var{ZONE} is @code{INTENT(OUT)} and has form (+-)hhmm,
1903 representing the difference with respect to Coordinated Universal Time (UTC).
1904 Unavailable time and date parameters return blanks.
1905
1906 @var{VALUES} is @code{INTENT(OUT)} and provides the following:
1907
1908 @multitable @columnfractions .15 .30 .60
1909 @item @tab @code{VALUE(1)}: @tab The year
1910 @item @tab @code{VALUE(2)}: @tab The month
1911 @item @tab @code{VALUE(3)}: @tab The day of the month
1912 @item @tab @code{VAlUE(4)}: @tab Time difference with UTC in minutes
1913 @item @tab @code{VALUE(5)}: @tab The hour of the day
1914 @item @tab @code{VALUE(6)}: @tab The minutes of the hour
1915 @item @tab @code{VALUE(7)}: @tab The seconds of the minute
1916 @item @tab @code{VALUE(8)}: @tab The milliseconds of the second
1917 @end multitable
1918
1919 @item @emph{Option}:
1920 f95, gnu
1921
1922 @item @emph{Class}:
1923 subroutine
1924
1925 @item @emph{Syntax}:
1926 @code{CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])}
1927
1928 @item @emph{Arguments}:
1929 @multitable @columnfractions .15 .80
1930 @item @var{DATE}  @tab (Optional) The type shall be @code{CHARACTER(8)} or larger.
1931 @item @var{TIME}  @tab (Optional) The type shall be @code{CHARACTER(10)} or larger.
1932 @item @var{ZONE}  @tab (Optional) The type shall be @code{CHARACTER(5)} or larger.
1933 @item @var{VALUES}@tab (Optional) The type shall be @code{INTEGER(8)}.
1934 @end multitable
1935
1936 @item @emph{Return value}:
1937 None
1938
1939 @item @emph{Example}:
1940 @smallexample
1941 program test_time_and_date
1942     character(8)  :: date
1943     character(10) :: time
1944     character(5)  :: zone
1945     integer,dimension(8) :: values
1946     ! using keyword arguments
1947     call date_and_time(date,time,zone,values)
1948     call date_and_time(DATE=date,ZONE=zone)
1949     call date_and_time(TIME=time)
1950     call date_and_time(VALUES=values)
1951     print '(a,2x,a,2x,a)', date, time, zone
1952     print '(8i5))', values
1953 end program test_time_and_date
1954 @end smallexample
1955 @end table
1956
1957
1958
1959 @node DBLE
1960 @section @code{DBLE} --- Double conversion function
1961 @findex @code{DBLE} intrinsic
1962 @cindex double conversion
1963
1964 @table @asis
1965 @item @emph{Description}:
1966 @code{DBLE(X)} Converts @var{X} to double precision real type.
1967 @code{DFLOAT} is an alias for @code{DBLE}
1968
1969 @item @emph{Option}:
1970 f95, gnu
1971
1972 @item @emph{Class}:
1973 elemental function
1974
1975 @item @emph{Syntax}:
1976 @code{X = DBLE(X)}
1977 @code{X = DFLOAT(X)}
1978
1979 @item @emph{Arguments}:
1980 @multitable @columnfractions .15 .80
1981 @item @var{X} @tab The type shall be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
1982 @end multitable
1983
1984 @item @emph{Return value}:
1985 The return value is of type double precision real.
1986
1987 @item @emph{Example}:
1988 @smallexample
1989 program test_dble
1990     real    :: x = 2.18
1991     integer :: i = 5
1992     complex :: z = (2.3,1.14)
1993     print *, dble(x), dble(i), dfloat(z)
1994 end program test_dble
1995 @end smallexample
1996 @end table
1997
1998
1999
2000 @node DCMPLX
2001 @section @code{DCMPLX} --- Double complex conversion function
2002 @findex @code{DCMPLX} intrinsic
2003 @cindex DCMPLX
2004
2005 @table @asis
2006 @item @emph{Description}:
2007 @code{DCMPLX(X [,Y])} returns a double complex number where @var{X} is
2008 converted to the real component.  If @var{Y} is present it is converted to the
2009 imaginary component.  If @var{Y} is not present then the imaginary component is
2010 set to 0.0.  If @var{X} is complex then @var{Y} must not be present.
2011
2012 @item @emph{Option}:
2013 f95, gnu
2014
2015 @item @emph{Class}:
2016 elemental function
2017
2018 @item @emph{Syntax}:
2019 @code{C = DCMPLX(X)}
2020 @code{C = DCMPLX(X,Y)}
2021
2022 @item @emph{Arguments}:
2023 @multitable @columnfractions .15 .80
2024 @item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
2025 @item @var{Y} @tab Optional if @var{X} is not @code{COMPLEX(*)}. May be @code{INTEGER(*)} or @code{REAL(*)}.
2026 @end multitable
2027
2028 @item @emph{Return value}:
2029 The return value is of type @code{COMPLEX(8)}
2030
2031 @item @emph{Example}:
2032 @smallexample
2033 program test_dcmplx
2034     integer :: i = 42
2035     real :: x = 3.14
2036     complex :: z
2037     z = cmplx(i, x)
2038     print *, dcmplx(i)
2039     print *, dcmplx(x)
2040     print *, dcmplx(z)
2041     print *, dcmplx(x,i)
2042 end program test_dcmplx
2043 @end smallexample
2044 @end table
2045
2046
2047
2048 @node DFLOAT
2049 @section @code{DFLOAT} --- Double conversion function
2050 @findex @code{DFLOAT} intrinsic
2051 @cindex double float conversion
2052
2053 @table @asis
2054 @item @emph{Description}:
2055 @code{DFLOAT(X)} Converts @var{X} to double precision real type.
2056 @code{DFLOAT} is an alias for @code{DBLE}.  See @code{DBLE}.
2057 @end table
2058
2059
2060
2061 @node DIGITS
2062 @section @code{DIGITS} --- Significant digits function
2063 @findex @code{DIGITS} intrinsic
2064 @cindex digits, significant
2065
2066 @table @asis
2067 @item @emph{Description}:
2068 @code{DIGITS(X)} returns the number of significant digits of the internal model
2069 representation of @var{X}.  For example, on a system using a 32-bit
2070 floating point representation, a default real number would likely return 24.
2071
2072 @item @emph{Option}:
2073 f95, gnu
2074
2075 @item @emph{Class}:
2076 inquiry function
2077
2078 @item @emph{Syntax}:
2079 @code{C = DIGITS(X)}
2080
2081 @item @emph{Arguments}:
2082 @multitable @columnfractions .15 .80
2083 @item @var{X} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}.
2084 @end multitable
2085
2086 @item @emph{Return value}:
2087 The return value is of type @code{INTEGER}.
2088
2089 @item @emph{Example}:
2090 @smallexample
2091 program test_digits
2092     integer :: i = 12345
2093     real :: x = 3.143
2094     real(8) :: y = 2.33
2095     print *, digits(i)
2096     print *, digits(x)
2097     print *, digits(y)
2098 end program test_digits
2099 @end smallexample
2100 @end table
2101
2102
2103
2104 @node DIM
2105 @section @code{DIM} --- Dim function
2106 @findex @code{DIM} intrinsic
2107 @findex @code{IDIM} intrinsic
2108 @findex @code{DDIM} intrinsic
2109 @cindex dim
2110
2111 @table @asis
2112 @item @emph{Description}:
2113 @code{DIM(X,Y)} returns the difference @code{X-Y} if the result is positive;
2114 otherwise returns zero.
2115
2116 @item @emph{Option}:
2117 f95, gnu
2118
2119 @item @emph{Class}:
2120 elemental function
2121
2122 @item @emph{Syntax}:
2123 @code{X = DIM(X,Y)}
2124
2125 @item @emph{Arguments}:
2126 @multitable @columnfractions .15 .80
2127 @item @var{X} @tab The type shall be @code{INTEGER(*)} or @code{REAL(*)}
2128 @item @var{Y} @tab The type shall be the same type and kind as @var{X}.
2129 @end multitable
2130
2131 @item @emph{Return value}:
2132 The return value is of type @code{INTEGER(*)} or @code{REAL(*)}.
2133
2134 @item @emph{Example}:
2135 @smallexample
2136 program test_dim
2137     integer :: i
2138     real(8) :: x
2139     i = dim(4, 15)
2140     x = dim(4.345_8, 2.111_8)
2141     print *, i
2142     print *, x
2143 end program test_dim
2144 @end smallexample
2145
2146 @item @emph{Specific names}:
2147 @multitable @columnfractions .24 .24 .24 .24
2148 @item Name            @tab Argument          @tab Return type       @tab Option
2149 @item @code{IDIM(X,Y)} @tab @code{INTEGER(4) X,Y} @tab @code{INTEGER(4)} @tab gnu
2150 @item @code{DDIM(X,Y)} @tab @code{REAL(8) X,Y}  @tab @code{REAL(8)} @tab gnu
2151 @end multitable
2152 @end table
2153
2154
2155
2156 @node DOT_PRODUCT
2157 @section @code{DOT_PRODUCT} --- Dot product function
2158 @findex @code{DOT_PRODUCT} intrinsic
2159 @cindex Dot product
2160
2161 @table @asis
2162 @item @emph{Description}:
2163 @code{DOT_PRODUCT(X,Y)} computes the dot product multiplication of two vectors
2164 @var{X} and @var{Y}.  The two vectors may be either numeric or logical
2165 and must be arrays of rank one and of equal size. If the vectors are
2166 @code{INTEGER(*)} or @code{REAL(*)}, the result is @code{SUM(X*Y)}. If the
2167 vectors are @code{COMPLEX(*)}, the result is @code{SUM(CONJG(X)*Y)}. If the
2168 vectors are @code{LOGICAL}, the result is @code{ANY(X.AND.Y)}.
2169
2170 @item @emph{Option}:
2171 f95
2172
2173 @item @emph{Class}:
2174 transformational function
2175
2176 @item @emph{Syntax}:
2177 @code{S = DOT_PRODUCT(X,Y)}
2178
2179 @item @emph{Arguments}:
2180 @multitable @columnfractions .15 .80
2181 @item @var{X} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
2182 @item @var{Y} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
2183 @end multitable
2184
2185 @item @emph{Return value}:
2186 If the arguments are numeric, the return value is a scaler of numeric type,
2187 @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.  If the arguments are
2188 @code{LOGICAL}, the return value is @code{.TRUE.} or @code{.FALSE.}.
2189
2190 @item @emph{Example}:
2191 @smallexample
2192 program test_dot_prod
2193     integer, dimension(3) :: a, b
2194     a = (/ 1, 2, 3 /)
2195     b = (/ 4, 5, 6 /)
2196     print '(3i3)', a
2197     print *
2198     print '(3i3)', b
2199     print *
2200     print *, dot_product(a,b)
2201 end program test_dot_prod
2202 @end smallexample
2203 @end table
2204
2205
2206
2207 @node DPROD
2208 @section @code{DPROD} --- Double product function
2209 @findex @code{DPROD} intrinsic
2210 @cindex Double product
2211
2212 @table @asis
2213 @item @emph{Description}:
2214 @code{DPROD(X,Y)} returns the product @code{X*Y}.
2215
2216 @item @emph{Option}:
2217 f95, gnu
2218
2219 @item @emph{Class}:
2220 elemental function
2221
2222 @item @emph{Syntax}:
2223 @code{D = DPROD(X,Y)}
2224
2225 @item @emph{Arguments}:
2226 @multitable @columnfractions .15 .80
2227 @item @var{X} @tab The type shall be @code{REAL}.
2228 @item @var{Y} @tab The type shall be @code{REAL}.
2229 @end multitable
2230
2231 @item @emph{Return value}:
2232 The return value is of type @code{REAL(8)}.
2233
2234 @item @emph{Example}:
2235 @smallexample
2236 program test_dprod
2237     integer :: i
2238     real :: x = 5.2
2239     real :: y = 2.3
2240     real(8) :: d
2241     d = dprod(x,y)
2242     print *, d
2243 end program test_dprod
2244 @end smallexample
2245 @end table
2246
2247
2248
2249 @node DREAL
2250 @section @code{DREAL} --- Double real part function
2251 @findex @code{DREAL} intrinsic
2252 @cindex Double real part
2253
2254 @table @asis
2255 @item @emph{Description}:
2256 @code{DREAL(Z)} returns the real part of complex variable @var{Z}.
2257
2258 @item @emph{Option}:
2259 gnu
2260
2261 @item @emph{Class}:
2262 elemental function
2263
2264 @item @emph{Syntax}:
2265 @code{D = DREAL(Z)}
2266
2267 @item @emph{Arguments}:
2268 @multitable @columnfractions .15 .80
2269 @item @var{Z} @tab The type shall be @code{COMPLEX(8)}.
2270 @end multitable
2271
2272 @item @emph{Return value}:
2273 The return value is of type @code{REAL(8)}.
2274
2275 @item @emph{Example}:
2276 @smallexample
2277 program test_dreal
2278     complex(8) :: z = (1.3_8,7.2_8)
2279     print *, dreal(z)
2280 end program test_dreal
2281 @end smallexample
2282 @end table
2283
2284
2285
2286 @node DTIME
2287 @section @code{DTIME} --- Execution time subroutine (or function)
2288 @findex @code{DTIME} intrinsic
2289 @cindex dtime subroutine
2290
2291 @table @asis
2292 @item @emph{Description}:
2293 @code{DTIME(TARRAY, RESULT)} initially returns the number of seconds of runtime
2294 since the start of the process's execution in @var{RESULT}.  @var{TARRAY}
2295 returns the user and system components of this time in @code{TARRAY(1)} and
2296 @code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{TARRAY(1) +
2297 TARRAY(2)}.
2298
2299 Subsequent invocations of @code{DTIME} return values accumulated since the
2300 previous invocation.
2301
2302 On some systems, the underlying timings are represented using types with
2303 sufficiently small limits that overflows (wraparounds) are possible, such as
2304 32-bit types. Therefore, the values returned by this intrinsic might be, or
2305 become, negative, or numerically less than previous values, during a single
2306 run of the compiled program.
2307
2308 If @code{DTIME} is invoked as a function, it can not be invoked as a
2309 subroutine, and vice versa.
2310
2311 @var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
2312
2313 @multitable @columnfractions .15 .30 .60
2314 @item @tab @code{TARRAY(1)}: @tab User time in seconds.
2315 @item @tab @code{TARRAY(2)}: @tab System time in seconds.
2316 @item @tab @code{RESULT}: @tab Run time since start in seconds.
2317 @end multitable
2318
2319 @item @emph{Option}:
2320 gnu
2321
2322 @item @emph{Class}:
2323 subroutine
2324
2325 @item @emph{Syntax}:
2326 @multitable @columnfractions .80
2327 @item @code{CALL DTIME(TARRAY, RESULT)}.
2328 @item @code{RESULT = DTIME(TARRAY)}, (not recommended).
2329 @end multitable
2330
2331 @item @emph{Arguments}:
2332 @multitable @columnfractions .15 .80
2333 @item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
2334 @item @var{RESULT}@tab The type shall be @code{REAL}.
2335 @end multitable
2336
2337 @item @emph{Return value}:
2338 Elapsed time in seconds since the start of program execution.
2339
2340 @item @emph{Example}:
2341 @smallexample
2342 program test_dtime
2343     integer(8) :: i, j
2344     real, dimension(2) :: tarray
2345     real :: result
2346     call dtime(tarray, result)
2347     print *, result
2348     print *, tarray(1)
2349     print *, tarray(2)
2350     do i=1,100000000    ! Just a delay
2351         j = i * i - i
2352     end do
2353     call dtime(tarray, result)
2354     print *, result
2355     print *, tarray(1)
2356     print *, tarray(2)
2357 end program test_dtime
2358 @end smallexample
2359 @end table
2360
2361
2362
2363 @node EOSHIFT
2364 @section @code{EOSHIFT} --- End-off shift function
2365 @findex @code{EOSHIFT} intrinsic
2366 @cindex eoshift intrinsic
2367
2368 @table @asis
2369 @item @emph{Description}:
2370 @code{EOSHIFT(ARRAY, SHIFT[,BOUNDARY, DIM])} performs an end-off shift on
2371 elements of @var{ARRAY} along the dimension of @var{DIM}.  If @var{DIM} is
2372 omitted it is taken to be @code{1}.  @var{DIM} is a scaler of type
2373 @code{INTEGER} in the range of @math{1 /leq DIM /leq n)} where @math{n} is the
2374 rank of @var{ARRAY}.  If the rank of @var{ARRAY} is one, then all elements of
2375 @var{ARRAY} are shifted by @var{SHIFT} places.  If rank is greater than one,
2376 then all complete rank one sections of @var{ARRAY} along the given dimension are
2377 shifted.  Elements shifted out one end of each rank one section are dropped.  If
2378 @var{BOUNDARY} is present then the corresponding value of from @var{BOUNDARY}
2379 is copied back in the other end.  If @var{BOUNDARY} is not present then the
2380 following are copied in depending on the type of @var{ARRAY}.
2381
2382 @multitable @columnfractions .15 .80
2383 @item @emph{Array Type} @tab @emph{Boundary Value}
2384 @item Numeric  @tab 0 of the type and kind of @var{ARRAY}.
2385 @item Logical  @tab @code{.FALSE.}.
2386 @item Character(@var{len}) @tab @var{len} blanks.
2387 @end multitable
2388
2389 @item @emph{Option}:
2390 f95, gnu
2391
2392 @item @emph{Class}:
2393 transformational function
2394
2395 @item @emph{Syntax}:
2396 @code{A = EOSHIFT(A, SHIFT[,BOUNDARY, DIM])}
2397
2398 @item @emph{Arguments}:
2399 @multitable @columnfractions .15 .80
2400 @item @var{ARRAY}  @tab May be any type, not scaler.
2401 @item @var{SHIFT}  @tab The type shall be @code{INTEGER}.
2402 @item @var{BOUNDARY} @tab Same type as @var{ARRAY}.
2403 @item @var{DIM}    @tab The type shall be @code{INTEGER}.
2404 @end multitable
2405
2406 @item @emph{Return value}:
2407 Returns an array of same type and rank as the @var{ARRAY} argument.
2408
2409 @item @emph{Example}:
2410 @smallexample
2411 program test_eoshift
2412     integer, dimension(3,3) :: a
2413     a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
2414     print '(3i3)', a(1,:)
2415     print '(3i3)', a(2,:)
2416     print '(3i3)', a(3,:)
2417     a = EOSHIFT(a, SHIFT=(/1, 2, 1/), BOUNDARY=-5, DIM=2)
2418     print *
2419     print '(3i3)', a(1,:)
2420     print '(3i3)', a(2,:)
2421     print '(3i3)', a(3,:)
2422 end program test_eoshift
2423 @end smallexample
2424 @end table
2425
2426
2427
2428 @node EPSILON
2429 @section @code{EPSILON} --- Epsilon function
2430 @findex @code{EPSILON} intrinsic
2431 @cindex epsilon, significant
2432
2433 @table @asis
2434 @item @emph{Description}:
2435 @code{EPSILON(X)} returns a nearly negligible number relative to @code{1}.
2436
2437 @item @emph{Option}:
2438 f95, gnu
2439
2440 @item @emph{Class}:
2441 inquiry function
2442
2443 @item @emph{Syntax}:
2444 @code{C = EPSILON(X)}
2445
2446 @item @emph{Arguments}:
2447 @multitable @columnfractions .15 .80
2448 @item @var{X} @tab The type shall be @code{REAL(*)}.
2449 @end multitable
2450
2451 @item @emph{Return value}:
2452 The return value is of same type as the argument.
2453
2454 @item @emph{Example}:
2455 @smallexample
2456 program test_epsilon
2457     real :: x = 3.143
2458     real(8) :: y = 2.33
2459     print *, EPSILON(x)
2460     print *, EPSILON(y)
2461 end program test_epsilon
2462 @end smallexample
2463 @end table
2464
2465
2466
2467 @node ERF
2468 @section @code{ERF} --- Error function
2469 @findex @code{ERF} intrinsic
2470 @cindex error function
2471
2472 @table @asis
2473 @item @emph{Description}:
2474 @code{ERF(X)} computes the error function of @var{X}.
2475
2476 @item @emph{Option}:
2477 gnu
2478
2479 @item @emph{Class}:
2480 elemental function
2481
2482 @item @emph{Syntax}:
2483 @code{X = ERF(X)}
2484
2485 @item @emph{Arguments}:
2486 @multitable @columnfractions .15 .80
2487 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
2488 @end multitable
2489
2490 @item @emph{Return value}:
2491 The return value is a scalar of type @code{REAL(*)} and it is positive
2492 (@math{ - 1 \leq erf (x) \leq 1 }.
2493
2494 @item @emph{Example}:
2495 @smallexample
2496 program test_erf
2497   real(8) :: x = 0.17_8
2498   x = erf(x)
2499 end program test_erf
2500 @end smallexample
2501
2502 @item @emph{Specific names}:
2503 @multitable @columnfractions .24 .24 .24 .24
2504 @item Name            @tab Argument          @tab Return type       @tab Option
2505 @item @code{DERF(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
2506 @end multitable
2507 @end table
2508
2509
2510
2511 @node ERFC
2512 @section @code{ERFC} --- Error function
2513 @findex @code{ERFC} intrinsic
2514 @cindex error function
2515
2516 @table @asis
2517 @item @emph{Description}:
2518 @code{ERFC(X)} computes the complementary error function of @var{X}.
2519
2520 @item @emph{Option}:
2521 gnu
2522
2523 @item @emph{Class}:
2524 elemental function
2525
2526 @item @emph{Syntax}:
2527 @code{X = ERFC(X)}
2528
2529 @item @emph{Arguments}:
2530 @multitable @columnfractions .15 .80
2531 @item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
2532 @end multitable
2533
2534 @item @emph{Return value}:
2535 The return value is a scalar of type @code{REAL(*)} and it is positive
2536 (@math{ 0 \leq erfc (x) \leq 2 }.
2537
2538 @item @emph{Example}:
2539 @smallexample
2540 program test_erfc
2541   real(8) :: x = 0.17_8
2542   x = erfc(x)
2543 end program test_erfc
2544 @end smallexample
2545
2546 @item @emph{Specific names}:
2547 @multitable @columnfractions .24 .24 .24 .24
2548 @item Name            @tab Argument          @tab Return type       @tab Option
2549 @item @code{DERFC(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
2550 @end multitable
2551 @end table
2552
2553
2554
2555 @node ETIME
2556 @section @code{ETIME} --- Execution time subroutine (or function)
2557 @findex @code{ETIME} intrinsic
2558 @cindex ETIME subroutine
2559
2560 @table @asis
2561 @item @emph{Description}:
2562 @code{ETIME(TARRAY, RESULT)} returns the number of seconds of runtime
2563 since the start of the process's execution in @var{RESULT}.  @var{TARRAY}
2564 returns the user and system components of this time in @code{TARRAY(1)} and
2565 @code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{TARRAY(1) + TARRAY(2)}.
2566
2567 On some systems, the underlying timings are represented using types with
2568 sufficiently small limits that overflows (wraparounds) are possible, such as
2569 32-bit types. Therefore, the values returned by this intrinsic might be, or
2570 become, negative, or numerically less than previous values, during a single
2571 run of the compiled program.
2572
2573 If @code{ETIME} is invoked as a function, it can not be invoked as a
2574 subroutine, and vice versa.
2575
2576 @var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
2577
2578 @multitable @columnfractions .15 .30 .60
2579 @item @tab @code{TARRAY(1)}: @tab User time in seconds.
2580 @item @tab @code{TARRAY(2)}: @tab System time in seconds.
2581 @item @tab @code{RESULT}: @tab Run time since start in seconds.
2582 @end multitable
2583
2584 @item @emph{Option}:
2585 gnu
2586
2587 @item @emph{Class}:
2588 subroutine
2589
2590 @item @emph{Syntax}:
2591 @multitable @columnfractions .8
2592 @item @code{CALL ETIME(TARRAY, RESULT)}.
2593 @item @code{RESULT = ETIME(TARRAY)}, (not recommended).
2594 @end multitable
2595
2596 @item @emph{Arguments}:
2597 @multitable @columnfractions .15 .80
2598 @item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
2599 @item @var{RESULT}@tab The type shall be @code{REAL}.
2600 @end multitable
2601
2602 @item @emph{Return value}:
2603 Elapsed time in seconds since the start of program execution.
2604
2605 @item @emph{Example}:
2606 @smallexample
2607 program test_etime
2608     integer(8) :: i, j
2609     real, dimension(2) :: tarray
2610     real :: result
2611     call ETIME(tarray, result)
2612     print *, result
2613     print *, tarray(1)
2614     print *, tarray(2)
2615     do i=1,100000000    ! Just a delay
2616         j = i * i - i
2617     end do
2618     call ETIME(tarray, result)
2619     print *, result
2620     print *, tarray(1)
2621     print *, tarray(2)
2622 end program test_etime
2623 @end smallexample
2624 @end table
2625
2626
2627
2628 @node EXIT
2629 @section @code{EXIT} --- Exit the program with status.
2630 @findex @code{EXIT}
2631 @cindex exit
2632
2633 @table @asis
2634 @item @emph{Description}:
2635 @code{EXIT} causes immediate termination of the program with status.  If status
2636 is omitted it returns the canonical @emph{success} for the system.  All Fortran
2637 I/O units are closed.
2638
2639 @item @emph{Option}:
2640 gnu
2641
2642 @item @emph{Class}:
2643 non-elemental subroutine
2644
2645 @item @emph{Syntax}:
2646 @code{CALL EXIT([STATUS])}
2647
2648 @item @emph{Arguments}:
2649 @multitable @columnfractions .15 .80
2650 @item @var{STATUS} @tab The type of the argument shall be @code{INTEGER(*)}.
2651 @end multitable
2652
2653 @item @emph{Return value}:
2654 @code{STATUS} is passed to the parent process on exit.
2655
2656 @item @emph{Example}:
2657 @smallexample
2658 program test_exit
2659   integer :: STATUS = 0
2660   print *, 'This program is going to exit.'
2661   call EXIT(STATUS)
2662 end program test_exit
2663 @end smallexample
2664 @end table
2665
2666
2667
2668 @node EXP
2669 @section @code{EXP} --- Exponential function
2670 @findex @code{EXP} intrinsic
2671 @findex @code{DEXP} intrinsic
2672 @findex @code{ZEXP} intrinsic
2673 @findex @code{CDEXP} intrinsic
2674 @cindex exponential
2675
2676 @table @asis
2677 @item @emph{Description}:
2678 @code{EXP(X)} computes the base @math{e} exponential of @var{X}.
2679
2680 @item @emph{Option}:
2681 f95, gnu
2682
2683 @item @emph{Class}:
2684 elemental function
2685
2686 @item @emph{Syntax}:
2687 @code{X = EXP(X)}
2688
2689 @item @emph{Arguments}:
2690 @multitable @columnfractions .15 .80
2691 @item @var{X} @tab The type shall be @code{REAL(*)} or
2692 @code{COMPLEX(*)}.
2693 @end multitable
2694
2695 @item @emph{Return value}:
2696 The return value has same type and kind as @var{X}.
2697
2698 @item @emph{Example}:
2699 @smallexample
2700 program test_exp
2701   real :: x = 1.0
2702   x = exp(x)
2703 end program test_exp
2704 @end smallexample
2705
2706 @item @emph{Specific names}:
2707 @multitable @columnfractions .24 .24 .24 .24
2708 @item Name            @tab Argument          @tab Return type       @tab Option
2709 @item @code{DEXP(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
2710 @item @code{CEXP(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
2711 @item @code{ZEXP(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
2712 @item @code{CDEXP(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
2713 @end multitable
2714 @end table
2715
2716
2717
2718 @node EXPONENT
2719 @section @code{EXPONENT} --- Exponent function
2720 @findex @code{EXPONENT} intrinsic
2721 @cindex exponent function
2722
2723 @table @asis
2724 @item @emph{Description}:
2725 @code{EXPONENT(X)} returns the value of the exponent part of @var{X}. If @var{X}
2726 is zero the value returned is zero.
2727
2728 @item @emph{Option}:
2729 f95, gnu
2730
2731 @item @emph{Class}:
2732 elemental function
2733
2734 @item @emph{Syntax}:
2735 @code{I = EXPONENT(X)}
2736
2737 @item @emph{Arguments}:
2738 @multitable @columnfractions .15 .80
2739 @item @var{X} @tab The type shall be @code{REAL(*)}.
2740 @end multitable
2741
2742 @item @emph{Return value}:
2743 The return value is of type default @code{INTEGER}.
2744
2745 @item @emph{Example}:
2746 @smallexample
2747 program test_exponent
2748   real :: x = 1.0
2749   integer :: i
2750   i = exponent(x)
2751   print *, i
2752   print *, exponent(0.0)
2753 end program test_exponent
2754 @end smallexample
2755 @end table
2756
2757
2758 @node FREE
2759 @section @code{FREE} --- Frees memory
2760 @findex @code{FREE} intrinsic
2761 @cindex FREE
2762
2763 @table @asis
2764 @item @emph{Description}:
2765 Frees memory previously allocated by @code{MALLOC()}. The @code{FREE}
2766 intrinsic is an extension intended to be used with Cray pointers, and is
2767 provided in @command{gfortran} to allow user to compile legacy code. For
2768 new code using Fortran 95 pointers, the memory de-allocation intrinsic is
2769 @code{DEALLOCATE}.
2770
2771 @item @emph{Option}:
2772 gnu
2773
2774 @item @emph{Class}:
2775 subroutine
2776
2777 @item @emph{Syntax}:
2778 @code{FREE(PTR)}
2779
2780 @item @emph{Arguments}:
2781 @multitable @columnfractions .15 .80
2782 @item @var{PTR} @tab The type shall be @code{INTEGER}. It represents the
2783 location of the memory that should be de-allocated.
2784 @end multitable
2785
2786 @item @emph{Return value}:
2787 None
2788
2789 @item @emph{Example}:
2790 See @code{MALLOC} for an example.
2791 @end table
2792
2793
2794 @node FDATE
2795 @section @code{FDATE} --- Get the current time as a string
2796 @findex @code{FDATE} intrinsic
2797 @cindex fdate subroutine
2798
2799 @table @asis
2800 @item @emph{Description}:
2801 @code{FDATE(DATE)} returns the current date (using the same format as
2802 @code{CTIME}) in @var{DATE}. It is equivalent to @code{CALL CTIME(DATE,
2803 TIME8())}.
2804
2805 If @code{FDATE} is invoked as a function, it can not be invoked as a
2806 subroutine, and vice versa.
2807
2808 @var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
2809
2810 @item @emph{Option}:
2811 gnu
2812
2813 @item @emph{Class}:
2814 subroutine
2815
2816 @item @emph{Syntax}:
2817 @multitable @columnfractions .80
2818 @item @code{CALL FDATE(DATE)}.
2819 @item @code{DATE = FDATE()}, (not recommended).
2820 @end multitable
2821
2822 @item @emph{Arguments}:
2823 @multitable @columnfractions .15 .80
2824 @item @var{DATE}@tab The type shall be of type @code{CHARACTER}.
2825 @end multitable
2826
2827 @item @emph{Return value}:
2828 The current date and time as a string.
2829
2830 @item @emph{Example}:
2831 @smallexample
2832 program test_fdate
2833     integer(8) :: i, j
2834     character(len=30) :: date
2835     call fdate(date)
2836     print *, 'Program started on ', date
2837     do i = 1, 100000000 ! Just a delay
2838         j = i * i - i
2839     end do
2840     call fdate(date)
2841     print *, 'Program ended on ', date
2842 end program test_fdate
2843 @end smallexample
2844 @end table
2845
2846 @node FLOAT
2847 @section @code{FLOAT} --- Convert integer to default real
2848 @findex @code{FLOAT} intrinsic
2849 @cindex float
2850
2851 @table @asis
2852 @item @emph{Description}:
2853 @code{FLOAT(I)} converts the integer @var{I} to a default real value.
2854
2855 @item @emph{Option}:
2856 gnu
2857
2858 @item @emph{Class}:
2859 function
2860
2861 @item @emph{Syntax}:
2862 @code{X = FLOAT(I)}
2863
2864 @item @emph{Arguments}:
2865 @multitable @columnfractions .15 .80
2866 @item @var{I} @tab The type shall be @code{INTEGER(*)}.
2867 @end multitable
2868
2869 @item @emph{Return value}:
2870 The return value is of type default @code{REAL}
2871
2872 @item @emph{Example}:
2873 @smallexample
2874 program test_float
2875     integer :: i = 1
2876     if (float(i) /= 1.) call abort
2877 end program test_float
2878 @end smallexample
2879 @end table
2880
2881
2882 @node FLOOR
2883 @section @code{FLOOR} --- Integer floor function
2884 @findex @code{FLOOR} intrinsic
2885 @cindex floor
2886
2887 @table @asis
2888 @item @emph{Description}:
2889 @code{FLOOR(X)} returns the greatest integer less than or equal to @var{X}.
2890
2891 @item @emph{Option}:
2892 f95, gnu
2893
2894 @item @emph{Class}:
2895 elemental function
2896
2897 @item @emph{Syntax}:
2898 @code{I = FLOOR(X[,KIND])}
2899
2900 @item @emph{Arguments}:
2901 @multitable @columnfractions .15 .80
2902 @item @var{X} @tab The type shall be @code{REAL(*)}.
2903 @item @var{KIND} @tab Optional scaler integer initialization expression.
2904 @end multitable
2905
2906 @item @emph{Return value}:
2907 The return value is of type @code{INTEGER(KIND)}
2908
2909 @item @emph{Example}:
2910 @smallexample
2911 program test_floor
2912     real :: x = 63.29
2913     real :: y = -63.59
2914     print *, floor(x) ! returns 63
2915     print *, floor(y) ! returns -64
2916 end program test_floor
2917 @end smallexample
2918 @end table
2919
2920
2921
2922 @node FNUM
2923 @section @code{FNUM} --- File number function
2924 @findex @code{FNUM} intrinsic
2925 @cindex fnum
2926
2927 @table @asis
2928 @item @emph{Description}:
2929 @code{FNUM(UNIT)} returns the Posix file descriptor number corresponding to the
2930 open Fortran I/O unit @code{UNIT}.
2931
2932 @item @emph{Option}:
2933 gnu
2934
2935 @item @emph{Class}:
2936 non-elemental function
2937
2938 @item @emph{Syntax}:
2939 @code{I = FNUM(UNIT)}
2940
2941 @item @emph{Arguments}:
2942 @multitable @columnfractions .15 .80
2943 @item @var{UNIT} @tab The type shall be @code{INTEGER}.
2944 @end multitable
2945
2946 @item @emph{Return value}:
2947 The return value is of type @code{INTEGER}
2948
2949 @item @emph{Example}:
2950 @smallexample
2951 program test_fnum
2952   integer :: i
2953   open (unit=10, status = "scratch")
2954   i = fnum(10)
2955   print *, i
2956   close (10)
2957 end program test_fnum
2958 @end smallexample
2959 @end table
2960
2961 @node LOC
2962 @section @code{LOC} --- Returns the address of a variable
2963 @findex @code{LOC} intrinsic
2964 @cindex loc
2965
2966 @table @asis
2967 @item @emph{Description}:
2968 @code{LOC(X)} returns the address of @var{X} as an integer.
2969
2970 @item @emph{Option}:
2971 gnu
2972
2973 @item @emph{Class}:
2974 inquiry function
2975
2976 @item @emph{Syntax}:
2977 @code{I = LOC(X)}
2978
2979 @item @emph{Arguments}:
2980 @multitable @columnfractions .15 .80
2981 @item @var{X} @tab Variable of any type.
2982 @end multitable
2983
2984 @item @emph{Return value}:
2985 The return value is of type @code{INTEGER(n)}, where @code{n} is the
2986 size (in bytes) of a memory address on the target machine.
2987
2988 @item @emph{Example}:
2989 @smallexample
2990 program test_loc
2991   integer :: i
2992   real :: r
2993   i = loc(r)
2994   print *, i
2995 end program test_loc
2996 @end smallexample
2997 @end table
2998
2999 @node LOG
3000 @section @code{LOG} --- Logarithm function
3001 @findex @code{LOG} intrinsic
3002 @findex @code{ALOG} intrinsic
3003 @findex @code{DLOG} intrinsic
3004 @findex @code{CLOG} intrinsic
3005 @findex @code{ZLOG} intrinsic
3006 @findex @code{CDLOG} intrinsic
3007 @cindex logarithm
3008
3009 @table @asis
3010 @item @emph{Description}:
3011 @code{LOG(X)} computes the logarithm of @var{X}.
3012
3013 @item @emph{Option}:
3014 f95, gnu
3015
3016 @item @emph{Class}:
3017 elemental function
3018
3019 @item @emph{Syntax}:
3020 @code{X = LOG(X)}
3021
3022 @item @emph{Arguments}:
3023 @multitable @columnfractions .15 .80
3024 @item @var{X} @tab The type shall be @code{REAL(*)} or
3025 @code{COMPLEX(*)}.
3026 @end multitable
3027
3028 @item @emph{Return value}:
3029 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
3030 The kind type parameter is the same as @var{X}.
3031
3032 @item @emph{Example}:
3033 @smallexample
3034 program test_log
3035   real(8) :: x = 1.0_8
3036   complex :: z = (1.0, 2.0)
3037   x = log(x)
3038   z = log(z)
3039 end program test_log
3040 @end smallexample
3041
3042 @item @emph{Specific names}:
3043 @multitable @columnfractions .24 .24 .24 .24
3044 @item Name            @tab Argument          @tab Return type       @tab Option
3045 @item @code{ALOG(X)}  @tab @code{REAL(4) X}  @tab @code{REAL(4)}    @tab f95, gnu
3046 @item @code{DLOG(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3047 @item @code{CLOG(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
3048 @item @code{ZLOG(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3049 @item @code{CDLOG(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3050 @end multitable
3051 @end table
3052
3053
3054
3055 @node LOG10
3056 @section @code{LOG10} --- Base 10 logarithm function
3057 @findex @code{LOG10} intrinsic
3058 @findex @code{ALOG10} intrinsic
3059 @findex @code{DLOG10} intrinsic
3060 @cindex logarithm
3061
3062 @table @asis
3063 @item @emph{Description}:
3064 @code{LOG10(X)} computes the base 10 logarithm of @var{X}.
3065
3066 @item @emph{Option}:
3067 f95, gnu
3068
3069 @item @emph{Class}:
3070 elemental function
3071
3072 @item @emph{Syntax}:
3073 @code{X = LOG10(X)}
3074
3075 @item @emph{Arguments}:
3076 @multitable @columnfractions .15 .80
3077 @item @var{X} @tab The type shall be @code{REAL(*)} or
3078 @code{COMPLEX(*)}.
3079 @end multitable
3080
3081 @item @emph{Return value}:
3082 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
3083 The kind type parameter is the same as @var{X}.
3084
3085 @item @emph{Example}:
3086 @smallexample
3087 program test_log10
3088   real(8) :: x = 10.0_8
3089   x = log10(x)
3090 end program test_log10
3091 @end smallexample
3092
3093 @item @emph{Specific names}:
3094 @multitable @columnfractions .24 .24 .24 .24
3095 @item Name            @tab Argument          @tab Return type       @tab Option
3096 @item @code{ALOG10(X)}  @tab @code{REAL(4) X}  @tab @code{REAL(4)}    @tab f95, gnu
3097 @item @code{DLOG10(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3098 @end multitable
3099 @end table
3100
3101
3102 @node MALLOC
3103 @section @code{MALLOC} --- Allocate dynamic memory
3104 @findex @code{MALLOC} intrinsic
3105 @cindex MALLOC
3106
3107 @table @asis
3108 @item @emph{Description}:
3109 @code{MALLOC(SIZE)} allocates @var{SIZE} bytes of dynamic memory and
3110 returns the address of the allocated memory. The @code{MALLOC} intrinsic
3111 is an extension intended to be used with Cray pointers, and is provided
3112 in @command{gfortran} to allow user to compile legacy code. For new code
3113 using Fortran 95 pointers, the memory allocation intrinsic is
3114 @code{ALLOCATE}.
3115
3116 @item @emph{Option}:
3117 gnu
3118
3119 @item @emph{Class}:
3120 non-elemental function
3121
3122 @item @emph{Syntax}:
3123 @code{PTR = MALLOC(SIZE)}
3124
3125 @item @emph{Arguments}:
3126 @multitable @columnfractions .15 .80
3127 @item @var{SIZE} @tab The type shall be @code{INTEGER(*)}.
3128 @end multitable
3129
3130 @item @emph{Return value}:
3131 The return value is of type @code{INTEGER(K)}, with @var{K} such that
3132 variables of type @code{INTEGER(K)} have the same size as
3133 C pointers (@code{sizeof(void *)}).
3134
3135 @item @emph{Example}:
3136 The following example demonstrates the use of @code{MALLOC} and
3137 @code{FREE} with Cray pointers. This example is intended to run on
3138 32-bit systems, where the default integer kind is suitable to store
3139 pointers; on 64-bit systems, ptr_x would need to be declared as
3140 @code{integer(kind=8)}.
3141
3142 @smallexample
3143 program test_malloc
3144   integer i
3145   integer ptr_x
3146   real*8 x(*), z
3147   pointer(ptr_x,x)
3148
3149   ptr_x = malloc(20*8)
3150   do i = 1, 20
3151     x(i) = sqrt(1.0d0 / i)
3152   end do
3153   z = 0
3154   do i = 1, 20
3155     z = z + x(i)
3156     print *, z
3157   end do
3158   call free(ptr_x)
3159 end program test_malloc
3160 @end smallexample
3161 @end table
3162
3163
3164 @node REAL
3165 @section @code{REAL} --- Convert to real type
3166 @findex @code{REAL} intrinsic
3167 @findex @code{REALPART} intrinsic
3168 @cindex true values
3169
3170 @table @asis
3171 @item @emph{Description}:
3172 @code{REAL(X [, KIND])} converts its argument @var{X} to a real type.  The
3173 @code{REALPART(X)} function is provided for compatibility with @command{g77},
3174 and its use is strongly discouraged.
3175
3176 @item @emph{Option}:
3177 f95, gnu
3178
3179 @item @emph{Class}:
3180 transformational function
3181
3182 @item @emph{Syntax}:
3183 @multitable @columnfractions .30 .80
3184 @item @code{X = REAL(X)}
3185 @item @code{X = REAL(X, KIND)}
3186 @item @code{X = REALPART(Z)}
3187 @end multitable
3188
3189 @item @emph{Arguments}:
3190 @multitable @columnfractions .15 .80
3191 @item @var{X} @tab shall be @code{INTEGER(*)}, @code{REAL(*)}, or
3192 @code{COMPLEX(*)}.
3193 @item @var{KIND}  @tab (Optional) @var{KIND} shall be a scalar integer.
3194 @end multitable
3195
3196 @item @emph{Return value}:
3197 These functions return the a @code{REAL(*)} variable or array under
3198 the following rules:
3199
3200 @table @asis
3201 @item (A)
3202 @code{REAL(X)} is converted to a default real type if @var{X} is an
3203 integer or real variable.
3204 @item (B)
3205 @code{REAL(X)} is converted to a real type with the kind type parameter
3206 of @var{X} if @var{X} is a complex variable.
3207 @item (C)
3208 @code{REAL(X, KIND)} is converted to a real type with kind type
3209 parameter @var{KIND} if @var{X} is a complex, integer, or real
3210 variable.
3211 @end table
3212
3213 @item @emph{Example}:
3214 @smallexample
3215 program test_real
3216   complex :: x = (1.0, 2.0)
3217   print *, real(x), real(x,8), realpart(x)
3218   end program test_real
3219 @end smallexample
3220 @end table
3221
3222
3223
3224 @node SIGNAL
3225 @section @code{SIGNAL} --- Signal handling subroutine (or function)
3226 @findex @code{SIGNAL} intrinsic
3227 @cindex SIGNAL subroutine
3228
3229 @table @asis
3230 @item @emph{Description}:
3231 @code{SIGNAL(NUMBER, HANDLER [, STATUS])} causes external subroutine
3232 @var{HANDLER} to be executed with a single integer argument when signal
3233 @var{NUMBER} occurs.  If @var{HANDLER} is an integer, it can be used to
3234 turn off handling of signal @var{NUMBER} or revert to its default
3235 action.  See @code{signal(2)}.
3236
3237 If @code{SIGNAL} is called as a subroutine and the @var{STATUS} argument
3238 is supplied, it is set to the value returned by @code{signal(2)}.
3239
3240 @item @emph{Option}:
3241 gnu
3242
3243 @item @emph{Class}:
3244 subroutine, non-elemental function
3245
3246 @item @emph{Syntax}:
3247 @multitable @columnfractions .30 .80
3248 @item @code{CALL ALARM(NUMBER, HANDLER)}
3249 @item @code{CALL ALARM(NUMBER, HANDLER, STATUS)}
3250 @item @code{STATUS = ALARM(NUMBER, HANDLER)}
3251 @end multitable
3252
3253 @item @emph{Arguments}:
3254 @multitable @columnfractions .15 .80
3255 @item @var{NUMBER} @tab shall be a scalar integer, with @code{INTENT(IN)}
3256 @item @var{HANDLER}@tab Signal handler (@code{INTEGER FUNCTION} or
3257 @code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
3258 @code{INTEGER}. It is @code{INTENT(IN)}.
3259 @item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar
3260 integer. It has @code{INTENT(OUT)}.
3261 @end multitable
3262
3263 @item @emph{Return value}:
3264 The @code{SIGNAL} functions returns the value returned by @code{signal(2)}.
3265
3266 @item @emph{Example}:
3267 @smallexample
3268 program test_signal
3269   intrinsic signal
3270   external handler_print
3271
3272   call signal (12, handler_print)
3273   call signal (10, 1)
3274
3275   call sleep (30)
3276 end program test_signal
3277 @end smallexample
3278 @end table
3279
3280
3281
3282
3283 @node SECNDS
3284 @section @code{SECNDS} --- Time subroutine
3285 @findex @code{SECNDS} intrinsic
3286 @cindex SECNDS
3287
3288 @table @asis
3289 @item @emph{Description}:
3290 @code{SECNDS(X)} gets the time in seconds from the real-time system clock.
3291 @var{X} is a reference time, also in seconds. If this is zero, the time in
3292 seconds from midnight is returned. This function is non-standard and its
3293 use is discouraged.
3294
3295 @item @emph{Option}:
3296 gnu
3297
3298 @item @emph{Class}:
3299 function
3300
3301 @item @emph{Syntax}:
3302 @code{T = SECNDS (X)}
3303
3304 @item @emph{Arguments}:
3305 @multitable @columnfractions .15 .80
3306 @item Name        @tab Type
3307 @item @var{T}     @tab REAL(4)
3308 @item @var{X}     @tab REAL(4)
3309 @end multitable
3310
3311 @item @emph{Return value}:
3312 None
3313
3314 @item @emph{Example}:
3315 @smallexample
3316 program test_secnds
3317     real(4) :: t1, t2
3318     print *, secnds (0.0)   ! seconds since midnight
3319     t1 = secnds (0.0)       ! reference time
3320     do i = 1, 10000000      ! do something
3321     end do
3322     t2 = secnds (t1)        ! elapsed time
3323     print *, "Something took ", t2, " seconds."
3324 end program test_secnds
3325 @end smallexample
3326 @end table
3327
3328
3329
3330 @node SIN
3331 @section @code{SIN} --- Sine function
3332 @findex @code{SIN} intrinsic
3333 @findex @code{DSIN} intrinsic
3334 @findex @code{ZSIN} intrinsic
3335 @findex @code{CDSIN} intrinsic
3336 @cindex sine
3337
3338 @table @asis
3339 @item @emph{Description}:
3340 @code{SIN(X)} computes the sine of @var{X}.
3341
3342 @item @emph{Option}:
3343 f95, gnu
3344
3345 @item @emph{Class}:
3346 elemental function
3347
3348 @item @emph{Syntax}:
3349 @code{X = SIN(X)}
3350
3351 @item @emph{Arguments}:
3352 @multitable @columnfractions .15 .80
3353 @item @var{X} @tab The type shall be @code{REAL(*)} or
3354 @code{COMPLEX(*)}.
3355 @end multitable
3356
3357 @item @emph{Return value}:
3358 The return value has same type and king than @var{X}.
3359
3360 @item @emph{Example}:
3361 @smallexample
3362 program test_sin
3363   real :: x = 0.0
3364   x = sin(x)
3365 end program test_sin
3366 @end smallexample
3367
3368 @item @emph{Specific names}:
3369 @multitable @columnfractions .24 .24 .24 .24
3370 @item Name            @tab Argument          @tab Return type       @tab Option
3371 @item @code{DSIN(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3372 @item @code{CSIN(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
3373 @item @code{ZSIN(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3374 @item @code{CDSIN(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3375 @end multitable
3376 @end table
3377
3378
3379
3380 @node SINH
3381 @section @code{SINH} --- Hyperbolic sine function
3382 @findex @code{SINH} intrinsic
3383 @findex @code{DSINH} intrinsic
3384 @cindex hyperbolic sine
3385
3386 @table @asis
3387 @item @emph{Description}:
3388 @code{SINH(X)} computes the hyperbolic sine of @var{X}.
3389
3390 @item @emph{Option}:
3391 f95, gnu
3392
3393 @item @emph{Class}:
3394 elemental function
3395
3396 @item @emph{Syntax}:
3397 @code{X = SINH(X)}
3398
3399 @item @emph{Arguments}:
3400 @multitable @columnfractions .15 .80
3401 @item @var{X} @tab The type shall be @code{REAL(*)}.
3402 @end multitable
3403
3404 @item @emph{Return value}:
3405 The return value is of type @code{REAL(*)}.
3406
3407 @item @emph{Example}:
3408 @smallexample
3409 program test_sinh
3410   real(8) :: x = - 1.0_8
3411   x = sinh(x)
3412 end program test_sinh
3413 @end smallexample
3414
3415 @item @emph{Specific names}:
3416 @multitable @columnfractions .24 .24 .24 .24
3417 @item Name            @tab Argument          @tab Return type       @tab Option
3418 @item @code{DSINH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3419 @end multitable
3420 @end table
3421
3422
3423
3424 @node SQRT
3425 @section @code{SQRT} --- Square-root function
3426 @findex @code{SQRT} intrinsic
3427 @findex @code{DSQRT} intrinsic
3428 @findex @code{CSQRT} intrinsic
3429 @findex @code{ZSQRT} intrinsic
3430 @findex @code{CDSQRT} intrinsic
3431 @cindex square-root
3432
3433 @table @asis
3434 @item @emph{Description}:
3435 @code{SQRT(X)} computes the square root of @var{X}.
3436
3437 @item @emph{Option}:
3438 f95, gnu
3439
3440 @item @emph{Class}:
3441 elemental function
3442
3443 @item @emph{Syntax}:
3444 @code{X = SQRT(X)}
3445
3446 @item @emph{Arguments}:
3447 @multitable @columnfractions .15 .80
3448 @item @var{X} @tab The type shall be @code{REAL(*)} or
3449 @code{COMPLEX(*)}.
3450 @end multitable
3451
3452 @item @emph{Return value}:
3453 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
3454 The kind type parameter is the same as @var{X}.
3455
3456 @item @emph{Example}:
3457 @smallexample
3458 program test_sqrt
3459   real(8) :: x = 2.0_8
3460   complex :: z = (1.0, 2.0)
3461   x = sqrt(x)
3462   z = sqrt(z)
3463 end program test_sqrt
3464 @end smallexample
3465
3466 @item @emph{Specific names}:
3467 @multitable @columnfractions .24 .24 .24 .24
3468 @item Name            @tab Argument          @tab Return type       @tab Option
3469 @item @code{DSQRT(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3470 @item @code{CSQRT(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
3471 @item @code{ZSQRT(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3472 @item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
3473 @end multitable
3474 @end table
3475
3476
3477
3478 @node TAN
3479 @section @code{TAN} --- Tangent function
3480 @findex @code{TAN} intrinsic
3481 @findex @code{DTAN} intrinsic
3482 @cindex tangent
3483
3484 @table @asis
3485 @item @emph{Description}:
3486 @code{TAN(X)} computes the tangent of @var{X}.
3487
3488 @item @emph{Option}:
3489 f95, gnu
3490
3491 @item @emph{Class}:
3492 elemental function
3493
3494 @item @emph{Syntax}:
3495 @code{X = TAN(X)}
3496
3497 @item @emph{Arguments}:
3498 @multitable @columnfractions .15 .80
3499 @item @var{X} @tab The type shall be @code{REAL(*)}.
3500 @end multitable
3501
3502 @item @emph{Return value}:
3503 The return value is of type @code{REAL(*)}.  The kind type parameter is
3504 the same as @var{X}.
3505
3506 @item @emph{Example}:
3507 @smallexample
3508 program test_tan
3509   real(8) :: x = 0.165_8
3510   x = tan(x)
3511 end program test_tan
3512 @end smallexample
3513
3514 @item @emph{Specific names}:
3515 @multitable @columnfractions .24 .24 .24 .24
3516 @item Name            @tab Argument          @tab Return type       @tab Option
3517 @item @code{DTAN(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3518 @end multitable
3519 @end table
3520
3521
3522
3523 @node TANH
3524 @section @code{TANH} --- Hyperbolic tangent function
3525 @findex @code{TANH} intrinsic
3526 @findex @code{DTANH} intrinsic
3527 @cindex hyperbolic tangent
3528
3529 @table @asis
3530 @item @emph{Description}:
3531 @code{TANH(X)} computes the hyperbolic tangent of @var{X}.
3532
3533 @item @emph{Option}:
3534 f95, gnu
3535
3536 @item @emph{Class}:
3537 elemental function
3538
3539 @item @emph{Syntax}:
3540 @code{X = TANH(X)}
3541
3542 @item @emph{Arguments}:
3543 @multitable @columnfractions .15 .80
3544 @item @var{X} @tab The type shall be @code{REAL(*)}.
3545 @end multitable
3546
3547 @item @emph{Return value}:
3548 The return value is of type @code{REAL(*)} and lies in the range
3549 @math{ - 1 \leq tanh(x) \leq 1 }.
3550
3551 @item @emph{Example}:
3552 @smallexample
3553 program test_tanh
3554   real(8) :: x = 2.1_8
3555   x = tanh(x)
3556 end program test_tanh
3557 @end smallexample
3558
3559 @item @emph{Specific names}:
3560 @multitable @columnfractions .24 .24 .24 .24
3561 @item Name            @tab Argument          @tab Return type       @tab Option
3562 @item @code{DTANH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
3563 @end multitable
3564 @end table
3565
3566
3567
3568 @comment sub   flush
3569 @comment
3570 @comment gen   fraction
3571 @comment
3572 @comment gen   fstat
3573 @comment sub   fstat
3574 @comment
3575 @comment sub   getarg
3576 @comment
3577 @comment gen   getcwd
3578 @comment sub   getcwd
3579 @comment
3580 @comment sub   getenv
3581 @comment
3582 @comment gen   getgid
3583 @comment
3584 @comment gen   getpid
3585 @comment
3586 @comment gen   getuid
3587 @comment
3588 @comment sub   get_command
3589 @comment
3590 @comment sub   get_command_argument
3591 @comment
3592 @comment sub   get_environment_variable
3593 @comment
3594 @comment gen   huge
3595 @comment
3596 @comment gen   iachar
3597 @comment
3598 @comment gen   iand
3599 @comment
3600 @comment gen   iargc
3601 @comment
3602 @comment gen   ibclr
3603 @comment
3604 @comment gen   ibits
3605 @comment
3606 @comment gen   ibset
3607 @comment
3608 @comment gen   ichar
3609 @comment
3610 @comment gen   ieor
3611 @comment
3612 @comment gen   index
3613 @comment
3614 @comment gen   int
3615 @comment       ifix
3616 @comment       idint
3617 @comment
3618 @comment gen   ior
3619 @comment
3620 @comment gen   irand
3621 @comment
3622 @comment gen   ishft
3623 @comment
3624 @comment gen   ishftc
3625 @comment
3626 @comment gen   kind
3627 @comment
3628 @comment gen   lbound
3629 @comment
3630 @comment gen   len
3631 @comment
3632 @comment gen   len_trim
3633 @comment
3634 @comment gen   lge
3635 @comment
3636 @comment gen   lgt
3637 @comment
3638 @comment gen   lle
3639 @comment
3640 @comment gen   llt
3641 @comment
3642 @comment gen   logical
3643 @comment
3644 @comment gen   matmul
3645 @comment
3646 @comment gen   max
3647 @comment       max0
3648 @comment       amax0
3649 @comment       amax1
3650 @comment       max1
3651 @comment       dmax1
3652 @comment
3653 @comment gen   maxexponent
3654 @comment
3655 @comment gen   maxloc
3656 @comment
3657 @comment gen   maxval
3658 @comment
3659 @comment gen   merge
3660 @comment
3661 @comment gen   min
3662 @comment       min0
3663 @comment       amin0
3664 @comment       amin1
3665 @comment       min1
3666 @comment       dmin1
3667 @comment
3668 @comment gen   minexponent
3669 @comment
3670 @comment gen   minloc
3671 @comment
3672 @comment gen   minval
3673 @comment
3674 @comment gen   mod
3675 @comment       amod
3676 @comment       dmod
3677 @comment
3678 @comment gen   modulo
3679 @comment
3680 @comment sub   mvbits
3681 @comment
3682 @comment gen   nearest
3683 @comment
3684 @comment gen   nint
3685 @comment       idnint
3686 @comment
3687 @comment gen   not
3688 @comment
3689 @comment gen   null
3690 @comment
3691 @comment gen   pack
3692 @comment
3693 @comment gen   precision
3694 @comment
3695 @comment gen   present
3696 @comment
3697 @comment gen   product
3698 @comment
3699 @comment gen   radix
3700 @comment
3701 @comment gen   rand
3702 @comment       ran
3703 @comment
3704 @comment sub   random_number
3705 @comment
3706 @comment sub   random_seed
3707 @comment
3708 @comment gen   range
3709 @comment
3710 @comment gen   real
3711 @comment       float
3712 @comment       sngl
3713 @comment
3714 @comment gen   repeat
3715 @comment
3716 @comment gen   reshape
3717 @comment
3718 @comment gen   rrspacing
3719 @comment
3720 @comment gen   scale
3721 @comment
3722 @comment gen   scan
3723 @comment
3724 @comment gen   second
3725 @comment sub   second
3726 @comment
3727 @comment gen   selected_int_kind
3728 @comment
3729 @comment gen   selected_real_kind
3730 @comment
3731 @comment gen   set_exponent
3732 @comment
3733 @comment gen   shape
3734 @comment
3735 @comment gen   sign
3736 @comment       isign
3737 @comment       dsign
3738 @comment
3739 @comment gen   size
3740 @comment
3741 @comment gen   spacing
3742 @comment
3743 @comment gen   spread
3744 @comment
3745 @comment sub   srand
3746 @comment
3747 @comment gen   stat
3748 @comment sub   stat
3749 @comment
3750 @comment gen   sum
3751 @comment
3752 @comment gen   system
3753 @comment sub   system
3754 @comment
3755 @comment sub system_clock
3756 @comment
3757 @comment gen   tiny
3758 @comment
3759 @comment gen   transfer
3760 @comment
3761 @comment gen   transpose
3762 @comment
3763 @comment gen   trim
3764 @comment
3765 @comment gen   ubound
3766 @comment
3767 @comment gen   umask
3768 @comment sub   umask
3769 @comment
3770 @comment gen   unlink
3771 @comment sub   unlink
3772 @comment
3773 @comment gen   unpack
3774 @comment
3775 @comment gen   verify
3776