Commit f874ba27 authored by Siyuan Cheng's avatar Siyuan Cheng Committed by Carles Cufi
Browse files

zdsp: add in-place operaton test for basicmath 



Add in-place calculatoin test for every functions in basicmath

Signed-off-by: default avatarSiyuan Cheng <siyuanc@synopsys.com>
parent b475e1fc

tests/subsys/dsp/basicmath/src/f16.c

+258 −0
Original line number Diff line number Diff line
@@ -51,6 +51,38 @@ DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, 23, in_com1, in_com2, ref_add 
DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, long, in_com1, in_com2, ref_add,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_add_f16_in_place(const uint16_t *input1, const uint16_t *input2,

				const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_add_f16(output, (float16_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16_in_place, 7, in_com1, in_com2, ref_add, 7);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16_in_place, 16, in_com1, in_com2, ref_add, 16);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16_in_place, 23, in_com1, in_com2, ref_add, 23);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16_in_place, long, in_com1, in_com2, ref_add,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_sub_f16(

	const uint16_t *input1, const uint16_t *input2, const uint16_t *ref,

	size_t length)
@@ -85,6 +117,38 @@ DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, 23, in_com1, in_com2, ref_sub 
DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, long, in_com1, in_com2, ref_sub,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_sub_f16_in_place(const uint16_t *input1, const uint16_t *input2,

				const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_sub_f16(output, (float16_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16_in_place, 7, in_com1, in_com2, ref_sub, 7);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16_in_place, 16, in_com1, in_com2, ref_sub, 16);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16_in_place, 23, in_com1, in_com2, ref_sub, 23);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16_in_place, long, in_com1, in_com2, ref_sub,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_mult_f16(

	const uint16_t *input1, const uint16_t *input2, const uint16_t *ref,

	size_t length)
@@ -119,6 +183,38 @@ DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, 23, in_com1, in_com2, ref_mu 
DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, long, in_com1, in_com2, ref_mult,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_mult_f16_in_place(const uint16_t *input1, const uint16_t *input2,

				const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_mult_f16(output, (float16_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16_in_place, 7, in_com1, in_com2, ref_mult, 7);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16_in_place, 16, in_com1, in_com2, ref_mult, 16);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16_in_place, 23, in_com1, in_com2, ref_mult, 23);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16_in_place, long, in_com1, in_com2, ref_mult,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_negate_f16(

	const uint16_t *input1, const uint16_t *ref, size_t length)

{
@@ -152,6 +248,38 @@ DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, 23, in_com1, ref_negate, 2 
DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, long, in_com1, ref_negate,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_negate_f16_in_place(const uint16_t *input1, const uint16_t *ref,

				size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_negate_f16(output, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16_in_place, 7, in_com1, ref_negate, 7);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16_in_place, 16, in_com1, ref_negate, 16);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16_in_place, 23, in_com1, ref_negate, 23);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16_in_place, long, in_com1, ref_negate,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_offset_f16(

	const uint16_t *input1, float16_t scalar, const uint16_t *ref,

	size_t length)
@@ -186,6 +314,40 @@ DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, 0p5_23, in_com1, 0.5f, ref 
DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, long, in_com1, 0.5f, ref_offset,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_offset_f16_in_place(const uint16_t *input1, float16_t scalar,

				const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_offset_f16(output, scalar, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16_in_place, 0p5_7, in_com1, 0.5f, ref_offset, 7);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16_in_place, 0p5_16, in_com1, 0.5f, ref_offset,

		     16);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16_in_place, 0p5_23, in_com1, 0.5f, ref_offset,

		     23);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16_in_place, long, in_com1, 0.5f, ref_offset,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_scale_f16(

	const uint16_t *input1, float16_t scalar, const uint16_t *ref,

	size_t length)
@@ -220,6 +382,38 @@ DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, 0p5_23, in_com1, 0.5f, ref_ 
DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, long, in_com1, 0.5f, ref_scale,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_scale_f16_in_place(const uint16_t *input1, float16_t scalar,

				const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_scale_f16(output, scalar, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16_in_place, 0p5_7, in_com1, 0.5f, ref_scale, 7);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16_in_place, 0p5_16, in_com1, 0.5f, ref_scale, 16);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16_in_place, 0p5_23, in_com1, 0.5f, ref_scale, 23);

DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16_in_place, long, in_com1, 0.5f, ref_scale,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_dot_prod_f16(

	const uint16_t *input1, const uint16_t *input2, const uint16_t *ref,

	size_t length)
@@ -287,6 +481,37 @@ DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, 16, in_com1, ref_abs, 16); 
DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, 23, in_com1, ref_abs, 23);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, long, in_com1, ref_abs, ARRAY_SIZE(in_com1));



