Yeppp!
 All Data Structures Functions Variables Enumerations Enumerator Groups Pages
yepCore: basic arithmetic operations.

Vector addition

enum YepStatus yepCore_Add_V8uV8u_V8u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep8u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements. More...
 
enum YepStatus yepCore_Add_V8uV8u_V16u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep16u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Add_V8sV8s_V16s (const Yep8s *restrict xPointer, const Yep8s *restrict yPointer, Yep16s *restrict sumPointer, YepSize length)
 Computes pairwise sums of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements. More...
 
enum YepStatus yepCore_Add_V16uV16u_V16u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep16u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Add_V16uV16u_V32u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep32u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Add_V16sV16s_V32s (const Yep16s *restrict xPointer, const Yep16s *restrict yPointer, Yep32s *restrict sumPointer, YepSize length)
 Computes pairwise sums of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements. More...
 
enum YepStatus yepCore_Add_V32uV32u_V32u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep32u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Add_V32uV32u_V64u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep64u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Add_V32sV32s_V64s (const Yep32s *restrict xPointer, const Yep32s *restrict yPointer, Yep64s *restrict sumPointer, YepSize length)
 Computes pairwise sums of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements. More...
 
enum YepStatus yepCore_Add_V64uV64u_V64u (const Yep64u *restrict xPointer, const Yep64u *restrict yPointer, Yep64u *restrict sumPointer, YepSize length)
 Computes pairwise sums of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Add_V32fV32f_V32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, Yep32f *restrict sumPointer, YepSize length)
 Computes pairwise sums of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements. More...
 
enum YepStatus yepCore_Add_V64fV64f_V64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, Yep64f *restrict sumPointer, YepSize length)
 Computes pairwise sums of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements. More...
 

Vector subtraction

enum YepStatus yepCore_Subtract_V8uV8u_V8u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep8u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V8uV8u_V16u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep16u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V8sV8s_V16s (const Yep8s *restrict xPointer, const Yep8s *restrict yPointer, Yep16s *restrict differencePointer, YepSize length)
 Computes pairwise differences of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V16uV16u_V16u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep16u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V16uV16u_V32u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep32u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V16sV16s_V32s (const Yep16s *restrict xPointer, const Yep16s *restrict yPointer, Yep32s *restrict differencePointer, YepSize length)
 Computes pairwise differences of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V32uV32u_V32u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep32u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V32uV32u_V64u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep64u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V32sV32s_V64s (const Yep32s *restrict xPointer, const Yep32s *restrict yPointer, Yep64s *restrict differencePointer, YepSize length)
 Computes pairwise differences of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V64uV64u_V64u (const Yep64u *restrict xPointer, const Yep64u *restrict yPointer, Yep64u *restrict differencePointer, YepSize length)
 Computes pairwise differences of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Subtract_V32fV32f_V32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, Yep32f *restrict differencePointer, YepSize length)
 Computes pairwise differences of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements. More...
 
enum YepStatus yepCore_Subtract_V64fV64f_V64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, Yep64f *restrict differencePointer, YepSize length)
 Computes pairwise differences of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements. More...
 

Vector negation

enum YepStatus yepCore_Negate_V8s_V8s (const Yep8s *restrict numberPointer, Yep8s *restrict negatedNumberPointer, YepSize length)
 Negates a vector of signed 8-bit integer elements, producing an array of signed 8-bit integer elements. More...
 
enum YepStatus yepCore_Negate_V16s_V16s (const Yep16s *restrict numberPointer, Yep16s *restrict negatedNumberPointer, YepSize length)
 Negates a vector of signed 16-bit integer elements, producing an array of signed 16-bit integer elements. More...
 
enum YepStatus yepCore_Negate_V32s_V32s (const Yep32s *restrict numberPointer, Yep32s *restrict negatedNumberPointer, YepSize length)
 Negates a vector of signed 32-bit integer elements, producing an array of signed 32-bit integer elements. More...
 
enum YepStatus yepCore_Negate_V64s_V64s (const Yep64s *restrict numberPointer, Yep64s *restrict negatedNumberPointer, YepSize length)
 Negates a vector of signed 64-bit integer elements, producing an array of signed 64-bit integer elements. More...
 
