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