vecLib Reference
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 wellknown libraries which are described in detail in external references:

cblas.h
andvblas.h
are the interfaces to Apple’s implementations of BLAS. You can find reference documentation in BLAS Reference. Additional documentation on the BLAS standard, including reference implementations, can be found on the web starting from the BLAS FAQ page at these URLs: http://www.netlib.org/blas/faq.html and http://www.netlib.org/blas/blastforum/blastforum.html. 
clapack.h is the interface to Apple’s implementation of LAPACK. Documentation of the LAPACK interfaces, including reference implementations, can be found on the web starting from the LAPACK FAQ page at this URL: http://netlib.org/lapack/faq.html
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 128bit 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 128bit 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 8bit values packed into 128bit vectors.
vfp.h
vfp.h declares a set of floatingpoint arithmetic, transcendental and trigonometric functions, on 128bit vectors, using the floatingpoint 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 singleprecision floatingpoint data. For example, vcosf
is the singleprecision 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 128bit 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 singleprecision floatingpoint data and one for doubleprecision data. The singleprecision forms have the suffix “f”, while the doubleprecision forms have no suffix. For example, vvcosf
is the singleprecision cosine function, while vvcos
is the doubleprecision 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()
andvvsincos()
, 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 128bit vectors containing singleprecision floatingpoint 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 128bit vectors.
vBigNum.h defines its own set of data types to represent large integer quantities, such as vS128
for a signed, 128bit integer or vU1024
for an unsigned, 1024bit integer. The function names begin with the data type name, followed by the name of the operation. For example, vS512Add
performs addition of two 128bit 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 128bit vectors, and the operations execute on the available vectorprocessing 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:
Functions by Task
Shift and Rotate Functions (from vBasicOps.h)

vLL128Shift

vLR128Shift

vLL64Shift

vLL64Shift2

vLR64Shift

vLR64Shift2

vA64Shift

vA64Shift2

vA128Shift

vL64Rotate

vR64Rotate

vL64Rotate2

vR64Rotate2

vL128Rotate

vR128Rotate
Integer Arithmetic Functions (from vBasicOps.h)

vU64Add

vU64AddS

vS64Add

vS64AddS

vU128Add

vU128AddS

vS128Add

vS128AddS

vU64Sub

vU64SubS

vS64Sub

vS64SubS

vU128Sub

vU128SubS

vS128Sub

vS128SubS

vU8HalfMultiply

vS8HalfMultiply

vU16HalfMultiply

vS16HalfMultiply

vU32HalfMultiply

vS32HalfMultiply

vU64HalfMultiply

vS64HalfMultiply

vU128HalfMultiply

vS128HalfMultiply

vU32FullMulEven

vU32FullMulOdd

vS32FullMulEven

vS32FullMulOdd

vU64FullMulEven

vU64FullMulOdd

vS64FullMulEven

vS64FullMulOdd

vU8Divide

vS8Divide

vU16Divide

vS16Divide

vU32Divide

vS32Divide

vU64Divide

vS64Divide

vU128Divide

vS128Divide
FloatingPoint 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)
ArrayOriented Arithmetic and Auxiliary Functions (from vForce.h)

vvceil

vvceilf

vvcopysign

vvcopysignf

vvdiv

vvdivf

vvfabs

vvfabsf

vvfloor

vvfloorf

vvfmod

vvfmodf

vvint

vvintf

vvnextafter

vvnextafterf

vvnint

vvnintf

vvrsqrt

vvrsqrtf

vvsqrt

vvsqrtf

vvrec

vvrecf

vvremainder

vvremainderf
ArrayOriented Exponential and Logarithmic Functions (from vForce.h)

vvexp

vvexpf

vvexp2

vvexp2f

vvexpm1

vvexpm1f

vvlog

vvlogf

vvlog1p

vvlog1pf

vvlog2

vvlog2f

vvlog10

vvlog10f

vvlogb

vvlogbf
ArrayOriented Power Functions (from vForce.h)
ArrayOriented Trigonometric Functions (from vForce.h)

vvsin

vvsinf

vvsinpi

vvsinpif

vvcos

vvcosf

vvcospi

vvcospif

vvcosisin

vvcosisinf

vvsincos

vvsincosf

vvtan

vvtanf

vvtanpi

vvtanpif

vvasin

vvasinf

vvacos

vvacosf

vvatan

vvatanf

vvatan2

vvatan2f
ArrayOriented Hyperbolic Functions (from vForce.h)
Shift and Rotate Functions on Big Numbers (from vBigNum.h)

vLL256Shift

vLR256Shift

vA256Shift

