vecLib Reference

Framework
Declared in
OSvKernDSPLib.h
vBasicOps.h
vBigNum.h
vForce.h
vecLibTypes.h
vectorOps.h
vfp.h

Overview

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 (Altivec or SSE3) 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:

http://developer.apple.com/technicalsupport/index.html

Functions by Task

Shift and Rotate Functions (from vBasicOps.h)

Integer Arithmetic Functions (from vBasicOps.h)

Floating-Point Arithmetic and Auxiliary Functions (from vfp.h)

Exponential and Logarithmic Functions (from vfp.h)

Trigonometric Functions (from vfp.h)

Hyperbolic Functions (from vfp.h)

Power Functions (from vfp.h)

Remainder Functions (from vfp.h)

Inquiry Functions (from vfp.h)

Array-Oriented Arithmetic and Auxiliary Functions (from vForce.h)

Array-Oriented Exponential and Logarithmic Functions (from vForce.h)

Array-Oriented Power Functions (from vForce.h)

Array-Oriented Trigonometric Functions (from vForce.h)

Array-Oriented Hyperbolic Functions (from vForce.h)

Shift and Rotate Functions on Big Numbers (from vBigNum.h)

Arithmetic Functions on Big Numbers (from vBigNum.h)

Vector-Scalar Linear Algebra Functions (from vectorOps.h)

Matrix-Vector Linear Algebra Functions (from vectorOps.h)

Matrix Operations (from vectorOps.h)

Deprecated Functions

Functions

vA1024Shift

1024-bit arithmetic shift.

