1vatan_(3MVEC)            Vector Math Library Functions           vatan_(3MVEC)
2
3
4

NAME

6       vatan_, vatanf_ - vector arctangent functions
7

SYNOPSIS

9       cc [ flag... ] file... -lmvec [ library... ]
10
11       void vatan_(int *n,double * restrict x, int *stridex,
12            double * restrict y, int *stridey);
13
14
15       void vatanf_(int *n, float * restrict x, int *stridex,
16            float * restrict y, int *stridey);
17
18

DESCRIPTION

20       These  functions  evaluate the function atan(x) for an entire vector of
21       values at once. The first parameter specifies the number of  values  to
22       compute. Subsequent parameters specify the argument and result vectors.
23       Each vector is described by a  pointer  to  the  first  element  and  a
24       stride, which is the increment between successive elements.
25
26
27       Specifically,  vatan_(n, x, sx, y, sy) computes y[i * *sy] = atan(x[i *
28       *sx]) for each i = 0, 1, ..., *n - 1. The vatanf_()  function  performs
29       the same computation for single precision data.
30
31
32       These  functions are not guaranteed to deliver results that are identi‐
33       cal to the results of the atan(3M) functions given the same  arguments.
34       Non-exceptional  results, however, are accurate to within a unit in the
35       last place.
36

USAGE

38       The element count *n must be greater than zero.  The  strides  for  the
39       argument  and  result  arrays can be arbitrary integers, but the arrays
40       themselves must not be the same or overlap. A zero  stride  effectively
41       collapses  an  entire  vector  into a single element. A negative stride
42       causes a vector to be accessed in descending  memory  order,  but  note
43       that the corresponding pointer must still point to the first element of
44       the vector to be used; if the stride is  negative,  this  will  be  the
45       highest-addressed  element  in memory. This convention differs from the
46       Level 1 BLAS, in which array parameters always  refer  to  the  lowest-
47       addressed element in memory even when negative increments are used.
48
49
50       These  functions  assume  that  the  default  round-to-nearest rounding
51       direction mode is in effect. On x86, these functions also  assume  that
52       the  default  round-to-64-bit rounding precision mode is in effect. The
53       result of calling a vector function with a non-default rounding mode in
54       effect is undefined.
55
56
57       These  functions handle special cases and exceptions in the same way as
58       the atan() functions when c99 MATHERREXCEPT conventions are in  effect.
59       See atan(3M) for the results for special cases.
60
61
62       An  application  wanting to check for exceptions should call feclearex‐
63       cept(FE_ALL_EXCEPT) before  calling  these  functions.  On  return,  if
64       fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW) is
65       non-zero, an exception has been raised. The application can then  exam‐
66       ine  the result or argument vectors for exceptional values. Some vector
67       functions can raise the inexact exception even if all elements  of  the
68       argument array are such that the numerical results are exact.
69

ATTRIBUTES

71       See attributes(5) for descriptions of the following attributes:
72
73
74
75
76       ┌─────────────────────────────┬─────────────────────────────┐
77       │      ATTRIBUTE TYPE         │      ATTRIBUTE VALUE        │
78       ├─────────────────────────────┼─────────────────────────────┤
79       │Interface Stability          │Committed                    │
80       ├─────────────────────────────┼─────────────────────────────┤
81       │MT-Level                     │MT-Safe                      │
82       └─────────────────────────────┴─────────────────────────────┘
83

SEE ALSO

85       atan(3M), feclearexcept(3M), fetestexcept(3M), attributes(5)
86
87
88
89SunOS 5.11                        14 Dec 2007                    vatan_(3MVEC)
Impressum