iOS Developer Library

Developer

Accelerate Framework Reference vecLib Reference

Options
Deployment Target:

On This Page
Language:

vecLib Reference

Inheritance


Not Applicable

Conforms To


Not Applicable

Import Statement


Swift

import Accelerate

Objective-C

@import Accelerate;

The vecLib framework contains nine C header files (not counting vecLib.h which merely includes the others). Two of them, vDSP.h and vDSP_translate.h, are covered in vDSP Programming Guide and vDSP Reference.

Three of the header files are Apple’s versions of well-known libraries which are described in detail in external references:

This document describes the functions declared in the remaining header files: vecLibTypes.h, vfp.h, vForce.h, vBasicOps.h, vectorOps.h, and vBigNum.h. These files support the vector mathematical functions library (also called “vMathLib”), which runs on vector processing hardware if available.

This library abstracts the vector processing capability so that code written for it will execute appropriate instructions for the processor available at runtime. For this reason, unless you are writing specialized code that targets a single CPU, you should generally use these functions rather than directly using vector instructions. By using these functions, your code does not have to deal with subtle differences in vector instruction availability between different microarchitectures, freeing you to focus on the problem you are trying to solve. Also, code written using vecLib tends to be easier to port to different CPU architectures (porting your core libraries to ARM on iOS, for example).

vecLibTypes.h

The vecLibTypes.h header file defines a set of vector data types (vFloat, vUInt32, etc.), which represent 128-bit vectors containing values of type float, UInt32, etc. The vBasicOps.h and vfp.h headers make use of these types.

The type names all begin with the letter “v,” followed by a mnemonic for the scalar data type used for elements of the vector. For example, vUInt32, vSInt16, vFloat, etc.

vBasicOps.h

vBasicOps.h declares a set of basic arithmetic and logical functions on 128-bit vectors, using the integer types from vecLibTypes.h.

The function names begin with “v,” followed by a mnemonic for the type of operation, e.g. “S” or “U” for signed or unsigned, then the width of the operation, then the name of the operation. For example, vS8Divide performs division of signed 8-bit values packed into 128-bit vectors.

vfp.h

vfp.h declares a set of floating-point arithmetic, transcendental and trigonometric functions, on 128-bit vectors, using the floating-point types from vecLibTypes.h.

These functions are named with their customary mathematical names, prefixed with the letter “v”, and all except vtablelookup() have the suffix “f” to indicate that they work with single-precision floating-point data. For example, vcosf is the single-precision cosine function.

vForce.h

vForce.h declares a set of trigonometric and transcendental functions in terms of C arrays (double * or float *), which can be of any desired length. Internally, the C arrays are converted piecewise into collections of 128-bit vectors, if appropriate for the current architecture.

The functions declared in vForce.h are named with the customary mathematical names, but with the prefix “vv.” Each mathematical function is available in two variants: one for single-precision floating-point data and one for double-precision data. The single-precision forms have the suffix “f”, while the double-precision forms have no suffix. For example, vvcosf is the single-precision cosine function, while vvcos is the double-precision variant.

All of the vForce.h functions follow a common format:

  • The return type is void.

  • The first parameter points to an array to hold the results. (The only exceptions are vvsincosf() and vvsincos(), which have two result arrays pointed to by the first two parameters.)

  • One or more parameters point to operand arrays, the same length as the result array.

  • The last parameter is the array length.

vectorOps.h

vectorOps.h declares a set of vector and matrix BLAS functions on arrays of 128-bit vectors containing single-precision floating-point values. The arrays can be of any desired length, but the number of float elements must be a multiple of 4.

vBigNum.h

vBigNum.h provides arithmetic and logical operations on large integers, which may be 128, 256, 512, or 1024 bits in length. It defines types for these values, and internally processes them as collections of 128-bit vectors.

vBigNum.h defines its own set of data types to represent large integer quantities, such as vS128 for a signed, 128-bit integer or vU1024 for an unsigned, 1024-bit integer. The function names begin with the data type name, followed by the name of the operation. For example, vS512Add performs addition of two 128-bit signed integers.