static void test_zdsp_abs_f16_in_place(const uint16_t *input1, const uint16_t *ref, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input1, length * sizeof(float16_t));



	/* Run test function */

	zdsp_abs_f16(output, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     "incorrect computation result");



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16_in_place, 7, in_com1, ref_abs, 7);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16_in_place, 16, in_com1, ref_abs, 16);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16_in_place, 23, in_com1, ref_abs, 23);

DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16_in_place, long, in_com1, ref_abs,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_clip_f16(

	const uint16_t *input, const uint16_t *ref, float16_t min, float16_t max, size_t length)

{
@@ -321,4 +546,37 @@ DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16, m0p5_0p5, in_clip, ref_clip2 
DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16, 0p1_0p5, in_clip, ref_clip3,

		     0.1f, 0.5f, ARRAY_SIZE(ref_clip3));



static void test_zdsp_clip_f16_in_place(const uint16_t *input, const uint16_t *ref, float16_t min,

				float16_t max, size_t length)

{

	float16_t *output;



	/* Allocate output buffer */

	output = malloc(length * sizeof(float16_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, (float16_t *)input, length * sizeof(float16_t));



	/* Run test function */

	zdsp_clip_f16(output, output, min, max, length);



	/* Validate output */

	zassert_true(test_snr_error_f16(length, output, (float16_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f16(length, output, (float16_t *)ref, REL_ERROR_THRESH),

		     "incorrect computation result");



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16_in_place, m0p5_m0p1, in_clip, ref_clip1, -0.5f,

		     -0.1f, ARRAY_SIZE(ref_clip1));

DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16_in_place, m0p5_0p5, in_clip, ref_clip2, -0.5f,

		     0.5f, ARRAY_SIZE(ref_clip2));

DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16_in_place, 0p1_0p5, in_clip, ref_clip3, 0.1f,

		     0.5f, ARRAY_SIZE(ref_clip3));



ZTEST_SUITE(basic_math_f16, NULL, NULL, NULL, NULL, NULL);

tests/subsys/dsp/basicmath/src/f32.c

+258 −0
Original line number Diff line number Diff line
@@ -49,6 +49,38 @@ DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, 11, in_com1, in_com2, ref_add 
DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, long, in_com1, in_com2, ref_add,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_add_f32_in_place(const DSP_DATA uint32_t *input1,

				const DSP_DATA uint32_t *input2, const uint32_t *ref, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_add_f32(output, (DSP_DATA float32_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32_in_place, 3, in_com1, in_com2, ref_add, 3);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32_in_place, 8, in_com1, in_com2, ref_add, 8);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32_in_place, 11, in_com1, in_com2, ref_add, 11);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32_in_place, long, in_com1, in_com2, ref_add,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_sub_f32(const DSP_DATA uint32_t *input1, const DSP_DATA uint32_t *input2,

				const uint32_t *ref, size_t length)

{
@@ -82,6 +114,38 @@ DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, 11, in_com1, in_com2, ref_sub 
DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, long, in_com1, in_com2, ref_sub,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_sub_f32_in_place(const DSP_DATA uint32_t *input1,

				const DSP_DATA uint32_t *input2, const uint32_t *ref, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_sub_f32(output, (DSP_DATA float32_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32_in_place, 3, in_com1, in_com2, ref_sub, 3);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32_in_place, 8, in_com1, in_com2, ref_sub, 8);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32_in_place, 11, in_com1, in_com2, ref_sub, 11);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32_in_place, long, in_com1, in_com2, ref_sub,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_mult_f32(const DSP_DATA uint32_t *input1, const DSP_DATA uint32_t *input2,

				const uint32_t *ref, size_t length)

{
@@ -115,6 +179,38 @@ DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, 11, in_com1, in_com2, ref_mu 
DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, long, in_com1, in_com2, ref_mult,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_mult_f32_in_place(const DSP_DATA uint32_t *input1,

				const DSP_DATA uint32_t *input2, const uint32_t *ref, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_mult_f32(output, (DSP_DATA float32_t *)input2, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32_in_place, 3, in_com1, in_com2, ref_mult, 3);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32_in_place, 8, in_com1, in_com2, ref_mult, 8);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32_in_place, 11, in_com1, in_com2, ref_mult, 11);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32_in_place, long, in_com1, in_com2, ref_mult,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_negate_f32(const DSP_DATA uint32_t *input1, const uint32_t *ref,

				size_t length)

{
@@ -148,6 +244,38 @@ DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, 11, in_com1, ref_negate, 1 
DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, long, in_com1, ref_negate,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_negate_f32_in_place(const DSP_DATA uint32_t *input1, const uint32_t *ref,

				size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_negate_f32(output, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32_in_place, 3, in_com1, ref_negate, 3);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32_in_place, 8, in_com1, ref_negate, 8);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32_in_place, 11, in_com1, ref_negate, 11);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32_in_place, long, in_com1, ref_negate,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_offset_f32(const DSP_DATA uint32_t *input1, float32_t scalar,

				const uint32_t *ref, size_t length)

{
@@ -181,6 +309,39 @@ DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, 0p5_11, in_com1, 0.5f, ref 
DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, long, in_com1, 0.5f, ref_offset,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_offset_f32_in_place(const DSP_DATA uint32_t *input1, float32_t scalar,

				const uint32_t *ref, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_offset_f32(output, scalar, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32_in_place, 0p5_3, in_com1, 0.5f, ref_offset, 3);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32_in_place, 0p5_8, in_com1, 0.5f, ref_offset, 8);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32_in_place, 0p5_11, in_com1, 0.5f, ref_offset,

		     11);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32_in_place, long, in_com1, 0.5f, ref_offset,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_scale_f32(const DSP_DATA uint32_t *input1, float32_t scalar,

				const uint32_t *ref, size_t length)

{
@@ -214,6 +375,38 @@ DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, 0p5_11, in_com1, 0.5f, ref_ 
DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, long, in_com1, 0.5f, ref_scale,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_scale_f32_in_place(const DSP_DATA uint32_t *input1, float32_t scalar,

				const uint32_t *ref, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_scale_f32(output, scalar, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     ASSERT_MSG_REL_ERROR_LIMIT_EXCEED);



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32_in_place, 0p5_3, in_com1, 0.5f, ref_scale, 3);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32_in_place, 0p5_8, in_com1, 0.5f, ref_scale, 8);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32_in_place, 0p5_11, in_com1, 0.5f, ref_scale, 11);

DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32_in_place, long, in_com1, 0.5f, ref_scale,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_dot_prod_f32(const DSP_DATA uint32_t *input1, const DSP_DATA uint32_t *input2,

				const uint32_t *ref, size_t length)

{
@@ -279,6 +472,38 @@ DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, 8, in_com1, ref_abs, 8); 
DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, 11, in_com1, ref_abs, 11);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, long, in_com1, ref_abs, ARRAY_SIZE(in_com1));



