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,      Arccosine 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{ALL}:       ALL,       Determine if all values are true
  45 * @code{ALLOCATED}: ALLOCATED, Status of allocatable entity
  46 * @code{ANINT}:     ANINT,     Nearest whole number
  47 * @code{ANY}:       ANY,       Determine if any values are true
  48 * @code{ASIN}:      ASIN,      Arcsine function
  49 * @code{ASSOCIATED}: ASSOCIATED, Status of a pointer or pointer/target pair
  50 * @code{ATAN}:       ATAN,      Arctangent function
  51 * @code{ATAN2}:      ATAN2,      Arctangent function
  52 * @code{BESJ0}:     BESJ0,     Bessel function of the first kind of order 0
  53 * @code{BESJ1}:     BESJ1,     Bessel function of the first kind of order 1
  54 * @code{BESJN}:     BESJN,     Bessel function of the first kind
  55 * @code{BESY0}:     BESY0,     Bessel function of the second kind of order 0
  56 * @code{BESY1}:     BESY1,     Bessel function of the second kind of order 1
  57 * @code{BESYN}:     BESYN,     Bessel function of the second kind
  58 * @code{COS}:       COS,       Cosine function
  59 * @code{COSH}:      COSH,      Hyperbolic cosine function
  60 * @code{ERF}:       ERF,       Error function
  61 * @code{ERFC}:      ERFC,      Complementary error function
  62 * @code{EXP}:       EXP,       Cosine function
  63 * @code{LOG}:       LOG,       Logarithm function
  64 * @code{LOG10}:     LOG10,     Base 10 logarithm function
  65 * @code{SQRT}:      SQRT,      Square-root function
  66 * @code{SIN}:       SIN,       Sine function
  67 * @code{SINH}:      SINH,      Hyperbolic sine function
  68 * @code{TAN}:       TAN,       Tangent function
  69 * @code{TANH}:      TANH,      Hyperbolic tangent function
  70 @end menu
  71
  72 @node Introduction
  73 @section Introduction to intrinsic procedures
  74
  75 Gfortran provides a rich set of intrinsic procedures that includes all
  76 the intrinsic procedures required by the Fortran 95 standard, a set of
  77 intrinsic procedures for backwards compatibility with Gnu Fortran 77
  78 (i.e., @command{g77}), and a small selection of intrinsic procedures
  79 from the Fortran 2003 standard.  Any description here, which conflicts with a
  80 description in either the Fortran 95 standard or the Fortran 2003 standard,
  81 is unintentional and the standard(s) should be considered authoritative.
  82
  83 The enumeration of the @code{KIND} type parameter is processor defined in
  84 the Fortran 95 standard.  Gfortran defines the default integer type and
  85 default real type by @code{INTEGER(KIND=4)} and @code{REAL(KIND=4)},
  86 respectively.  The standard mandates that both data types shall have
  87 another kind, which have more precision.  On typical target architectures
  88 supports by @command{gfortran}, this kind type parameter is @code{KIND=8}.
  89 Hence, @code{REAL(KIND=8)} and @code{DOUBLE PRECISION} are equivalent.
  90 In the description of generic intrinsic procedures, the kind type parameter
  91 will be specified by @code{KIND=*}, and in the description of specific
  92 names for an intrinsic procedure the kind type parameter will be explicitly
  93 given (e.g., @code{REAL(KIND=4)} or @code{REAL(KIND=8)}).  Finally, for
  94 brevity the optional @code{KIND=} syntax will be omitted.
  95
  96 Many of the intrinsics procedures take one or more optional arguments.
  97 This document follows the convention used in the Fortran 95 standard,
  98 and denotes such arguments by square brackets.
  99
 100 @command{Gfortran} offers the @option{-std=f95} and @option{-std=gnu} options,
 101 which can be used to restrict the set of intrinsic procedures to a
 102 given standard.  By default, @command{gfortran} sets the @option{-std=gnu}
 103 option, and so all intrinsic procedures describe here are accepted.  There
 104 is one caveat.  For a select group of intrinsic procedures, @command{g77}
 105 implemented both a function and a subroutine.  Both classes
 106 have been implemented in @command{gfortran} for backwards compatibility
 107 with @command{g77}.  It is noted here that these functions and subroutines
 108 cannot be intermixed in a given subprogram.  In the descriptions that follow,
 109 the applicable option(s) is noted.
 110
 111
 112
 113 @node ABORT
 114 @section @code{ABORT} --- Abort the program
 115 @findex @code{ABORT}
 116 @cindex abort
 117
 118 @table @asis
 119 @item @emph{Description}:
 120 @code{ABORT} causes immediate termination of the program.  On operating
 121 systems that support a core dump, @code{ABORT} will produce a core dump,
 122 which is suitable for debugging purposes.
 123
 124 @item @emph{Option}:
 125 gnu
 126
 127 @item @emph{Type}:
 128 non-elemental subroutine
 129
 130 @item @emph{Syntax}:
 131 @code{CALL ABORT}
 132
 133 @item @emph{Return value}:
 134 Does not return.
 135
 136 @item @emph{Example}:
 137 @smallexample
 138 program test_abort
 139   integer :: i = 1, j = 2
 140   if (i /= j) call abort
 141 end program test_abort
 142 @end smallexample
 143 @end table
 144
 145
 146
 147 @node ABS
 148 @section @code{ABS} --- Absolute value
 149 @findex @code{ABS} intrinsic
 150 @findex @code{CABS} intrinsic
 151 @findex @code{DABS} intrinsic
 152 @findex @code{IABS} intrinsic
 153 @findex @code{ZABS} intrinsic
 154 @findex @code{CDABS} intrinsic
 155 @cindex absolute value
 156
 157 @table @asis
 158 @item @emph{Description}:
 159 @code{ABS(X)} computes the absolute value of @code{X}.
 160
 161 @item @emph{Option}:
 162 f95, gnu
 163
 164 @item @emph{Type}:
 165 elemental function
 166
 167 @item @emph{Syntax}:
 168 @code{X = ABS(X)}
 169
 170 @item @emph{Arguments}:
 171 @multitable @columnfractions .15 .80
 172 @item @var{X} @tab The type of the argument shall be an @code{INTEGER(*)},
 173 @code{REAL(*)}, or @code{COMPLEX(*)}.
 174 @end multitable
 175
 176 @item @emph{Return value}:
 177 The return value is of the same type and
 178 kind as the argument except the return value is @code{REAL(*)} for a
 179 @code{COMPLEX(*)} argument.
 180
 181 @item @emph{Example}:
 182 @smallexample
 183 program test_abs
 184   integer :: i = -1
 185   real :: x = -1.e0
 186   complex :: z = (-1.e0,0.e0)
 187   i = abs(i)
 188   x = abs(x)
 189   x = abs(z)
 190 end program test_abs
 191 @end smallexample
 192
 193 @item @emph{Specific names}:
 194 @multitable @columnfractions .24 .24 .24 .24
 195 @item Name            @tab Argument            @tab Return type       @tab Option
 196 @item @code{CABS(Z)}  @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)}    @tab f95, gnu
 197 @item @code{DABS(X)}  @tab @code{REAL(8)    X} @tab @code{REAL(8)}    @tab f95, gnu
 198 @item @code{IABS(I)}  @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab f95, gnu
 199 @item @code{ZABS(Z)}  @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
 200 @item @code{CDABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
 201 @end multitable
 202 @end table
 203
 204
 205
 206 @node ACHAR
 207 @section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence
 208 @findex @code{ACHAR} intrinsic
 209 @cindex @acronym{ASCII} collating sequence
 210
 211 @table @asis
 212 @item @emph{Description}:
 213 @code{ACHAR(I)} returns the character located at position @code{I}
 214 in the @acronym{ASCII} collating sequence.
 215
 216 @item @emph{Option}:
 217 f95, gnu
 218
 219 @item @emph{Type}:
 220 elemental function
 221
 222 @item @emph{Syntax}:
 223 @code{C = ACHAR(I)}
 224
 225 @item @emph{Arguments}:
 226 @multitable @columnfractions .15 .80
 227 @item @var{I} @tab The type shall be an @code{INTEGER(*)}.
 228 @end multitable
 229
 230 @item @emph{Return value}:
 231 The return value is of type @code{CHARACTER} with a length of one.  The
 232 kind type parameter is the same as  @code{KIND('A')}.
 233
 234 @item @emph{Example}:
 235 @smallexample
 236 program test_achar
 237   character c
 238   c = achar(32)
 239 end program test_achar
 240 @end smallexample
 241 @end table
 242
 243
 244
 245 @node ACOS
 246 @section @code{ACOS} --- Arccosine function
 247 @findex @code{ACOS} intrinsic
 248 @findex @code{DACOS} intrinsic
 249 @cindex arccosine
 250
 251 @table @asis
 252 @item @emph{Description}:
 253 @code{ACOS(X)} computes the arccosine of its @var{X}.
 254
 255 @item @emph{Option}:
 256 f95, gnu
 257
 258 @item @emph{Type}:
 259 elemental function
 260
 261 @item @emph{Syntax}:
 262 @code{X = ACOS(X)}
 263
 264 @item @emph{Arguments}:
 265 @multitable @columnfractions .15 .80
 266 @item @var{X} @tab The type shall be an @code{REAL(*)}, and a magnitude that is
 267 less than one.
 268 @end multitable
 269
 270 @item @emph{Return value}:
 271 The return value is of type @code{REAL(*)} and it lies in the
 272 range @math{ 0 \leq \arccos (x) \leq \pi}.  The kind type
 273 parameter is the same as @var{X}.
 274
 275 @item @emph{Example}:
 276 @smallexample
 277 program test_acos
 278   real(8) :: x = 0.866_8
 279   x = achar(x)
 280 end program test_acos
 281 @end smallexample
 282
 283 @item @emph{Specific names}:
 284 @multitable @columnfractions .24 .24 .24 .24
 285 @item Name            @tab Argument          @tab Return type       @tab Option
 286 @item @code{DACOS(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 287 @end multitable
 288 @end table
 289
 290
 291
 292 @node ADJUSTL
 293 @section @code{ADJUSTL} --- Left adjust a string
 294 @findex @code{ADJUSTL} intrinsic
 295 @cindex adjust string
 296
 297 @table @asis
 298 @item @emph{Description}:
 299 @code{ADJUSTL(STR)} will left adjust a string by removing leading spaces.
 300 Spaces are inserted at the end of the string as needed.
 301
 302 @item @emph{Option}:
 303 f95, gnu
 304
 305 @item @emph{Type}:
 306 elemental function
 307
 308 @item @emph{Syntax}:
 309 @code{STR = ADJUSTL(STR)}
 310
 311 @item @emph{Arguments}:
 312 @multitable @columnfractions .15 .80
 313 @item @var{STR} @tab The type shall be @code{CHARACTER}.
 314 @end multitable
 315
 316 @item @emph{Return value}:
 317 The return value is of type @code{CHARACTER} where leading spaces
 318 are removed and the same number of spaces are inserted on the end
 319 of @var{STR}.
 320
 321 @item @emph{Example}:
 322 @smallexample
 323 program test_adjustl
 324   character(len=20) :: str = '   gfortran'
 325   str = adjustl(str)
 326   print *, str
 327 end program test_adjustl
 328 @end smallexample
 329 @end table
 330
 331
 332 @node ADJUSTR
 333 @section @code{ADJUSTR} --- Right adjust a string
 334 @findex @code{ADJUSTR} intrinsic
 335 @cindex adjust string
 336
 337 @table @asis
 338 @item @emph{Description}:
 339 @code{ADJUSTR(STR)} will right adjust a string by removing trailing spaces.
 340 Spaces are inserted at the start of the string as needed.
 341
 342 @item @emph{Option}:
 343 f95, gnu
 344
 345 @item @emph{Type}:
 346 elemental function
 347
 348 @item @emph{Syntax}:
 349 @code{STR = ADJUSTR(STR)}
 350
 351 @item @emph{Arguments}:
 352 @multitable @columnfractions .15 .80
 353 @item @var{STR} @tab The type shall be @code{CHARACTER}.
 354 @end multitable
 355
 356 @item @emph{Return value}:
 357 The return value is of type @code{CHARACTER} where trailing spaces
 358 are removed and the same number of spaces are inserted at the start
 359 of @var{STR}.
 360
 361 @item @emph{Example}:
 362 @smallexample
 363 program test_adjustr
 364   character(len=20) :: str = 'gfortran'
 365   str = adjustr(str)
 366   print *, str
 367 end program test_adjustr
 368 @end smallexample
 369 @end table
 370
 371
 372 @node AIMAG
 373 @section @code{AIMAG} --- Imaginary part of complex number
 374 @findex @code{AIMAG} intrinsic
 375 @findex @code{DIMAG} intrinsic
 376 @cindex Imaginary part
 377
 378 @table @asis
 379 @item @emph{Description}:
 380 @code{AIMAG(Z)} yields the imaginary part of complex argument @code{Z}.
 381
 382 @item @emph{Option}:
 383 f95, gnu
 384
 385 @item @emph{Type}:
 386 elemental function
 387
 388 @item @emph{Syntax}:
 389 @code{X = AIMAG(Z)}
 390
 391 @item @emph{Arguments}:
 392 @multitable @columnfractions .15 .80
 393 @item @var{Z} @tab The type of the argument shall be @code{COMPLEX(*)}.
 394 @end multitable
 395
 396 @item @emph{Return value}:
 397 The return value is of type real with the
 398 kind type parameter of the argument.
 399
 400 @item @emph{Example}:
 401 @smallexample
 402 program test_aimag
 403   complex(4) z4
 404   complex(8) z8
 405   z4 = cmplx(1.e0_4, 0.e0_4)
 406   z8 = cmplx(0.e0_8, 1.e0_8)
 407   print *, aimag(z4), dimag(z8)
 408 end program test_aimag
 409 @end smallexample
 410
 411 @item @emph{Specific names}:
 412 @multitable @columnfractions .24 .24 .24 .24
 413 @item Name            @tab Argument            @tab Return type       @tab Option
 414 @item @code{DIMAG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{REAL(8)}    @tab f95, gnu
 415 @end multitable
 416 @end table
 417
 418
 419 @node AINT
 420 @section @code{AINT} --- Imaginary part of complex number
 421 @findex @code{AINT} intrinsic
 422 @findex @code{DINT} intrinsic
 423 @cindex whole number
 424
 425 @table @asis
 426 @item @emph{Description}:
 427 @code{AINT(X [, KIND])} truncates its argument to a whole number.
 428
 429 @item @emph{Option}:
 430 f95, gnu
 431
 432 @item @emph{Type}:
 433 elemental function
 434
 435 @item @emph{Syntax}:
 436 @code{X = AINT(X)} @*
 437 @code{X = AINT(X, KIND)}
 438
 439 @item @emph{Arguments}:
 440 @multitable @columnfractions .15 .80
 441 @item @var{X}    @tab The type of the argument shall be @code{REAL(*)}.
 442 @item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
 443 initialization expression.
 444 @end multitable
 445
 446 @item @emph{Return value}:
 447 The return value is of type real with the kind type parameter of the
 448 argument if the optional @var{KIND} is absence; otherwise, the kind
 449 type parameter will be given by @var{KIND}.  If the magnitude of
 450 @var{X} is less than one, then @code{AINT(X)} returns zero.  If the
 451 magnitude is equal to or greater than one, then it returns the largest
 452 whole number that does not exceed its magnitude.  The sign is the same
 453 as the sign of @var{X}.
 454
 455 @item @emph{Example}:
 456 @smallexample
 457 program test_aint
 458   real(4) x4
 459   real(8) x8
 460   x4 = 1.234E0_4
 461   x8 = 4.321_8
 462   print *, aint(x4), dint(x8)
 463   x8 = aint(x4,8)
 464 end program test_aint
 465 @end smallexample
 466
 467 @item @emph{Specific names}:
 468 @multitable @columnfractions .24 .24 .24 .24
 469 @item Name           @tab Argument         @tab Return type      @tab Option
 470 @item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
 471 @end multitable
 472 @end table
 473
 474
 475 @node ALL
 476 @section @code{ALL} --- All values in @var{MASK} along @var{DIM} are true
 477 @findex @code{ALL} intrinsic
 478 @cindex true values
 479
 480 @table @asis
 481 @item @emph{Description}:
 482 @code{ALL(MASK [, DIM])} determines if all the values are true in @var{MASK}
 483 in the array along dimension @var{DIM}.
 484
 485 @item @emph{Option}:
 486 f95, gnu
 487
 488 @item @emph{Type}:
 489 transformational function
 490
 491 @item @emph{Syntax}:
 492 @code{L = ALL(MASK)} @*
 493 @code{L = ALL(MASK, DIM)}
 494
 495 @item @emph{Arguments}:
 496 @multitable @columnfractions .15 .80
 497 @item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
 498 it shall not be scalar.
 499 @item @var{DIM}  @tab (Optional) @var{DIM} shall be a scalar integer
 500 with a value that lies between one and the rank of @var{MASK}.
 501 @end multitable
 502
 503 @item @emph{Return value}:
 504 @code{ALL(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
 505 the kind type parameter is the same as the kind type parameter of
 506 @var{MASK}.  If @var{DIM} is present, then @code{ALL(MASK, DIM)} returns
 507 an array with the rank of @var{MASK} minus 1.  The shape is determined from
 508 the shape of @var{MASK} where the @var{DIM} dimension is elided.
 509
 510 @table @asis
 511 @item (A)
 512 @code{ALL(MASK)} is true if all elements of @var{MASK} are true.
 513 It also is true if @var{MASK} has zero size; otherwise, it is false.
 514 @item (B)
 515 If the rank of @var{MASK} is one, then @code{ALL(MASK,DIM)} is equivalent
 516 to @code{ALL(MASK)}.  If the rank is greater than one, then @code{ALL(MASK,DIM)}
 517 is determined by applying @code{ALL} to the array sections.
 518 @end table
 519
 520 @item @emph{Example}:
 521 @smallexample
 522 program test_all
 523   logical l
 524   l = all((/.true., .true., .true./))
 525   print *, l
 526   call section
 527   contains
 528     subroutine section
 529       integer a(2,3), b(2,3)
 530       a = 1
 531       b = 1
 532       b(2,2) = 2
 533       print *, all(a .eq. b, 1)
 534       print *, all(a .eq. b, 2)
 535     end subroutine section
 536 end program test_all
 537 @end smallexample
 538 @end table
 539
 540
 541
 542 @node ALLOCATED
 543 @section @code{ALLOCATED} --- Status of an allocatable entity
 544 @findex @code{ALLOCATED} intrinsic
 545 @cindex allocation status
 546
 547 @table @asis
 548 @item @emph{Description}:
 549 @code{ALLOCATED(X)} checks the status of wether @var{X} is allocated.
 550
 551 @item @emph{Option}:
 552 f95, gnu
 553
 554 @item @emph{Type}:
 555 inquiry function
 556
 557 @item @emph{Syntax}:
 558 @code{L = ALLOCATED(X)}
 559
 560 @item @emph{Arguments}:
 561 @multitable @columnfractions .15 .80
 562 @item @var{X}    @tab The argument shall be an @code{ALLOCATABLE} array.
 563 @end multitable
 564
 565 @item @emph{Return value}:
 566 The return value is a scalar @code{LOGICAL} with the default logical
 567 kind type parameter.  If @var{X} is allocated, @code{ALLOCATED(X)}
 568 is @code{.TRUE.}; otherwise, it returns the @code{.TRUE.}
 569
 570 @item @emph{Example}:
 571 @smallexample
 572 program test_allocated
 573   integer :: i = 4
 574   real(4), allocatable :: x(:)
 575   if (allocated(x) .eqv. .false.) allocate(x(i)
 576 end program test_allocated
 577 @end smallexample
 578 @end table
 579
 580
 581 @node ANINT
 582 @section @code{ANINT} --- Imaginary part of complex number
 583 @findex @code{ANINT} intrinsic
 584 @findex @code{DNINT} intrinsic
 585 @cindex whole number
 586
 587 @table @asis
 588 @item @emph{Description}:
 589 @code{ANINT(X [, KIND])} rounds its argument to the nearest whole number.
 590
 591 @item @emph{Option}:
 592 f95, gnu
 593
 594 @item @emph{Type}:
 595 elemental function
 596
 597 @item @emph{Syntax}:
 598 @code{X = ANINT(X)} @*
 599 @code{X = ANINT(X, KIND)}
 600
 601 @item @emph{Arguments}:
 602 @multitable @columnfractions .15 .80
 603 @item @var{X}    @tab The type of the argument shall be @code{REAL(*)}.
 604 @item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
 605 initialization expression.
 606 @end multitable
 607
 608 @item @emph{Return value}:
 609 The return value is of type real with the kind type parameter of the
 610 argument if the optional @var{KIND} is absence; otherwise, the kind
 611 type parameter will be given by @var{KIND}.  If @var{X} is greater than
 612 zero, then @code{ANINT(X)} returns @code{AINT(X+0.5)}.  If @var{X} is
 613 less than or equal to zero, then return @code{AINT(X-0.5)}.
 614
 615 @item @emph{Example}:
 616 @smallexample
 617 program test_anint
 618   real(4) x4
 619   real(8) x8
 620   x4 = 1.234E0_4
 621   x8 = 4.321_8
 622   print *, anint(x4), dnint(x8)
 623   x8 = anint(x4,8)
 624 end program test_anint
 625 @end smallexample
 626
 627 @item @emph{Specific names}:
 628 @multitable @columnfractions .24 .24 .24 .24
 629 @item Name            @tab Argument         @tab Return type      @tab Option
 630 @item @code{DNINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
 631 @end multitable
 632 @end table
 633
 634
 635 @node ANY
 636 @section @code{ANY} --- Any value in @var{MASK} along @var{DIM} is true
 637 @findex @code{ANY} intrinsic
 638 @cindex true values
 639
 640 @table @asis
 641 @item @emph{Description}:
 642 @code{ANY(MASK [, DIM])} determines if any of the values is true in @var{MASK}
 643 in the array along dimension @var{DIM}.
 644
 645 @item @emph{Option}:
 646 f95, gnu
 647
 648 @item @emph{Type}:
 649 transformational function
 650
 651 @item @emph{Syntax}:
 652 @code{L = ANY(MASK)} @*
 653 @code{L = ANY(MASK, DIM)}
 654
 655 @item @emph{Arguments}:
 656 @multitable @columnfractions .15 .80
 657 @item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
 658 it shall not be scalar.
 659 @item @var{DIM}  @tab (Optional) @var{DIM} shall be a scalar integer
 660 with a value that lies between one and the rank of @var{MASK}.
 661 @end multitable
 662
 663 @item @emph{Return value}:
 664 @code{ANY(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
 665 the kind type parameter is the same as the kind type parameter of
 666 @var{MASK}.  If @var{DIM} is present, then @code{ANY(MASK, DIM)} returns
 667 an array with the rank of @var{MASK} minus 1.  The shape is determined from
 668 the shape of @var{MASK} where the @var{DIM} dimension is elided.
 669
 670 @table @asis
 671 @item (A)
 672 @code{ANY(MASK)} is true if any element of @var{MASK} is true;
 673 otherwise, it is false.  It also is false if @var{MASK} has zero size.
 674 @item (B)
 675 If the rank of @var{MASK} is one, then @code{ANY(MASK,DIM)} is equivalent
 676 to @code{ANY(MASK)}.  If the rank is greater than one, then @code{ANY(MASK,DIM)}
 677 is determined by applying @code{ANY} to the array sections.
 678 @end table
 679
 680 @item @emph{Example}:
 681 @smallexample
 682 program test_any
 683   logical l
 684   l = any((/.true., .true., .true./))
 685   print *, l
 686   call section
 687   contains
 688     subroutine section
 689       integer a(2,3), b(2,3)
 690       a = 1
 691       b = 1
 692       b(2,2) = 2
 693       print *, any(a .eq. b, 1)
 694       print *, any(a .eq. b, 2)
 695     end subroutine section
 696 end program test_any
 697 @end smallexample
 698 @end table
 699
 700
 701 @node ASIN
 702 @section @code{ASIN} --- Arcsine function
 703 @findex @code{ASIN} intrinsic
 704 @findex @code{DASIN} intrinsic
 705 @cindex arcsine
 706
 707 @table @asis
 708 @item @emph{Description}:
 709 @code{ASIN(X)} computes the arcsine of its @var{X}.
 710
 711 @item @emph{Option}:
 712 f95, gnu
 713
 714 @item @emph{Type}:
 715 elemental function
 716
 717 @item @emph{Syntax}:
 718 @code{X = ASIN(X)}
 719
 720 @item @emph{Arguments}:
 721 @multitable @columnfractions .15 .80
 722 @item @var{X} @tab The type shall be an @code{REAL(*)}, and a magnitude that is
 723 less than one.
 724 @end multitable
 725
 726 @item @emph{Return value}:
 727 The return value is of type @code{REAL(*)} and it lies in the
 728 range @math{-\pi / 2 \leq \arccos (x) \leq \pi / 2}.  The kind type
 729 parameter is the same as @var{X}.
 730
 731 @item @emph{Example}:
 732 @smallexample
 733 program test_asin
 734   real(8) :: x = 0.866_8
 735   x = asin(x)
 736 end program test_asin
 737 @end smallexample
 738
 739 @item @emph{Specific names}:
 740 @multitable @columnfractions .24 .24 .24 .24
 741 @item Name            @tab Argument          @tab Return type       @tab Option
 742 @item @code{DASIN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 743 @end multitable
 744 @end table
 745
 746
 747 @node ASSOCIATED
 748 @section @code{ASSOCIATED} --- Status of a pointer or pointer/target pair
 749 @findex @code{ASSOCIATED} intrinsic
 750 @cindex pointer status
 751
 752 @table @asis
 753 @item @emph{Description}:
 754 @code{ASSOCIATED(PTR [, TGT])} determines the status of the pointer @var{PTR}
 755 or if @var{PTR} is associated with the target @var{TGT}.
 756
 757 @item @emph{Option}:
 758 f95, gnu
 759
 760 @item @emph{Type}:
 761 inquiry function
 762
 763 @item @emph{Syntax}:
 764 @code{L = ASSOCIATED(PTR)} @*
 765 @code{L = ASSOCIATED(PTR [, TGT])}
 766
 767 @item @emph{Arguments}:
 768 @multitable @columnfractions .15 .80
 769 @item @var{PTR} @tab @var{PTR} shall have the @code{POINTER} attribute and
 770 it can be of any type.
 771 @item @var{TGT} @tab (Optional) @var{TGT} shall be a @code{POINTER} or
 772 a @code{TARGET}.  It must have the same type, kind type parameter, and
 773 array rank as @var{PTR}.
 774 @end multitable
 775 The status of neither @var{PTR} nor @var{TGT} can be undefined.
 776
 777 @item @emph{Return value}:
 778 @code{ASSOCIATED(PTR)} returns a scalar value of type @code{LOGICAL(4)}.
 779 There are several cases:
 780 @table @asis
 781 @item (A) If the optional @var{TGT} is not present, then @code{ASSOCIATED(PTR)}
 782 is true if @var{PTR} is associated with a target; otherwise, it returns false.
 783 @item (B) If @var{TGT} is present and a scalar target, the result is true if
 784 @var{TGT}
 785 is not a 0 sized storage sequence and the target associated with @var{PTR}
 786 occupies the same storage units.  If @var{PTR} is disassociated, then the
 787 result is false.
 788 @item (C) If @var{TGT} is present and an array target, the result is true if
 789 @var{TGT} and @var{PTR} have the same shape, are not 0 sized arrays, are
 790 arrays whose elements are not 0 sized storage sequences, and @var{TGT} and
 791 @var{PTR} occupy the same storage units in array element order.
 792 As in case(B), the result is false, if @var{PTR} is disassociated.
 793 @item (D) If @var{TGT} is present and an scalar pointer, the result is true if
 794 target associated with @var{PTR} and the target associated with @var{TGT}
 795 are not 0 sized storage sequences and occupy the same storage units.
 796 The result is false, if either @var{TGT} or @var{PTR} is disassociated.
 797 @item (E) If @var{TGT} is present and an array pointer, the result is true if
 798 target assoicated with @var{PTR} and the target associated with @var{TGT}
 799 have the same shape, are not 0 sized arrays, are arrays whose elements are
 800 not 0 sized storage sequences, and @var{TGT} and @var{PTR} occupy the same
 801 storage units in array element order.
 802 The result is false, if either @var{TGT} or @var{PTR} is disassociated.
 803 @end table
 804
 805 @item @emph{Example}:
 806 @smallexample
 807 program test_associated
 808    implicit none
 809    real, target  :: tgt(2) = (/1., 2./)
 810    real, pointer :: ptr(:)
 811    ptr => tgt
 812    if (associated(ptr)     .eqv. .false.) call abort
 813    if (associated(ptr,tgt) .eqv. .false.) call abort
 814 end program test_associated
 815 @end smallexample
 816 @end table
 817
 818
 819 @node ATAN
 820 @section @code{ATAN} --- Arctangent function
 821 @findex @code{ATAN} intrinsic
 822 @findex @code{DATAN} intrinsic
 823 @cindex arctangent
 824
 825 @table @asis
 826 @item @emph{Description}:
 827 @code{ATAN(X)} computes the arctangent of @var{X}.
 828
 829 @item @emph{Option}:
 830 f95, gnu
 831
 832 @item @emph{Type}:
 833 elemental function
 834
 835 @item @emph{Syntax}:
 836 @code{X = ATAN(X)}
 837
 838 @item @emph{Arguments}:
 839 @multitable @columnfractions .15 .80
 840 @item @var{X} @tab The type shall be an @code{REAL(*)}.
 841 @end multitable
 842
 843 @item @emph{Return value}:
 844 The return value is of type @code{REAL(*)} and it lies in the
 845 range @math{ - \pi / 2 \leq \arcsin (x) \leq \pi / 2}.
 846
 847 @item @emph{Example}:
 848 @smallexample
 849 program test_atan
 850   real(8) :: x = 2.866_8
 851   x = atan(x)
 852 end program test_atan
 853 @end smallexample
 854
 855 @item @emph{Specific names}:
 856 @multitable @columnfractions .24 .24 .24 .24
 857 @item Name            @tab Argument          @tab Return type       @tab Option
 858 @item @code{DATAN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
 859 @end multitable
 860 @end table
 861
 862
 863 @node ATAN2
 864 @section @code{ATAN2} --- Arctangent function
 865 @findex @code{ATAN2} intrinsic
 866 @findex @code{DATAN2} intrinsic
 867 @cindex arctangent
 868
 869 @table @asis
 870 @item @emph{Description}:
 871 @code{ATAN2(Y,X)} computes the arctangent of the complex number @math{X + i Y}.
 872
 873 @item @emph{Option}:
 874 f95, gnu
 875
 876 @item @emph{Type}:
 877 elemental function
 878
 879 @item @emph{Syntax}:
 880 @code{X = ATAN2(Y,X)}
 881
 882 @item @emph{Arguments}:
 883 @multitable @columnfractions .15 .80
 884 @item @var{Y} @tab The type shall be @code{REAL(*)}.
 885 @item @var{X} @tab The type and kind type paremeter shall be the same as @var{Y}.
 886 If @var{Y} is zero, then @var{X} must be nonzero.
 887 @end multitable
 888
 889 @item @emph{Return value}:
 890 The return value has the same type and kind type paremeter as @var{Y}.
 891 It is the principle value of the complex number @math{X + i Y}.  If
 892 @var{X} is nonzero, then it lies in the range @math{-\pi \le \arccos (x) \leq \pi}.
 893 The sign is positive if @var{Y} is positive.  If @var{Y} is zero, then
 894 the return value is zero if @var{X} is positive and @math{\pi} if @var{X}
 895 is negative.  Finally, if @var{X} is zero, then the magnitude of the result
 896 is @math{\pi/2}.
 897
 898 @item @emph{Example}:
 899 @smallexample
 900 program test_atan2
 901   real(4) :: x = 1.e0_4, y = 0.5e0_4
 902   x = atan2(y,x)
 903 end program test_atan2
 904 @end smallexample
 905
 906 @item @emph{Specific names}:
 907 @multitable @columnfractions .24 .24 .24 .24
 908 @item Name            @tab Argument          @tab Return type    @tab Option
 909 @item @code{DATAN2(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
 910 @end multitable
 911 @end table
 912
 913
 914 @node BESJ0
 915 @section @code{BESJ0} --- Bessel function of the first kind of order 0
 916 @findex @code{BESJ0} intrinsic
 917 @findex @code{DBESJ0} intrinsic
 918 @cindex Bessel
 919
 920 @table @asis
 921 @item @emph{Description}:
 922 @code{BESJ0(X)} computes the Bessel function of the first kind of order 0
 923 of @var{X}.
 924
 925 @item @emph{Option}:
 926 gnu
 927
 928 @item @emph{Type}:
 929 elemental function
 930
 931 @item @emph{Syntax}:
 932 @code{X = BESJ0(X)}
 933
 934 @item @emph{Arguments}:
 935 @multitable @columnfractions .15 .80
 936 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
 937 @end multitable
 938
 939 @item @emph{Return value}:
 940 The return value is of type @code{REAL(*)} and it lies in the
 941 range @math{ - 0.4027... \leq Bessel (0,x) \leq 1}.
 942
 943 @item @emph{Example}:
 944 @smallexample
 945 program test_besj0
 946   real(8) :: x = 0.0_8
 947   x = besj0(x)
 948 end program test_besj0
 949 @end smallexample
 950
 951 @item @emph{Specific names}:
 952 @multitable @columnfractions .24 .24 .24 .24
 953 @item Name            @tab Argument          @tab Return type       @tab Option
 954 @item @code{DBESJ0(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
 955 @end multitable
 956 @end table
 957
 958
 959
 960 @node BESJ1
 961 @section @code{BESJ1} --- Bessel function of the first kind of order 1
 962 @findex @code{BESJ1} intrinsic
 963 @findex @code{DBESJ1} intrinsic
 964 @cindex Bessel
 965
 966 @table @asis
 967 @item @emph{Description}:
 968 @code{BESJ1(X)} computes the Bessel function of the first kind of order 1
 969 of @var{X}.
 970
 971 @item @emph{Option}:
 972 gnu
 973
 974 @item @emph{Type}:
 975 elemental function
 976
 977 @item @emph{Syntax}:
 978 @code{X = BESJ1(X)}
 979
 980 @item @emph{Arguments}:
 981 @multitable @columnfractions .15 .80
 982 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
 983 @end multitable
 984
 985 @item @emph{Return value}:
 986 The return value is of type @code{REAL(*)} and it lies in the
 987 range @math{ - 0.5818... \leq Bessel (0,x) \leq 0.5818 }.
 988
 989 @item @emph{Example}:
 990 @smallexample
 991 program test_besj1
 992   real(8) :: x = 1.0_8
 993   x = besj1(x)
 994 end program test_besj1
 995 @end smallexample
 996
 997 @item @emph{Specific names}:
 998 @multitable @columnfractions .24 .24 .24 .24
 999 @item Name            @tab Argument          @tab Return type       @tab Option
1000 @item @code{DBESJ1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1001 @end multitable
1002 @end table
1003
1004
1005
1006 @node BESJN
1007 @section @code{BESJN} --- Bessel function of the first kind
1008 @findex @code{BESJN} intrinsic
1009 @findex @code{DBESJN} intrinsic
1010 @cindex Bessel
1011
1012 @table @asis
1013 @item @emph{Description}:
1014 @code{BESJN(N, X)} computes the Bessel function of the first kind of order
1015 @var{N} of @var{X}.
1016
1017 @item @emph{Option}:
1018 gnu
1019
1020 @item @emph{Type}:
1021 elemental function
1022
1023 @item @emph{Syntax}:
1024 @code{Y = BESJN(N, X)}
1025
1026 @item @emph{Arguments}:
1027 @multitable @columnfractions .15 .80
1028 @item @var{N} @tab The type shall be an @code{INTEGER(*)}, and it shall be scalar.
1029 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1030 @end multitable
1031
1032 @item @emph{Return value}:
1033 The return value is a scalar of type @code{REAL(*)}.
1034
1035 @item @emph{Example}:
1036 @smallexample
1037 program test_besjn
1038   real(8) :: x = 1.0_8
1039   x = besjn(5,x)
1040 end program test_besjn
1041 @end smallexample
1042
1043 @item @emph{Specific names}:
1044 @multitable @columnfractions .24 .24 .24 .24
1045 @item Name             @tab Argument            @tab Return type       @tab Option
1046 @item @code{DBESJN(X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}    @tab gnu
1047 @item                  @tab @code{REAL(8) X}    @tab                   @tab
1048 @end multitable
1049 @end table
1050
1051
1052
1053 @node BESY0
1054 @section @code{BESY0} --- Bessel function of the second kind of order 0
1055 @findex @code{BESY0} intrinsic
1056 @findex @code{DBESY0} intrinsic
1057 @cindex Bessel
1058
1059 @table @asis
1060 @item @emph{Description}:
1061 @code{BESY0(X)} computes the Bessel function of the second kind of order 0
1062 of @var{X}.
1063
1064 @item @emph{Option}:
1065 gnu
1066
1067 @item @emph{Type}:
1068 elemental function
1069
1070 @item @emph{Syntax}:
1071 @code{X = BESY0(X)}
1072
1073 @item @emph{Arguments}:
1074 @multitable @columnfractions .15 .80
1075 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1076 @end multitable
1077
1078 @item @emph{Return value}:
1079 The return value is a scalar of type @code{REAL(*)}.
1080
1081 @item @emph{Example}:
1082 @smallexample
1083 program test_besy0
1084   real(8) :: x = 0.0_8
1085   x = besy0(x)
1086 end program test_besy0
1087 @end smallexample
1088
1089 @item @emph{Specific names}:
1090 @multitable @columnfractions .24 .24 .24 .24
1091 @item Name            @tab Argument          @tab Return type       @tab Option
1092 @item @code{DBESY0(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1093 @end multitable
1094 @end table
1095
1096
1097
1098 @node BESY1
1099 @section @code{BESY1} --- Bessel function of the second kind of order 1
1100 @findex @code{BESY1} intrinsic
1101 @findex @code{DBESY1} intrinsic
1102 @cindex Bessel
1103
1104 @table @asis
1105 @item @emph{Description}:
1106 @code{BESY1(X)} computes the Bessel function of the second kind of order 1
1107 of @var{X}.
1108
1109 @item @emph{Option}:
1110 gnu
1111
1112 @item @emph{Type}:
1113 elemental function
1114
1115 @item @emph{Syntax}:
1116 @code{X = BESY1(X)}
1117
1118 @item @emph{Arguments}:
1119 @multitable @columnfractions .15 .80
1120 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1121 @end multitable
1122
1123 @item @emph{Return value}:
1124 The return value is a scalar of type @code{REAL(*)}.
1125
1126 @item @emph{Example}:
1127 @smallexample
1128 program test_besy1
1129   real(8) :: x = 1.0_8
1130   x = besy1(x)
1131 end program test_besy1
1132 @end smallexample
1133
1134 @item @emph{Specific names}:
1135 @multitable @columnfractions .24 .24 .24 .24
1136 @item Name            @tab Argument          @tab Return type       @tab Option
1137 @item @code{DBESY1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1138 @end multitable
1139 @end table
1140
1141
1142
1143 @node BESYN
1144 @section @code{BESYN} --- Bessel function of the second kind
1145 @findex @code{BESYN} intrinsic
1146 @findex @code{DBESYN} intrinsic
1147 @cindex Bessel
1148
1149 @table @asis
1150 @item @emph{Description}:
1151 @code{BESYN(N, X)} computes the Bessel function of the second kind of order
1152 @var{N} of @var{X}.
1153
1154 @item @emph{Option}:
1155 gnu
1156
1157 @item @emph{Type}:
1158 elemental function
1159
1160 @item @emph{Syntax}:
1161 @code{Y = BESYN(N, X)}
1162
1163 @item @emph{Arguments}:
1164 @multitable @columnfractions .15 .80
1165 @item @var{N} @tab The type shall be an @code{INTEGER(*)}, and it shall be scalar.
1166 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1167 @end multitable
1168
1169 @item @emph{Return value}:
1170 The return value is a scalar of type @code{REAL(*)}.
1171
1172 @item @emph{Example}:
1173 @smallexample
1174 program test_besyn
1175   real(8) :: x = 1.0_8
1176   x = besyn(5,x)
1177 end program test_besyn
1178 @end smallexample
1179
1180 @item @emph{Specific names}:
1181 @multitable @columnfractions .24 .24 .24 .24
1182 @item Name               @tab Argument            @tab Return type     @tab Option
1183 @item @code{DBESYN(N,X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}  @tab gnu
1184 @item                    @tab @code{REAL(8)    X} @tab                 @tab
1185 @end multitable
1186 @end table
1187
1188
1189 @node COS
1190 @section @code{COS} --- Cosine function
1191 @findex @code{COS} intrinsic
1192 @findex @code{DCOS} intrinsic
1193 @findex @code{ZCOS} intrinsic
1194 @findex @code{CDCOS} intrinsic
1195 @cindex cosine
1196
1197 @table @asis
1198 @item @emph{Description}:
1199 @code{COS(X)} computes the cosine of @var{X}.
1200
1201 @item @emph{Option}:
1202 f95, gnu
1203
1204 @item @emph{Type}:
1205 elemental function
1206
1207 @item @emph{Syntax}:
1208 @code{X = COS(X)}
1209
1210 @item @emph{Arguments}:
1211 @multitable @columnfractions .15 .80
1212 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1213 @code{COMPLEX(*)}.
1214 @end multitable
1215
1216 @item @emph{Return value}:
1217 The return value has same type and kind than @var{X}.
1218
1219 @item @emph{Example}:
1220 @smallexample
1221 program test_cos
1222   real :: x = 0.0
1223   x = cos(x)
1224 end program test_cos
1225 @end smallexample
1226
1227 @item @emph{Specific names}:
1228 @multitable @columnfractions .24 .24 .24 .24
1229 @item Name            @tab Argument          @tab Return type       @tab Option
1230 @item @code{DCOS(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1231 @item @code{CCOS(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
1232 @item @code{ZCOS(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1233 @item @code{CDCOS(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1234 @end multitable
1235 @end table
1236
1237
1238 @node COSH
1239 @section @code{COSH} --- Hyperbolic cosine function
1240 @findex @code{COSH} intrinsic
1241 @findex @code{DCOSH} intrinsic
1242 @cindex hyperbolic cosine
1243
1244 @table @asis
1245 @item @emph{Description}:
1246 @code{COSH(X)} computes the hyperbolic cosine of @var{X}.
1247
1248 @item @emph{Option}:
1249 f95, gnu
1250
1251 @item @emph{Type}:
1252 elemental function
1253
1254 @item @emph{Syntax}:
1255 @code{X = COSH(X)}
1256
1257 @item @emph{Arguments}:
1258 @multitable @columnfractions .15 .80
1259 @item @var{X} @tab The type shall be an @code{REAL(*)}.
1260 @end multitable
1261
1262 @item @emph{Return value}:
1263 The return value is of type @code{REAL(*)} and it is positive
1264 (@math{ \cosh (x) \geq 0 }.
1265
1266 @item @emph{Example}:
1267 @smallexample
1268 program test_cosh
1269   real(8) :: x = 1.0_8
1270   x = cosh(x)
1271 end program test_cosh
1272 @end smallexample
1273
1274 @item @emph{Specific names}:
1275 @multitable @columnfractions .24 .24 .24 .24
1276 @item Name            @tab Argument          @tab Return type       @tab Option
1277 @item @code{DCOSH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1278 @end multitable
1279 @end table
1280
1281
1282 @node ERF
1283 @section @code{ERF} --- Error function
1284 @findex @code{ERF} intrinsic
1285 @cindex error function
1286
1287 @table @asis
1288 @item @emph{Description}:
1289 @code{ERF(X)} computes the error function of @var{X}.
1290
1291 @item @emph{Option}:
1292 gnu
1293
1294 @item @emph{Type}:
1295 elemental function
1296
1297 @item @emph{Syntax}:
1298 @code{X = ERF(X)}
1299
1300 @item @emph{Arguments}:
1301 @multitable @columnfractions .15 .80
1302 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1303 @end multitable
1304
1305 @item @emph{Return value}:
1306 The return value is a scalar of type @code{REAL(*)} and it is positive
1307 (@math{ - 1 \leq erf (x) \leq 1 }.
1308
1309 @item @emph{Example}:
1310 @smallexample
1311 program test_erf
1312   real(8) :: x = 0.17_8
1313   x = erf(x)
1314 end program test_erf
1315 @end smallexample
1316
1317 @item @emph{Specific names}:
1318 @multitable @columnfractions .24 .24 .24 .24
1319 @item Name            @tab Argument          @tab Return type       @tab Option
1320 @item @code{DERF(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1321 @end multitable
1322 @end table
1323
1324
1325
1326 @node ERFC
1327 @section @code{ERFC} --- Error function
1328 @findex @code{ERFC} intrinsic
1329 @cindex error function
1330
1331 @table @asis
1332 @item @emph{Description}:
1333 @code{ERFC(X)} computes the complementary error function of @var{X}.
1334
1335 @item @emph{Option}:
1336 gnu
1337
1338 @item @emph{Type}:
1339 elemental function
1340
1341 @item @emph{Syntax}:
1342 @code{X = ERFC(X)}
1343
1344 @item @emph{Arguments}:
1345 @multitable @columnfractions .15 .80
1346 @item @var{X} @tab The type shall be an @code{REAL(*)}, and it shall be scalar.
1347 @end multitable
1348
1349 @item @emph{Return value}:
1350 The return value is a scalar of type @code{REAL(*)} and it is positive
1351 (@math{ 0 \leq erfc (x) \leq 2 }.
1352
1353 @item @emph{Example}:
1354 @smallexample
1355 program test_erfc
1356   real(8) :: x = 0.17_8
1357   x = erfc(x)
1358 end program test_erfc
1359 @end smallexample
1360
1361 @item @emph{Specific names}:
1362 @multitable @columnfractions .24 .24 .24 .24
1363 @item Name            @tab Argument          @tab Return type       @tab Option
1364 @item @code{DERFC(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
1365 @end multitable
1366 @end table
1367
1368
1369
1370 @node EXP
1371 @section @code{EXP} --- Exponential function
1372 @findex @code{EXP} intrinsic
1373 @findex @code{DEXP} intrinsic
1374 @findex @code{ZEXP} intrinsic
1375 @findex @code{CDEXP} intrinsic
1376 @cindex exponential
1377
1378 @table @asis
1379 @item @emph{Description}:
1380 @code{EXP(X)} computes the base @math{e} exponential of @var{X}.
1381
1382 @item @emph{Option}:
1383 f95, gnu
1384
1385 @item @emph{Type}:
1386 elemental function
1387
1388 @item @emph{Syntax}:
1389 @code{X = EXP(X)}
1390
1391 @item @emph{Arguments}:
1392 @multitable @columnfractions .15 .80
1393 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1394 @code{COMPLEX(*)}.
1395 @end multitable
1396
1397 @item @emph{Return value}:
1398 The return value has same type and kind than @var{X}.
1399
1400 @item @emph{Example}:
1401 @smallexample
1402 program test_exp
1403   real :: x = 1.0
1404   x = exp(x)
1405 end program test_exp
1406 @end smallexample
1407
1408 @item @emph{Specific names}:
1409 @multitable @columnfractions .24 .24 .24 .24
1410 @item Name            @tab Argument          @tab Return type       @tab Option
1411 @item @code{DEXP(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1412 @item @code{CEXP(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
1413 @item @code{ZEXP(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1414 @item @code{CDEXP(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1415 @end multitable
1416 @end table
1417
1418
1419 @node LOG
1420 @section @code{LOG} --- Logarithm function
1421 @findex @code{LOG} intrinsic
1422 @findex @code{ALOG} intrinsic
1423 @findex @code{DLOG} intrinsic
1424 @findex @code{CLOG} intrinsic
1425 @findex @code{ZLOG} intrinsic
1426 @findex @code{CDLOG} intrinsic
1427 @cindex logarithm
1428
1429 @table @asis
1430 @item @emph{Description}:
1431 @code{LOG(X)} computes the logarithm of @var{X}.
1432
1433 @item @emph{Option}:
1434 f95, gnu
1435
1436 @item @emph{Type}:
1437 elemental function
1438
1439 @item @emph{Syntax}:
1440 @code{X = LOG(X)}
1441
1442 @item @emph{Arguments}:
1443 @multitable @columnfractions .15 .80
1444 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1445 @code{COMPLEX(*)}.
1446 @end multitable
1447
1448 @item @emph{Return value}:
1449 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
1450 The kind type parameter is the same as @var{X}.
1451
1452 @item @emph{Example}:
1453 @smallexample
1454 program test_log
1455   real(8) :: x = 1.0_8
1456   complex :: z = (1.0, 2.0)
1457   x = log(x)
1458   z = log(z)
1459 end program test_log
1460 @end smallexample
1461
1462 @item @emph{Specific names}:
1463 @multitable @columnfractions .24 .24 .24 .24
1464 @item Name            @tab Argument          @tab Return type       @tab Option
1465 @item @code{ALOG(X)}  @tab @code{REAL(4) X}  @tab @code{REAL(4)}    @tab f95, gnu
1466 @item @code{DLOG(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1467 @item @code{CLOG(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
1468 @item @code{ZLOG(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1469 @item @code{CDLOG(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1470 @end multitable
1471 @end table
1472
1473
1474
1475 @node LOG10
1476 @section @code{LOG10} --- Base 10 logarithm function
1477 @findex @code{LOG10} intrinsic
1478 @findex @code{ALOG10} intrinsic
1479 @findex @code{DLOG10} intrinsic
1480 @cindex logarithm
1481
1482 @table @asis
1483 @item @emph{Description}:
1484 @code{LOG10(X)} computes the base 10 logarithm of @var{X}.
1485
1486 @item @emph{Option}:
1487 f95, gnu
1488
1489 @item @emph{Type}:
1490 elemental function
1491
1492 @item @emph{Syntax}:
1493 @code{X = LOG10(X)}
1494
1495 @item @emph{Arguments}:
1496 @multitable @columnfractions .15 .80
1497 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1498 @code{COMPLEX(*)}.
1499 @end multitable
1500
1501 @item @emph{Return value}:
1502 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
1503 The kind type parameter is the same as @var{X}.
1504
1505 @item @emph{Example}:
1506 @smallexample
1507 program test_log10
1508   real(8) :: x = 10.0_8
1509   x = log10(x)
1510 end program test_log10
1511 @end smallexample
1512
1513 @item @emph{Specific names}:
1514 @multitable @columnfractions .24 .24 .24 .24
1515 @item Name            @tab Argument          @tab Return type       @tab Option
1516 @item @code{ALOG10(X)}  @tab @code{REAL(4) X}  @tab @code{REAL(4)}    @tab f95, gnu
1517 @item @code{DLOG10(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1518 @end multitable
1519 @end table
1520
1521
1522
1523 @node SIN
1524 @section @code{SIN} --- Sine function
1525 @findex @code{SIN} intrinsic
1526 @findex @code{DSIN} intrinsic
1527 @findex @code{ZSIN} intrinsic
1528 @findex @code{CDSIN} intrinsic
1529 @cindex sine
1530
1531 @table @asis
1532 @item @emph{Description}:
1533 @code{SIN(X)} computes the sine of @var{X}.
1534
1535 @item @emph{Option}:
1536 f95, gnu
1537
1538 @item @emph{Type}:
1539 elemental function
1540
1541 @item @emph{Syntax}:
1542 @code{X = SIN(X)}
1543
1544 @item @emph{Arguments}:
1545 @multitable @columnfractions .15 .80
1546 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1547 @code{COMPLEX(*)}.
1548 @end multitable
1549
1550 @item @emph{Return value}:
1551 The return value has same type and king than @var{X}.
1552
1553 @item @emph{Example}:
1554 @smallexample
1555 program test_sin
1556   real :: x = 0.0
1557   x = sin(x)
1558 end program test_sin
1559 @end smallexample
1560
1561 @item @emph{Specific names}:
1562 @multitable @columnfractions .24 .24 .24 .24
1563 @item Name            @tab Argument          @tab Return type       @tab Option
1564 @item @code{DSIN(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1565 @item @code{CSIN(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
1566 @item @code{ZSIN(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1567 @item @code{CDSIN(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1568 @end multitable
1569 @end table
1570
1571
1572
1573
1574 @node SINH
1575 @section @code{SINH} --- Hyperbolic sine function
1576 @findex @code{SINH} intrinsic
1577 @findex @code{DSINH} intrinsic
1578 @cindex hyperbolic sine
1579
1580 @table @asis
1581 @item @emph{Description}:
1582 @code{SINH(X)} computes the hyperbolic sine of @var{X}.
1583
1584 @item @emph{Option}:
1585 f95, gnu
1586
1587 @item @emph{Type}:
1588 elemental function
1589
1590 @item @emph{Syntax}:
1591 @code{X = SINH(X)}
1592
1593 @item @emph{Arguments}:
1594 @multitable @columnfractions .15 .80
1595 @item @var{X} @tab The type shall be an @code{REAL(*)}.
1596 @end multitable
1597
1598 @item @emph{Return value}:
1599 The return value is of type @code{REAL(*)}.
1600
1601 @item @emph{Example}:
1602 @smallexample
1603 program test_sinh
1604   real(8) :: x = - 1.0_8
1605   x = sinh(x)
1606 end program test_sinh
1607 @end smallexample
1608
1609 @item @emph{Specific names}:
1610 @multitable @columnfractions .24 .24 .24 .24
1611 @item Name            @tab Argument          @tab Return type       @tab Option
1612 @item @code{DSINH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1613 @end multitable
1614 @end table
1615
1616
1617
1618 @node SQRT
1619 @section @code{SQRT} --- Square-root function
1620 @findex @code{SQRT} intrinsic
1621 @findex @code{DSQRT} intrinsic
1622 @findex @code{CSQRT} intrinsic
1623 @findex @code{ZSQRT} intrinsic
1624 @findex @code{CDSQRT} intrinsic
1625 @cindex square-root
1626
1627 @table @asis
1628 @item @emph{Description}:
1629 @code{SQRT(X)} computes the square root of @var{X}.
1630
1631 @item @emph{Option}:
1632 f95, gnu
1633
1634 @item @emph{Type}:
1635 elemental function
1636
1637 @item @emph{Syntax}:
1638 @code{X = SQRT(X)}
1639
1640 @item @emph{Arguments}:
1641 @multitable @columnfractions .15 .80
1642 @item @var{X} @tab The type shall be an @code{REAL(*)} or
1643 @code{COMPLEX(*)}.
1644 @end multitable
1645
1646 @item @emph{Return value}:
1647 The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}.
1648 The kind type parameter is the same as @var{X}.
1649
1650 @item @emph{Example}:
1651 @smallexample
1652 program test_sqrt
1653   real(8) :: x = 2.0_8
1654   complex :: z = (1.0, 2.0)
1655   x = sqrt(x)
1656   z = sqrt(z)
1657 end program test_sqrt
1658 @end smallexample
1659
1660 @item @emph{Specific names}:
1661 @multitable @columnfractions .24 .24 .24 .24
1662 @item Name            @tab Argument          @tab Return type       @tab Option
1663 @item @code{DSQRT(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1664 @item @code{CSQRT(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
1665 @item @code{ZSQRT(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1666 @item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
1667 @end multitable
1668 @end table
1669
1670
1671
1672 @node TAN
1673 @section @code{TAN} --- Tangent function
1674 @findex @code{TAN} intrinsic
1675 @findex @code{DTAN} intrinsic
1676 @cindex tangent
1677
1678 @table @asis
1679 @item @emph{Description}:
1680 @code{TAN(X)} computes the tangent of @var{X}.
1681
1682 @item @emph{Option}:
1683 f95, gnu
1684
1685 @item @emph{Type}:
1686 elemental function
1687
1688 @item @emph{Syntax}:
1689 @code{X = TAN(X)}
1690
1691 @item @emph{Arguments}:
1692 @multitable @columnfractions .15 .80
1693 @item @var{X} @tab The type shall be an @code{REAL(*)}.
1694 @end multitable
1695
1696 @item @emph{Return value}:
1697 The return value is of type @code{REAL(*)}.  The kind type parameter is
1698 the same as @var{X}.
1699
1700 @item @emph{Example}:
1701 @smallexample
1702 program test_tan
1703   real(8) :: x = 0.165_8
1704   x = tan(x)
1705 end program test_tan
1706 @end smallexample
1707
1708 @item @emph{Specific names}:
1709 @multitable @columnfractions .24 .24 .24 .24
1710 @item Name            @tab Argument          @tab Return type       @tab Option
1711 @item @code{DTAN(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1712 @end multitable
1713 @end table
1714
1715
1716 @node TANH
1717 @section @code{TANH} --- Hyperbolic tangent function
1718 @findex @code{TANH} intrinsic
1719 @findex @code{DTANH} intrinsic
1720 @cindex hyperbolic tangent
1721
1722 @table @asis
1723 @item @emph{Description}:
1724 @code{TANH(X)} computes the hyperbolic tangent of @var{X}.
1725
1726 @item @emph{Option}:
1727 f95, gnu
1728
1729 @item @emph{Type}:
1730 elemental function
1731
1732 @item @emph{Syntax}:
1733 @code{X = TANH(X)}
1734
1735 @item @emph{Arguments}:
1736 @multitable @columnfractions .15 .80
1737 @item @var{X} @tab The type shall be an @code{REAL(*)}.
1738 @end multitable
1739
1740 @item @emph{Return value}:
1741 The return value is of type @code{REAL(*)} and lies in the range
1742 @math{ - 1 \leq tanh(x) \leq 1 }.
1743
1744 @item @emph{Example}:
1745 @smallexample
1746 program test_tanh
1747   real(8) :: x = 2.1_8
1748   x = tanh(x)
1749 end program test_tanh
1750 @end smallexample
1751
1752 @item @emph{Specific names}:
1753 @multitable @columnfractions .24 .24 .24 .24
1754 @item Name            @tab Argument          @tab Return type       @tab Option
1755 @item @code{DTANH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
1756 @end multitable
1757 @end table
1758
1759
1760
1761
1762
1763 @comment gen   bit_size
1764 @comment
1765 @comment gen   btest
1766 @comment
1767 @comment gen   ceiling
1768 @comment
1769 @comment gen   char
1770 @comment
1771 @comment gen   cmplx
1772 @comment
1773 @comment gen   command_argument_count
1774 @comment
1775 @comment gen   conjg
1776 @comment       dconjg
1777 @comment
1778 @comment gen   count
1779 @comment
1780 @comment sub   cpu_time
1781 @comment
1782 @comment gen   cshift
1783 @comment
1784 @comment sub   date_and_time
1785 @comment
1786 @comment gen   dble
1787 @comment       dfloat
1788 @comment
1789 @comment gen   dcmplx
1790 @comment
1791 @comment gen   digits
1792 @comment
1793 @comment gen   dim
1794 @comment       idim
1795 @comment       ddim
1796 @comment
1797 @comment gen   dot_product
1798 @comment
1799 @comment gen   dprod
1800 @comment
1801 @comment gen   dreal
1802 @comment
1803 @comment sub   dtime
1804 @comment
1805 @comment gen   eoshift
1806 @comment
1807 @comment gen   epsilon
1808 @comment
1809 @comment gen   etime
1810 @comment sub   etime
1811 @comment
1812 @comment sub   exit
1813 @comment
1814 @comment gen   exponent
1815 @comment
1816 @comment gen   floor
1817 @comment
1818 @comment sub   flush
1819 @comment
1820 @comment gen   fnum
1821 @comment
1822 @comment gen   fraction
1823 @comment
1824 @comment gen   fstat
1825 @comment sub   fstat
1826 @comment
1827 @comment sub   getarg
1828 @comment
1829 @comment gen   getcwd
1830 @comment sub   getcwd
1831 @comment
1832 @comment sub   getenv
1833 @comment
1834 @comment gen   getgid
1835 @comment
1836 @comment gen   getpid
1837 @comment
1838 @comment gen   getuid
1839 @comment
1840 @comment sub   get_command
1841 @comment
1842 @comment sub   get_command_argument
1843 @comment
1844 @comment sub   get_environment_variable
1845 @comment
1846 @comment gen   huge
1847 @comment
1848 @comment gen   iachar
1849 @comment
1850 @comment gen   iand
1851 @comment
1852 @comment gen   iargc
1853 @comment
1854 @comment gen   ibclr
1855 @comment
1856 @comment gen   ibits
1857 @comment
1858 @comment gen   ibset
1859 @comment
1860 @comment gen   ichar
1861 @comment
1862 @comment gen   ieor
1863 @comment
1864 @comment gen   index
1865 @comment
1866 @comment gen   int
1867 @comment       ifix
1868 @comment       idint
1869 @comment
1870 @comment gen   ior
1871 @comment
1872 @comment gen   irand
1873 @comment
1874 @comment gen   ishft
1875 @comment
1876 @comment gen   ishftc
1877 @comment
1878 @comment gen   kind
1879 @comment
1880 @comment gen   lbound
1881 @comment
1882 @comment gen   len
1883 @comment
1884 @comment gen   len_trim
1885 @comment
1886 @comment gen   lge
1887 @comment
1888 @comment gen   lgt
1889 @comment
1890 @comment gen   lle
1891 @comment
1892 @comment gen   llt
1893 @comment
1894 @comment gen   logical
1895 @comment
1896 @comment gen   matmul
1897 @comment
1898 @comment gen   max
1899 @comment       max0
1900 @comment       amax0
1901 @comment       amax1
1902 @comment       max1
1903 @comment       dmax1
1904 @comment
1905 @comment gen   maxexponent
1906 @comment
1907 @comment gen   maxloc
1908 @comment
1909 @comment gen   maxval
1910 @comment
1911 @comment gen   merge
1912 @comment
1913 @comment gen   min
1914 @comment       min0
1915 @comment       amin0
1916 @comment       amin1
1917 @comment       min1
1918 @comment       dmin1
1919 @comment
1920 @comment gen   minexponent
1921 @comment
1922 @comment gen   minloc
1923 @comment
1924 @comment gen   minval
1925 @comment
1926 @comment gen   mod
1927 @comment       amod
1928 @comment       dmod
1929 @comment
1930 @comment gen   modulo
1931 @comment
1932 @comment sub   mvbits
1933 @comment
1934 @comment gen   nearest
1935 @comment
1936 @comment gen   nint
1937 @comment       idnint
1938 @comment
1939 @comment gen   not
1940 @comment
1941 @comment gen   null
1942 @comment
1943 @comment gen   pack
1944 @comment
1945 @comment gen   precision
1946 @comment
1947 @comment gen   present
1948 @comment
1949 @comment gen   product
1950 @comment
1951 @comment gen   radix
1952 @comment
1953 @comment gen   rand
1954 @comment       ran
1955 @comment
1956 @comment sub   random_number
1957 @comment
1958 @comment sub   random_seed
1959 @comment
1960 @comment gen   range
1961 @comment
1962 @comment gen   real
1963 @comment       float
1964 @comment       sngl
1965 @comment
1966 @comment gen   repeat
1967 @comment
1968 @comment gen   reshape
1969 @comment
1970 @comment gen   rrspacing
1971 @comment
1972 @comment gen   scale
1973 @comment
1974 @comment gen   scan
1975 @comment
1976 @comment gen   second
1977 @comment sub   second
1978 @comment
1979 @comment gen   selected_int_kind
1980 @comment
1981 @comment gen   selected_real_kind
1982 @comment
1983 @comment gen   set_exponent
1984 @comment
1985 @comment gen   shape
1986 @comment
1987 @comment gen   sign
1988 @comment       isign
1989 @comment       dsign
1990 @comment
1991 @comment gen   size
1992 @comment
1993 @comment gen   spacing
1994 @comment
1995 @comment gen   spread
1996 @comment
1997 @comment sub   srand
1998 @comment
1999 @comment gen   stat
2000 @comment sub   stat
2001 @comment
2002 @comment gen   sum
2003 @comment
2004 @comment gen   system
2005 @comment sub   system
2006 @comment
2007 @comment sub system_clock
2008 @comment
2009 @comment gen   tiny
2010 @comment
2011 @comment gen   transfer
2012 @comment
2013 @comment gen   transpose
2014 @comment
2015 @comment gen   trim
2016 @comment
2017 @comment gen   ubound
2018 @comment
2019 @comment gen   umask
2020 @comment sub   umask
2021 @comment
2022 @comment gen   unlink
2023 @comment sub   unlink
2024 @comment
2025 @comment gen   unpack
2026 @comment
2027 @comment gen   verify
2028