enum YepStatus yepCore_Negate_V32f_V32f (const Yep32f *restrict numberPointer, Yep32f *restrict negatedNumberPointer, YepSize length)
 Negates a vector of single-precision (32-bit) floating-point elements, producing an array of single-precision (32-bit) floating-point elements. More...
 
enum YepStatus yepCore_Negate_V64f_V64f (const Yep64f *restrict numberPointer, Yep64f *restrict negatedNumberPointer, YepSize length)
 Negates a vector of double-precision (64-bit) floating-point elements, producing an array of double-precision (64-bit) floating-point elements. More...
 

Vector elementwise multiplication

enum YepStatus yepCore_Multiply_V8uV8u_V8u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep8u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V8uV8u_V16u (const Yep8u *restrict xPointer, const Yep8u *restrict yPointer, Yep16u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V8sV8s_V16s (const Yep8s *restrict xPointer, const Yep8s *restrict yPointer, Yep16s *restrict productPointer, YepSize length)
 Computes pairwise products of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V16uV16u_V16u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep16u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V16uV16u_V32u (const Yep16u *restrict xPointer, const Yep16u *restrict yPointer, Yep32u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V16sV16s_V32s (const Yep16s *restrict xPointer, const Yep16s *restrict yPointer, Yep32s *restrict productPointer, YepSize length)
 Computes pairwise products of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V32uV32u_V32u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep32u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V32uV32u_V64u (const Yep32u *restrict xPointer, const Yep32u *restrict yPointer, Yep64u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V32sV32s_V64s (const Yep32s *restrict xPointer, const Yep32s *restrict yPointer, Yep64s *restrict productPointer, YepSize length)
 Computes pairwise products of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V64uV64u_V64u (const Yep64u *restrict xPointer, const Yep64u *restrict yPointer, Yep64u *restrict productPointer, YepSize length)
 Computes pairwise products of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements. More...
 
enum YepStatus yepCore_Multiply_V32fV32f_V32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, Yep32f *restrict productPointer, YepSize length)
 Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements. More...
 
enum YepStatus yepCore_Multiply_V64fV64f_V64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, Yep64f *restrict productPointer, YepSize length)
 Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements. More...
 

Vector elementwise multiplication and addition

enum YepStatus yepCore_MultiplyAdd_V32fV32fV32f_V32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, const Yep32f *restrict zPointer, Yep32f *restrict macPointer, YepSize length)
 Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays and then adds the third single-precision (32-bit) floating-point array to the result, producing an array of single-precision (32-bit) floating-point elements. More...
 
enum YepStatus yepCore_MultiplyAdd_V64fV64fV64f_V64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, const Yep64f *restrict zPointer, Yep64f *restrict macPointer, YepSize length)
 Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays and then adds the third double-precision (64-bit) floating-point array to the result, producing an array of double-precision (64-bit) floating-point elements. More...
 
enum YepStatus yepCore_MultiplyAdd_V32fS32fIV32f_IV32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, Yep32f *restrict zPointer, YepSize length)
 Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays and then adds the third single-precision (32-bit) floating-point array to the result, overwriting the third array. More...
 
enum YepStatus yepCore_MultiplyAdd_V64fS64fIV64f_IV64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, Yep64f *restrict zPointer, YepSize length)
 Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays and then adds the third double-precision (64-bit) floating-point array to the result, overwriting the third array. More...
 

Dot product

enum YepStatus yepCore_DotProduct_V32fV32f_S32f (const Yep32f *restrict xPointer, const Yep32f *restrict yPointer, Yep32f *restrict dotProductPointer, YepSize length)
 Computes the dot product of single-precision (32-bit) floating-point elements in two arrays. More...
 
enum YepStatus yepCore_DotProduct_V64fV64f_S64f (const Yep64f *restrict xPointer, const Yep64f *restrict yPointer, Yep64f *restrict dotProductPointer, YepSize length)
 Computes the dot product of double-precision (64-bit) floating-point elements in two arrays. More...
 

Summation of squares (squared L2 norm)

