Man Page clibmvec.3m




NAME

     clibmvec - vector  versions  of  some  complex  mathematical
     functions


SYNOPSIS

     f77 [ flag ... ] file ...  -lmvec [ library ... ]

     or

     f77 [ flag ... ] file ...  -lmvec_mt [ library ... ]

     subroutine vc_abs(n, a, stridea, r, strider)

     subroutine vc_exp(n, a, stridea, b, strideb, rtmp)

     subroutine vc_log(n, a, stridea, b, strideb)

     subroutine vc_pow(n, a, stridea,  b,  strideb,  c,  stridec,
     rtmp3)

     subroutine vz_abs(n, x, stridex, d, strided)

     subroutine vz_exp(n, x, stridex, y, stridey, dtmp)

     subroutine vz_log(n, x, stridex, y, stridey)

     subroutine vz_pow(n, x, stridex,  y,  stridey,  z,  stridez,
     dtmp3)

     integer n, stridea, strideb, stridec, strider

     integer stridex, stridey, stridez, strided

     complex  a(1+(n-1)*stridea),   b(1+(n-1)*strideb),   c(1+(n-
     1)*stridec)

     real r(1+(n-1)*strider), rtmp(n), rtmp3(3*n)

     complex*16 x(1+(n-1)*stridex),  y(1+(n-1)*stridey),  z(1+(n-
     1)*stridez)

     real*16 d(1+(n-1)*strided), dtmp(n), dtmp3(3*n)


DESCRIPTION

     These routines evaluate common complex elementary  functions
     for an entire vector of values at once.  The first parameter
     indicates the  number  of  values  to  compute.   Subsequent
     parameters  specify  the  argument and result vectors.  Each
     vector is described by the first array element  to  be  used
     and a stride, which is the increment between successive ele-
     ments.

     vc_abs(n,    a,    stridea,     r,     strider)     computes
     r(1+(i-1)*strider) = abs(a(1+(i-1)*stridea)) for each i = 1,
     2, ..., n.  Note that the output vector is of real type.

     vc_exp(n,   a,   stridea,   b,   strideb,   rtmp)   computes
     b(1+(i-1)*strideb)   =  exp(a(1+(i-1)*stridea)).   The  rtmp
     parameter provides scratch space and must be large enough to
     hold n elements of real type.

     vc_log(n,    a,    stridea,     b,     strideb)     computes
     b(1+(i-1)*strideb) = log(a(1+(i-1)*stridea)).

     vc_pow(n, a, stridea, b, strideb, c,  stridec,  rtmp3)  com-
     putes                  c(1+(i-1)*stridec)                  =
     a(1+(i-1)*stridea)**b(1+(i-1)*strideb).  The rtmp3 parameter
     provides  scratch space and must be large enough to hold 3*n
     elements of real type.

     The subroutines vz_abs, vz_exp, vz_log, and vz_pow are  dou-
     ble  precision complex versions of the single precision com-
     plex functions listed above.

     For each function, the element count n must be greater  than
     zero.  The strides for the argument and result arrays may be
     arbitrary integers, but the arrays themselves  must  not  be
     the  same  or  overlap.   For example, the result of calling
     vc_log(n, a, 1, a, 1) is undefined.  Note that a zero stride
     may  be  specified,  which  effectively collapses the entire
     vector into a single element.  Thus, for  example,  one  can
     use vc_pow to compute values of a(i)**b for a fixed value of
     b by setting strideb to 0.  Finally, note that a stride  may
     be  negative,  but  the  corresponding  array parameter must
     still refer to the first element accessed in the vector;  if
     the  stride  is negative, this will be the highest-addressed
     element in memory.  (This convention differs from the  Level
     1  BLAS,  in  which  array  parameters  always  refer to the
     lowest-addressed element in memory even when negative incre-
     ments  are used.)  For example, to set b(i) = exp(a(n-i+1)),
     call vc_exp(n, a(n), -1, b, 1, rtmp).


ATTRIBUTES

     See attributes(5) for descriptions of the  following  attri-
     butes:









     _______________________________________
    |   ATTRIBUTE TYPE   |  ATTRIBUTE VALUE|
    |____________________|__________________|_
    | Availability       |  SPROlang       |
    | Interface Stability|  Evolving       |
    | MT-Level           |  MT-Safe        |
    |____________________|_________________|


SEE ALSO

     libmvec(3M), attributes(5)


DIAGNOSTICS

     The vector functions treat exceptional cases in  the  spirit
     of  IEEE  754, producing essentially the same results as the
     corresponding Fortran scalar functions.  Some  vector  func-
     tions  may  raise the inexact exception even if all elements
     of the argument array are such that  the  numerical  results
     are exact.


NOTES

     The vector functions listed above are provided  in  each  of
     two  libraries, libmvec.a and libmvec_mt.a.  The latter con-
     tains parallelized versions of the functions  that  work  in
     conjunction  with  the automatic parallelization provided by
     the compiler.  To use libmvec_mt.a, you must link  with  one
     of the parallelization options -xparallel, -xexplicitpar, or
     -xautopar.

     In vector and parallel execution, elements need not be  pro-
     cessed    in   the   natural   order   x(1),   x(1+stridex),
     x(1+2*stridex), etc.  Therefore, exceptions that  occur  may
     not  be  raised  in  order.  For example, if exp(x(1)) would
     raise the overflow exception, and exp(x(9)) would raise  the
     invalid  operation  exception,  there is no guarantee that a
     call to vc_exp will indicate the overflow first.