vLL512Shift

vLR512Shift

vA512Shift

vLL1024Shift

vLR1024Shift

vA1024Shift

vL256Rotate

vR256Rotate

vL512Rotate

vR512Rotate

vL1024Rotate

vR1024Rotate
Arithmetic Functions on Big Numbers (from vBigNum.h)

vU256Add

vU256AddS

vS256Add

vS256AddS

vU512Add

vU512AddS

vS512Add

vS512AddS

vU1024Add

vU1024AddS

vS1024Add

vS1024AddS

vU256Sub

vU256SubS

vS256Sub

vS256SubS

vU512Sub

vU512SubS

vS512Sub

vS512SubS

vU1024Sub

vU1024SubS

vS1024Sub

vS1024SubS

vU64Neg

vU128Neg

vU256Neg

vS64Neg

vS128Neg

vS256Neg

vU512Neg

vS512Neg

vU1024Neg

vS1024Neg

vU256Mod

vS256Mod

vU512Mod

vS512Mod

vU1024Mod

vS1024Mod

vU256HalfMultiply

vS256HalfMultiply

vU512HalfMultiply

vS512HalfMultiply

vU1024HalfMultiply

vS1024HalfMultiply

vU128FullMultiply

vS128FullMultiply

vU256FullMultiply

vS256FullMultiply

vU512FullMultiply

vS512FullMultiply

vU256Divide

vS256Divide

vU512Divide

vS512Divide

vU1024Divide

vS1024Divide
VectorScalar Linear Algebra Functions (from vectorOps.h)

vIsamax

vIsamin

vIsmax

vIsmin

vSasum

vSsum

vSaxpy

vSnaxpy

vScopy

vSdot

vSndot

vSnrm2

vSnorm2

vSrot

vSscal

vSswap

vSyax

vSzaxpy
MatrixVector Linear Algebra Functions (from vectorOps.h)
Matrix Operations (from vectorOps.h)
Deprecated Functions

vvfabf
Deprecated in OS X v10.7
Functions
vA1024Shift
1024bit 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
128bit 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 128bit vector as a single value to shift.
Availability
 OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h
vA256Shift
256bit 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
512bit 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
64bit 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 64bit values to shift.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vA64Shift2
64bit 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 64bit 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 floatingpoint values.
vFloat vceilf ( vFloat A );
Parameters
 A

The input vector.
Return Value
Returns a vector of floatingpoint 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 floatingpoint 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 floatingpoint values.
vFloat vfloorf ( vFloat A );
Parameters
 A

The input vector.
Return Value
Returns a vector of floatingpoint 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 floatingpoint values.
vFloat vintf ( vFloat A );
Parameters
 A

The input vector.
Return Value
Returns a vector of floatingpoint 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
1024bit 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
128bit 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 128bit vector as a single value to rotate.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vL256Rotate
256bit 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
512bit 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
64bit 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 64bit values to rotate.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vL64Rotate2
64bit 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 64bit values to rotate.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vLL1024Shift
1024bit 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
128bit 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 128bit vector as a single value to shift.
Availability
 Available in OS X v10.5 and later.
Declared In
vBasicOps.h
vLL256Shift
256bit 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
512bit 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
64bit logical left shift.
vUInt32 vLL64Shift ( vUInt32 vA, vUInt8 vShiftFactor );
Discussion
This function treats the vector as a pair of 64bit values to shift.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vLL64Shift2
64bit 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 64bit values to shift.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vlog10f
Computes the base10 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 base10 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
1024bit 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
128bit 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 128bit vector as a single value to shift.
Availability
 Available in OS X v10.5 and later.