enum YepStatus yepCore_SumSquares_V32f_S32f (const Yep32f *restrict numberPointer, Yep32f *restrict sumSquaresPointer, YepSize length)
 Computes the sum of squares of single-precision (32-bit) floating-point elements in the input array. More...
 
enum YepStatus yepCore_SumSquares_V64f_S64f (const Yep64f *restrict numberPointer, Yep64f *restrict sumSquaresPointer, YepSize length)
 Computes the sum of squares of double-precision (64-bit) floating-point elements in the input array. More...
 

Detailed Description

Function Documentation

enum YepStatus yepCore_Add_V8uV8u_V8u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep8u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 8-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Add_V8uV8u_V16u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep16u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 16-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V8sV8s_V16s ( const Yep8s *restrict  xPointer,
const Yep8s *restrict  yPointer,
Yep16s *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 8-bit integer elements to be added.
[in]yPointerPointer the second input array of signed 8-bit integer elements to be added.
[out]sumPointerPointer the output array of signed 16-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V16uV16u_V16u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep16u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 16-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Add_V16uV16u_V32u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep32u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 32-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V16sV16s_V32s ( const Yep16s *restrict  xPointer,
const Yep16s *restrict  yPointer,
Yep32s *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 16-bit integer elements to be added.
[in]yPointerPointer the second input array of signed 16-bit integer elements to be added.
[out]sumPointerPointer the output array of signed 32-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V32uV32u_V32u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep32u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 32-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Add_V32uV32u_V64u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep64u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 64-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V32sV32s_V64s ( const Yep32s *restrict  xPointer,
const Yep32s *restrict  yPointer,
Yep64s *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 32-bit integer elements to be added.
[in]yPointerPointer the second input array of signed 32-bit integer elements to be added.
[out]sumPointerPointer the output array of signed 64-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Add_V64uV64u_V64u ( const Yep64u *restrict  xPointer,
const Yep64u *restrict  yPointer,
Yep64u *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 64-bit integer elements to be added.
[in]yPointerPointer the second input array of unsigned 64-bit integer elements to be added.
[out]sumPointerPointer the output array of unsigned 64-bit integer elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Add_V32fV32f_V32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
Yep32f *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of single-precision (32-bit) floating-point elements to be added.
[in]yPointerPointer the second input array of single-precision (32-bit) floating-point elements to be added.
[out]sumPointerPointer the output array of single-precision (32-bit) floating-point elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
enum YepStatus yepCore_Add_V64fV64f_V64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
Yep64f *restrict  sumPointer,
YepSize  length 
)

Computes pairwise sums of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of double-precision (64-bit) floating-point elements to be added.
[in]yPointerPointer the second input array of double-precision (64-bit) floating-point elements to be added.
[out]sumPointerPointer the output array of double-precision (64-bit) floating-point elements of the pairwise sums.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and sumPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or sumPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or sumPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Subtract_V8uV8u_V8u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep8u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 8-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Subtract_V8uV8u_V16u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep16u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 16-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V8sV8s_V16s ( const Yep8s *restrict  xPointer,
const Yep8s *restrict  yPointer,
Yep16s *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 8-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of signed 8-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of signed 16-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V16uV16u_V16u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep16u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 16-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Subtract_V16uV16u_V32u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep32u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 32-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V16sV16s_V32s ( const Yep16s *restrict  xPointer,
const Yep16s *restrict  yPointer,
Yep32s *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 16-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of signed 16-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of signed 32-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V32uV32u_V32u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep32u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 32-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Subtract_V32uV32u_V64u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep64u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 64-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V32sV32s_V64s ( const Yep32s *restrict  xPointer,
const Yep32s *restrict  yPointer,
Yep64s *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 32-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of signed 32-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of signed 64-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Subtract_V64uV64u_V64u ( const Yep64u *restrict  xPointer,
const Yep64u *restrict  yPointer,
Yep64u *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 64-bit integer elements to be subtracted from.
[in]yPointerPointer the second input array of unsigned 64-bit integer elements to be subtracted.
[out]differencePointerPointer the output array of unsigned 64-bit integer elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Subtract_V32fV32f_V32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
Yep32f *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of single-precision (32-bit) floating-point elements to be subtracted from.
[in]yPointerPointer the second input array of single-precision (32-bit) floating-point elements to be subtracted.
[out]differencePointerPointer the output array of single-precision (32-bit) floating-point elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
enum YepStatus yepCore_Subtract_V64fV64f_V64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
Yep64f *restrict  differencePointer,
YepSize  length 
)

Computes pairwise differences of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of double-precision (64-bit) floating-point elements to be subtracted from.
[in]yPointerPointer the second input array of double-precision (64-bit) floating-point elements to be subtracted.
[out]differencePointerPointer the output array of double-precision (64-bit) floating-point elements of the pairwise differences.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and differencePointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or differencePointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or differencePointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Negate_V8s_V8s ( const Yep8s *restrict  numberPointer,
Yep8s *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of signed 8-bit integer elements, producing an array of signed 8-bit integer elements.

Parameters
[in]numberPointerPointer the input array of signed 8-bit integer elements to be negated from.
[out]negatedNumberPointerPointer the output array of signed 8-bit integer negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Negate_V16s_V16s ( const Yep16s *restrict  numberPointer,
Yep16s *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of signed 16-bit integer elements, producing an array of signed 16-bit integer elements.

Parameters
[in]numberPointerPointer the input array of signed 16-bit integer elements to be negated from.
[out]negatedNumberPointerPointer the output array of signed 16-bit integer negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Negate_V32s_V32s ( const Yep32s *restrict  numberPointer,
Yep32s *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of signed 32-bit integer elements, producing an array of signed 32-bit integer elements.

Parameters
[in]numberPointerPointer the input array of signed 32-bit integer elements to be negated from.
[out]negatedNumberPointerPointer the output array of signed 32-bit integer negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Negate_V64s_V64s ( const Yep64s *restrict  numberPointer,
Yep64s *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of signed 64-bit integer elements, producing an array of signed 64-bit integer elements.

Parameters
[in]numberPointerPointer the input array of signed 64-bit integer elements to be negated from.
[out]negatedNumberPointerPointer the output array of signed 64-bit integer negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Negate_V32f_V32f ( const Yep32f *restrict  numberPointer,
Yep32f *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of single-precision (32-bit) floating-point elements, producing an array of single-precision (32-bit) floating-point elements.

Parameters
[in]numberPointerPointer the input array of single-precision (32-bit) floating-point elements to be negated from.
[out]negatedNumberPointerPointer the output array of single-precision (32-bit) floating-point negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Negate_V64f_V64f ( const Yep64f *restrict  numberPointer,
Yep64f *restrict  negatedNumberPointer,
YepSize  length 
)

Negates a vector of double-precision (64-bit) floating-point elements, producing an array of double-precision (64-bit) floating-point elements.

Parameters
[in]numberPointerPointer the input array of double-precision (64-bit) floating-point elements to be negated from.
[out]negatedNumberPointerPointer the output array of double-precision (64-bit) floating-point negated elements.
[in]lengthThe length of the arrays pointed by numberPointer and negatedNumberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the numberPointer or negatedNumberPointer arguments is null.
YepStatusMisalignedPointerOne of the numberPointer or negatedNumberPointer arguments is not properly aligned.
enum YepStatus yepCore_Multiply_V8uV8u_V8u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep8u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 8-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 8-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
enum YepStatus yepCore_Multiply_V8uV8u_V16u ( const Yep8u *restrict  xPointer,
const Yep8u *restrict  yPointer,
Yep16u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 8-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 8-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 8-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 16-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
enum YepStatus yepCore_Multiply_V8sV8s_V16s ( const Yep8s *restrict  xPointer,
const Yep8s *restrict  yPointer,
Yep16s *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of signed 8-bit integer elements in two arrays, producing an array of signed 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 8-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of signed 8-bit integer elements to be multiplied.
[out]productPointerPointer the output array of signed 16-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
enum YepStatus yepCore_Multiply_V16uV16u_V16u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep16u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 16-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 16-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Multiply_V16uV16u_V32u ( const Yep16u *restrict  xPointer,
const Yep16u *restrict  yPointer,
Yep32u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 16-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 16-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 16-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 32-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Multiply_V16sV16s_V32s ( const Yep16s *restrict  xPointer,
const Yep16s *restrict  yPointer,
Yep32s *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of signed 16-bit integer elements in two arrays, producing an array of signed 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 16-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of signed 16-bit integer elements to be multiplied.
[out]productPointerPointer the output array of signed 32-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_Multiply_V32uV32u_V32u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep32u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 32-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 32-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Multiply_V32uV32u_V64u ( const Yep32u *restrict  xPointer,
const Yep32u *restrict  yPointer,
Yep64u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 32-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 32-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 32-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 64-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Multiply_V32sV32s_V64s ( const Yep32s *restrict  xPointer,
const Yep32s *restrict  yPointer,
Yep64s *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of signed 32-bit integer elements in two arrays, producing an array of signed 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of signed 32-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of signed 32-bit integer elements to be multiplied.
[out]productPointerPointer the output array of signed 64-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE4.1, SSE2
enum YepStatus yepCore_Multiply_V64uV64u_V64u ( const Yep64u *restrict  xPointer,
const Yep64u *restrict  yPointer,
Yep64u *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of unsigned 64-bit integer elements in two arrays, producing an array of unsigned 64-bit integer elements.

Parameters
[in]xPointerPointer the first input array of unsigned 64-bit integer elements to be multiplied.
[in]yPointerPointer the second input array of unsigned 64-bit integer elements to be multiplied.
[out]productPointerPointer the output array of unsigned 64-bit integer elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
enum YepStatus yepCore_Multiply_V32fV32f_V32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
Yep32f *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays, producing an array of single-precision (32-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of single-precision (32-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of single-precision (32-bit) floating-point elements to be multiplied.
[out]productPointerPointer the output array of single-precision (32-bit) floating-point elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE
enum YepStatus yepCore_Multiply_V64fV64f_V64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
Yep64f *restrict  productPointer,
YepSize  length 
)

Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays, producing an array of double-precision (64-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of double-precision (64-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of double-precision (64-bit) floating-point elements to be multiplied.
[out]productPointerPointer the output array of double-precision (64-bit) floating-point elements of the pairwise products.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and productPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or productPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or productPointer arguments is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE2
enum YepStatus yepCore_MultiplyAdd_V32fV32fV32f_V32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
const Yep32f *restrict  zPointer,
Yep32f *restrict  macPointer,
YepSize  length 
)

Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays and then adds the third single-precision (32-bit) floating-point array to the result, producing an array of single-precision (32-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of single-precision (32-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of single-precision (32-bit) floating-point elements to be multiplied.
[in]zPointerPointer the input array of single-precision (32-bit) floating-point elements to be added to the intermediate multiplication result.
[out]macPointerPointer the output array of single-precision (32-bit) floating-point elements.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, zPointer, and macPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, zPointer, or macPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, zPointer, or macPointer arguments is not properly aligned.
enum YepStatus yepCore_MultiplyAdd_V64fV64fV64f_V64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
const Yep64f *restrict  zPointer,
Yep64f *restrict  macPointer,
YepSize  length 
)

Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays and then adds the third double-precision (64-bit) floating-point array to the result, producing an array of double-precision (64-bit) floating-point elements.

Parameters
[in]xPointerPointer the first input array of double-precision (64-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of double-precision (64-bit) floating-point elements to be multiplied.
[in]zPointerPointer the input array of double-precision (64-bit) floating-point elements to be added to the intermediate multiplication result.
[out]macPointerPointer the output array of double-precision (64-bit) floating-point elements.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, zPointer, and macPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, zPointer, or macPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, zPointer, or macPointer arguments is not properly aligned.
enum YepStatus yepCore_MultiplyAdd_V32fS32fIV32f_IV32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
Yep32f *restrict  zPointer,
YepSize  length 
)

Computes pairwise products of single-precision (32-bit) floating-point elements in two arrays and then adds the third single-precision (32-bit) floating-point array to the result, overwriting the third array.

Parameters
[in]xPointerPointer the first input array of single-precision (32-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of single-precision (32-bit) floating-point elements to be multiplied.
[in,out]zPointerPointer the input/output array of single-precision (32-bit) floating-point elements to be added to the intermediate multiplication result.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and zPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or zPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or zPointer arguments is not properly aligned.
enum YepStatus yepCore_MultiplyAdd_V64fS64fIV64f_IV64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
Yep64f *restrict  zPointer,
YepSize  length 
)

Computes pairwise products of double-precision (64-bit) floating-point elements in two arrays and then adds the third double-precision (64-bit) floating-point array to the result, overwriting the third array.

Parameters
[in]xPointerPointer the first input array of double-precision (64-bit) floating-point elements to be multiplied.
[in]yPointerPointer the second input array of double-precision (64-bit) floating-point elements to be multiplied.
[in,out]zPointerPointer the input/output array of double-precision (64-bit) floating-point elements to be added to the intermediate multiplication result.
[in]lengthThe length of the arrays pointed by xPointer, yPointer, and zPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or zPointer arguments is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or zPointer arguments is not properly aligned.
enum YepStatus yepCore_DotProduct_V32fV32f_S32f ( const Yep32f *restrict  xPointer,
const Yep32f *restrict  yPointer,
Yep32f *restrict  dotProductPointer,
YepSize  length 
)

Computes the dot product of single-precision (32-bit) floating-point elements in two arrays.

Parameters
[in]xPointerPointer the first input vector of single-precision (32-bit) floating-point elements.
[in]yPointerPointer the second input vector of single-precision (32-bit) floating-point elements.
[out]dotProductPointerPointer the output single-precision (32-bit) floating-point variable.
[in]lengthThe length of the arrays pointed by xPointer and yPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or dotProductPointer pointers is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or dotProductPointer pointers is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE3
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerFMA4, AVX
enum YepStatus yepCore_DotProduct_V64fV64f_S64f ( const Yep64f *restrict  xPointer,
const Yep64f *restrict  yPointer,
Yep64f *restrict  dotProductPointer,
YepSize  length 
)

Computes the dot product of double-precision (64-bit) floating-point elements in two arrays.

Parameters
[in]xPointerPointer the first input vector of double-precision (64-bit) floating-point elements.
[in]yPointerPointer the second input vector of double-precision (64-bit) floating-point elements.
[out]dotProductPointerPointer the output double-precision (64-bit) floating-point variable.
[in]lengthThe length of the arrays pointed by xPointer and yPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointerOne of the xPointer, yPointer, or dotProductPointer pointers is null.
YepStatusMisalignedPointerOne of the xPointer, yPointer, or dotProductPointer pointers is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE3, SSE2
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerFMA4, AVX
x86-64Intel BonnellSSE, SSE2
Examples:
Entropy.c.
enum YepStatus yepCore_SumSquares_V32f_S32f ( const Yep32f *restrict  numberPointer,
Yep32f *restrict  sumSquaresPointer,
YepSize  length 
)

Computes the sum of squares of single-precision (32-bit) floating-point elements in the input array.

Parameters
[in]numberPointerPointer the input array of single-precision (32-bit) floating-point elements.
[out]sumSquaresPointerPointer the single-precision (32-bit) floating-point element to hold the sum of squares.
[in]lengthThe length of the array pointed by numberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointernumberPointer or sumSquaresPointer argument is null.
YepStatusMisalignedPointernumberPointer or sumSquaresPointer argument is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE, SSE3
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerFMA4, AVX
enum YepStatus yepCore_SumSquares_V64f_S64f ( const Yep64f *restrict  numberPointer,
Yep64f *restrict  sumSquaresPointer,
YepSize  length 
)

Computes the sum of squares of double-precision (64-bit) floating-point elements in the input array.

Parameters
[in]numberPointerPointer the input array of double-precision (64-bit) floating-point elements.
[out]sumSquaresPointerPointer the double-precision (64-bit) floating-point element to hold the sum of squares.
[in]lengthThe length of the array pointed by numberPointer.
Return values
YepStatusOkThe computations finished successfully.
YepStatusNullPointernumberPointer or sumSquaresPointer argument is null.
YepStatusMisalignedPointernumberPointer or sumSquaresPointer argument is not properly aligned.
Optimized implementations
ArchitectureTarget microarchitectureRequired instruction extensions
x86-64Intel NehalemSSE3, SSE2
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerFMA4, AVX