Vector functions#

sl_math_mvp_vector_add_f16#

sl_status_t sl_math_mvp_vector_add_f16 (const float16_t * input_a, const float16_t * input_b, float16_t * output, size_t num_elements)

Add two vectors of 16 bit floats.

This function will perform the following operation: Z = A + B. All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_add_i8#

sl_status_t sl_math_mvp_vector_add_i8 (const int8_t * input_a, const int8_t * input_b, int8_t * output, size_t num_elements)

Add two vectors of signed 8 bit integers.

All vectors must be of the same length. This function will perform the following operation: Z = A + B. The add operation is performing a saturation add, which means that the operation will never overflow or underflow. When adding two elements would overflow (>127) then the result will be 127. When adding two elements would underflow (<-128) then the result will be -128.

Returns

• SL_STATUS_OK.

sl_math_mvp_vector_clip_f16#

sl_status_t sl_math_mvp_vector_clip_f16 (const float16_t * input, float16_t * output, float16_t low, float16_t high, size_t num_elements)

Element-by-element clipping of a value.

This function will do an element-by-element clipping of a value. The value is constrained between 2 bounds. Both vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_mult_f16#

sl_status_t sl_math_mvp_vector_mult_f16 (const float16_t * input_a, const float16_t * input_b, float16_t * output, size_t num_elements)

Elementwise multiply two vectors of 16 bit floats.

This function will perform the following operation: Z[i] = A[i] * B[i]. All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_copy_f16#

sl_status_t sl_math_mvp_vector_copy_f16 (const float16_t * input, float16_t * output, size_t num_elements)

Copy one 16 bit float vector into another.

This function will perform the following operation: Z = A. All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_complex_vector_dot_product_f16#

sl_status_t sl_math_mvp_complex_vector_dot_product_f16 (float16_t * input_a, float16_t * input_b, size_t num_elements, float16_t * output)

Computes the dot product of two complex vectors.

The vectors are multiplied element-by-element and then summed.

Maximum vector length is 1M (2^20), and all vectors must be 4-byte aligned.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_scale_f16#

sl_status_t sl_math_mvp_vector_scale_f16 (const float16_t * input, float16_t scale, float16_t * output, size_t num_elements)

Scale a vector of 16-bits floats with a float16 scale.

This function will perform the following operation: Z[i] = A[i] * scale. All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_complex_vector_conjugate_f16#

sl_status_t sl_math_mvp_complex_vector_conjugate_f16 (float16_t * input, float16_t * output, size_t num_elements)

Conjugates the elements of a complex data vector.

Maximum vector length is 1M (2^20), and all vectors must be 4-byte aligned.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_sub_f16#

sl_status_t sl_math_mvp_vector_sub_f16 (const float16_t * input_a, const float16_t * input_b, float16_t * output, size_t num_elements)

Subtract two vectors of 16 bit floats.

This function will perform the following operation: Z = A - B. All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_complex_vector_magnitude_squared_f16#

sl_status_t sl_math_mvp_complex_vector_magnitude_squared_f16 (const float16_t * input, float16_t * output, size_t num_elements)

Computes the magnitude squared of the elements of a complex data vector.

The input vector shall point to the source that is a vector of complex numbers and the output vector shall point to a vector where the result will be written.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_abs_f16#

sl_status_t sl_math_mvp_vector_abs_f16 (float16_t * input, float16_t * output, size_t num_elements)

Computes the absolute value of a vector on an element-by-element basis.

The output vector can be the same as or differnt to the input vector. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_negate_f16#

sl_status_t sl_math_mvp_vector_negate_f16 (const float16_t * input, float16_t * output, size_t num_elements)

Negate a vector of 16 bit floats.

This function will perform the following operation: Z = - A. Vectors must be of equal length. If both vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case. In-place negation is supported (input and output reference same buffer).

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_clamp_i8#

sl_status_t sl_math_mvp_clamp_i8 (int8_t * data, size_t num_elements, int8_t min, int8_t max)

Clamp all signed 8 bit integers in a vector to a certain range.

Given a min/max value, this function will make sure that none of the element in the input vector will be < min or > max. If any elements are < min then the value will be modified to min. If any elements are > max then value will be modified to max.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_offset_f16#

sl_status_t sl_math_mvp_vector_offset_f16 (const float16_t * input, const float16_t offset, float16_t * output, size_t num_elements)

Adds a constant offset to each element of a vector.

Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_complex_vector_mult_real_f16#

sl_status_t sl_math_mvp_complex_vector_mult_real_f16 (const float16_t * input_a, const float16_t * input_b, float16_t * output, size_t num_elements)

Multiply a vector of complex f16 by a vector of real f16.

This function will perform the following operation: Z = A * B. Both vectors must be of same length. If both vector buffers are 4-byte aligned, the function will operate twice as fast using MVP complex processing. Maximum vector length is 1M (2^20) elements in the 4-byte aligned case, and 512K when oen or more of the complex vectors are 2-byte aligned.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_complex_vector_mult_f16#

sl_status_t sl_math_mvp_complex_vector_mult_f16 (const float16_t * input_a, const float16_t * input_b, float16_t * output, size_t num_elements)

Multiply complex f16 vectors.

This function will multiply two complex vectors. It is assumed that both input vectors, and the output vector have same length. All input and output buffers must be 4-byte aligned. Maximum vector length is 1M (2^20) elements.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_dot_product_f16#

sl_status_t sl_math_mvp_vector_dot_product_f16 (const float16_t * input_a, const float16_t * input_b, size_t num_elements, float16_t * output)

Computes the dot product of two vectors.

The vectors are multiplied element-by-element and then summed.

All vectors must be of equal length. If all vector buffers are 4-byte aligned, the function will operate twice as fast using MVP parallel processing. Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Note

• Depending on the function arguments, the MVP implementation can calculate the dot product in different ways that may effect the rounding errors. If the same input vectors are calculated with different memory alignmen, the results may not be identical.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.

sl_math_mvp_vector_fill_f16#

sl_status_t sl_math_mvp_vector_fill_f16 (float16_t * output, const float16_t value, size_t num_elements)

Fills a constant value into a floating-point vector.

Maximum vector length is 1M (2^20), and 2M in the 4-byte aligned case.

Returns

• SL_STATUS_OK on success. On failure, an appropriate sl_status_t errorcode is returned.