static void test_zdsp_abs_f32_in_place(const DSP_DATA uint32_t *input1, const uint32_t *ref,

				size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input1, length * sizeof(float32_t));



	/* Run test function */

	zdsp_abs_f32(output, output, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     "incorrect computation result");



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32_in_place, 3, in_com1, ref_abs, 3);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32_in_place, 8, in_com1, ref_abs, 8);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32_in_place, 11, in_com1, ref_abs, 11);

DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32_in_place, long, in_com1, ref_abs,

		     ARRAY_SIZE(in_com1));



static void test_zdsp_clip_f32(const DSP_DATA uint32_t *input, const uint32_t *ref, float32_t min,

				float32_t max, size_t length)

{
@@ -313,4 +538,37 @@ DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32, m0p5_0p5, in_clip, ref_clip2 
DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32, 0p1_0p5, in_clip, ref_clip3,

		     0.1f, 0.5f, ARRAY_SIZE(ref_clip3));



static void test_zdsp_clip_f32_in_place(const DSP_DATA uint32_t *input, const uint32_t *ref,

				float32_t min, float32_t max, size_t length)

{

	DSP_DATA float32_t *output;



	/* Allocate output buffer */

	output = (DSP_DATA float32_t *)malloc(length * sizeof(float32_t));

	zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED);



	/* Copy input data to output*/

	memcpy(output, input, length * sizeof(float32_t));



	/* Run test function */

	zdsp_clip_f32(output, output, min, max, length);



	/* Validate output */

	zassert_true(test_snr_error_f32(length, output, (float32_t *)ref, SNR_ERROR_THRESH),

		     ASSERT_MSG_SNR_LIMIT_EXCEED);



	zassert_true(test_rel_error_f32(length, output, (float32_t *)ref, REL_ERROR_THRESH),

		     "incorrect computation result");



	/* Free output buffer */

	free(output);

}



DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32_in_place, m0p5_m0p1, in_clip, ref_clip1, -0.5f,

		     -0.1f, ARRAY_SIZE(ref_clip1));

DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32_in_place, m0p5_0p5, in_clip, ref_clip2, -0.5f,

		     0.5f, ARRAY_SIZE(ref_clip2));

DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32_in_place, 0p1_0p5, in_clip, ref_clip3, 0.1f,

		     0.5f, ARRAY_SIZE(ref_clip3));



ZTEST_SUITE(basic_math_f32, NULL, NULL, NULL, NULL, NULL);

tests/subsys/dsp/basicmath/src/q15.c

+423 −0

File changed.

Preview size limit exceeded, changes collapsed.

tests/subsys/dsp/basicmath/src/q31.c

+420 −0

File changed.

Preview size limit exceeded, changes collapsed.

tests/subsys/dsp/basicmath/src/q7.c

+411 −0

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE