Yeppp!
 All Data Structures Functions Variables Enumerations Enumerator Groups Pages
yepCore.h: 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 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...
 

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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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_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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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 NehalemSSE2, SSE4.1
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_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-64Intel HaswellAVX, FMA3
x86-64AMD BulldozerAVX, FMA4
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 NehalemSSE2, SSE3
x86-64Intel Sandy BridgeAVX
x86-64Intel HaswellAVX, FMA3
x86-64AMD BulldozerAVX, FMA4
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 BulldozerAVX, FMA4
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 NehalemSSE, SSE2, SSE3
x86-64Intel Sandy BridgeAVX
x86-64AMD BulldozerAVX, FMA4