The functions perform logical and arithmetic operations on scalar values that may be 128, 256, 512, or 1024 bits in width. These values are implemented as structures of one, two, four, or eight 128-bit vectors, and the operations execute on the available vector-processing hardware if possible.

The functions have names that are compatible with those in vBasicOps.h.

Threading Model

In versions of vecLib prior to OS X v10.7, many vecLib routines used multiple POSIX threads to improve performance. In some cases, this could cause performance problems in applications that use large numbers of POSIX threads.

An application can limit the number of threads used by vecLib by setting the environment variable VECLIB_MAXIMUM_THREADS as follows:

  • #include <stdlib.h>
  • setenv("VECLIB_MAXIMUM_THREADS", "1", true);

To remove the limit, you can unset the environment variable as follows:

  • unsetenv("VECLIB_MAXIMUM_THREADS");

In OS X v10.7, these routines use Grand Central Dispatch, so the use of this environment variable should no longer be necessary.

For More Information

For information about membership in Apple’s developer program, go to this URL:

http://developer.apple.com/membership/

For information about the Velocity Engine, go to this URL:

http://developer.apple.com/hardwaredrivers/ve/index.html

For general technical support from Apple, go to this URL:

https://developer.apple.com/support/

Functions

  • Computes the ceiling of values in a vector of floating-point values.

    Declaration

    Objective-C

    vFloat vceilf ( vFloat );

    Parameters

    A

    The input vector.

    Return Value

    Returns a vector of floating-point values, each of which is the ceiling of the corresponding value in A.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, produces a value with the magnitude of arg2 and sign arg1. Note that the order of the arguments matches the recommendation of the IEEE 754 floating-point standard, which is opposite from the SANE copysign function.

    Declaration

    Objective-C

    vFloat vcopysignf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates A/B.

    Declaration

    Objective-C

    vFloat vdivf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • Computes the floor of values in a vector of floating-point values.

    Declaration

    Objective-C

    vFloat vfloorf ( vFloat );

    Parameters

    A

    The input vector.

    Return Value

    Returns a vector of floating-point values, each of which is the floor of the corresponding value in A.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • Rounds to the nearest integer (nearest even for ties).

    Declaration

    Objective-C

    vFloat vnintf ( vFloat );

    Parameters

    A

    The input vector.

    Return Value

    Returns a vector of floating-point values, each of which is the result of rounding the corresponding value in A to the nearest integer, with ties rounded to the nearest even integer.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the next representable value after x in the direction of y. If x is equal to y, then y is returned.

    Declaration

    Objective-C

    vFloat vnextafterf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • Computes the reciprocal of values in a vector.

    Declaration

    Objective-C

    vFloat vrecf ( vFloat );

    Parameters

    A

    The source vector

    Return Value

    Returns a vector containing the reciprocals of the values in the source vector.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the inverse of the square root of X.

    Declaration

    Objective-C

    vFloat vrsqrtf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the square root of X.

    Declaration

    Objective-C

    vFloat vsqrtf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element of Index_Vect, returns the corresponding value from Table.

    Declaration

    Objective-C

    vUInt32 vtablelookup ( vSInt32 , uint32_t * );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the exponential of X.

    Declaration

    Objective-C

    vFloat vexpf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates ExpM1(x) = Exp(x) - 1. But, for small enough arguments, ExpM1(x) is expected to be more accurate than Exp(x) - 1.

    Declaration

    Objective-C

    vFloat vexpm1f ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the natural logarithm of X.

    Declaration

    Objective-C

    vFloat vlogf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates Log1P = Log(1 + x). But, for small enough arguments, Log1P is expected to be more accurate than Log(1 + x).

    Declaration

    Objective-C

    vFloat vlog1pf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • Computes the base-10 logarithm of values in a vector.

    Declaration

    Objective-C

    vFloat vlog10f ( vFloat );

    Parameters

    X

    The source vector.

    Return Value

    Returns a vector of floating point values, each of which is the base-10 logarithm of the corresponding value in the source vector.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, extracts the exponent of X, as a signed integral value. A subnormal argument is treated as though it were first normalized. Thus: 1 <= x * 2^(-logb(x)) < 2.

    Declaration

    Objective-C

    vFloat vlogbf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates x * 2^n efficiently. This is not normally done by computing 2^n explicitly.

    Declaration

    Objective-C

    vFloat vscalbf ( vFloat , vSInt32 );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the sine.

    Declaration

    Objective-C

    vFloat vsinf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the cosine.

    Declaration

    Objective-C

    vFloat vcosf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • Simultaneously computes sine and cosine of values in a vector.

    Declaration

    Objective-C

    vFloat vsincosf ( vFloat , vFloat * );

    Parameters

    arg

    The source vector.

    sine_result

    An output vector. On return, this contains the result of sin(x) for each value (x) in the source vector.

    Return Value

    Returns a vector that contains the result of cos(x) for each value (x) in the source vector.

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the tangent.

    Declaration

    Objective-C

    vFloat vtanf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the arcsine. Results are in the interval [-pi/2, pi/2].

    Declaration

    Objective-C

    vFloat vasinf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the arccosine. Results are in the interval [0, pi].

    Declaration

    Objective-C

    vFloat vacosf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the arctangent. Results are in the interval [-pi/2, pi/2].

    Declaration

    Objective-C

    vFloat vatanf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the arctangent of arg2/arg1 in the interval [-pi,pi] using the sign of both arguments to determine the quadrant of the computed value.

    Declaration

    Objective-C

    vFloat vatan2f ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the hyperbolic sine of X.

    Declaration

    Objective-C

    vFloat vsinhf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the hyperbolic cosine of X.

    Declaration

    Objective-C

    vFloat vcoshf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the hyperbolic tangent of X.

    Declaration

    Objective-C

    vFloat vtanhf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the inverse hyperbolic sine of X.

    Declaration

    Objective-C

    vFloat vasinhf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the inverse hyperbolic cosine of X.

    Declaration

    Objective-C

    vFloat vacoshf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the inverse hyperbolic tangent of X.

    Declaration

    Objective-C

    vFloat vatanhf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates X to the integer power of Y.

    Declaration

    Objective-C

    vFloat vipowf ( vFloat , vSInt32 );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates X to the floating-point power of Y. The result is more accurate than using exp(log(X)*Y).

    Declaration

    Objective-C

    vFloat vpowf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates X modulo Y.

    Declaration

    Objective-C

    vFloat vfmodf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the remainder of X/Y, according to the IEEE 754 floating-point standard.

    Declaration

    Objective-C

    vFloat vremainderf ( vFloat , vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, calculates the remainder of X/Y, according to the SANE standard. It stores into QUO the 7 low-order bits of the integer quotient, such that -127 <= QUO <= 127.

    Declaration

    Objective-C

    vFloat vremquof ( vFloat , vFloat, vUInt32 * );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, returns the class of the argument (one of the FP_ ... constants defined in math.h).

    Declaration

    Objective-C

    vUInt32 vclassifyf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each vector element, returns a non-zero value if and only if the sign of arg is negative. This includes NaNs, infinities and zeros.

    Declaration

    Objective-C

    vUInt32 vsignbitf ( vFloat );

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 6.0 and later.

  • For each double-precision array element, sets y to the ceiling of x.

    Declaration

    Swift

    func vvceil(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvceil ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the ceiling of x.

    Declaration

    Swift

    func vvceilf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvceilf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Copies an array, setting the sign of each value based on a second array.

    Declaration

    Swift

    func vvcopysign(_ z: UnsafeMutablePointer<Double>, _ y: UnsafePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvcopysign ( double *, const double *, const double *, const int * );

    Parameters

    z

    The output array.

    y

    The magnitude input array.

    x

    The sign input array.

    n

    The address of an integer containing the number of elements to copy.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Copies an array, setting the sign of each value based on a second array.

    Declaration

    Swift

    func vvcopysignf(_ result: UnsafeMutablePointer<Float>, _ signs: UnsafePointer<Float>, _ float: UnsafePointer<Float>, _ int: UnsafePointer<Int32>)

    Objective-C

    void vvcopysignf ( float *, const float *, const float *, const int * );

    Parameters

    result

    Storage for the result. Modified on return.

    signs

    Array containing values with the desired signs.

    float

    Array containing values with the desired values.

    int

    The length of the arrays.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets z to y/x.

    Declaration

    Swift

    func vvdiv(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvdiv ( double *, const double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets z to y/x.

    Declaration

    Swift

    func vvdivf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvdivf ( float *, const float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to abs(x[i]-1) for i in 0..n-1.

    Declaration

    Swift

    func vvfabs(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvfabs ( double *, const double *, const int * );

    Parameters

    y

    An input array of double-precision floating point numbers

    x

    An output array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to abs(x[i]-1) for i in 0..n-1.

    Declaration

    Swift

    func vvfabsf(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvfabsf ( float *, const float *, const int * );

    Parameters

    y

    An input array of single-precision floating point values.

    x

    An output array of single-precision floating point values.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the floor of x.

    Declaration

    Swift

    func vvfloor(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvfloor ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the floor of x.

    Declaration

    Swift

    func vvfloorf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvfloorf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the floating point remainder of (y[i]/x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvfmod(_ z: UnsafeMutablePointer<Double>, _ y: UnsafePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvfmod ( double *, const double *, const double *, const int * );

    Parameters

    z

    An output array of double-precision floating point numbers.

    y

    Numerator input array of double-precision floating point numbers.

    x

    Denominator input array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Computes the remainders after dividing values in a pair of arrays.

    Declaration

    Swift

    func vvfmodf(_ result: UnsafeMutablePointer<Float>, _ divisors: UnsafePointer<Float>, _ dividends: UnsafePointer<Float>, _ count: UnsafePointer<Int32>)

    Objective-C

    void vvfmodf ( float *, const float *, const float *, const int * );

    Parameters

    result

    An array, modified on return, where the results are stored.

    divisors

    An array of divisors.

    dividends

    An array of dividends.

    count

    The number of values in the input and result arrays.

    Discussion

    On return, the result array contains the remainders after calculating dividend[i] / divisor[i] for each value of i from 0 through count-1.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the integer truncation of x.

    Declaration

    Swift

    func vvint(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvint ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the integer truncation of x.

    Declaration

    Swift

    func vvintf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvintf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element z[i] to the next machine-representable value from y[i] towards x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvnextafter(_ z: UnsafeMutablePointer<Double>, _ y: UnsafePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvnextafter ( double *, const double *, const double *, const int * );

    Parameters

    z

    An output array of double-precision floating point numbers.

    y

    An input array of double-precision floating point numbers.

    x

    An input array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Discussion

    Not all values can be represented as a floating-point value of a given precision. This function sets a value in z[i] that is either minimally larger than the value in y[i] (if x[i] is larger than y[i]) or minimally smaller than the value in y[i] (if x[i] is smaller than y[i]).

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element z[i] to the next machine-representable value from y[i] towards x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvnextafterf(_ z: UnsafeMutablePointer<Float>, _ y: UnsafePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvnextafterf ( float *, const float *, const float *, const int * );

    Parameters

    z

    An array where results are stored on return.

    y

    An array of floating-point values providing the direction relative to x.

    x

    An array of floating-point values providing the starting point.

    n

    A pointer to an integer containing the number of elements to process.

    Discussion

    Not all values can be represented as a floating-point value of a given precision. This function sets a value in z[i] that is either minimally larger than the value in y[i] (if x[i] is larger than y[i]) or minimally smaller than the value in y[i] (if x[i] is smaller than y[i]).

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the nearest integer to x.

    Declaration

    Swift

    func vvnint(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvnint ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the nearest integer to x.

    Declaration

    Swift

    func vvnintf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvnintf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the reciprocal of the square root of x.

    Declaration

    Swift

    func vvrsqrt(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvrsqrt ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the reciprocal of the square root of x.

    Declaration

    Swift

    func vvrsqrtf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvrsqrtf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the square root of x.

    Declaration

    Swift

    func vvsqrt(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsqrt ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the square root of x.

    Declaration

    Swift

    func vvsqrtf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsqrtf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the reciprocal of y.

    Declaration

    Swift

    func vvrec(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvrec ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the reciprocal of y.

    Declaration

    Swift

    func vvrecf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvrecf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets z[i] to the remainder relative to a round-to-even division of y[i]/x[i] for each i in 0..n-1.

    Declaration

    Swift

    func vvremainder(_ z: UnsafeMutablePointer<Double>, _ y: UnsafePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvremainder ( double *, const double *, const double *, const int * );

    Parameters

    z

    An array for storing the results.

    y

    An array of divisors.

    x

    An array of dividends.

    n

    A pointer to an integer containing the number of elements to process.

    Discussion

    This function performs the equivalent of vnintf for each dividend/divisor pair, then multiplies the result by the divisor, and subtracts the result from the dividend.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Computes the remainder relative to a round-to-even division.

    Declaration

    Swift

    func vvremainderf(_ results: UnsafeMutablePointer<Float>, _ divisors: UnsafePointer<Float>, _ dividends: UnsafePointer<Float>, _ count: UnsafePointer<Int32>)

    Objective-C

    void vvremainderf ( float *, const float *, const float *, const int * );

    Parameters

    results

    An array for storing the results.

    divisors

    An array of divisors.

    dividends

    An array of dividends.

    count

    A pointer to an integer containing the number of elements to process.

    Discussion

    This function performs the equivalent of vnintf for each dividend/divisor pair, then multiplies the result by the divisor, and subtracts the result from the dividend.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the exponential of x.

    Declaration

    Swift

    func vvexp(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvexp ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the exponential of x.

    Declaration

    Swift

    func vvexpf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvexpf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to 2 raised to (x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvexp2(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvexp2 ( double *, const double *, const int * );

    Parameters

    y

    An input array of double-precision floating point numbers

    x

    An output array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to 2 raised to (x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvexp2f(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvexp2f ( float *, const float *, const int * );

    Parameters

    y

    An input array of single-precision floating point values.

    x

    An output array of single-precision floating point values.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Returns (e^x)-1 for each element y[i].

    Declaration

    Swift

    func vvexpm1(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvexpm1 ( double *, const double *, const int * );

    Parameters

    y

    An input array of double-precision floating point numbers

    x

    An output array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Discussion

    This is accurate for very small values of x[i].

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Computes (e^x)-1 for each element in an array.

    Declaration

    Swift

    func vvexpm1f(_ result: UnsafeMutablePointer<Float>, _ src: UnsafePointer<Float>, _ count: UnsafePointer<Int32>)

    Objective-C

    void vvexpm1f ( float *, const float *, const int * );

    Parameters

    result

    An array, modified on return, where the results are stored.

    src

    The input array.

    count

    The number of values in the input and result arrays.

    Discussion

    Provides additional accuracy for values of x near -1.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the natural logarithm of x.

    Declaration

    Swift

    func vvlog(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvlog ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the natural logarithm of x.

    Declaration

    Swift

    func vvlogf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvlogf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to log(1+x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvlog1p(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvlog1p ( double *, const double *, const int * );

    Parameters

    y

    An output array of double-precision floating point numbers.

    x

    An input array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Computes the natural logarithm of a value plus 1.

    Declaration

    Swift

    func vvlog1pf(_ results: UnsafeMutablePointer<Float>, _ values: UnsafePointer<Float>, _ count: UnsafePointer<Int32>)

    Objective-C

    void vvlog1pf ( float *, const float *, const int * );

    Parameters

    results

    An array where results are stored on return.

    values

    The source array.

    count

    A pointer to an integer containing the number of elements to process.

    Discussion

    This algorithm computes

    log(1+x)

    for each element x in the source array.

    This algorithm is tuned to provide increased accuracy for values of x near 1.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the base-2 logarithm of x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvlog2(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvlog2 ( double *, const double *, const int * );

    Parameters

    y

    An output array of double-precision floating point numbers.

    x

    An input array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the base 2 logarithm of x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvlog2f(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvlog2f ( float *, const float *, const int * );

    Parameters

    y

    An output array of single-precision floating point numbers.

    x

    An input array of single-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the base 10 logarithm of x.

    Declaration

    Swift

    func vvlog10(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvlog10 ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the base 10 logarithm of x.

    Declaration

    Swift

    func vvlog10f(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvlog10f ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the exponent of x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvlogb(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvlogb ( double *, const double *, const int * );

    Parameters

    y

    An output array of double-precision floating point numbers.

    x

    An input array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Discussion

    Floating point numbers are internally represented as a mantissa multiplied times a base raised to an exponent. That exponent is returned in the output array.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the exponent of x[i] for i in 0..n-1.

    Declaration

    Swift

    func vvlogbf(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvlogbf ( float *, const float *, const int * );

    Parameters

    y

    An array where results are stored on return.

    x

    The source array.

    n

    A pointer to an integer containing the number of elements to process.

    Discussion

    Floating point numbers are internally represented as a mantissa multiplied times a base raised to an exponent. That exponent is returned in the output array.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets z to x raised to the power of y.

    Declaration

    Swift

    func vvpowf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvpowf ( float *, const float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets z to x raised to the power of y.

    Declaration

    Swift

    func vvpow(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvpow ( double *, const double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the sine of x.

    Declaration

    Swift

    func vvsin(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsin ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the sine of x.

    Declaration

    Swift

    func vvsinf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsinf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets y[i] to sin(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvsinpi(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvsinpi ( double *, const double *, const int * );

    Parameters

    y

    An array where results are stored on return.

    x

    The source array.

    n

    A pointer to an integer containing the number of elements to process.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets y[i] to sin(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvsinpif(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvsinpif ( float *, const float *, const int * );

    Parameters

    y

    An array where results are stored on return.

    x

    The source array.

    n

    A pointer to an integer containing the number of elements to process.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the cosine of x.

    Declaration

    Swift

    func vvcos(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcos ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the cosine of x.

    Declaration

    Swift

    func vvcosf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcosf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the sin(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvcospi(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvcospi ( double *, const double *, const int * );

    Parameters

    y

    An input array of double-precision floating point numbers

    x

    An output array of double-precision floating point numbers.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets each element y[i] to the sin(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvcospif(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvcospif ( float *, const float *, const int * );

    Parameters

    y

    An input array of single-precision floating point values.

    x

    An output array of single-precision floating point values.

    n

    A pointer to an integer containing the number of floating point elements to set.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets the real part of C to the cosine of x and the imaginary part of C to the sine of x, for n elements.

    Declaration

    Swift

    func vvcosisin(_ _: COpaquePointer, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcosisin ( __double_complex_t *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets the real part of C to the cosine of x and the imaginary part of C to the sine of x, for n elements.

    Declaration

    Swift

    func vvcosisinf(_ _: COpaquePointer, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcosisinf ( __float_complex_t *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets z to the sine of x and y to the cosine of x.

    Declaration

    Swift

    func vvsincos(_ _: UnsafeMutablePointer<Double>, _ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsincos ( double *, double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets z to the sine of x and y to the cosine of x.

    Declaration

    Swift

    func vvsincosf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsincosf ( float *, float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the tangent of x.

    Declaration

    Swift

    func vvtan(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvtan ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the tangent of x.

    Declaration

    Swift

    func vvtanf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvtanf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets y[i] to tan(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvtanpi(_ y: UnsafeMutablePointer<Double>, _ x: UnsafePointer<Double>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvtanpi ( double *, const double *, const int * );

    Parameters

    y

    An array where results are stored on return.

    x

    The source array.

    n

    A pointer to an integer containing the number of elements to process.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • Sets y[i] to tan(pi * x[i]) for i in 0..n-1.

    Declaration

    Swift

    func vvtanpif(_ y: UnsafeMutablePointer<Float>, _ x: UnsafePointer<Float>, _ n: UnsafePointer<Int32>)

    Objective-C

    void vvtanpif ( float *, const float *, const int * );

    Parameters

    y

    An array where results are stored on return.

    x

    The source array.

    n

    A pointer to an integer containing the number of elements to process.

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the arcsine of x.

    Declaration

    Swift

    func vvasin(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvasin ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the arcsine of x.

    Declaration

    Swift

    func vvasinf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvasinf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the arccosine of x.

    Declaration

    Swift

    func vvacos(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvacos ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the arccosine of x.

    Declaration

    Swift

    func vvacosf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvacosf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the arctangent of x.

    Declaration

    Swift

    func vvatan(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatan ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the arctangent of x.

    Declaration

    Swift

    func vvatanf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatanf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets z to the arctangent of y/x.

    Declaration

    Swift

    func vvatan2(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatan2 ( double *, const double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets z to the arctangent of y/x.

    Declaration

    Swift

    func vvatan2f(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatan2f ( float *, const float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the hyperbolic sine of x.

    Declaration

    Swift

    func vvsinhf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsinhf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the hyperbolic sine of x.

    Declaration

    Swift

    func vvsinh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvsinh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the hyperbolic cosine of x.

    Declaration

    Swift

    func vvcoshf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcoshf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the hyperbolic cosine of x.

    Declaration

    Swift

    func vvcosh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvcosh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the hyperbolic tangent of x.

    Declaration

    Swift

    func vvtanhf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvtanhf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the hyperbolic tangent of x.

    Declaration

    Swift

    func vvtanh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvtanh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the inverse hyperbolic sine of x.

    Declaration

    Swift

    func vvasinhf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvasinhf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the inverse hyperbolic sine of x.

    Declaration

    Swift

    func vvasinh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvasinh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the inverse hyperbolic cosine of x.

    Declaration

    Swift

    func vvacoshf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvacoshf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the inverse hyperbolic cosine of x.

    Declaration

    Swift

    func vvacosh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvacosh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each single-precision array element, sets y to the inverse hyperbolic tangent of x.

    Declaration

    Swift

    func vvatanhf(_ _: UnsafeMutablePointer<Float>, _ _: UnsafePointer<Float>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatanhf ( float *, const float *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

  • For each double-precision array element, sets y to the inverse hyperbolic tangent of x.

    Declaration

    Swift

    func vvatanh(_ _: UnsafeMutablePointer<Double>, _ _: UnsafePointer<Double>, _ _: UnsafePointer<Int32>)

    Objective-C

    void vvatanh ( double *, const double *, const int * );

    Import Statement

    Objective-C

    @import Accelerate;

    Swift

    import Accelerate

    Availability

    Available in iOS 5.0 and later.

Data Types

All data structures passed to vecLib must be naturally aligned. For example, a 32-bit floating-point value must be aligned to a four-byte boundary. Many routines in vecLib generate exceptions on unaligned data.

  • A 128-bit vector packed with unsigned char values.

    Declaration

    Objective-C

    typedef vector unsigned char vUInt8;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with signed char values.

    Declaration

    Objective-C

    typedef vector signed char vSInt8;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with unsigned short values.

    Declaration

    Objective-C

    typedef vector unsigned short vUInt16;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with signed short values.

    Declaration

    Objective-C

    typedef vector signed short vSInt16;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with unsigned int values.

    Declaration

    Objective-C

    typedef vector unsigned int vUInt32;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with signed int values.

    Declaration

    Objective-C

    typedef vector signed int vSInt32;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with uint64_t values.

    Declaration

    Objective-C

    typedef vector unsigned int vUInt64;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 7.0 through iOS 7.1.

  • A 128-bit vector packed with int64_t values.

    Declaration

    Objective-C

    typedef vector signed int vSInt64;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 7.0 through iOS 7.1.

  • A 128-bit vector packed with float values.

    Declaration

    Objective-C

    typedef vector float vFloat;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A 128-bit vector packed with double values.

    Declaration

    Objective-C

    typedef double vDouble __attribute__((__vector_size__ (16)));

    Import Statement

  • A 128-bit vector packed with bool int values.

    Declaration

    Objective-C

    typedef vector bool int vBool32;

    Import Statement

    Objective-C

    @import Accelerate;

    Availability

    Available in iOS 4.0 and later.

  • A single-precision complex number type.

    Declaration

    Objective-C

    typedef complex float __float_complex_t;

    Import Statement

  • A double-precision complex number type.

    Declaration

    Objective-C

    typedef complex double __double_complex_t;

    Import Statement