Declared In
OSvKernDSPLib.h
vLR256Shift
256bit 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
512bit 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
64bit 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 64bit values to shift.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vLR64Shift2
64bit 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 64bit 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 floatingpoint 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 floatingpoint 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
1024bit 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
128bit 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 128bit vector as a single value to rotate.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vR256Rotate
256bit 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
512bit 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
64bit 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 64bit values to rotate.
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vR64Rotate2
64bit 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 64bit 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 floatingpoint 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 loworder 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 256bit 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 1024bit 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 1024bit 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 1024bit 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 128bit addition (modular arithmetic).
vSInt32 vS128Add ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS128AddS
Signed 128bit addition with saturation (clipping).
vSInt32 vS128AddS ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS128Divide
Signed 128bit division.
vSInt32 vS128Divide ( vSInt32 vN, vSInt32 vD, vSInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS128FullMultiply
Signed 128bit 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 128bit 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 128bit 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 128bit subtraction (modular arithmetic).
vSInt32 vS128Sub ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h
vS128SubS
Signed 128bit subtraction with saturation (clipping).
vSInt32 vS128SubS ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS16Divide
Signed 16bit division.
vSInt16 vS16Divide ( vSInt16 vN, vSInt16 vD, vSInt16 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS16HalfMultiply
Signed 16bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 32bit division.
vSInt32 vS32Divide ( vSInt32 vN, vSInt32 vD, vSInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS32FullMulEven
Signed 32bit multiplication; results are twice as wide as multiplicands, evennumbered elements of multiplicand vectors are used. Note the bigendian 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 32bit multiplication; results are twice as wide as multiplicands, oddnumbered elements of multiplicand vectors are used. Note the bigendian 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 32bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 64bit addition (modular arithmetic).
vSInt32 vS64Add ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS64AddS
Signed 64bit addition with saturation (clipping).
vSInt32 vS64AddS ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS64Divide
Signed 64bit division.
vSInt32 vS64Divide ( vSInt32 vN, vSInt32 vD, vSInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS64FullMulEven
Signed 64bit multiplication; results are twice as wide as multiplicands, evennumbered elements of multiplicand vectors are used. Note the bigendian 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 64bit multiplication; results are twice as wide as multiplicands, oddnumbered elements of multiplicand vectors are used. Note the bigendian 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 64bit 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 64bit 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 64bit subtraction (modular arithmetic).
vSInt32 vS64Sub ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS64SubS
Signed 64bit subtraction with saturation (clipping).
vSInt32 vS64SubS ( vSInt32 vA, vSInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS8Divide
Signed 8bit division.
vSInt8 vS8Divide ( vSInt8 vN, vSInt8 vD, vSInt8 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vS8HalfMultiply
Signed 8bit 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; ifformb
= ‘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 nonzero 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 n1, 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 floatingpoint vectors, each containing m values.
 y

A second matrix whose rows are n floatingpoint vectors, each containing m values.
Discussion
For i = 0 to n1, 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 xcoordinates of the points.  y

vector with n/4 elements of type
vector float
, representing the ycoordinates 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 1024bit 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 128bit addition (modular arithmetic).
vUInt32 vU128Add ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h
vU128AddS
Unsigned 128bit addition with saturation (clipping).
vUInt32 vU128AddS ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h
vU128Divide
Unsigned 128bit division.
vUInt32 vU128Divide ( vUInt32 vN, vUInt32 vD, vUInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU128FullMultiply
Unsigned 128bit 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 128bit 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 128bit 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 128bit subtraction (modular arithmetic).
vUInt32 vU128Sub ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
OSvKernDSPLib.h
vU128SubS
Unsigned 128bit subtraction with saturation (clipping).
vUInt32 vU128SubS ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU16Divide
Unsigned 16bit division.
vUInt16 vU16Divide ( vUInt16 vN, vUInt16 vD, vUInt16 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU16HalfMultiply
Unsigned 16bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 256bit 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 32bit division.
vUInt32 vU32Divide ( vUInt32 vN, vUInt32 vD, vUInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU32FullMulEven
Unsigned 32bit multiplication; results are twice as wide as multiplicands, evennumbered elements of multiplicand vectors are used. Note the bigendian 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 32bit multiplication; results are twice as wide as multiplicands, oddnumbered elements of multiplicand vectors are used. Note the bigendian 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 32bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 512bit 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 64bit addition (modular arithmetic).
vUInt32 vU64Add ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU64AddS
Unsigned 64bit addition with saturation (clipping).
vUInt32 vU64AddS ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU64Divide
Unsigned 64bit division.
vUInt32 vU64Divide ( vUInt32 vN, vUInt32 vD, vUInt32 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU64FullMulEven
Unsigned 64bit multiplication; results are twice as wide as multiplicands, evennumbered elements of multiplicand vectors are used. Note the bigendian 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 64bit multiplication; results are twice as wide as multiplicands, oddnumbered elements of multiplicand vectors are used. Note the bigendian 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 64bit 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 64bit 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 64bit subtraction (modular arithmetic).
vUInt32 vU64Sub ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU64SubS
Unsigned 64bit subtraction with saturation (clipping).
vUInt32 vU64SubS ( vUInt32 vA, vUInt32 vB );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU8Divide
Unsigned 8bit division.
vUInt8 vU8Divide ( vUInt8 vN, vUInt8 vD, vUInt8 *vRemainder );
Availability
 OS X version 10.0 and later.
Declared In
vBasicOps.h
vU8HalfMultiply
Unsigned 8bit 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 doubleprecision 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 singleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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..n1
.
void vvcospi ( double *, const double *, const int * );
Parameters
 y

An input array of doubleprecision floating point numbers
 x

An output array of doubleprecision 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..n1
.
void vvcospif ( float *, const float *, const int * );
Parameters
 y

An input array of singleprecision floating point values.
 x

An output array of singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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..n1
.
void vvexp2 ( double *, const double *, const int * );
Parameters
 y

An input array of doubleprecision floating point numbers
 x

An output array of doubleprecision 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..n1
.
void vvexp2f ( float *, const float *, const int * );
Parameters
 y

An input array of singleprecision floating point values.
 x

An output array of singleprecision 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 singleprecision 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 doubleprecision floating point numbers
 x

An output array of doubleprecision 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..n1
.
void vvfabs ( double *, const double *, const int * );
Parameters
 y

An input array of doubleprecision floating point numbers
 x

An output array of doubleprecision 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..n1
.
void vvfabsf ( float *, const float *, const int * );
Parameters
 y

An input array of singleprecision floating point values.
 x

An output array of singleprecision 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 doubleprecision 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 singleprecision 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..n1
.
void vvfmod ( double *, double *, const double *, const int * );
Parameters
 z

An output array of doubleprecision floating point numbers.
 y

Numerator input array of doubleprecision floating point numbers.
 x

Denominator input array of doubleprecision 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 count1
.
Availability
 Available in OS X v10.5 and later.
Declared In
vForce.h
vvint
For each doubleprecision 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 singleprecision 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 doubleprecision 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 doubleprecision 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 singleprecision 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..n1
.
void vvlog1p ( double *, const double *, const int * );
Parameters
 y

An output array of doubleprecision floating point numbers.
 x

An input array of doubleprecision 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 base2 logarithm of x[i]
for i
in 0..n1
.
void vvlog2 ( double *, const double *, const int * );
Parameters
 y

An output array of doubleprecision floating point numbers.
 x

An input array of doubleprecision 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..n1
.
void vvlog2f ( float *, const float *, const int * );
Parameters
 y

An output array of singleprecision floating point numbers.
 x

An input array of singleprecision 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..n1
.
void vvlogb ( double *, const double *, const int * );
Parameters
 y

An output array of doubleprecision floating point numbers.
 x

An input array of doubleprecision 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..n1
.
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 singleprecision 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 machinerepresentable value from y[i]
towards x[i]
for i
in 0..n1
.
void vvnextafter ( double *, double *, const double *, const int * );
Parameters
 z

An output array of doubleprecision floating point numbers.
 y

An input array of doubleprecision floating point numbers.
 x

An input array of doubleprecision 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 floatingpoint 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 machinerepresentable value from y[i]
towards x[i]
for i
in 0..n1
.
void vvnextafterf ( float *, const float *, const float *, const int * );
Parameters
 z

An array where results are stored on return.
 y

An array of floatingpoint values providing the direction relative to
x
.  x

An array of floatingpoint 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 floatingpoint 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 roundtoeven division of y[i]/x[i]
for each i
in 0..n1
.
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 roundtoeven 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 doubleprecision 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 singleprecision 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 doubleprecision 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 doubleprecision 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 singleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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..n1
.
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..n1
.
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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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 doubleprecision 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 singleprecision 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..n1
.
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..n1
.
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 32bit floatingpoint value must be aligned to a fourbyte boundary. Many routines in vecLib generate exceptions on unaligned data.
vUInt8
A 128bit 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 128bit 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 128bit 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 128bit 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 128bit 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 128bit 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 128bit 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 128bit 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 128bit vector packed with float
values.
typedef vector float vFloat;
Availability
 Available in OS X v10.4 and later.
Declared In
vecLibTypes.h
vDouble
A 128bit vector packed with double
values.
typedef double vDouble __attribute__((__vector_size__ (16)));
vBool32
A 128bit 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 singleprecision complex number type.
typedef complex float __float_complex_t;
Declared In
__double_complex_t
A doubleprecision complex number type.
typedef complex double __double_complex_t;
Declared In
vU128
A union containing one vUInt32
vector or four 32bit integers, representing a 128bit 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 32bit integers, representing a 128bit 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 32bit integers, representing a 256bit 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 32bit integers, representing a 256bit 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 32bit integers, representing a 256bit 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 32bit integers, representing a 256bit 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 thirtytwo 32bit integers, representing a 1024bit 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 thirtytwo 32bit integers, representing a 1024bit 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
Copyright © 2005, 2013 Apple Inc. All Rights Reserved. Terms of Use  Privacy Policy  Updated: 20130423