VML Mathematical Functions

Inv performs element by element inversion of the vector.
Fortran:
``` call vsinv (n, a, y) call vdinv (n, a, y) ``` C:
``` vsInv (n, a, y); vdInv (n, a, y); ```

Div performs element by element division of vector `a` by vector `b`.
Fortran:
``` call vsdiv (n, a, b, y) call vddiv (n, a, b, y) ``` C:
``` vsDiv (n, a, b, y); vdDiv (n, a, b, y); ```

Sqrt computes a square root of vector elements.
Fortran:
``` call vssqrt (n, a, y) call vdsqrt (n, a, y) ``` C:
``` vsSqrt (n, a, y); vdSqrt (n, a, y); ```

InvSqrt computes an inverse square root of vector elements.
Fortran:
``` call vsinvsqrt (n, a, y) call vdinvsqrt (n, a, y) ``` C:
``` vsInvSqrt (n, a, y); vdInvSqrt (n, a, y); ```

Cbrt computes a cube root of vector elements.
Fortran:
``` call vscbrt (n, a, y) call vdcbrt (n, a, y) ``` C:
``` vsCbrt (n, a, y); vdCbrt (n, a, y); ```

InvCbrt computes an inverse cube root of vector elements.
Fortran:
``` call vsinvcbrt (n, a, y) call vdinvcbrt (n, a, y) ``` C:
``` vsInvCbrt (n, a, y); vdInvCbrt (n, a, y); ```

Pow computes `a` to the power `b` for elements of two vectors.
Fortran:
``` call vspow (n, a, b, y) call vdpow (n, a, b, y) ``` C:
``` vsPow (n, a, b, y); vdPow (n, a, b, y); ```

Powx raises each element of a vector to the constant power.
Fortran:
``` call vspowx (n, a, b, y) call vdpowx (n, a, b, y) ``` C:
``` vsPowx (n, a, b, y); vdPowx (n, a, b, y); ```

Exp computes an exponential of vector elements.
Fortran:
``` call vsexp (n, a, y) call vdexp (n, a, y) ``` C:
``` vsExp (n, a, y); vdExp (n, a, y); ```

Ln computes natural logarithm of vector elements.
Fortran:
``` call vsln (n, a, y) call vdln (n, a, y) ``` C:
``` vsLn (n, a, y); vdLn (n, a, y); ```

Log10 computes denary logarithm of vector elements.
Fortran:
``` call vslog10 (n, a, y) call vdlog10 (n, a, y) ``` C:
``` vsLog10 (n, a, y); vdLog10 (n, a, y); ```

Cos computes cosine of vector elements.
Fortran:
``` call vscos (n, a, y) call vdcos (n, a, y) ``` C:
``` vsCos (n, a, y); vdCos (n, a, y); ```

Sin computes sine of vector elements.
Fortran:
``` call vssin (n, a, y) call vdsin (n, a, y) ``` C:
``` vsSin (n, a, y); vdSin (n, a, y); ```

SinCos computes sine and cosine of vector elements.
Fortran:
``` call vssincos (n, a, y, z) call vdsincos (n, a, y, z) ``` C:
``` vsSinCos (n, a, y, z); vdSinCos (n, a, y, z); ```

Tan computes tangent of vector elements.
Fortran:
``` call vstan (n, a, y) call vdtan (n, a, y) ``` C:
``` vsTan (n, a, y); vdTan (n, a, y); ```

Acos computes inverse cosine of vector elements.
Fortran:
``` call vsacos (n, a, y) call vdacos (n, a, y) ``` C:
``` vsAcos (n, a, y); vdAcos (n, a, y); ```

Asin computes inverse sine of vector elements.
Fortran:
``` call vsasin (n, a, y) call vdasin (n, a, y) ``` C:
``` vsAsin (n, a, y); vdAsin (n, a, y); ```

Atan computes inverse tangent of vector elements.
Fortran:
``` call vsatan (n, a, y) call vdatan (n, a, y) ``` C:
``` vsAtan (n, a, y); vdAtan (n, a, y); ```

Atan2 computes four-quadrant inverse tangent of vector elements of two vectors.
Fortran:
``` call vsatan2 (n, a, b, y) call vdatan2 (n, a, b, y) ``` C:
``` vsAtan2 (n, a, b, y); vdAtan2 (n, a, b, y); ```

Cosh computes hyperbolic cosine of vector elements.
Fortran:
``` call vscosh (n, a, y) call vdcosh (n, a, y) ``` C:
``` vsCosh (n, a, y); vdCosh (n, a, y); ```

Sinh computes hyperbolic sine of vector elements.
Fortran:
``` call vssinh (n, a, y) call vdsinh (n, a, y) ``` C:
``` vsSinh (n, a, y); vdSinh (n, a, y); ```

Tanh computes hyperbolic tangent of vector elements.
Fortran:
``` call vstanh (n, a, y) call vdtanh (n, a, y) ``` C:
``` vsTanh (n, a, y); vdTanh (n, a, y); ```

Acosh computes inverse hyperbolic cosine (non-negative) of vector elements.
Fortran:
``` call vsacosh (n, a, y) call vdacosh (n, a, y) ``` C:
``` vsAcosh (n, a, y); vdAcosh (n, a, y); ```

Asinh computes inverse hyperbolic sine of vector elements.
Fortran:
``` call vsasinh (n, a, y) call vdasinh (n, a, y) ``` C:
``` vsAsinh (n, a, y); vdAsinh (n, a, y); ```

Atanh computes inverse hyperbolic tangent of vector elements.
Fortran:
``` call vsatanh (n, a, y) call vdatanh (n, a, y) ``` C:
``` vsAtanh (n, a, y); vdAtanh (n, a, y); ```

Erf computes the error function value of vector elements.
Fortran:
``` call vserf (n, a, y) call vderf (n, a, y) ``` C:
``` vsErf (n, a, y); vdErf (n, a, y); ```

Erfc computes the complementary error function value of vector elements.
Fortran:
``` call vserfc (n, a, y) call vderfc (n, a, y) ``` C:
``` vsErfc (n, a, y); vdErfc (n, a, y); ```

* Legal Information © 1999, 2002-2004, Intel Corporation