void vA1024Shift (
   const vS1024 *a,
   uint32_t shiftAmount,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vA128Shift

128-bit arithmetic (signed) shift.

vUInt32 vA128Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the entire 128-bit vector as a single value to shift.

Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vA256Shift

256-bit arithmetic shift.

void vA256Shift (
   const vS256 *a,
   uint32_t shiftAmount,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vA512Shift

512-bit arithmetic shift.

void vA512Shift (
   const vS512 *a,
   uint32_t shiftAmount,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vA64Shift

64-bit arithmetic (signed) shift.

vUInt32 vA64Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vA64Shift2

64-bit arithmetic (signed) shift with two shift factors.

vUInt32 vA64Shift2 (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vacosf

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

vFloat vacosf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vacoshf

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

vFloat vacoshf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vasinf

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

vFloat vasinf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vasinhf

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

vFloat vasinhf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vatan2f

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.

vFloat vatan2f (
   vFloat arg1,
   vFloat arg2
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vatanf

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

vFloat vatanf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vatanhf

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

vFloat vatanhf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vceilf

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

vFloat vceilf (
   vFloat A
);
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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vclassifyf

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

vUInt32 vclassifyf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vcopysignf

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.

vFloat vcopysignf (
   vFloat arg2,
   vFloat arg1
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vcosf

For each vector element, calculates the cosine.

vFloat vcosf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vcoshf

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

vFloat vcoshf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vdivf

For each vector element, calculates A/B.

vFloat vdivf (
   vFloat A,
   vFloat B
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vexpf

For each vector element, calculates the exponential of X.

vFloat vexpf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vexpm1f

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.

vFloat vexpm1f (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vfabf

For each vector element, calculates the absolute value of v.

vFloat vfabf (
   vFloat v
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vfloorf

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

vFloat vfloorf (
   vFloat A
);
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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vfmodf

For each vector element, calculates X modulo Y.

vFloat vfmodf (
   vFloat X,
   vFloat Y
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vintf

Truncates the decimal portion of a vector of floating-point values.

vFloat vintf (
   vFloat A
);
Parameters
A

The input vector.

Return Value

Returns a vector of floating-point values, each of which is the result of truncating the fractional portion of the corresponding value in A.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vipowf

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

vFloat vipowf (
   vFloat X,
   vSInt32 Y
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vIsamax

Finds the position of the first vector element having the largest absolute value.

int32_t vIsamax (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The index of the first element having the largest absolute value in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vIsamin

Finds the position of the first vector element having the smallest absolute value.

int32_t vIsamin (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The index of the first element having the smallest absolute value in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vIsmax

Finds the position of the first vector element having the maximum value.

int32_t vIsmax (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The index of the first element having the maximum value in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vIsmin

Finds the position of the first vector element having the minimum value.

int32_t vIsmin (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The index of the first element having the minimum value in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vL1024Rotate

1024-bit left rotate.

void vL1024Rotate (
   const vU1024 *a,
   uint32_t rotateAmount,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vL128Rotate

128-bit left rotate.

vUInt32 vL128Rotate (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the entire 128-bit vector as a single value to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vL256Rotate

256-bit left rotate.

void vL256Rotate (
   const vU256 *a,
   uint32_t rotateAmount,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vL512Rotate

512-bit left rotate.

void vL512Rotate (
   const vU512 *a,
   uint32_t rotateAmount,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vL64Rotate

64-bit left rotate.

vUInt32 vL64Rotate (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vL64Rotate2

64-bit left rotate with two rotation factors.

vUInt32 vL64Rotate2 (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vLL1024Shift

1024-bit logical left shift.

void vLL1024Shift (
   const vU1024 *a,
   uint32_t shiftAmount,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLL128Shift

128-bit logical left shift.

vUInt32 vLL128Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the entire 128-bit vector as a single value to shift.

Availability
  • Available in OS X v10.5 and later.
Declared In
vBasicOps.h

vLL256Shift

256-bit logical left shift.

void vLL256Shift (
   const vU256 *a,
   uint32_t shiftAmount,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLL512Shift

512-bit logical left shift.

void vLL512Shift (
   const vU512 *a,
   uint32_t shiftAmount,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLL64Shift

64-bit logical left shift.

vUInt32 vLL64Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vLL64Shift2

64-bit logical left shift with two shift factors.

vUInt32 vLL64Shift2 (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vlog10f

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

vFloat vlog10f (
   vFloat X
);
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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vlog1pf

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).

vFloat vlog1pf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vlogbf

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.

vFloat vlogbf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vlogf

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

vFloat vlogf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vLR1024Shift

1024-bit logical right shift .

void vLR1024Shift (
   const vU1024 *a,
   uint32_t shiftAmount,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLR128Shift

128-bit logical right shift.

vUInt32 vLR128Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the entire 128-bit vector as a single value to shift.

Availability
  • Available in OS X v10.5 and later.
Declared In
OSvKernDSPLib.h

vLR256Shift

256-bit logical right shift.

void vLR256Shift (
   const vU256 *a,
   uint32_t shiftAmount,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLR512Shift

512-bit logical right shift .

void vLR512Shift (
   const vU512 *a,
   uint32_t shiftAmount,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vLR64Shift

64-bit logical right shift.

vUInt32 vLR64Shift (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vLR64Shift2

64-bit logical right shift with two shift factors.

vUInt32 vLR64Shift2 (
   vUInt32 vA,
   vUInt8 vShiftFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to shift.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vnextafterf

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.

vFloat vnextafterf (
   vFloat x,
   vFloat y
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vnintf

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

vFloat vnintf (
   vFloat A
);
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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vpowf

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

vFloat vpowf (
   vFloat X,
   vFloat Y
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vR1024Rotate

1024-bit right rotate.

void vR1024Rotate (
   const vU1024 *a,
   uint32_t rotateAmount,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vR128Rotate

128-bit right rotate.

vUInt32 vR128Rotate (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the entire 128-bit vector as a single value to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vR256Rotate

256-bit right rotate.

void vR256Rotate (
   const vU256 *a,
   uint32_t rotateAmount,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vR512Rotate

512-bit right rotate.

void vR512Rotate (
   const vU512 *a,
   uint32_t rotateAmount,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vR64Rotate

64-bit right rotate.

vUInt32 vR64Rotate (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vR64Rotate2

64-bit right rotate with two rotation factors.

vUInt32 vR64Rotate2 (
   vUInt32 vA,
   vUInt8 vRotateFactor
);
Parameters
vA

The vector to shift.

vShiftFactor

The number of bits to shift the vector.

Return Value

Returns the shifted vector.

Discussion

This function treats the vector as a pair of 64-bit values to rotate.

Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vrecf

Computes the reciprocal of values in a vector.

vFloat vrecf (
   vFloat A
);
Parameters
A

The source vector

Return Value

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

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vremainderf

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

vFloat vremainderf (
   vFloat X,
   vFloat Y
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vremquof

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.

vFloat vremquof (
   vFloat X,
   vFloat Y,
   vUInt32 *QUO
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vrsqrtf

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

vFloat vrsqrtf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vS1024Add

Signed 1024-bit addition (modular arithmetic).

void vS1024Add (
   const vS1024 *a,
   const vS1024 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024AddS

Signed 1024-bit addition with saturation (clipping).

void vS1024AddS (
   const vS1024 *a,
   const vS1024 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024Divide

Signed 1024-bit division.

void vS1024Divide (
   const vS1024 *numerator,
   const vS1024 *divisor,
   vS1024 *result,
   vS1024 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024HalfMultiply

Signed 1024-bit multiplication; result is the same width as multiplicands.

void vS1024HalfMultiply (
   const vS1024 *a,
   const vS1024 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024Mod

Signed 256-bit Mod.

void vS1024Mod (
   const vS1024 *numerator,
   const vS1024 *divisor,
   vS1024 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024Neg

Signed 1024-bit negation.

void vS1024Neg (
   const vS1024 *a,
   vS1024 *result
);
Parameters
a

The value to negate.

Return Value

Returns the negated value through the result parameter.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024Sub

Signed 1024-bit subtraction (modular arithmetic).

void vS1024Sub (
   const vS1024 *a,
   const vS1024 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS1024SubS

Signed 1024-bit subtraction with saturation (clipping).

void vS1024SubS (
   const vS1024 *a,
   const vS1024 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS128Add

Signed 128-bit addition (modular arithmetic).

vSInt32 vS128Add (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS128AddS

Signed 128-bit addition with saturation (clipping).

vSInt32 vS128AddS (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS128Divide

Signed 128-bit division.

vSInt32 vS128Divide (
   vSInt32 vN,
   vSInt32 vD,
   vSInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS128FullMultiply

Signed 128-bit multiplication; result is twice as wide as multiplicands.

void vS128FullMultiply (
   const vS128 *a,
   const vS128 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS128HalfMultiply

Signed 128-bit multiplication; results are same width as multiplicands.

vSInt32 vS128HalfMultiply (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS128Neg

Signed 128-bit negation.

vSInt32 vS128Neg (
   vSInt32 vA
);
Parameters
vA

The value to negate.

Return Value

Returns the negated value.

Availability
  • Available in OS X v10.5 and later.
Declared In
vBasicOps.h

vS128Sub

Signed 128-bit subtraction (modular arithmetic).

vSInt32 vS128Sub (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vS128SubS

Signed 128-bit subtraction with saturation (clipping).

vSInt32 vS128SubS (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS16Divide

Signed 16-bit division.

vSInt16 vS16Divide (
   vSInt16 vN,
   vSInt16 vD,
   vSInt16 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS16HalfMultiply

Signed 16-bit multiplication; results are same width as multiplicands.

vSInt16 vS16HalfMultiply (
   vSInt16 vA,
   vSInt16 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS256Add

Signed 256-bit addition (modular arithmetic).

void vS256Add (
   const vS256 *a,
   const vS256 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256AddS

Signed 256-bit addition with saturation (clipping).

void vS256AddS (
   const vS256 *a,
   const vS256 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256Divide

Signed 256-bit division.

void vS256Divide (
   const vS256 *numerator,
   const vS256 *divisor,
   vS256 *result,
   vS256 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256FullMultiply

Signed 256-bit multiplication; result is twice as wide as multiplicands.

void vS256FullMultiply (
   const vS256 *a,
   const vS256 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256HalfMultiply

Signed 256-bit multiplication; result is the same width as multiplicands.

void vS256HalfMultiply (
   const vS256 *a,
   const vS256 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256Mod

Signed 256-bit mod.

void vS256Mod (
   const vS256 *numerator,
   const vS256 *divisor,
   vS256 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256Neg

Signed 256-bit negation.

void vS256Neg (
   const vS256 *a,
   vS256 *result
);
Parameters
a

The value to negate.

Return Value

Returns the negated value through the result parameter.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256Sub

Signed 256-bit subtraction (modular arithmetic).

void vS256Sub (
   const vS256 *a,
   const vS256 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS256SubS

Signed 256-bit subtraction with saturation (clipping).

void vS256SubS (
   const vS256 *a,
   const vS256 *b,
   vS256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS32Divide

Signed 32-bit division.

vSInt32 vS32Divide (
   vSInt32 vN,
   vSInt32 vD,
   vSInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS32FullMulEven

Signed 32-bit multiplication; results are twice as wide as multiplicands, even-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vSInt32 vS32FullMulEven (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS32FullMulOdd

Signed 32-bit multiplication; results are twice as wide as multiplicands, odd-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vSInt32 vS32FullMulOdd (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS32HalfMultiply

Signed 32-bit multiplication; results are same width as multiplicands.

vSInt32 vS32HalfMultiply (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS512Add

Signed 512-bit addition (modular arithmetic).

void vS512Add (
   const vS512 *a,
   const vS512 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512AddS

Signed 512-bit addition with saturation (clipping).

void vS512AddS (
   const vS512 *a,
   const vS512 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512Divide

Signed 512-bit division.

void vS512Divide (
   const vS512 *numerator,
   const vS512 *divisor,
   vS512 *result,
   vS512 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512FullMultiply

Signed 512-bit multiplication; result is twice as wide as multiplicands.

void vS512FullMultiply (
   const vS512 *a,
   const vS512 *b,
   vS1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512HalfMultiply

Signed 512-bit multiplication; result is the same width as multiplicands.

void vS512HalfMultiply (
   const vS512 *a,
   const vS512 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512Mod

Signed 512-bit mod.

void vS512Mod (
   const vS512 *numerator,
   const vS512 *divisor,
   vS512 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512Neg

Signed 512-bit negation.

void vS512Neg (
   const vS512 *a,
   vS512 *result
);
Parameters
a

The value to negate.

Return Value

Returns the negated value through the result parameter.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512Sub

Signed 512-bit subtraction (modular arithmetic).

void vS512Sub (
   const vS512 *a,
   const vS512 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS512SubS

Signed 512-bit subtraction with saturation (clipping).

void vS512SubS (
   const vS512 *a,
   const vS512 *b,
   vS512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vS64Add

Signed 64-bit addition (modular arithmetic).

vSInt32 vS64Add (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64AddS

Signed 64-bit addition with saturation (clipping).

vSInt32 vS64AddS (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64Divide

Signed 64-bit division.

vSInt32 vS64Divide (
   vSInt32 vN,
   vSInt32 vD,
   vSInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64FullMulEven

Signed 64-bit multiplication; results are twice as wide as multiplicands, even-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vSInt32 vS64FullMulEven (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64FullMulOdd

Signed 64-bit multiplication; results are twice as wide as multiplicands, odd-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vSInt32 vS64FullMulOdd (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64HalfMultiply

Signed 64-bit multiplication; results are same width as multiplicands.

vSInt32 vS64HalfMultiply (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64Neg

Signed 64-bit negation.

vSInt32 vS64Neg (
   vSInt32 vA
);
Parameters
vA

The value to negate.

Return Value

Returns the negated value.

Availability
  • Available in OS X v10.5 and later.
Declared In
vBasicOps.h

vS64Sub

Signed 64-bit subtraction (modular arithmetic).

vSInt32 vS64Sub (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS64SubS

Signed 64-bit subtraction with saturation (clipping).

vSInt32 vS64SubS (
   vSInt32 vA,
   vSInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS8Divide

Signed 8-bit division.

vSInt8 vS8Divide (
   vSInt8 vN,
   vSInt8 vD,
   vSInt8 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vS8HalfMultiply

Signed 8-bit multiplication; results are same width as multiplicands.

vSInt8 vS8HalfMultiply (
   vSInt8 vA,
   vSInt8 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vSasum

Finds the sum of the absolute values of the elements in a vector.

float vSasum (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The sum of the absolute values of the elements in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSaxpy

Multiplies a vector by a scalar , adds it to a second vector , and stores the result in the second vector.

void vSaxpy (
   int32_t n,
   float alpha,
   const vFloat x[],
   vFloat y[]
);
Parameters
n

Number of elements in each of the vectors x and y; must be a multiple of 4.

alpha

A multiplier for the vector x.

x

A vector array of float values.

y

A second vector array of float values.

Discussion

The elements of x are multiplied by alpha and added to the corresponding elements of y. The results are stored in y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vscalbf

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

vFloat vscalbf (
   vFloat X,
   vSInt32 n
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vScopy

Copies one vector to another.

void vScopy (
   int32_t n,
   const vFloat x[],
   vFloat y[]
);
Parameters
n

Number of elements in vectors x and y; must be a multiple of 4.

x

A vector array of float values.

y

A second vector array of float values.

Discussion

The elements of x are copied to the corresponding elements of y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSdot

Computes the dot product of two vectors.

float vSdot (
   int32_t n,
   const vFloat x[],
   const vFloat y[]
);
Parameters
n

Number of elements in vectors x and y; must be a multiple of 4.

x

A vector array of float values.

y

A second vector array of float values.

Return Value

The dot product of the two vectors.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgeadd

Adds two general matrices or their transposes.

void vSgeadd (
   int32_t height,
   int32_t width,
   const vFloat a[],
   char forma,
   const vFloat b[],
   char formb,
   vFloat c[]
);
Parameters
height

number of rows in the matrices to be added; must be a multiple of 4.

width

number of columns in the matrices to be added; must be a multiple of 4.

a

a matrix with elements of type float. If forma = ‘N’, the matrix itself is used in the calculation and it has height rows and width columns. If forma = ‘T’, the transpose is used and a has width rows and height columns.

forma

selector with a value of‘N’ or ‘T’.

b

a matrix with elements of type float. If formb = ‘N’, the matrix itself is used in the calculation and it has height rows and width columns. If formb = ‘T’, the transpose is used and b has width rows and height columns.

formb

selector with a value of ‘N’ or ‘T’.

c

destination matrix with height rows and width columns.

Discussion

Matrix a (or its transpose) is added to matrix b (or its transpose); the result is stored in mactrix c.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgemm

Multiples two general matrices or their transposes, then scales and adds a third.

void vSgemm (
   int32_t l,
   int32_t m,
   int32_t n,
   const vFloat a[],
   char forma,
   const vFloat b[],
   char formb,
   vFloat c[],
   float alpha,
   float beta,
   vFloat matrix[]
);
Parameters
l

number of rows in matrix c; must be a multiple of 4.

m

if forma = ‘N’, m is the number of columns in matrix a ; if forma = ‘T’, m is the number of rows in matrix a. Also, if formb = ‘N’, m is the number of rows in matrix b; if formb = ‘T’, m is the number of columns in matrix b. m must be a multiple of 4.

n

number of columns in matrix c; must be a multiple of 4.

a

a matrix with elements of type float. If forma = ‘N’, the matrix itself is used in the calculation and it has l rows and m columns. If forma = ‘T’, the transpose is used and a has m rows and l columns. Thus the matrix used in the calculation is l by n.

forma

selector with a value of ‘N’ or ‘T’.

b

a matrix with elements of type float. If formb = ‘N’, the matrix itself is used in the calculation and it has m rows and n columns. If formb = ‘T’, the transpose is used and b has n rows and m columns. Thus the matrix used in the calculation is m by n.

formb

selector with a value of ‘N’ or ‘T’.

c

an l by n matrix with elements of type float.

alpha

multiplier for matrix a.

beta

multiplier for matrix c.

matrix

destination matrix with l rows and n columns.

Discussion

Matrix a (or its transpose) is multiplied by matrix b (or its transpose); matrix c is multiplied by beta, and the result is added to the result of the matrix multiplication; the result is stored in matrix matrix

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgemtx

Forms the transpose of a matrix, multiplies it by a scalar and then by a vector, and adds the resulting vector to a second vector.

void vSgemtx (
   int32_t m,
   int32_t n,
   float alpha,
   const vFloat a[],
   const vFloat x[],
   vFloat y[]
);
Parameters
m

number of rows in a, and the length of vector y; must be a multiple of 4.

n

number of columns in a, and the length of vector x; must be a multiple of 4.

alpha

scalar multiplier for matrix a.

a

m by n matrix with elements of type float.

x

vector with elements of type float.

y

destination vector with n elements of type float.

Discussion

The transpose of matrix a is multiplied by alpha and then by vector x; the resulting vector is added to vector y, and the results are stored in y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgemul

Multiplies two general matrices or their transposes.

void vSgemul (
   int32_t l,
   int32_t m,
   int32_t n,
   const vFloat a[],
   char forma,
   const vFloat b[],
   char formb,
   vFloat matrix[]
);
Parameters
l

number of rows in matrix matrix; must be a multiple of 4.

m

if forma = ‘N’, m is the number of columns in matrix a ; if forma = ‘T’, m is the number of rows in matrix a. Also, if formb = ‘N’, m is the number of rows in matrix b; if formb = ‘T’, m is the number of columns in matrix b. m must be a multiple of 4.

n

number of columns in the matrix matrix; must be a multiple of 4.

a

a matrix with elements of type float. If forma = ‘N’, the matrix itself is used in the calculation and it has l rows and m columns. If forma = ‘T’, the transpose is used and a has m rows and l columns. Thus the matrix used in the calculation is l by m.

forma

selector with a value of ‘N’ or ‘T’.

b

a matrix with elements of type float. If formb = ‘N’, the matrix itself is used in the calculation and it has m rows and n columns. If formb = ‘T’, the transpose is used and b has n rows and m columns. Thus the matrix used in the calculation is m by n.

formb

selector with a value of ‘N’ or ‘T’.

matrix

destination matrix with l rows and n columns.

Discussion

Matrix a (or its transpose) is multiplied by matrix b (or its transpose); the result is stored in matrix matrix.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgemv

Multiplies a vector by a scalar. Multiplies a matrix by another scalar, then by a second vector, and adds the resulting vector to the first vector. This function can also perform the calculation with the transpose of the original matrix instead of the matrix itself. A selector parameter determines whether the transpose is used.

void vSgemv (
   char forma,
   int32_t m,
   int32_t n,
   float alpha,
   const vFloat a[],
   const vFloat x[],
   float beta,
   vFloat y[]
);
Parameters
forma

selects the variant computation to be performed: ‘T’ causes the transpose of matrix a to be used, ‘N’ causes a itself to be used.

m

number of rows in a. If forma = ‘N’, m is the length of vector y; if forma = ‘T’, m is the length of vector x; must be a multiple of 4.

n

number of columns in a. If forma = ‘N’, m is the length of vector x; if forma = ‘T’, m is the length of vector y; must be a multiple of 4.

alpha

scalar multiplier for matrix a.

a

m by n matrix with elements of type float.

x

vector with elements of type float.

beta

scalar multiplier for vector y.

y

destination vector with n elements of type float.

Discussion

Vector y is multiplied by beta. Matrix a is multiplied by alpha. Then if forma = ‘N’, a is multiplied by vector x; if forma = ‘T’, the transpose of a is multiplied by x. The resulting vector is added to vector y, and the results are stored in y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgemx

Multiplies a matrix by a scalar and then by a vector, and adds the resulting vector to a second vector.

void vSgemx (
   int32_t m,
   int32_t n,
   float alpha,
   const vFloat a[],
   const vFloat x[],
   vFloat y[]
);
Parameters
m

number of rows in a, and the length of vector y; must be a multiple of 4.

n

number of columns in a, and the length of vector x; must be a multiple of 4.

alpha

scalar multiplier for matrix a.

a

m by n matrix with elements of type float.

x

vector with elements of type float.

y

destination vector with n elements of type float.

Discussion

Matrix a is multiplied by alpha and then by vector x; the resulting vector is added to vector y, and the results are stored in y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgesub

Subtracts two general matrices or their transposes.

void vSgesub (
   int32_t height,
   int32_t width,
   const vFloat a[],
   char forma,
   const vFloat b[],
   char formb,
   vFloat c[]
);
Parameters
height

number of rows in the matrices to be subtracted; must be a multiple of 4.

width

number of columns in the matrices to be subtracted; must be a multiple of 4.

a

a matrix with elements of type float. If forma = ‘N’, the matrix itself is used in the calculation and it has height rows and width columns. If forma = ‘T’, the transpose is used and a has width rows and height columns.

forma

selector with a value of ‘N’ or ‘T’.

b

a matrix with elements of type float. If formb = ‘N’, the matrix itself is used in the calculation and it has height rows and width columns. If formb = ‘T’, the transpose is used and b has width rows and height columns.

formb

selector with a value of ‘N’ or ‘T’.

c

destination matrix with height rows and width columns.

Discussion

Matrix b (or its transpose) is subtracted from matrix a (or its transpose); the result is stored in mactrix c.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgetmi

Transposes a matrix in place.

void vSgetmi (
   int32_t size,
   vFloat x[]
);
Parameters
size

number of rows and columns in matrix x; must be a multiple of 4.

x

square matrix with size rows and size columns.

Discussion

The matrix x is transposed in place.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgetmo

Transposes a matrix out of place.

void vSgetmo (
   int32_t height,
   int32_t width,
   const vFloat x[],
   vFloat y[]
);
Parameters
height

number of rows in matrix x and number of columns in matrix y; must be a multiple of 4.

width

number of columns in matrix x and number of rows in matrix y; must be a multiple of 4.

x

matrix with height rows and width columns.

y

matrix with width rows and height columns.

Discussion

The matrix x is transposed into matrix y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSgevv

Multiplies two matrices and places the results in a third matrix.

void vSgevv (
   int32_t l,
   int32_t n,
   const vFloat A[],
   const vFloat B[],
   vFloat M[]
);
Parameters
l

number of rows in matrix a and in matrix m; must be a multiple of 4.

n

number of columns in matrix b and in matrix m; must be a multiple of 4.

A

matrix with l rows.

B

matrix with n columns.

M

matrix with l rows and n columns.

Discussion

The matrices a and b are multiplied and the result is stored in matrix m.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vsignbitf

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.

vUInt32 vsignbitf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vsincosf

Simultaneously computes sine and cosine of values in a vector.

vFloat vsincosf (
   vFloat arg,
   vFloat *sine_result
);
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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vfp.h

vsinf

For each vector element, calculates the sine.

vFloat vsinf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vsinhf

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

vFloat vsinhf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vSnaxpy

Performs the computation of vSaxpy n times, using a different multiplier each time.

void vSnaxpy (
   int32_t n,
   int32_t m,
   const vFloat a[],
   const vFloat x[],
   vFloat y[]
);
Parameters
n

Number of elements in vector a; must be a multiple of 4.

m

Number of elements in each of the vectors x and y; must be a multiple of 4.

x

A vector array of float values.

y

A second vector array of float values.

Discussion

For i = 0 to n-1, the elements of x are multiplied by a[i] and added to the corresponding elements of y. The results are accumulated and stored in y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSndot

Computes the dot products of n pairs of vectors, accumulating or storing the results in an array of n float values.

void vSndot (
   int32_t n,
   int32_t m,
   float s[],
   int32_t isw,
   const vFloat x[],
   const vFloat y[]
);
Parameters
n

Number of dot products to compute, and number of elements in vector s ; must be a multiple of 4.

m

Number of elements in the vectors whose dot products are computed; must be a multiple of 4.

s

Destination vector; the n dot products are accumulated or stored here.

isw

A key that selects one of the four variants of this function: see Discussion below.

x

A matrix whose rows are n floating-point vectors, each containing m values.

y

A second matrix whose rows are n floating-point vectors, each containing m values.

Discussion

For i = 0 to n-1, the dot product of vectors x[i] and y[i] is computed. The dot product is accumulated or stored in s[i], according to the value of isw:

  • if isw = 1, the dot product is stored in s[i].

  • if isw = 2, the dot product is negated and then stored in s[i].

  • if isw = 3, the dot product is added to the value in s[i].

  • if isw = 4, the dot product is negated and then added to the value in s[i].

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSnorm2

Finds the Euclidean length of a vector.

float vSnorm2 (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The Euclidean length of x.

Discussion

Input is not scaled.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSnrm2

Finds the Euclidean length of a vector.

float vSnrm2 (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The Euclidean length of x.

Discussion

Input is scaled to avoid destructive underflow and overflow.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vsqrtf

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

vFloat vsqrtf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vSrot

Applies planar rotation to a set of n points whose x and y coordinates are contained in two arrays of vectors.

void vSrot (
   int32_t n,
   vFloat x[],
   vFloat y[],
   float c,
   float s
);
Parameters
n

number of points to be rotated; must be a multiple of 4.

x

vector with n/4 elements of type vector float, representing the x-coordinates of the points.

y

vector with n/4 elements of type vector float, representing the y-coordinates of the points.

c

cosine of the angle of rotation.

s

sine of the angle of rotation.

Discussion

The coordinates are modified in place in the vectors in arrays x and y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSscal

Scales a vector in place.

void vSscal (
   int32_t n,
   float alpha,
   vFloat x[]
);
Parameters
n

number of elements in vector x; must be a multiple of 4.

alpha

scaling factor.

v

vector with n elements of type float.

Discussion

Each element of vector x is multiplied in place by alpha.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSsum

Finds the sum of the values of the elements in a vector.

float vSsum (
   int32_t count,
   const vFloat x[]
);
Parameters
count

Number of elements in the vector x; must be a multiple of 4.

x

A vector array of float values.

Return Value

The sum of the values of the elements in the vector.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSswap

Interchanges the elements of two vectors.

void vSswap (
   int32_t n,
   vFloat x[],
   vFloat y[]
);
Parameters
n

number of elements in vectors x and y; must be a multiple of 4.

x

vector with n elements of type float.

y

vector with n elements of type float.

Discussion

Each element of vector x is replaced by the corresponding element of y, and vice versa.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSyax

Multiplies each element of a vector and stores the results in a second vector.

void vSyax (
   int32_t n,
   float alpha,
   const vFloat x[],
   vFloat y[]
);
Parameters
n

number of elements in vectors x and y; must be a multiple of 4.

alpha

multiplier.

x

source vector with n elements of type float.

y

destination vector with n elements of type float.

Discussion

Each element of vector x is multiplied by alpha, and stored in the corresponding element of y.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vSzaxpy

Multiplies a vector by a scalar, adds it to a second vector, and stores the result in a third vector.

void vSzaxpy (
   int32_t n,
   float alpha,
   const vFloat x[],
   const vFloat yY[],
   vFloat z[]
);
Parameters
n

number of elements in vectors x, y, and z; must be a multiple of 4.

alpha

multiplier.

x

source vector with n elements of type float.

yY

source vector with n elements of type float.

z

destination vector with n elements of type float.

Discussion

Each element of vector x is multiplied by alpha, then the corresponding element of yY is added. Results are stored in the corresponding elements of z.

Availability
  • OS X version 10.0 and later.
Declared In
vectorOps.h

vtablelookup

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

vUInt32 vtablelookup (
   vSInt32 Index_Vect,
   uint32_t *Table
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vtanf

For each vector element, calculates the tangent.

vFloat vtanf (
   vFloat arg
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vtanhf

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

vFloat vtanhf (
   vFloat X
);
Availability
  • OS X version 10.0 and later.
Declared In
vfp.h

vU1024Add

Unsigned 1024-bit addition (modular arithmetic).

void vU1024Add (
   const vU1024 *a,
   const vU1024 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024AddS

Unsigned 1024-bit addition with saturation (clipping).

void vU1024AddS (
   const vU1024 *a,
   const vU1024 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024Divide

Unsigned 1024-bit division.

void vU1024Divide (
   const vU1024 *numerator,
   const vU1024 *divisor,
   vU1024 *result,
   vU1024 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024HalfMultiply

Unsigned 1024-bit multiplication; result is the same width as multiplicands.

void vU1024HalfMultiply (
   const vU1024 *a,
   const vU1024 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024Mod

Unsigned 1024-bit mod.

void vU1024Mod (
   const vU1024 *numerator,
   const vU1024 *divisor,
   vU1024 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024Neg

Unsigned 1024-bit negation.

void vU1024Neg (
   const vU1024 *a,
   vU1024 *result
);
Parameters
a

The value to negate.

Return Value

Returns the negated value through the result parameter.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024Sub

Unsigned 1024-bit subtraction (modular arithmetic).

void vU1024Sub (
   const vU1024 *a,
   const vU1024 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU1024SubS

Unsigned 1024-bit subtraction with saturation (clipping).

void vU1024SubS (
   const vU1024 *a,
   const vU1024 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU128Add

Unsigned 128-bit addition (modular arithmetic).

vUInt32 vU128Add (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vU128AddS

Unsigned 128-bit addition with saturation (clipping).

vUInt32 vU128AddS (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vU128Divide

Unsigned 128-bit division.

vUInt32 vU128Divide (
   vUInt32 vN,
   vUInt32 vD,
   vUInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU128FullMultiply

Unsigned 128-bit multiplication; result is twice as wide as multiplicands.

void vU128FullMultiply (
   const vU128 *a,
   const vU128 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU128HalfMultiply

Unsigned 128-bit multiplication; results are same width as multiplicands.

vUInt32 vU128HalfMultiply (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU128Neg

Unsigned 128-bit negation.

vUInt32 vU128Neg (
   vUInt32 vA
);
Parameters
vA

The value to negate.

Return Value

Returns the negated value.

Availability
  • Available in OS X v10.5 and later.
Declared In
vBasicOps.h

vU128Sub

Unsigned 128-bit subtraction (modular arithmetic).

vUInt32 vU128Sub (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vU128SubS

Unsigned 128-bit subtraction with saturation (clipping).

vUInt32 vU128SubS (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU16Divide

Unsigned 16-bit division.

vUInt16 vU16Divide (
   vUInt16 vN,
   vUInt16 vD,
   vUInt16 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU16HalfMultiply

Unsigned 16-bit multiplication; results are same width as multiplicands.

vUInt16 vU16HalfMultiply (
   vUInt16 vA,
   vUInt16 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU256Add

Unsigned 256-bit addition (modular arithmetic).

void vU256Add (
   const vU256 *a,
   const vU256 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256AddS

Unsigned 256-bit addition with saturation (clipping).

void vU256AddS (
   const vU256 *a,
   const vU256 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256Divide

Unsigned 256-bit division.

void vU256Divide (
   const vU256 *numerator,
   const vU256 *divisor,
   vU256 *result,
   vU256 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256FullMultiply

Unsigned 256-bit multiplication; result is twice as wide as multiplicands.

void vU256FullMultiply (
   const vU256 *a,
   const vU256 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256HalfMultiply

Unsigned 256-bit multiplication; result is the same width as multiplicands.

void vU256HalfMultiply (
   const vU256 *a,
   const vU256 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256Mod

Unsigned 256-bit mod.

void vU256Mod (
   const vU256 *numerator,
   const vU256 *divisor,
   vU256 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256Neg

Unsigned 256-bit negation.

void vU256Neg (
   const vU256 *a,
   vU256 *result
);
Parameters
vA

The value to negate.

Return Value

Returns the negated value.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256Sub

Unsigned 256-bit subtraction (modular arithmetic).

void vU256Sub (
   const vU256 *a,
   const vU256 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU256SubS

Unsigned 256-bit subtraction with saturation (clipping).

void vU256SubS (
   const vU256 *a,
   const vU256 *b,
   vU256 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU32Divide

Unsigned 32-bit division.

vUInt32 vU32Divide (
   vUInt32 vN,
   vUInt32 vD,
   vUInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU32FullMulEven

Unsigned 32-bit multiplication; results are twice as wide as multiplicands, even-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vUInt32 vU32FullMulEven (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU32FullMulOdd

Unsigned 32-bit multiplication; results are twice as wide as multiplicands, odd-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vUInt32 vU32FullMulOdd (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU32HalfMultiply

Unsigned 32-bit multiplication; results are same width as multiplicands.

vUInt32 vU32HalfMultiply (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU512Add

Unsigned 512-bit addition (modular arithmetic).

void vU512Add (
   const vU512 *a,
   const vU512 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512AddS

Unsigned 512-bit addition with saturation (clipping).

void vU512AddS (
   const vU512 *a,
   const vU512 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512Divide

Unsigned 512-bit division.

void vU512Divide (
   const vU512 *numerator,
   const vU512 *divisor,
   vU512 *result,
   vU512 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512FullMultiply

Unsigned 512-bit multiplication; result is twice as wide as multiplicands.

void vU512FullMultiply (
   const vU512 *a,
   const vU512 *b,
   vU1024 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512HalfMultiply

Unsigned 512-bit multiplication; result is the same width as multiplicands.

void vU512HalfMultiply (
   const vU512 *a,
   const vU512 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512Mod

Unsigned 512-bit mod.

void vU512Mod (
   const vU512 *numerator,
   const vU512 *divisor,
   vU512 *remainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512Neg

Unsigned 512-bit negation.

void vU512Neg (
   const vU512 *a,
   vU512 *result
);
Parameters
a

The value to negate.

Return Value

Returns the negated value through the result parameter.

Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512Sub

Unsigned 512-bit subtraction (modular arithmetic).

void vU512Sub (
   const vU512 *a,
   const vU512 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU512SubS

Unsigned 512-bit subtraction with saturation (clipping).

void vU512SubS (
   const vU512 *a,
   const vU512 *b,
   vU512 *result
);
Availability
  • OS X version 10.0 and later.
Declared In
vBigNum.h

vU64Add

Unsigned 64-bit addition (modular arithmetic).

vUInt32 vU64Add (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64AddS

Unsigned 64-bit addition with saturation (clipping).

vUInt32 vU64AddS (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64Divide

Unsigned 64-bit division.

vUInt32 vU64Divide (
   vUInt32 vN,
   vUInt32 vD,
   vUInt32 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64FullMulEven

Unsigned 64-bit multiplication; results are twice as wide as multiplicands, even-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vUInt32 vU64FullMulEven (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64FullMulOdd

Unsigned 64-bit multiplication; results are twice as wide as multiplicands, odd-numbered elements of multiplicand vectors are used. Note the big-endian convention: the leftmost element is element 0.

vUInt32 vU64FullMulOdd (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h

vU64HalfMultiply

Unsigned 64-bit multiplication; results are same width as multiplicands.

vUInt32 vU64HalfMultiply (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64Neg

Unsigned 64-bit negation.

vUInt32 vU64Neg (
   vUInt32 vA
);
Parameters
vA

The value to negate.

Return Value

Returns the negated value.

Availability
  • Available in OS X v10.0 and later.
Declared In
vBasicOps.h

vU64Sub

Unsigned 64-bit subtraction (modular arithmetic).

vUInt32 vU64Sub (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU64SubS

Unsigned 64-bit subtraction with saturation (clipping).

vUInt32 vU64SubS (
   vUInt32 vA,
   vUInt32 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU8Divide

Unsigned 8-bit division.

vUInt8 vU8Divide (
   vUInt8 vN,
   vUInt8 vD,
   vUInt8 *vRemainder
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vU8HalfMultiply

Unsigned 8-bit multiplication; results are same width as multiplicands.

vUInt8 vU8HalfMultiply (
   vUInt8 vA,
   vUInt8 vB
);
Availability
  • OS X version 10.0 and later.
Declared In
vBasicOps.h

vvacos

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

void vvacos (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvacosf

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

void vvacosf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvacosh

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

void vvacosh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvacoshf

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

void vvacoshf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvasin

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

void vvasin (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvasinf

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

void vvasinf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvasinh

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

void vvasinh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvasinhf

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

void vvasinhf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatan

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

void vvatan (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatan2

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

void vvatan2 (
   double *,
   const double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatan2f

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

void vvatan2f (
   float *,
   const float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatanf

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

void vvatanf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatanh

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

void vvatanh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvatanhf

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

void vvatanhf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvceil

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

void vvceil (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvceilf

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

void vvceilf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcopysign

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

void vvcopysign (
   double *,
   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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvcopysignf

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

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvcos

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

void vvcos (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcosf

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

void vvcosf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcosh

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

void vvcosh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcoshf

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

void vvcoshf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcosisin

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

void vvcosisin (
   __double_complex_t *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcosisinf

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.

void vvcosisinf (
   __float_complex_t *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvcospi

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvcospif

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvdiv

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

void vvdiv (
   double *,
   const double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvdivf

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

void vvdivf (
   float *,
   const float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvexp

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

void vvexp (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvexp2

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvexp2f

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvexpf

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

void vvexpf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
OSvKernDSPLib.h

vvexpm1

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

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].

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvexpm1f

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

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvfabs

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvfabsf

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvfloor

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

void vvfloor (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvfloorf

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

void vvfloorf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvfmod

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

void vvfmod (
   double *,
   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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvfmodf

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

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvint

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

void vvint (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvintf

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

void vvintf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvlog

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

void vvlog (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvlog10

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

void vvlog10 (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvlog10f

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

void vvlog10f (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvlog1p

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvlog1pf

Computes the natural logarithm of a value plus 1.

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvlog2

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvlog2f

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvlogb

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvlogbf

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

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvlogf

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

void vvlogf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvnextafter

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

void vvnextafter (
   double *,
   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]).

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvnextafterf

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

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]).

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvnint

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

void vvnint (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvnintf

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

void vvnintf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvpow

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

void vvpow (
   double *,
   const double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvpowf

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

void vvpowf (
   float *,
   const float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvrec

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

void vvrec (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvrecf

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

void vvrecf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvremainder

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.

void vvremainder (
   double *,
   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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvremainderf

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

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.

Availability
  • Available in OS X v10.5 and later.
Declared In
vForce.h

vvrsqrt

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

void vvrsqrt (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvrsqrtf

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

void vvrsqrtf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsin

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

void vvsin (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsincos

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

void vvsincos (
   double *,
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsincosf

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

void vvsincosf (
   float *,
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsinf

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

void vvsinf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsinh

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

void vvsinh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsinhf

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

void vvsinhf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsinpi

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvsinpif

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvsqrt

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

void vvsqrt (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvsqrtf

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

void vvsqrtf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvtan

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

void vvtan (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvtanf

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

void vvtanf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvtanh

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

void vvtanh (
   double *,
   const double *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvtanhf

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

void vvtanhf (
   float *,
   const float *,
   const int *
);
Availability
  • Available in OS X v10.4 and later.
Declared In
vForce.h

vvtanpi

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

vvtanpif

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

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.

Availability
  • Available in OS X v10.7 and later.
Declared In
vForce.h

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.

vUInt8

A 128-bit vector packed with unsigned char values.

typedef vector unsigned char vUInt8;
Availability
  • Available in OS X v10.4 and later.
Declared In
OSvKernDSPLib.h

vSInt8

A 128-bit vector packed with signed char values.

typedef vector signed char vSInt8;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vUInt16

A 128-bit vector packed with unsigned short values.

typedef vector unsigned short vUInt16;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vSInt16

A 128-bit vector packed with signed short values.

typedef vector signed short vSInt16;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vUInt32

A 128-bit vector packed with unsigned int values.

typedef vector unsigned int vUInt32;
Availability
  • Available in OS X v10.4 and later.
Declared In
OSvKernDSPLib.h

vSInt32

A 128-bit vector packed with signed int values.

typedef vector signed int vSInt32;
Availability
  • Available in OS X v10.4 and later.
Declared In
OSvKernDSPLib.h

vUInt64

A 128-bit vector packed with uint64_t values.

typedef vector unsigned int vUInt64;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vSInt64

A 128-bit vector packed with int64_t values.

typedef vector signed int vSInt64;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vFloat

A 128-bit vector packed with float values.

typedef vector float vFloat;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

vDouble

A 128-bit vector packed with double values.

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

vBool32

A 128-bit vector packed with bool int values.

typedef vector bool int vBool32;
Availability
  • Available in OS X v10.4 and later.
Declared In
vecLibTypes.h

__float_complex_t

A single-precision complex number type.

typedef complex float __float_complex_t;
Declared In

__double_complex_t

A double-precision complex number type.

typedef complex double __double_complex_t;
Declared In

vU128

A union containing one vUInt32 vector or four 32-bit integers, representing a 128-bit unsigned integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vU128 {
   vUInt32    v;
   struct {
         vUInt32  v1;
   }        vs;
   struct {
         UInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   LSW;
   }        s;
};
typedef union vU128 vU128;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vS128

A union containing one vSInt32 vector or four 32-bit integers, representing a 128-bit signed integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vS128 {
   vUInt32    v;
   struct {
         vUInt32  v1;
   }        vs;
   struct {
         SInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   LSW;
   }        s;
};
typedef union vS128 vS128;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vU256

A union containing an array or structure of two vUInt32 vectors or eight 32-bit integers, representing a 256-bit unsigned integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vU256 {
   vUInt32    v[2];
   struct {
         vUInt32  v1;
         vUInt32  v2;
   }        vs;
   struct {
         UInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   LSW;
   }        s;
};
typedef union vU256 vU256;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vS256

A union containing an array or structure of two vUInt32 vectors or eight 32-bit integers, representing a 256-bit signed integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vS256 {
   vUInt32    v[2];
   struct {
         vUInt32  v1;
         vUInt32  v2;
   }        vs;
   struct {
         SInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   LSW;
   }        s;
};
typedef union vS256 vS256;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vU512

A union containing an array or structure of four vUInt32 vectors or sixteen 32-bit integers, representing a 256-bit unsigned integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vU512 {
   vUInt32    v[4];
   struct {
         vUInt32  v1;
         vUInt32  v2;
         vUInt32  v3;
         vUInt32  v4;
   }        vs;
   struct {
         UInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   d8;
         UInt32   d9;
         UInt32   d10;
         UInt32   d11;
         UInt32   d12;
         UInt32   d13;
         UInt32   d14;
         UInt32   d15;
         UInt32   LSW;
   }        s;
};
typedef union vU512 vU512;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vS512

A union containing an array or structure of four vUInt32 vectors or sixteen 32-bit integers, representing a 256-bit signed integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vS512 {
   vUInt32    v[4];
   struct {
         vUInt32  v1;
         vUInt32  v2;
         vUInt32  v3;
         vUInt32  v4;
   }        vs;
   struct {
         SInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   d8;
         UInt32   d9;
         UInt32   d10;
         UInt32   d11;
         UInt32   d12;
         UInt32   d13;
         UInt32   d14;
         UInt32   d15;
         UInt32   LSW;
   }        s;
};
typedef union vS512 vS512;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vU1024

A union containing an array or structure of eight vUInt32 vectors or thirty-two 32-bit integers, representing a 1024-bit unsigned integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vU1024 {
   vUInt32    v[8];
   struct {
         vUInt32  v1;
         vUInt32  v2;
         vUInt32  v3;
         vUInt32  v4;
         vUInt32  v5;
         vUInt32  v6;
         vUInt32  v7;
         vUInt32  v8;
   }        vs;
   struct {
         UInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   d8;
         UInt32   d9;
         UInt32   d10;
         UInt32   d11;
         UInt32   d12;
         UInt32   d13;
         UInt32   d14;
         UInt32   d15;
         UInt32   d16;
         UInt32   d17;
         UInt32   d18;
         UInt32   d19;
         UInt32   d20;
         UInt32   d21;
         UInt32   d22;
         UInt32   d23;
         UInt32   d24;
         UInt32   d25;
         UInt32   d26;
         UInt32   d27;
         UInt32   d28;
         UInt32   d29;
         UInt32   d30;
         UInt32   d31;
         UInt32   LSW;
   }        s;
};
typedef union vU1024 vU1024;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h

vS1024

A union containing an array or structure of eight vUInt32 vectors or thirty-two 32-bit integers, representing a 1024-bit signed integer. Conditional definitions provide compatibility with both PowerPC and Intel architectures; see the header file for details.

union vS1024 {
   vUInt32    v[8];
   struct {
         vUInt32  v1;
         vUInt32  v2;
         vUInt32  v3;
         vUInt32  v4;
         vUInt32  v5;
         vUInt32  v6;
         vUInt32  v7;
         vUInt32  v8;
   }        vs;
   struct {
         SInt32   MSW;
         UInt32   d2;
         UInt32   d3;
         UInt32   d4;
         UInt32   d5;
         UInt32   d6;
         UInt32   d7;
         UInt32   d8;
         UInt32   d9;
         UInt32   d10;
         UInt32   d11;
         UInt32   d12;
         UInt32   d13;
         UInt32   d14;
         UInt32   d15;
         UInt32   d16;
         UInt32   d17;
         UInt32   d18;
         UInt32   d19;
         UInt32   d20;
         UInt32   d21;
         UInt32   d22;
         UInt32   d23;
         UInt32   d24;
         UInt32   d25;
         UInt32   d26;
         UInt32   d27;
         UInt32   d28;
         UInt32   d29;
         UInt32   d30;
         UInt32   d31;
         UInt32   LSW;
   }        s;
};
typedef union vS1024 vS1024;
Availability
  • Available in OS X v10.4 and later.
Declared In
vBigNum.h