Initial commit
This commit is contained in:
@ -0,0 +1,9 @@
|
||||
#ifndef _ALL_TESTS_H_
|
||||
#define _ALL_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(all_tests);
|
||||
|
||||
#endif /* _ALL_TESTS_H_ */
|
||||
@ -0,0 +1,267 @@
|
||||
#ifndef _BASIC_MATH_TEMPLATES_H_
|
||||
#define _BASIC_MATH_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Compare the outputs used by basic math tests for the function under test and
|
||||
* the reference function.
|
||||
*/
|
||||
#define BASIC_MATH_COMPARE_INTERFACE(block_size, output_type) \
|
||||
TEST_ASSERT_BUFFERS_EQUAL( \
|
||||
basic_math_output_ref.data_ptr, \
|
||||
basic_math_output_fut.data_ptr, \
|
||||
block_size * sizeof(output_type))
|
||||
|
||||
/*
|
||||
* Comparison SNR thresholds for the data types used in basic_math_tests.
|
||||
*/
|
||||
#define BASIC_MATH_SNR_THRESHOLD_float32_t 120
|
||||
#define BASIC_MATH_SNR_THRESHOLD_q31_t 100
|
||||
#define BASIC_MATH_SNR_THRESHOLD_q15_t 75
|
||||
#define BASIC_MATH_SNR_THRESHOLD_q7_t 25
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs using SNR.
|
||||
*
|
||||
* @note The outputs are converted to float32_t before comparison.
|
||||
*/
|
||||
#define BASIC_MATH_SNR_COMPARE_INTERFACE(block_size, output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
basic_math_output_f32_ref, \
|
||||
basic_math_output_ref.data_ptr, \
|
||||
basic_math_output_f32_fut, \
|
||||
basic_math_output_fut.data_ptr, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
BASIC_MATH_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs using SNR.
|
||||
*
|
||||
* @note The outputs are converted to float32_t before comparison.
|
||||
*/
|
||||
#define BASIC_MATH_SNR_ELT1_COMPARE_INTERFACE(block_size, output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
basic_math_output_f32_ref, \
|
||||
basic_math_output_ref.data_ptr, \
|
||||
basic_math_output_f32_fut, \
|
||||
basic_math_output_fut.data_ptr, \
|
||||
1, \
|
||||
output_type, \
|
||||
BASIC_MATH_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
#define ARM_abs_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, basic_math_output_fut.data_ptr, block_size)
|
||||
|
||||
#define REF_abs_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, basic_math_output_ref.data_ptr, block_size)
|
||||
|
||||
#define ARM_add_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_add_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
#define ARM_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, block_size, basic_math_output_fut.data_ptr) \
|
||||
|
||||
#define REF_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, block_size, basic_math_output_ref.data_ptr) \
|
||||
|
||||
#define ARM_mult_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_mult_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
#define ARM_negate_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, basic_math_output_fut.data_ptr, block_size)
|
||||
|
||||
#define REF_negate_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, basic_math_output_ref.data_ptr, block_size)
|
||||
|
||||
#define ARM_offset_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_offset_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
#define ARM_shift_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_shift_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
#define ARM_scale_float_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_scale_float_INPUT_INTERFACE(input, elt, block_size) \
|
||||
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
/* These two are for the fixed point functions */
|
||||
#define ARM_scale_INPUT_INTERFACE(input, elt1, elt2, block_size) \
|
||||
PAREN(input, elt1, elt2, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_scale_INPUT_INTERFACE(input, elt1, elt2, block_size) \
|
||||
PAREN(input, elt1, elt2, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
#define ARM_sub_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
|
||||
|
||||
#define REF_sub_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for basic math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_BLK( \
|
||||
basic_math_f_all, \
|
||||
basic_math_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
BASIC_MATH_COMPARE_INTERFACE); \
|
||||
}
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF2_BLK() for basic math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF2_BLK( \
|
||||
basic_math_f_all, \
|
||||
basic_math_f_all, \
|
||||
basic_math_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_ELT1_BLK() for basic math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
elt_type, \
|
||||
output_type) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_ELT1_BLK( \
|
||||
basic_math_f_all, \
|
||||
basic_math_elts, \
|
||||
basic_math_block_sizes, \
|
||||
input_type, \
|
||||
elt_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
BASIC_MATH_COMPARE_INTERFACE); \
|
||||
}
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_ELT2_BLK() for basic math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT2_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
elt1_type, \
|
||||
elt2_type, \
|
||||
output_type) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_ELT2_BLK( \
|
||||
basic_math_f_all, \
|
||||
basic_math_elts, \
|
||||
basic_math_elts2, \
|
||||
basic_math_block_sizes, \
|
||||
input_type, \
|
||||
elt1_type, \
|
||||
elt2_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
BASIC_MATH_COMPARE_INTERFACE); \
|
||||
}
|
||||
|
||||
#endif /* _BASIC_MATH_TEMPLATES_H_ */
|
||||
@ -0,0 +1,46 @@
|
||||
#ifndef ARM_BASIC_MATH_TEST_DATA_H
|
||||
#define ARM_BASIC_MATH_TEST_DATA_H
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#define BASIC_MATH_MAX_INPUT_ELEMENTS 32
|
||||
#define BASIC_MATH_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
ARR_DESC_DECLARE(basic_math_output_fut);
|
||||
ARR_DESC_DECLARE(basic_math_output_ref);
|
||||
|
||||
extern BASIC_MATH_BIGGEST_INPUT_TYPE
|
||||
basic_math_output_f32_ref[BASIC_MATH_MAX_INPUT_ELEMENTS];
|
||||
|
||||
extern BASIC_MATH_BIGGEST_INPUT_TYPE
|
||||
basic_math_output_f32_fut[BASIC_MATH_MAX_INPUT_ELEMENTS];
|
||||
|
||||
/* Block Sizes*/
|
||||
ARR_DESC_DECLARE(basic_math_block_sizes);
|
||||
|
||||
/* Numbers */
|
||||
ARR_DESC_DECLARE(basic_math_elts);
|
||||
ARR_DESC_DECLARE(basic_math_elts2);
|
||||
ARR_DESC_DECLARE(basic_math_eltsf);
|
||||
|
||||
/* Float Inputs */
|
||||
ARR_DESC_DECLARE(basic_math_zeros);
|
||||
ARR_DESC_DECLARE(basic_math_f_2);
|
||||
ARR_DESC_DECLARE(basic_math_f_15);
|
||||
ARR_DESC_DECLARE(basic_math_f_32);
|
||||
ARR_DESC_DECLARE(basic_math_f_all);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _BASIC_MATH_TEST_GROUP_H_
|
||||
#define _BASIC_MATH_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(basic_math_tests);
|
||||
|
||||
#endif /* _BASIC_MATH_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef _BASIC_MATH_TESTS_H_
|
||||
#define _BASIC_MATH_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(abs_tests);
|
||||
JTEST_DECLARE_GROUP(add_tests);
|
||||
JTEST_DECLARE_GROUP(dot_prod_tests);
|
||||
JTEST_DECLARE_GROUP(mult_tests);
|
||||
JTEST_DECLARE_GROUP(negate_tests);
|
||||
JTEST_DECLARE_GROUP(offset_tests);
|
||||
JTEST_DECLARE_GROUP(scale_tests);
|
||||
JTEST_DECLARE_GROUP(shift_tests);
|
||||
JTEST_DECLARE_GROUP(sub_tests);
|
||||
|
||||
#endif /* _BASIC_MATH_TESTS_H_ */
|
||||
@ -0,0 +1,222 @@
|
||||
#ifndef _COMPLEX_MATH_TEMPLATES_H_
|
||||
#define _COMPLEX_MATH_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Compare the real outputs from the function under test and the reference
|
||||
* function.
|
||||
*/
|
||||
#define COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size, output_type) \
|
||||
TEST_ASSERT_BUFFERS_EQUAL( \
|
||||
complex_math_output_ref_a.data_ptr, \
|
||||
complex_math_output_fut_a.data_ptr, \
|
||||
block_size * sizeof(output_type))
|
||||
|
||||
/**
|
||||
* Compare the real and imaginary outputs from the function under test and the
|
||||
* reference function.
|
||||
*/
|
||||
#define COMPLEX_MATH_COMPARE_CMPLX_INTERFACE(block_size, output_type) \
|
||||
do \
|
||||
{ \
|
||||
COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size * 2, output_type); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*
|
||||
* Comparison SNR thresholds for the data types used in complex_math_tests.
|
||||
*/
|
||||
#define COMPLEX_MATH_SNR_THRESHOLD_float32_t 120
|
||||
#define COMPLEX_MATH_SNR_THRESHOLD_q31_t 100
|
||||
#define COMPLEX_MATH_SNR_THRESHOLD_q15_t 75
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs using SNR.
|
||||
*
|
||||
* The output_suffix specifies which output buffers to use for the
|
||||
* comparison. An output_suffix of 'a' expands to the following buffers:
|
||||
*
|
||||
* - complex_math_output_f32_ref_a
|
||||
* - complex_math_output_f32_fut_a
|
||||
* - complex_math_output_ref_a
|
||||
* - complex_math_output_fut_a
|
||||
*
|
||||
* @note The outputs are converted to float32_t before comparison.
|
||||
*/
|
||||
#define COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
|
||||
output_type, \
|
||||
output_suffix) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
complex_math_output_f32_ref_##output_suffix, \
|
||||
complex_math_output_ref_##output_suffix.data_ptr, \
|
||||
complex_math_output_f32_fut_##output_suffix, \
|
||||
complex_math_output_fut_##output_suffix.data_ptr, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
COMPLEX_MATH_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for real outputs.
|
||||
*/
|
||||
#define COMPLEX_MATH_SNR_COMPARE_RE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
|
||||
output_type, \
|
||||
a)
|
||||
|
||||
/**
|
||||
* Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for complex outputs.
|
||||
*/
|
||||
#define COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size * 2, \
|
||||
output_type, \
|
||||
a)
|
||||
|
||||
/**
|
||||
* Compare reference and fut split outputs using SNR.
|
||||
*
|
||||
* 'Split' refers to two separate output buffers; one for real and one for
|
||||
* complex.
|
||||
*/
|
||||
#define COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
|
||||
output_type, \
|
||||
a); \
|
||||
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
|
||||
output_type, \
|
||||
b); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
#define ARM_cmplx_conj_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
|
||||
|
||||
#define REF_cmplx_conj_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
|
||||
|
||||
#define ARM_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, block_size, \
|
||||
complex_math_output_fut_a.data_ptr, \
|
||||
complex_math_output_fut_b.data_ptr)
|
||||
|
||||
#define REF_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, block_size, \
|
||||
complex_math_output_ref_a.data_ptr, \
|
||||
complex_math_output_ref_b.data_ptr)
|
||||
|
||||
#define ARM_cmplx_mag_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
|
||||
|
||||
#define REF_cmplx_mag_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
|
||||
|
||||
#define ARM_cmplx_mag_squared_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
|
||||
|
||||
#define REF_cmplx_mag_squared_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
|
||||
|
||||
#define ARM_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
|
||||
|
||||
#define REF_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
|
||||
|
||||
#define ARM_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
|
||||
|
||||
#define REF_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
|
||||
PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for complex math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_BLK( \
|
||||
complex_math_f_all, \
|
||||
complex_math_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF2_BLK1() for complex math tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF2_BLK( \
|
||||
complex_math_f_all, \
|
||||
complex_math_f_all, \
|
||||
complex_math_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
#endif /* _COMPLEX_MATH_TEMPLATES_H_ */
|
||||
@ -0,0 +1,50 @@
|
||||
#ifndef _COMPLEX_MATH_TEST_DATA_H_
|
||||
#define _COMPLEX_MATH_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#define COMPLEX_MATH_MAX_INPUT_ELEMENTS 32
|
||||
#define COMPLEX_MATH_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Decalare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
ARR_DESC_DECLARE(complex_math_output_fut_a);
|
||||
ARR_DESC_DECLARE(complex_math_output_fut_b);
|
||||
ARR_DESC_DECLARE(complex_math_output_ref_a);
|
||||
ARR_DESC_DECLARE(complex_math_output_ref_b);
|
||||
|
||||
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
|
||||
complex_math_output_f32_ref_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
|
||||
|
||||
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
|
||||
complex_math_output_f32_ref_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
|
||||
|
||||
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
|
||||
complex_math_output_f32_fut_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
|
||||
|
||||
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
|
||||
complex_math_output_f32_fut_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
|
||||
|
||||
/* Block Sizes*/
|
||||
ARR_DESC_DECLARE(complex_math_block_sizes);
|
||||
|
||||
/* Float Inputs */
|
||||
ARR_DESC_DECLARE(complex_math_zeros);
|
||||
ARR_DESC_DECLARE(complex_math_f_2);
|
||||
ARR_DESC_DECLARE(complex_math_f_15);
|
||||
ARR_DESC_DECLARE(complex_math_f_32);
|
||||
ARR_DESC_DECLARE(complex_math_f_all);
|
||||
|
||||
|
||||
#endif /* _COMPLEX_MATH_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _COMPLEX_MATH_TEST_GROUP_H_
|
||||
#define _COMPLEX_MATH_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(complex_math_tests);
|
||||
|
||||
#endif /* _COMPLEX_MATH_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,14 @@
|
||||
#ifndef _COMPLEX_MATH_TESTS_H_
|
||||
#define _COMPLEX_MATH_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(cmplx_conj_tests);
|
||||
JTEST_DECLARE_GROUP(cmplx_dot_prod_tests);
|
||||
JTEST_DECLARE_GROUP(cmplx_mag_tests);
|
||||
JTEST_DECLARE_GROUP(cmplx_mag_squared_tests);
|
||||
JTEST_DECLARE_GROUP(cmplx_mult_cmplx_tests);
|
||||
JTEST_DECLARE_GROUP(cmplx_mult_real_tests);
|
||||
|
||||
#endif /* _COMPLEX_MATH_TESTS_H_ */
|
||||
@ -0,0 +1,46 @@
|
||||
#ifndef _CONTROLLER_TEMPLATES_H_
|
||||
#define _CONTROLLER_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
#include <string.h> /* memcpy() */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Comparison SNR thresholds for the data types used in transform_tests.
|
||||
*/
|
||||
#define CONTROLLER_SNR_THRESHOLD_float32_t 110
|
||||
#define CONTROLLER_SNR_THRESHOLD_q31_t 100
|
||||
#define CONTROLLER_SNR_THRESHOLD_q15_t 45
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define CONTROLLER_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
controller_output_f32_ref, \
|
||||
(output_type *) controller_output_ref, \
|
||||
controller_output_f32_fut, \
|
||||
(output_type *) controller_output_fut, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
CONTROLLER_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* TEST Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#endif /* _CONTROLLER_TEMPLATES_H_ */
|
||||
@ -0,0 +1,33 @@
|
||||
#ifndef _CONTROLLER_TEST_DATA_H_
|
||||
#define _CONTROLLER_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define CONTROLLER_MAX_LEN 1024
|
||||
#define CONTROLLER_MAX_COEFFS_LEN (12 * 3)
|
||||
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Variable Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
extern float32_t controller_output_fut[CONTROLLER_MAX_LEN];
|
||||
extern float32_t controller_output_ref[CONTROLLER_MAX_LEN];
|
||||
extern float32_t controller_output_f32_fut[CONTROLLER_MAX_LEN];
|
||||
extern float32_t controller_output_f32_ref[CONTROLLER_MAX_LEN];
|
||||
extern const float32_t controller_f32_inputs[CONTROLLER_MAX_LEN];
|
||||
extern const q31_t controller_q31_inputs[CONTROLLER_MAX_LEN];
|
||||
extern const q15_t * controller_q15_inputs;
|
||||
extern const float32_t controller_f32_coeffs[CONTROLLER_MAX_COEFFS_LEN];
|
||||
extern const q31_t controller_q31_coeffs[CONTROLLER_MAX_COEFFS_LEN];
|
||||
extern const q15_t controller_q15_coeffs[CONTROLLER_MAX_COEFFS_LEN];
|
||||
|
||||
#endif /* _CONTROLLER_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _CONTROLLER_TEST_GROUP_H_
|
||||
#define _CONTROLLER_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Group */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(controller_tests);
|
||||
|
||||
#endif /* _CONTROLLER_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,11 @@
|
||||
#ifndef _CONTROLLER_TESTS_H_
|
||||
#define _CONTROLLER_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(pid_reset_tests);
|
||||
JTEST_DECLARE_GROUP(sin_cos_tests);
|
||||
JTEST_DECLARE_GROUP(pid_tests);
|
||||
|
||||
#endif /* _CONTROLLER_TESTS_H_ */
|
||||
@ -0,0 +1,102 @@
|
||||
#ifndef _FAST_MATH_TEMPLATES_H_
|
||||
#define _FAST_MATH_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
#include <string.h> /* memcpy() */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Comparison SNR thresholds for the data types used in transform_tests.
|
||||
*/
|
||||
#define FAST_MATH_SNR_THRESHOLD_float32_t 95
|
||||
#define FAST_MATH_SNR_THRESHOLD_q31_t 95
|
||||
#define FAST_MATH_SNR_THRESHOLD_q15_t 45
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define FAST_MATH_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
fast_math_output_f32_ref, \
|
||||
(output_type *) fast_math_output_ref, \
|
||||
fast_math_output_f32_fut, \
|
||||
(output_type *) fast_math_output_fut, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
FAST_MATH_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* TEST Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define SQRT_TEST_TEMPLATE_ELT1(suffix) \
|
||||
\
|
||||
JTEST_DEFINE_TEST(arm_sqrt_##suffix##_test, arm_sqrt_##suffix) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<FAST_MATH_MAX_LEN;i++) \
|
||||
{ \
|
||||
arm_sqrt_##suffix( \
|
||||
(suffix##_t)fast_math_##suffix##_inputs[i] \
|
||||
,(suffix##_t*)fast_math_output_fut + i); \
|
||||
}); \
|
||||
\
|
||||
for(i=0;i<FAST_MATH_MAX_LEN;i++) \
|
||||
{ \
|
||||
ref_sqrt_##suffix( \
|
||||
(suffix##_t)fast_math_##suffix##_inputs[i] \
|
||||
,(suffix##_t*)fast_math_output_ref + i); \
|
||||
} \
|
||||
\
|
||||
FAST_MATH_SNR_COMPARE_INTERFACE( \
|
||||
FAST_MATH_MAX_LEN, \
|
||||
suffix##_t); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
|
||||
#define SIN_COS_TEST_TEMPLATE_ELT1(suffix, type, func) \
|
||||
\
|
||||
JTEST_DEFINE_TEST(arm_##func##_##suffix##_test, arm_##func##_##suffix) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<FAST_MATH_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((type*)fast_math_output_fut + i) = arm_##func##_##suffix( \
|
||||
fast_math_##suffix##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<FAST_MATH_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((type*)fast_math_output_ref + i) = ref_##func##_##suffix( \
|
||||
fast_math_##suffix##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
FAST_MATH_SNR_COMPARE_INTERFACE( \
|
||||
FAST_MATH_MAX_LEN, \
|
||||
type); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
#endif /* _FAST_MATH_TEMPLATES_H_ */
|
||||
@ -0,0 +1,29 @@
|
||||
#ifndef _FAST_MATH_TEST_DATA_H_
|
||||
#define _FAST_MATH_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define FAST_MATH_MAX_LEN 1024
|
||||
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Variable Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
extern float32_t fast_math_output_fut[FAST_MATH_MAX_LEN];
|
||||
extern float32_t fast_math_output_ref[FAST_MATH_MAX_LEN];
|
||||
extern float32_t fast_math_output_f32_fut[FAST_MATH_MAX_LEN];
|
||||
extern float32_t fast_math_output_f32_ref[FAST_MATH_MAX_LEN];
|
||||
extern const float32_t fast_math_f32_inputs[FAST_MATH_MAX_LEN];
|
||||
extern const q31_t fast_math_q31_inputs[FAST_MATH_MAX_LEN];
|
||||
extern const q15_t * fast_math_q15_inputs;
|
||||
|
||||
#endif /* _FAST_MATH_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _FAST_MATH_TEST_GROUP_H_
|
||||
#define _FAST_MATH_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(fast_math_tests);
|
||||
|
||||
#endif /* _FAST_MATH_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,91 @@
|
||||
#ifndef _FILTERING_TEMPLATES_H_
|
||||
#define _FILTERING_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Comparison SNR thresholds for the data types used in statistics_tests.
|
||||
*/
|
||||
#define FILTERING_SNR_THRESHOLD_float64_t 120
|
||||
#define FILTERING_SNR_THRESHOLD_float32_t 99
|
||||
#define FILTERING_SNR_THRESHOLD_q31_t 90
|
||||
#define FILTERING_SNR_THRESHOLD_q15_t 60
|
||||
#define FILTERING_SNR_THRESHOLD_q7_t 30
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs using SNR.
|
||||
*
|
||||
* @note The outputs are converted to float32_t before comparison.
|
||||
*/
|
||||
#define FILTERING_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
FILTERING_SNR_COMPARE_INTERFACE_OFFSET(0, block_size, output_type)
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs starting at some offset using SNR.
|
||||
*/
|
||||
#define FILTERING_SNR_COMPARE_INTERFACE_OFFSET(offset, \
|
||||
block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
filtering_output_f32_ref, \
|
||||
(output_type *) filtering_output_ref + offset, \
|
||||
filtering_output_f32_fut, \
|
||||
(output_type *) filtering_output_fut + offset, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
FILTERING_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs starting at some offset using SNR.
|
||||
* Special case for float64_t
|
||||
*/
|
||||
#define FILTERING_DBL_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_ASSERT_DBL_SNR( \
|
||||
(float64_t*)filtering_output_ref, \
|
||||
(float64_t*)filtering_output_fut, \
|
||||
block_size, \
|
||||
FILTERING_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
|
||||
#endif /* _FILTERING_TEMPLATES_H_ */
|
||||
@ -0,0 +1,81 @@
|
||||
#ifndef FILTERING_TEST_DATA_H
|
||||
#define FILTERING_TEST_DATA_H
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define FILTERING_MAX_BLOCKSIZE 33
|
||||
#define LMS_MAX_BLOCKSIZE 512
|
||||
#define FILTERING_MAX_NUMTAPS 34
|
||||
#define FILTERING_MAX_NUMSTAGES 14
|
||||
#define FILTERING_MAX_POSTSHIFT 8
|
||||
#define FILTERING_MAX_TAP_DELAY 0xFF
|
||||
#define FILTERING_MAX_L 3
|
||||
#define FILTERING_MAX_M 33
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
extern float32_t filtering_output_fut[LMS_MAX_BLOCKSIZE*2];
|
||||
extern float32_t filtering_output_ref[LMS_MAX_BLOCKSIZE*2];
|
||||
extern float32_t filtering_output_f32_fut[LMS_MAX_BLOCKSIZE*2];
|
||||
extern float32_t filtering_output_f32_ref[LMS_MAX_BLOCKSIZE*2];
|
||||
extern float32_t filtering_input_lms[LMS_MAX_BLOCKSIZE*2];
|
||||
extern float32_t filtering_pState[LMS_MAX_BLOCKSIZE + FILTERING_MAX_NUMTAPS];
|
||||
extern float32_t filtering_scratch[FILTERING_MAX_BLOCKSIZE * 3];
|
||||
extern float32_t filtering_scratch2[FILTERING_MAX_BLOCKSIZE * 3];
|
||||
extern float32_t filtering_coeffs_lms[FILTERING_MAX_NUMTAPS];
|
||||
|
||||
extern const float64_t filtering_f64_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
|
||||
extern const float32_t filtering_f32_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
|
||||
extern const q31_t filtering_q31_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
|
||||
extern const q15_t * filtering_q15_inputs;
|
||||
extern const q7_t * filtering_q7_inputs;
|
||||
|
||||
/* Block Sizes */
|
||||
ARR_DESC_DECLARE(filtering_blocksizes);
|
||||
ARR_DESC_DECLARE(lms_blocksizes);
|
||||
ARR_DESC_DECLARE(filtering_numtaps);
|
||||
ARR_DESC_DECLARE(filtering_numtaps2);
|
||||
ARR_DESC_DECLARE(filtering_postshifts);
|
||||
ARR_DESC_DECLARE(filtering_numstages);
|
||||
ARR_DESC_DECLARE(filtering_Ls);
|
||||
ARR_DESC_DECLARE(filtering_Ms);
|
||||
|
||||
/* Coefficient Lists */
|
||||
extern const float64_t filtering_coeffs_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
|
||||
extern const float64_t filtering_coeffs_b_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
|
||||
extern const float32_t filtering_coeffs_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
|
||||
extern const float32_t filtering_coeffs_b_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
|
||||
extern const float32_t *filtering_coeffs_c_f32;
|
||||
extern float32_t filtering_coeffs_lms_f32[FILTERING_MAX_NUMTAPS];
|
||||
extern const q31_t filtering_coeffs_q31[FILTERING_MAX_NUMSTAGES * 6 + 2];
|
||||
extern const q31_t *filtering_coeffs_b_q31;
|
||||
extern const q31_t *filtering_coeffs_c_q31;
|
||||
extern q31_t filtering_coeffs_lms_q31[FILTERING_MAX_NUMTAPS];
|
||||
extern const q15_t filtering_coeffs_q15[FILTERING_MAX_NUMSTAGES * 6 + 4];
|
||||
extern const q15_t *filtering_coeffs_b_q15;
|
||||
extern const q15_t *filtering_coeffs_c_q15;
|
||||
extern q15_t filtering_coeffs_lms_q15[FILTERING_MAX_NUMTAPS];
|
||||
extern const q7_t filtering_coeffs_q7[FILTERING_MAX_NUMSTAGES * 6 + 8];
|
||||
extern const q7_t *filtering_coeffs_b_q7;
|
||||
extern const q7_t *filtering_coeffs_c_q7;
|
||||
|
||||
/* Tap Delay Lists */
|
||||
extern const int32_t filtering_tap_delay[FILTERING_MAX_NUMTAPS];
|
||||
|
||||
/* Numbers */
|
||||
|
||||
/* Float Inputs */
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _FILTERING_TEST_GROUP_H_
|
||||
#define _FILTERING_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(filtering_tests);
|
||||
|
||||
#endif /* _FILTERING_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,15 @@
|
||||
#ifndef _FILTERING_TESTS_H_
|
||||
#define _FILTERING_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
JTEST_DECLARE_GROUP(biquad_tests);
|
||||
JTEST_DECLARE_GROUP(conv_tests);
|
||||
JTEST_DECLARE_GROUP(correlate_tests);
|
||||
JTEST_DECLARE_GROUP(fir_tests);
|
||||
JTEST_DECLARE_GROUP(iir_tests);
|
||||
JTEST_DECLARE_GROUP(lms_tests);
|
||||
|
||||
#endif /* _FILTERING_TESTS_H_ */
|
||||
@ -0,0 +1,166 @@
|
||||
#ifndef _INTRINSICS_TEMPLATES_H_
|
||||
#define _INTRINSICS_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
#include <string.h> /* memcpy() */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Comparison SNR thresholds for the data types used in transform_tests.
|
||||
*/
|
||||
#define INTRINSICS_SNR_THRESHOLD_q63_t 120
|
||||
#define INTRINSICS_SNR_THRESHOLD_q31_t 95
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define INTRINSICS_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
intrinsics_output_f32_ref, \
|
||||
(output_type##_t *) intrinsics_output_ref, \
|
||||
intrinsics_output_f32_fut, \
|
||||
(output_type##_t *) intrinsics_output_fut, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
INTRINSICS_SNR_THRESHOLD_##output_type##_t \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* TEST Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define INTRINSICS_TEST_TEMPLATE_ELT1(functionName, dataType) \
|
||||
\
|
||||
JTEST_DEFINE_TEST(functionName##_test, functionName) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_fut + i) = \
|
||||
functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_ref + i) = \
|
||||
ref##functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
} \
|
||||
\
|
||||
INTRINSICS_SNR_COMPARE_INTERFACE( \
|
||||
INTRINSICS_MAX_LEN, \
|
||||
dataType); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
#define INTRINSICS_TEST_TEMPLATE_ELT2(functionName, dataType) \
|
||||
\
|
||||
JTEST_DEFINE_TEST(functionName##_test, functionName) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_fut + i) = \
|
||||
functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_ref + i) = \
|
||||
ref##functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
} \
|
||||
\
|
||||
INTRINSICS_SNR_COMPARE_INTERFACE( \
|
||||
INTRINSICS_MAX_LEN, \
|
||||
dataType); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
#define INTRINSICS_TEST_TEMPLATE_ELT3(functionName, dataType) \
|
||||
\
|
||||
JTEST_DEFINE_TEST(functionName##_test, functionName) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_fut + i) = \
|
||||
functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType##_t*)intrinsics_output_ref + i) = \
|
||||
ref##functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i]); \
|
||||
} \
|
||||
\
|
||||
INTRINSICS_SNR_COMPARE_INTERFACE( \
|
||||
INTRINSICS_MAX_LEN, \
|
||||
dataType); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
#define INTRINSICS_TEST_TEMPLATE_ELT4(functionName, dataType, dataType2) \
|
||||
JTEST_DEFINE_TEST(functionName##_test, functionName) \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
JTEST_COUNT_CYCLES( \
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType2##_t*)intrinsics_output_fut + i) = \
|
||||
functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType2##_t)intrinsics_##dataType2##_inputs[i]); \
|
||||
}); \
|
||||
\
|
||||
for(i=0;i<INTRINSICS_MAX_LEN;i++) \
|
||||
{ \
|
||||
*((dataType2##_t*)intrinsics_output_ref + i) = \
|
||||
ref##functionName( \
|
||||
(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType##_t)intrinsics_##dataType##_inputs[i] \
|
||||
,(dataType2##_t)intrinsics_##dataType2##_inputs[i]); \
|
||||
} \
|
||||
\
|
||||
INTRINSICS_SNR_COMPARE_INTERFACE( \
|
||||
INTRINSICS_MAX_LEN, \
|
||||
dataType2); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
}
|
||||
|
||||
#endif /* _INTRINSICS_TEMPLATES_H_ */
|
||||
@ -0,0 +1,27 @@
|
||||
#ifndef _INTRINSICS_TEST_DATA_H_
|
||||
#define _INTRINSICS_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define INTRINSICS_MAX_LEN 1024
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Variable Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
extern q63_t intrinsics_output_fut[INTRINSICS_MAX_LEN];
|
||||
extern q63_t intrinsics_output_ref[INTRINSICS_MAX_LEN];
|
||||
extern float32_t intrinsics_output_f32_fut[INTRINSICS_MAX_LEN];
|
||||
extern float32_t intrinsics_output_f32_ref[INTRINSICS_MAX_LEN];
|
||||
extern const q63_t intrinsics_q63_inputs[INTRINSICS_MAX_LEN];
|
||||
extern const q31_t *intrinsics_q31_inputs;
|
||||
|
||||
#endif /* _INTRINSICS_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _INTRINSICS_TEST_GROUP_H_
|
||||
#define _INTRINSICS_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(intrinsics_tests);
|
||||
|
||||
#endif /* _INTRINSICS_TEST_GROUP_H_ */
|
||||
52
Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/math_helper.h
Normal file
52
Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/math_helper.h
Normal file
@ -0,0 +1,52 @@
|
||||
/* ----------------------------------------------------------------------
|
||||
* Copyright (C) 2010 ARM Limited. All rights reserved.
|
||||
*
|
||||
* $Date: 29. November 2010
|
||||
* $Revision: V1.0.3
|
||||
*
|
||||
* Project: CMSIS DSP Library
|
||||
*
|
||||
* Title: math_helper.h
|
||||
*
|
||||
*
|
||||
* Description: Prototypes of all helper functions required.
|
||||
*
|
||||
* Target Processor: Cortex-M4/Cortex-M3
|
||||
*
|
||||
* Version 1.0.3 2010/11/29
|
||||
* Re-organized the CMSIS folders and updated documentation.
|
||||
*
|
||||
* Version 1.0.2 2010/11/11
|
||||
* Documentation updated.
|
||||
*
|
||||
* Version 1.0.1 2010/10/05
|
||||
* Production release and review comments incorporated.
|
||||
*
|
||||
* Version 1.0.0 2010/09/20
|
||||
* Production release and review comments incorporated.
|
||||
*
|
||||
* Version 0.0.7 2010/06/10
|
||||
* Misra-C changes done
|
||||
* -------------------------------------------------------------------- */
|
||||
|
||||
#ifndef MATH_HELPER_H
|
||||
#define MATH_HELPER_H
|
||||
|
||||
#include "arm_math.h"
|
||||
|
||||
float arm_snr_f32(float *pRef, float *pTest, uint32_t buffSize);
|
||||
double arm_snr_f64(double *pRef, double *pTest, uint32_t buffSize);
|
||||
void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples);
|
||||
void arm_provide_guard_bits_q15(q15_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
|
||||
void arm_provide_guard_bits_q31(q31_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
|
||||
void arm_float_to_q14(float *pIn, q15_t *pOut, uint32_t numSamples);
|
||||
void arm_float_to_q29(float *pIn, q31_t *pOut, uint32_t numSamples);
|
||||
void arm_float_to_q28(float *pIn, q31_t *pOut, uint32_t numSamples);
|
||||
void arm_float_to_q30(float *pIn, q31_t *pOut, uint32_t numSamples);
|
||||
void arm_clip_f32(float *pIn, uint32_t numSamples);
|
||||
uint32_t arm_calc_guard_bits(uint32_t num_adds);
|
||||
void arm_apply_guard_bits (float32_t * pIn, uint32_t numSamples, uint32_t guard_bits);
|
||||
uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples);
|
||||
uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t *pOut, uint32_t numSamples);
|
||||
uint32_t arm_calc_2pow(uint32_t guard_bits);
|
||||
#endif
|
||||
@ -0,0 +1,370 @@
|
||||
#ifndef _MATRIX_TEMPLATES_H_
|
||||
#define _MATRIX_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function.
|
||||
*/
|
||||
#define MATRIX_COMPARE_INTERFACE(output_type, output_content_type) \
|
||||
TEST_ASSERT_BUFFERS_EQUAL( \
|
||||
((output_type *) &matrix_output_ref)->pData, \
|
||||
((output_type *) &matrix_output_fut)->pData, \
|
||||
((output_type *) &matrix_output_fut)->numRows * \
|
||||
((output_type *) &matrix_output_ref)->numCols * \
|
||||
sizeof(output_content_type))
|
||||
|
||||
/**
|
||||
* Comparison SNR thresholds for the data types used in matrix_tests.
|
||||
*/
|
||||
#define MATRIX_SNR_THRESHOLD 120
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define MATRIX_SNR_COMPARE_INTERFACE(output_type, output_content_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
(float32_t *)matrix_output_f32_ref, \
|
||||
((output_type *) &matrix_output_ref)->pData, \
|
||||
(float32_t *)matrix_output_f32_fut, \
|
||||
((output_type *) &matrix_output_ref)->pData, \
|
||||
((output_type *) &matrix_output_fut)->numRows * \
|
||||
((output_type *) &matrix_output_ref)->numCols, \
|
||||
output_content_type, \
|
||||
MATRIX_SNR_THRESHOLD \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR. This is special for float64_t
|
||||
*/
|
||||
#define MATRIX_DBL_SNR_COMPARE_INTERFACE(output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_ASSERT_DBL_SNR( \
|
||||
(float64_t *)matrix_output_f32_ref, \
|
||||
(float64_t *)matrix_output_f32_fut, \
|
||||
((output_type *) &matrix_output_fut)->numRows * \
|
||||
((output_type *) &matrix_output_ref)->numCols, \
|
||||
MATRIX_SNR_THRESHOLD \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
#define ARM_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_inverse_INPUT_INTERFACE(input_ptr) \
|
||||
PAREN(input_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_inverse_INPUT_INTERFACE(input_ptr) \
|
||||
PAREN(input_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
|
||||
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
#define ARM_mat_trans_INPUT_INTERFACE(input_ptr) \
|
||||
PAREN(input_ptr, (void *) &matrix_output_fut)
|
||||
|
||||
#define REF_mat_trans_INPUT_INTERFACE(input_ptr) \
|
||||
PAREN(input_ptr, (void *) &matrix_output_ref)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Dimension Validation Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS(input_type, \
|
||||
matrix_a_ptr, \
|
||||
matrix_b_ptr) \
|
||||
((((input_type) (matrix_a_ptr))->numRows == \
|
||||
((input_type) (matrix_b_ptr))->numRows) && \
|
||||
(((input_type) (matrix_a_ptr))->numCols == \
|
||||
((input_type) (matrix_b_ptr))->numCols))
|
||||
|
||||
#define MATRIX_TEST_VALID_MULTIPLICATIVE_DIMENSIONS(input_type, \
|
||||
matrix_a_ptr, \
|
||||
matrix_b_ptr) \
|
||||
(((input_type) (matrix_a_ptr))->numCols == \
|
||||
((input_type) (matrix_b_ptr))->numRows)
|
||||
|
||||
#define MATRIX_TEST_VALID_SQUARE_DIMENSIONS(input_type, \
|
||||
matrix_ptr) \
|
||||
(((input_type)(matrix_ptr))->numRows == \
|
||||
((input_type)(matrix_ptr))->numCols)
|
||||
|
||||
#define MATRIX_TEST_VALID_DIMENSIONS_ALWAYS(input_type, \
|
||||
matrix_ptr) \
|
||||
(1 == 1) \
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Output Configuration Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* The matrix tests assume the output matrix is always the correct size. These
|
||||
* interfaces size the properly size the output matrices according to the input
|
||||
* matrices and the operation at hand.*/
|
||||
|
||||
#define MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT(input_type, \
|
||||
matrix_a_ptr, \
|
||||
matrix_b_ptr) \
|
||||
do \
|
||||
{ \
|
||||
((input_type) &matrix_output_fut)->numRows = \
|
||||
((input_type)(matrix_a_ptr))->numRows; \
|
||||
((input_type) &matrix_output_fut)->numCols = \
|
||||
((input_type)(matrix_a_ptr))->numCols; \
|
||||
((input_type) &matrix_output_ref)->numRows = \
|
||||
((input_type)(matrix_a_ptr))->numRows; \
|
||||
((input_type) &matrix_output_ref)->numCols = \
|
||||
((input_type)(matrix_a_ptr))->numCols; \
|
||||
} while (0)
|
||||
|
||||
#define MATRIX_TEST_CONFIG_MULTIPLICATIVE_OUTPUT(input_type, \
|
||||
matrix_a_ptr, \
|
||||
matrix_b_ptr) \
|
||||
do \
|
||||
{ \
|
||||
((input_type) &matrix_output_fut)->numRows = \
|
||||
((input_type)(matrix_a_ptr))->numRows; \
|
||||
((input_type) &matrix_output_fut)->numCols = \
|
||||
((input_type)(matrix_b_ptr))->numCols; \
|
||||
((input_type) &matrix_output_ref)->numRows = \
|
||||
((input_type)(matrix_a_ptr))->numRows; \
|
||||
((input_type) &matrix_output_ref)->numCols = \
|
||||
((input_type)(matrix_b_ptr))->numCols; \
|
||||
} while (0)
|
||||
|
||||
#define MATRIX_TEST_CONFIG_SAMESIZE_OUTPUT(input_type, \
|
||||
matrix_ptr) \
|
||||
do \
|
||||
{ \
|
||||
((input_type) &matrix_output_fut)->numRows = \
|
||||
((input_type)(matrix_ptr))->numRows; \
|
||||
((input_type) &matrix_output_fut)->numCols = \
|
||||
((input_type)(matrix_ptr))->numCols; \
|
||||
((input_type) &matrix_output_ref)->numRows = \
|
||||
((input_type)(matrix_ptr))->numRows; \
|
||||
((input_type) &matrix_output_ref)->numCols = \
|
||||
((input_type)(matrix_ptr))->numCols; \
|
||||
} while (0)
|
||||
|
||||
#define MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT(input_type, \
|
||||
matrix_ptr) \
|
||||
do \
|
||||
{ \
|
||||
((input_type) &matrix_output_fut)->numRows = \
|
||||
((input_type)(matrix_ptr))->numCols; \
|
||||
((input_type) &matrix_output_fut)->numCols = \
|
||||
((input_type)(matrix_ptr))->numRows; \
|
||||
((input_type) &matrix_output_ref)->numRows = \
|
||||
((input_type)(matrix_ptr))->numCols; \
|
||||
((input_type) &matrix_output_ref)->numCols = \
|
||||
((input_type)(matrix_ptr))->numRows; \
|
||||
} while (0)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* TEST Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define MATRIX_TEST_TEMPLATE_ELT1(arr_desc_inputs, \
|
||||
input_type, \
|
||||
output_type, output_content_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
input_idx, input_type, input, arr_desc_inputs \
|
||||
, \
|
||||
JTEST_DUMP_STRF("Matrix Dimensions: %dx%d\n", \
|
||||
(int)input->numRows, \
|
||||
(int)input->numCols); \
|
||||
\
|
||||
if (dim_validation_interface(input_type, \
|
||||
input)) { \
|
||||
output_config_interface(input_type, \
|
||||
input); \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface(input), \
|
||||
ref, ref_arg_interface(input)); \
|
||||
compare_interface(output_type, \
|
||||
output_content_type); \
|
||||
} else { \
|
||||
arm_status matrix_test_retval; \
|
||||
TEST_CALL_FUT( \
|
||||
matrix_test_retval = fut, \
|
||||
fut_arg_interface(input)); \
|
||||
\
|
||||
/* If dimensions are known bad, the fut should */ \
|
||||
/* detect it. */ \
|
||||
if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \
|
||||
return JTEST_TEST_FAILED; \
|
||||
} \
|
||||
}); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
|
||||
#define MATRIX_TEST_TEMPLATE_ELT2(arr_desc_inputs_a, \
|
||||
arr_desc_inputs_b, \
|
||||
input_type, \
|
||||
output_type, output_content_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
input_a_idx, input_type, input_a, arr_desc_inputs_a \
|
||||
, \
|
||||
input_type input_b = ARR_DESC_ELT( \
|
||||
input_type, input_a_idx, \
|
||||
&(arr_desc_inputs_b)); \
|
||||
\
|
||||
JTEST_DUMP_STRF("Matrix Dimensions: A %dx%d B %dx%d\n", \
|
||||
(int)input_a->numRows, \
|
||||
(int)input_a->numCols, \
|
||||
(int)input_b->numRows, \
|
||||
(int)input_b->numCols); \
|
||||
\
|
||||
if (dim_validation_interface(input_type, \
|
||||
input_a, \
|
||||
input_b)) { \
|
||||
\
|
||||
output_config_interface(input_type, \
|
||||
input_a, \
|
||||
input_b); \
|
||||
\
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface(input_a, input_b), \
|
||||
ref, ref_arg_interface(input_a, input_b)); \
|
||||
\
|
||||
compare_interface(output_type, output_content_type); \
|
||||
\
|
||||
} else { \
|
||||
arm_status matrix_test_retval; \
|
||||
TEST_CALL_FUT( \
|
||||
matrix_test_retval = fut, fut_arg_interface(input_a, input_b)); \
|
||||
\
|
||||
/* If dimensions are known bad, the fut should */ \
|
||||
/* detect it. */ \
|
||||
if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \
|
||||
return JTEST_TEST_FAILED; \
|
||||
} \
|
||||
}); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Specialization of #MATRIX_TEST_TEMPLATE_ELT2() for matrix tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT2(fn_name, suffix, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
MATRIX_TEST_TEMPLATE_ELT2( \
|
||||
matrix_##suffix##_a_inputs, \
|
||||
matrix_##suffix##_b_inputs, \
|
||||
arm_matrix_instance_##suffix * , \
|
||||
arm_matrix_instance_##suffix, \
|
||||
TYPE_FROM_ABBREV(suffix), \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface, \
|
||||
comparison_interface); \
|
||||
} \
|
||||
|
||||
/**
|
||||
* Specialization of #MATRIX_TEST_TEMPLATE_ELT1() for matrix tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT1(fn_name, suffix, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
MATRIX_TEST_TEMPLATE_ELT1( \
|
||||
matrix_##suffix##_a_inputs, \
|
||||
arm_matrix_instance_##suffix * , \
|
||||
arm_matrix_instance_##suffix, \
|
||||
TYPE_FROM_ABBREV(suffix), \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
output_config_interface, \
|
||||
dim_validation_interface, \
|
||||
MATRIX_COMPARE_INTERFACE); \
|
||||
} \
|
||||
|
||||
|
||||
#endif /* _MATRIX_TEMPLATES_H_ */
|
||||
@ -0,0 +1,54 @@
|
||||
#ifndef _MATRIX_TEST_DATA_H_
|
||||
#define _MATRIX_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h" /* float32_t */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#define MATRIX_TEST_MAX_ROWS 4
|
||||
#define MATRIX_TEST_MAX_COLS 4
|
||||
#define MATRIX_TEST_BIGGEST_INPUT_TYPE float64_t
|
||||
#define MATRIX_TEST_MAX_ELTS (MATRIX_TEST_MAX_ROWS * MATRIX_TEST_MAX_COLS)
|
||||
#define MATRIX_MAX_COEFFS_LEN 16
|
||||
#define MATRIX_MAX_SHIFTS_LEN 5
|
||||
|
||||
/**
|
||||
* Declare the matrix inputs defined by MATRIX_DEFINE_INPUTS.
|
||||
*/
|
||||
#define MATRIX_DECLARE_INPUTS(suffix) \
|
||||
ARR_DESC_DECLARE(matrix_##suffix##_a_inputs); \
|
||||
ARR_DESC_DECLARE(matrix_##suffix##_b_inputs); \
|
||||
ARR_DESC_DECLARE(matrix_##suffix##_invertible_inputs)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
extern arm_matrix_instance_f32 matrix_output_fut;
|
||||
extern arm_matrix_instance_f32 matrix_output_ref;
|
||||
extern arm_matrix_instance_f64 matrix_output_fut64;
|
||||
extern arm_matrix_instance_f64 matrix_output_ref64;
|
||||
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_fut[MATRIX_TEST_MAX_ELTS];
|
||||
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_ref[MATRIX_TEST_MAX_ELTS];
|
||||
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_scratch[MATRIX_TEST_MAX_ELTS];
|
||||
|
||||
/* Matrix Inputs */
|
||||
MATRIX_DECLARE_INPUTS(f64);
|
||||
MATRIX_DECLARE_INPUTS(f32);
|
||||
MATRIX_DECLARE_INPUTS(q31);
|
||||
MATRIX_DECLARE_INPUTS(q15);
|
||||
|
||||
extern const float32_t matrix_f32_scale_values[MATRIX_MAX_COEFFS_LEN];
|
||||
extern const q31_t matrix_q31_scale_values[MATRIX_MAX_COEFFS_LEN];
|
||||
extern const q15_t matrix_q15_scale_values[MATRIX_MAX_COEFFS_LEN];
|
||||
extern const int32_t matrix_shift_values[MATRIX_MAX_SHIFTS_LEN];
|
||||
|
||||
#endif /* _MATRIX_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _MATRIX_TEST_GROUP_H_
|
||||
#define _MATRIX_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(matrix_tests);
|
||||
|
||||
#endif /* _MATRIX_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef _MATRIX_TESTS_H_
|
||||
#define _MATRIX_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(mat_add_tests);
|
||||
JTEST_DECLARE_GROUP(mat_cmplx_mult_tests);
|
||||
JTEST_DECLARE_GROUP(mat_init_tests);
|
||||
JTEST_DECLARE_GROUP(mat_inverse_tests);
|
||||
JTEST_DECLARE_GROUP(mat_mult_tests);
|
||||
JTEST_DECLARE_GROUP(mat_mult_fast_tests);
|
||||
JTEST_DECLARE_GROUP(mat_sub_tests);
|
||||
JTEST_DECLARE_GROUP(mat_trans_tests);
|
||||
JTEST_DECLARE_GROUP(mat_scale_tests);
|
||||
|
||||
#endif /* _MATRIX_TESTS_H_ */
|
||||
@ -0,0 +1,157 @@
|
||||
#ifndef _STATISTICS_TEMPLATES_H_
|
||||
#define _STATISTICS_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference function.
|
||||
*/
|
||||
#define STATISTICS_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_ASSERT_BUFFERS_EQUAL( \
|
||||
statistics_output_ref.data_ptr, \
|
||||
statistics_output_fut.data_ptr, \
|
||||
1 * sizeof(output_type) /* All fns return one value*/ \
|
||||
); \
|
||||
TEST_ASSERT_EQUAL( \
|
||||
statistics_idx_fut, \
|
||||
statistics_idx_ref); \
|
||||
} while (0) \
|
||||
|
||||
/*
|
||||
* Comparison SNR thresholds for the data types used in statistics_tests.
|
||||
*/
|
||||
#define STATISTICS_SNR_THRESHOLD_float32_t 120
|
||||
#define STATISTICS_SNR_THRESHOLD_q31_t 100
|
||||
#define STATISTICS_SNR_THRESHOLD_q15_t 60
|
||||
#define STATISTICS_SNR_THRESHOLD_q7_t 30
|
||||
|
||||
/**
|
||||
* Compare reference and fut outputs using SNR.
|
||||
*
|
||||
* @note The outputs are converted to float32_t before comparison.
|
||||
*/
|
||||
#define STATISTICS_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
statistics_output_f32_ref, \
|
||||
statistics_output_ref.data_ptr, \
|
||||
statistics_output_f32_fut, \
|
||||
statistics_output_fut.data_ptr, \
|
||||
1, /* All fns return one element*/ \
|
||||
output_type, \
|
||||
STATISTICS_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
#define ARM_max_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, \
|
||||
statistics_output_fut.data_ptr, &statistics_idx_fut)
|
||||
|
||||
#define REF_max_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, \
|
||||
statistics_output_ref.data_ptr, &statistics_idx_ref)
|
||||
|
||||
#define ARM_mean_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_fut.data_ptr)
|
||||
|
||||
#define REF_mean_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_ref.data_ptr)
|
||||
|
||||
#define ARM_min_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, \
|
||||
statistics_output_fut.data_ptr, &statistics_idx_fut)
|
||||
|
||||
#define REF_min_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, \
|
||||
statistics_output_ref.data_ptr, &statistics_idx_ref)
|
||||
|
||||
#define ARM_power_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_fut.data_ptr)
|
||||
|
||||
#define REF_power_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_ref.data_ptr)
|
||||
|
||||
#define ARM_rms_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_fut.data_ptr)
|
||||
|
||||
#define REF_rms_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_ref.data_ptr)
|
||||
|
||||
#define ARM_std_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_fut.data_ptr)
|
||||
|
||||
#define REF_std_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_ref.data_ptr)
|
||||
|
||||
#define ARM_var_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_fut.data_ptr)
|
||||
|
||||
#define REF_var_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, block_size, statistics_output_ref.data_ptr)
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for statistics tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_BLK( \
|
||||
statistics_f_all, \
|
||||
statistics_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
|
||||
#endif /* _STATISTICS_TEMPLATES_H_ */
|
||||
@ -0,0 +1,44 @@
|
||||
#ifndef _STATISTICS_TEST_DATA_H_
|
||||
#define _STATISTICS_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#define STATISTICS_MAX_INPUT_ELEMENTS 32
|
||||
#define STATISTICS_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
ARR_DESC_DECLARE(statistics_output_fut);
|
||||
ARR_DESC_DECLARE(statistics_output_ref);
|
||||
extern uint32_t statistics_idx_fut;
|
||||
extern uint32_t statistics_idx_ref;
|
||||
|
||||
extern STATISTICS_BIGGEST_INPUT_TYPE
|
||||
statistics_output_f32_ref[STATISTICS_MAX_INPUT_ELEMENTS];
|
||||
|
||||
extern STATISTICS_BIGGEST_INPUT_TYPE
|
||||
statistics_output_f32_fut[STATISTICS_MAX_INPUT_ELEMENTS];
|
||||
|
||||
|
||||
/* Block Sizes */
|
||||
ARR_DESC_DECLARE(statistics_block_sizes);
|
||||
|
||||
/* Float Inputs */
|
||||
ARR_DESC_DECLARE(statistics_zeros);
|
||||
ARR_DESC_DECLARE(statistics_f_2);
|
||||
ARR_DESC_DECLARE(statistics_f_15);
|
||||
ARR_DESC_DECLARE(statistics_f_32);
|
||||
ARR_DESC_DECLARE(statistics_f_all);
|
||||
|
||||
#endif /* _STATISTICS_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _STATISTICS_TEST_GROUP_H_
|
||||
#define _STATISTICS_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(statistics_tests);
|
||||
|
||||
#endif /* _STATISTICS_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,15 @@
|
||||
#ifndef _STATISTICS_TESTS_H_
|
||||
#define _STATISTICS_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(max_tests);
|
||||
JTEST_DECLARE_GROUP(mean_tests);
|
||||
JTEST_DECLARE_GROUP(min_tests);
|
||||
JTEST_DECLARE_GROUP(power_tests);
|
||||
JTEST_DECLARE_GROUP(rms_tests);
|
||||
JTEST_DECLARE_GROUP(std_tests);
|
||||
JTEST_DECLARE_GROUP(var_tests);
|
||||
|
||||
#endif /* _STATISTICS_TESTS_H_ */
|
||||
@ -0,0 +1,120 @@
|
||||
#ifndef _SUPPORT_TEMPLATES_H_
|
||||
#define _SUPPORT_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference function.
|
||||
*/
|
||||
#define SUPPORT_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_ASSERT_BUFFERS_EQUAL( \
|
||||
support_output_ref.data_ptr, \
|
||||
support_output_fut.data_ptr, \
|
||||
block_size * sizeof(output_type)); \
|
||||
} while (0) \
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Input Interfaces */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/*
|
||||
* General:
|
||||
* Input interfaces provide inputs to functions inside test templates. They
|
||||
* ONLY provide the inputs. The output variables should be hard coded.
|
||||
*
|
||||
* The input interfaces must have the following format:
|
||||
*
|
||||
* ARM_xxx_INPUT_INTERFACE() or
|
||||
* REF_xxx_INPUT_INTERFACE()
|
||||
*
|
||||
* The xxx must be lowercase, and is intended to be the indentifying substring
|
||||
* in the function's name. Acceptable values are 'sub' or 'add' from the
|
||||
* functions arm_add_q31.
|
||||
*/
|
||||
|
||||
#define ARM_copy_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, support_output_fut.data_ptr, block_size)
|
||||
|
||||
#define REF_copy_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, support_output_ref.data_ptr, block_size)
|
||||
|
||||
#define ARM_fill_INPUT_INTERFACE(elt, block_size) \
|
||||
PAREN(elt, support_output_fut.data_ptr, block_size)
|
||||
|
||||
#define REF_fill_INPUT_INTERFACE(elt, block_size) \
|
||||
PAREN(elt, support_output_ref.data_ptr, block_size)
|
||||
|
||||
#define ARM_x_to_y_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, support_output_fut.data_ptr, block_size)
|
||||
|
||||
#define REF_x_to_y_INPUT_INTERFACE(input, block_size) \
|
||||
PAREN(input, support_output_ref.data_ptr, block_size)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for support tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define SUPPORT_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
|
||||
suffix, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_BUF1_BLK( \
|
||||
support_f_all, \
|
||||
support_block_sizes, \
|
||||
input_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
/**
|
||||
* Specialization of #TEST_TEMPLATE_ELT1_BLK() for support tests.
|
||||
*
|
||||
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
|
||||
* REF_xxx_INPUT_INTERFACEs.
|
||||
*/
|
||||
#define SUPPORT_DEFINE_TEST_TEMPLATE_ELT1_BLK(fn_name, \
|
||||
suffix, \
|
||||
elt_type, \
|
||||
output_type, \
|
||||
comparison_interface) \
|
||||
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
|
||||
arm_##fn_name##_##suffix) \
|
||||
{ \
|
||||
TEST_TEMPLATE_ELT1_BLK( \
|
||||
support_elts, \
|
||||
support_block_sizes, \
|
||||
elt_type, \
|
||||
output_type, \
|
||||
arm_##fn_name##_##suffix, \
|
||||
ARM_##fn_name##_INPUT_INTERFACE, \
|
||||
ref_##fn_name##_##suffix, \
|
||||
REF_##fn_name##_INPUT_INTERFACE, \
|
||||
comparison_interface); \
|
||||
}
|
||||
|
||||
#endif /* _SUPPORT_TEMPLATES_H_ */
|
||||
@ -0,0 +1,31 @@
|
||||
#ifndef ARM_SUPPORT_TEST_DATA_H
|
||||
#define ARM_SUPPORT_TEST_DATA_H
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Variables */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Input/Output Buffers */
|
||||
ARR_DESC_DECLARE(support_output_fut);
|
||||
ARR_DESC_DECLARE(support_output_ref);
|
||||
|
||||
/* Block Sizes*/
|
||||
ARR_DESC_DECLARE(support_block_sizes);
|
||||
|
||||
/* Numbers */
|
||||
ARR_DESC_DECLARE(support_elts);
|
||||
|
||||
/* Float Inputs */
|
||||
ARR_DESC_DECLARE(support_zeros);
|
||||
ARR_DESC_DECLARE(support_f_2);
|
||||
ARR_DESC_DECLARE(support_f_15);
|
||||
ARR_DESC_DECLARE(support_f_32);
|
||||
ARR_DESC_DECLARE(support_f_all);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _SUPPORT_TEST_GROUP_H_
|
||||
#define _SUPPORT_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(support_tests);
|
||||
|
||||
#endif /* _SUPPORT_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,11 @@
|
||||
#ifndef _SUPPORT_TESTS_H_
|
||||
#define _SUPPORT_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(copy_tests);
|
||||
JTEST_DECLARE_GROUP(fill_tests);
|
||||
JTEST_DECLARE_GROUP(x_to_y_tests);
|
||||
|
||||
#endif /* _SUPPORT_TESTS_H_ */
|
||||
@ -0,0 +1,88 @@
|
||||
#ifndef _TEMPLATE_H_
|
||||
#define _TEMPLATE_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Looping and Iteration */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Template for the general structure of a loop.
|
||||
*/
|
||||
#define TEMPLATE_LOOP(setup, loop_def, body) \
|
||||
do \
|
||||
{ \
|
||||
setup; \
|
||||
loop_def { \
|
||||
body; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for looping over an array-like sequence.
|
||||
*/
|
||||
#define TEMPLATE_DO_ARR_LIKE(iter_idx, type, \
|
||||
arr, arr_length, \
|
||||
iter_elem_setup, \
|
||||
body) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_LOOP( \
|
||||
int iter_idx, \
|
||||
for(iter_idx = 0; iter_idx < (arr_length); ++iter_idx), \
|
||||
iter_elem_setup; \
|
||||
body); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for looping over the contents of an array.
|
||||
*/
|
||||
#define TEMPLATE_DO_ARR(iter_idx, type, iter_elem, arr, arr_length, body) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_LIKE( \
|
||||
iter_idx, type, arr, arr_length, \
|
||||
type iter_elem = (arr)[iter_idx], \
|
||||
body); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for looping over the contents of an #ARR_DESC.
|
||||
*/
|
||||
#define TEMPLATE_DO_ARR_DESC(iter_idx, type, iter_elem, arr_desc, body) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_LIKE( \
|
||||
iter_idx, type, arr_desc, (arr_desc).element_count, \
|
||||
type iter_elem = ARR_DESC_ELT(type, iter_idx, &(arr_desc)), \
|
||||
body); \
|
||||
} while (0)
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test Definition */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Template for the general structure of a test.
|
||||
*/
|
||||
#define TEMPLATE_TEST(setup, body, teardown) \
|
||||
do \
|
||||
{ \
|
||||
setup; \
|
||||
body; \
|
||||
teardown; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for calling a function.
|
||||
*
|
||||
* @note Surround function arguments with the #PAREN() macro.
|
||||
*
|
||||
* @example
|
||||
* void my_func(int arg1, int arg2);
|
||||
*
|
||||
* TEMPLATE_CALL_FN(my_func, PAREN(3, 7));
|
||||
*/
|
||||
#define TEMPLATE_CALL_FN(fn, fn_args) \
|
||||
fn fn_args
|
||||
|
||||
#endif /* _TEMPLATE_H_ */
|
||||
@ -0,0 +1,466 @@
|
||||
#ifndef _TEST_TEMPLATES_H_
|
||||
#define _TEST_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#include "template.h"
|
||||
#include <string.h> /* memcmp() */
|
||||
#include <inttypes.h> /* PRIu32 */
|
||||
#include "math_helper.h" /* arm_snr_f32() */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Function Aliases for use in Templates. */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
#define ref_q31_t_to_float ref_q31_to_float
|
||||
#define ref_q15_t_to_float ref_q15_to_float
|
||||
#define ref_q7_t_to_float ref_q7_to_float
|
||||
#define ref_float_to_q31_t ref_float_to_q31
|
||||
#define ref_float_to_q15_t ref_float_to_q15
|
||||
#define ref_float_to_q7_t ref_float_to_q7
|
||||
#define ref_float32_t_to_float ref_copy_f32
|
||||
#define ref_float_to_float32_t ref_copy_f32
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Call the function-under-test.
|
||||
*/
|
||||
#define TEST_CALL_FUT(fut, fut_args) \
|
||||
JTEST_COUNT_CYCLES(TEMPLATE_CALL_FN(fut, fut_args))
|
||||
|
||||
/**
|
||||
* Call the reference-function.
|
||||
*/
|
||||
#define TEST_CALL_REF(ref, ref_args) \
|
||||
TEMPLATE_CALL_FN(ref, ref_args)
|
||||
|
||||
/**
|
||||
* Call the function-under-test and the reference-function.
|
||||
*/
|
||||
#define TEST_CALL_FUT_AND_REF(fut, fut_args, ref, ref_args) \
|
||||
do { \
|
||||
TEST_CALL_FUT(fut, fut_args); \
|
||||
TEST_CALL_REF(ref, ref_args); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* This macro eats a variable number of arguments and evaluates to a null
|
||||
* statement.
|
||||
*/
|
||||
#define TEST_NULL_STATEMENT(...) (void) "TEST_NULL_STATEMENT"
|
||||
|
||||
/**
|
||||
* A function name, Usable in any template where a fut or ref name is accepted,
|
||||
* that evaluates to a #TEST_NULL_STATEMENT().
|
||||
*/
|
||||
#define TEST_NULL_FN TEST_NULL_STATEMENT
|
||||
|
||||
/**
|
||||
* Assert that buffers A and B are byte-equivalent for a number of bytes.
|
||||
*/
|
||||
|
||||
#define TEST_ASSERT_BUFFERS_EQUAL(buf_a, buf_b, bytes)\
|
||||
do \
|
||||
{ \
|
||||
if (memcmp(buf_a, buf_b, bytes) != 0) \
|
||||
{ \
|
||||
return JTEST_TEST_FAILED; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Assert that the two entities are equal.
|
||||
*/
|
||||
#define TEST_ASSERT_EQUAL(a, b) \
|
||||
do \
|
||||
{ \
|
||||
if ((a) != (b)) \
|
||||
{ \
|
||||
return JTEST_TEST_FAILED;\
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Convert elements to from src_type to float.
|
||||
*/
|
||||
#define TEST_CONVERT_TO_FLOAT(src_ptr, dst_ptr, block_size, src_type) \
|
||||
do \
|
||||
{ \
|
||||
ref_##src_type##_to_float( \
|
||||
src_ptr, \
|
||||
dst_ptr, \
|
||||
block_size); \
|
||||
} while (0) \
|
||||
|
||||
/**
|
||||
* Convert elements to from float to dst_type .
|
||||
*/
|
||||
#define TEST_CONVERT_FLOAT_TO(src_ptr, dst_ptr, block_size, dst_type) \
|
||||
do \
|
||||
{ \
|
||||
ref_float_to_##dst_type( \
|
||||
src_ptr, \
|
||||
dst_ptr, \
|
||||
block_size); \
|
||||
} while (0) \
|
||||
|
||||
/**
|
||||
* Assert that the SNR between a reference and test sample is above a given
|
||||
* threshold.
|
||||
*/
|
||||
|
||||
#define TEST_ASSERT_SNR(ref_ptr, tst_ptr, block_size, threshold) \
|
||||
do \
|
||||
{ \
|
||||
float32_t snr = arm_snr_f32(ref_ptr, tst_ptr, block_size);\
|
||||
if ( snr <= threshold) \
|
||||
{ \
|
||||
JTEST_DUMP_STRF("SNR: %f\n", snr); \
|
||||
return JTEST_TEST_FAILED; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
/**
|
||||
* Assert that the SNR between a reference and test sample is above a given
|
||||
* threshold. Special case for float64_t
|
||||
*/
|
||||
|
||||
#define TEST_ASSERT_DBL_SNR(ref_ptr, tst_ptr, block_size, threshold)\
|
||||
do \
|
||||
{ \
|
||||
float64_t snr = arm_snr_f64(ref_ptr, tst_ptr, block_size); \
|
||||
if ( snr <= threshold) \
|
||||
{ \
|
||||
JTEST_DUMP_STRF("SNR: %f\n", snr); \
|
||||
return JTEST_TEST_FAILED; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
/**
|
||||
* Compare test and reference elements by converting to float and
|
||||
* calculating an SNR.
|
||||
*
|
||||
* This macro is a merger of the #TEST_CONVERT_TO_FLOAT() and
|
||||
* #TEST_ASSERT_SNR() macros.
|
||||
*/
|
||||
#define TEST_CONVERT_AND_ASSERT_SNR(ref_dst_ptr, ref_src_ptr, \
|
||||
tst_dst_ptr, tst_src_ptr, \
|
||||
block_size, \
|
||||
tst_src_type, \
|
||||
threshold) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_TO_FLOAT(ref_src_ptr, \
|
||||
ref_dst_ptr, \
|
||||
block_size, \
|
||||
tst_src_type); \
|
||||
TEST_CONVERT_TO_FLOAT(tst_src_ptr, \
|
||||
tst_dst_ptr, \
|
||||
block_size, \
|
||||
tst_src_type); \
|
||||
TEST_ASSERT_SNR(ref_dst_ptr, \
|
||||
tst_dst_ptr, \
|
||||
block_size, \
|
||||
threshold); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Execute statements only if the combination of block size, function type
|
||||
* specifier, and input ARR_DESC_t are valid.
|
||||
*
|
||||
* @example An ARR_DESC_t that contains 64 bytes cant service a 32 element
|
||||
* block size if they are extracted in float32_t increments.
|
||||
*
|
||||
* 8 * 32 = 256 > 64.
|
||||
*/
|
||||
#define TEST_DO_VALID_BLOCKSIZE(block_size, fn_type_spec, \
|
||||
input_arr_desc, body) \
|
||||
do \
|
||||
{ \
|
||||
if (block_size * sizeof(fn_type_spec) <= \
|
||||
ARR_DESC_BYTES(input_arr_desc)) \
|
||||
{ \
|
||||
JTEST_DUMP_STRF("Block Size: %"PRIu32"\n", block_size); \
|
||||
body; \
|
||||
} \
|
||||
} while (0) \
|
||||
|
||||
/**
|
||||
* Template for tests that rely on one input buffer and a blocksize parameter.
|
||||
*
|
||||
* The buffer is an #ARR_DESC_t. It is iterated over and it's values are
|
||||
* passed to the function under test and reference functions through their
|
||||
* appropriate argument interfaces. The argument interfaces this template to
|
||||
* execute structurally similar functions.
|
||||
*
|
||||
*/
|
||||
#define TEST_TEMPLATE_BUF1_BLK(arr_desc_inputs, \
|
||||
arr_desc_block_sizes, \
|
||||
input_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
block_size_idx, uint32_t, block_size, arr_desc_block_sizes \
|
||||
, \
|
||||
void * input_data_ptr = input_ptr->data_ptr; \
|
||||
\
|
||||
TEST_DO_VALID_BLOCKSIZE( \
|
||||
block_size, input_type, input_ptr \
|
||||
, \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
input_data_ptr, block_size), \
|
||||
ref, ref_arg_interface( \
|
||||
input_data_ptr, block_size)); \
|
||||
\
|
||||
compare_interface(block_size, output_type)))); \
|
||||
\
|
||||
return JTEST_TEST_PASSED; \
|
||||
\
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for tests that rely on an input buffer and an element.
|
||||
*
|
||||
* An element can is any thing which doesn't walk and talk like a
|
||||
* sequence. Examples include numbers, and structures.
|
||||
*/
|
||||
#define TEST_TEMPLATE_BUF1_ELT1(arr_desc_inputs, \
|
||||
arr_desc_elts, \
|
||||
input_type, elt_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt_idx, elt_type, elt, arr_desc_elts \
|
||||
, \
|
||||
void * input_data_ptr = input_ptr->data_ptr; \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface(input_data_ptr, elt), \
|
||||
ref, ref_arg_interface(input_data_ptr, elt)); \
|
||||
\
|
||||
compare_interface(output_type))); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for tests that rely on an input buffer, an element, and a blocksize
|
||||
* parameter.
|
||||
*/
|
||||
#define TEST_TEMPLATE_BUF1_ELT1_BLK(arr_desc_inputs, \
|
||||
arr_desc_elts, \
|
||||
arr_desc_block_sizes, \
|
||||
input_type, elt_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface); \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
block_size_idx, uint32_t, block_size, \
|
||||
arr_desc_block_sizes \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt_idx, elt_type, elt, arr_desc_elts \
|
||||
, \
|
||||
void * input_data_ptr = input_ptr->data_ptr; \
|
||||
TEST_DO_VALID_BLOCKSIZE( \
|
||||
block_size, input_type, input_ptr, \
|
||||
\
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
input_data_ptr, elt, block_size), \
|
||||
ref, ref_arg_interface( \
|
||||
input_data_ptr, elt, block_size)); \
|
||||
compare_interface(block_size, output_type))))); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for tests that rely on an input buffer, two elements, and a blocksize
|
||||
* parameter.
|
||||
*/
|
||||
#define TEST_TEMPLATE_BUF1_ELT2_BLK(arr_desc_inputs, \
|
||||
arr_desc_elt1s, \
|
||||
arr_desc_elt2s, \
|
||||
arr_desc_block_sizes, \
|
||||
input_type, elt1_type, \
|
||||
elt2_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
block_size_idx, uint32_t, block_size, \
|
||||
arr_desc_block_sizes \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt1_idx, elt1_type, elt1, arr_desc_elt1s \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt2_idx, elt2_type, elt2, arr_desc_elt2s \
|
||||
, \
|
||||
void * input_data_ptr = input_ptr->data_ptr; \
|
||||
TEST_DO_VALID_BLOCKSIZE( \
|
||||
block_size, input_type, input_ptr, \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
input_data_ptr, elt1, elt2, block_size), \
|
||||
ref, ref_arg_interface( \
|
||||
input_data_ptr, elt1, elt2, block_size)); \
|
||||
compare_interface(block_size, output_type)))))); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Template for tests that rely on two input buffers and a blocksize parameter.
|
||||
*
|
||||
* The two #ARR_DESC_t, input buffers are iterated through in parallel. The
|
||||
* length of the first #ARR_DESC_t determines the length of the iteration.
|
||||
*/
|
||||
#define TEST_TEMPLATE_BUF2_BLK(arr_desc_inputs_a, \
|
||||
arr_desc_inputs_b, \
|
||||
arr_desc_block_sizes, \
|
||||
input_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
/* Iterate over two input arrays in parallel.*/ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs_a \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
block_size_idx, uint32_t, block_size, arr_desc_block_sizes, \
|
||||
void * input_a_ptr = input_ptr->data_ptr; \
|
||||
void * input_b_ptr = ARR_DESC_ELT( \
|
||||
ARR_DESC_t *, input_idx, \
|
||||
&(arr_desc_inputs_b))->data_ptr; \
|
||||
\
|
||||
TEST_DO_VALID_BLOCKSIZE( \
|
||||
block_size, input_type, input_ptr \
|
||||
, \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
input_a_ptr, input_b_ptr, block_size), \
|
||||
ref, ref_arg_interface( \
|
||||
input_a_ptr, input_b_ptr, block_size)); \
|
||||
\
|
||||
compare_interface(block_size, output_type)))); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Test template that uses a single element.
|
||||
*/
|
||||
#define TEST_TEMPLATE_ELT1(arr_desc_elts, \
|
||||
elt_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt_idx, elt_type, elt, arr_desc_elts \
|
||||
, \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
elt), \
|
||||
ref, ref_arg_interface( \
|
||||
elt)); \
|
||||
/* Comparison interfaces typically accept */ \
|
||||
/* a block_size. Pass a dummy value 1.*/ \
|
||||
compare_interface(1, output_type)); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Test template that iterates over two sets of elements in parallel.
|
||||
*
|
||||
* The length of the first set determines the number of iteratsions.
|
||||
*/
|
||||
#define TEST_TEMPLATE_ELT2(arr_desc_elts_a, \
|
||||
arr_desc_elts_b, \
|
||||
elt_a_type, elt_b_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt_a_idx, elt_a_type, elt_a, arr_desc_elts_a \
|
||||
, \
|
||||
elt_b_type * elt_b = ARR_DESC_ELT( \
|
||||
elt_b_type, \
|
||||
elt_a_idx, \
|
||||
arr_desc_elts_b); \
|
||||
\
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
elt_a, elt_b), \
|
||||
ref, ref_arg_interface( \
|
||||
elt_a, elt_b)); \
|
||||
/* Comparison interfaces typically accept */ \
|
||||
/* a block_size. Pass a dummy value 1.*/ \
|
||||
compare_interface(1, output_type)); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Test template that uses an element and a block size.
|
||||
*/
|
||||
#define TEST_TEMPLATE_ELT1_BLK(arr_desc_elts, \
|
||||
arr_desc_block_sizes, \
|
||||
elt_type, output_type, \
|
||||
fut, fut_arg_interface, \
|
||||
ref, ref_arg_interface, \
|
||||
compare_interface) \
|
||||
do \
|
||||
{ \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
block_size_idx, uint32_t, block_size, \
|
||||
arr_desc_block_sizes \
|
||||
, \
|
||||
TEMPLATE_DO_ARR_DESC( \
|
||||
elt_idx, elt_type, elt, arr_desc_elts \
|
||||
, \
|
||||
JTEST_DUMP_STRF("Block Size: %d\n", \
|
||||
(int)block_size); \
|
||||
TEST_CALL_FUT_AND_REF( \
|
||||
fut, fut_arg_interface( \
|
||||
elt, block_size), \
|
||||
ref, ref_arg_interface( \
|
||||
elt, block_size)); \
|
||||
compare_interface(block_size, output_type))); \
|
||||
return JTEST_TEST_PASSED; \
|
||||
} while (0)
|
||||
|
||||
#endif /* _TEST_TEMPLATES_H_ */
|
||||
@ -0,0 +1,181 @@
|
||||
#ifndef _TRANSFORM_TEMPLATES_H_
|
||||
#define _TRANSFORM_TEMPLATES_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "test_templates.h"
|
||||
#include <string.h> /* memcpy() */
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Group Specific Templates */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Comparison SNR thresholds for the data types used in transform_tests.
|
||||
*/
|
||||
#define TRANSFORM_SNR_THRESHOLD_float32_t 90
|
||||
#define TRANSFORM_SNR_THRESHOLD_q31_t 90
|
||||
#define TRANSFORM_SNR_THRESHOLD_q15_t 30
|
||||
|
||||
#define DCT4_TRANSFORM_SNR_THRESHOLD_float32_t 80
|
||||
#define DCT4_TRANSFORM_SNR_THRESHOLD_q31_t 75
|
||||
#define DCT4_TRANSFORM_SNR_THRESHOLD_q15_t 11
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define TRANSFORM_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
transform_fft_output_f32_ref, \
|
||||
(output_type *) transform_fft_output_ref, \
|
||||
transform_fft_output_f32_fut, \
|
||||
(output_type *) transform_fft_output_fut, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
TRANSFORM_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* Compare the outputs from the function under test and the reference
|
||||
* function using SNR.
|
||||
*/
|
||||
#define DCT_TRANSFORM_SNR_COMPARE_INTERFACE(block_size, \
|
||||
output_type) \
|
||||
do \
|
||||
{ \
|
||||
TEST_CONVERT_AND_ASSERT_SNR( \
|
||||
transform_fft_output_f32_ref, \
|
||||
(output_type *) transform_fft_output_ref, \
|
||||
transform_fft_output_f32_fut, \
|
||||
(output_type *) transform_fft_output_fut, \
|
||||
block_size, \
|
||||
output_type, \
|
||||
DCT4_TRANSFORM_SNR_THRESHOLD_##output_type \
|
||||
); \
|
||||
} while (0) \
|
||||
|
||||
/**
|
||||
* Specialization on #TRANSFORM_SNR_COMPARE_INTERFACE() to fix the block_size
|
||||
* for complex datasets.
|
||||
*/
|
||||
#define TRANSFORM_SNR_COMPARE_CMPLX_INTERFACE(block_size, output_type) \
|
||||
/* Complex numbers have two components*/ \
|
||||
TRANSFORM_SNR_COMPARE_INTERFACE(block_size * 2, output_type )
|
||||
|
||||
/**
|
||||
* This macro copys data from the input_ptr into input arrays.
|
||||
*
|
||||
* Some functions modify their input data; in order to provide the same data to
|
||||
* multiple tests, copies must be made so the changes from one function don't
|
||||
* impact the others.
|
||||
*/
|
||||
#define TRANSFORM_COPY_INPUTS(input_ptr, \
|
||||
bytes) \
|
||||
do \
|
||||
{ \
|
||||
memcpy( \
|
||||
transform_fft_input_fut, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
memcpy( \
|
||||
transform_fft_input_ref, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* This macro copys data from the input_ptr into input arrays. It also creates
|
||||
* symmetric input data for rfft inverse.
|
||||
*
|
||||
* The 4.534234f just makes the middle entry of the array semi random. It's
|
||||
* actual value doesn't seem to matter much.
|
||||
*
|
||||
* Some functions modify their input data; in order to provide the same data to
|
||||
* multiple tests, copies must be made so the changes from one function don't
|
||||
* impact the others.
|
||||
*/
|
||||
#define TRANSFORM_PREPARE_INVERSE_INPUTS(input_ptr, \
|
||||
fftlen, input_type, bytes) \
|
||||
do \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
\
|
||||
memcpy( \
|
||||
transform_fft_input_fut, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
\
|
||||
((input_type*)transform_fft_input_fut)[1] = 0; \
|
||||
((input_type*)transform_fft_input_fut)[fftlen + 0] = 0; \
|
||||
((input_type*)transform_fft_input_fut)[fftlen + 1] = 0; \
|
||||
for(i=1;i<fftlen/2;i++) \
|
||||
{ \
|
||||
*((input_type*)transform_fft_input_fut + fftlen + 2*i + 0) = \
|
||||
*((input_type*)transform_fft_input_fut + fftlen - 2*i + 0); \
|
||||
*((input_type*)transform_fft_input_fut + fftlen + 2*i + 1) = \
|
||||
-(*((input_type*)transform_fft_input_fut + fftlen - 2*i + 1)); \
|
||||
\
|
||||
} \
|
||||
\
|
||||
memcpy( \
|
||||
transform_fft_input_ref, \
|
||||
transform_fft_input_fut, \
|
||||
bytes * 2); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* This macro copys data from the input_ptr into the in-place input arrays.
|
||||
*
|
||||
* Some functions modify their input data; in order to provide the same data to
|
||||
* multiple tests, copies must be made so the changes from one function don't
|
||||
* impact the others.
|
||||
*/
|
||||
#define TRANSFORM_PREPARE_INPLACE_INPUTS_DOWNSHIFT(input_ptr, \
|
||||
bytes, \
|
||||
type) \
|
||||
do \
|
||||
{ \
|
||||
uint32_t i; \
|
||||
memcpy( \
|
||||
transform_fft_inplace_input_fut, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
memcpy( \
|
||||
transform_fft_inplace_input_ref, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
for(i=0;i<bytes/sizeof(type);i++) { \
|
||||
*((type*)transform_fft_inplace_input_fut + i) >>= 1; \
|
||||
*((type*)transform_fft_inplace_input_ref + i) >>= 1;} \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* This macro copys data from the input_ptr into the in-place input arrays.
|
||||
*
|
||||
* Some functions modify their input data; in order to provide the same data to
|
||||
* multiple tests, copies must be made so the changes from one function don't
|
||||
* impact the others.
|
||||
*/
|
||||
#define TRANSFORM_PREPARE_INPLACE_INPUTS(input_ptr, \
|
||||
bytes) \
|
||||
do \
|
||||
{ \
|
||||
memcpy( \
|
||||
transform_fft_inplace_input_fut, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
memcpy( \
|
||||
transform_fft_inplace_input_ref, \
|
||||
input_ptr, \
|
||||
bytes); \
|
||||
} while (0)
|
||||
|
||||
|
||||
#endif /* _TRANSFORM_TEMPLATES_H_ */
|
||||
@ -0,0 +1,48 @@
|
||||
#ifndef _TRANSFORM_TEST_DATA_H_
|
||||
#define _TRANSFORM_TEST_DATA_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Includes */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#include "arr_desc.h"
|
||||
#include "arm_math.h"
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
#define TRANSFORM_MAX_FFT_LEN 4096
|
||||
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Variable Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/* Lengths are multiplied by 2 to accomodate complex numbers*/
|
||||
extern float32_t transform_fft_output_fut[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t transform_fft_output_ref[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t transform_fft_input_fut[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t transform_fft_input_ref[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t transform_fft_output_f32_fut[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t transform_fft_output_f32_ref[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern float32_t * transform_fft_inplace_input_fut;
|
||||
extern float32_t * transform_fft_inplace_input_ref;
|
||||
extern float32_t transform_fft_f32_inputs[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern q31_t transform_fft_q31_inputs[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
extern q15_t * transform_fft_q15_inputs;
|
||||
extern q15_t dct4_transform_fft_q15_inputs[TRANSFORM_MAX_FFT_LEN * 2];
|
||||
|
||||
/* FFT Lengths */
|
||||
ARR_DESC_DECLARE(transform_radix2_fftlens);
|
||||
ARR_DESC_DECLARE(transform_radix4_fftlens);
|
||||
ARR_DESC_DECLARE(transform_rfft_fftlens);
|
||||
ARR_DESC_DECLARE(transform_rfft_fast_fftlens);
|
||||
ARR_DESC_DECLARE(transform_dct_fftlens);
|
||||
|
||||
/* CFFT Structs */
|
||||
ARR_DESC_DECLARE(transform_cfft_f32_structs);
|
||||
ARR_DESC_DECLARE(transform_cfft_q31_structs);
|
||||
ARR_DESC_DECLARE(transform_cfft_q15_structs);
|
||||
|
||||
#endif /* _TRANSFORM_TEST_DATA_H_ */
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _TRANSFORM_TEST_GROUP_H_
|
||||
#define _TRANSFORM_TEST_GROUP_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Declare Test Groups */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(transform_tests);
|
||||
|
||||
#endif /* _TRANSFORM_TEST_GROUP_H_ */
|
||||
@ -0,0 +1,13 @@
|
||||
#ifndef _TRANSFORM_TESTS_H_
|
||||
#define _TRANSFORM_TESTS_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Test/Group Declarations */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
JTEST_DECLARE_GROUP(cfft_tests);
|
||||
JTEST_DECLARE_GROUP(cfft_family_tests);
|
||||
JTEST_DECLARE_GROUP(dct4_tests);
|
||||
JTEST_DECLARE_GROUP(rfft_tests);
|
||||
JTEST_DECLARE_GROUP(rfft_fast_tests);
|
||||
|
||||
#endif /* _TRANSFORM_TESTS_H_ */
|
||||
37
Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/type_abbrev.h
Normal file
37
Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/type_abbrev.h
Normal file
@ -0,0 +1,37 @@
|
||||
#ifndef _TYPE_ABBREV_H_
|
||||
#define _TYPE_ABBREV_H_
|
||||
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
/* Macros and Defines */
|
||||
/*--------------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Expand the abbreviation for a type into the type itself.
|
||||
*/
|
||||
#define TYPE_FROM_ABBREV(abbrev) \
|
||||
TYPE_ABBREV_##abbrev \
|
||||
|
||||
/**
|
||||
* Expand the type to an abbreviation for that type.
|
||||
*
|
||||
* Inverse of #TYPE_FROM_ABBREV().
|
||||
*
|
||||
* @note Should be able to get a type back by writing.
|
||||
* TYPE_FROM_ABBREV(ABBREV_FROM_TYPE(type))
|
||||
*/
|
||||
#define ABBREV_FROM_TYPE(type) \
|
||||
TYPE_SUFFIX_##type
|
||||
|
||||
#define TYPE_ABBREV_f64 float64_t
|
||||
#define TYPE_ABBREV_f32 float32_t
|
||||
#define TYPE_ABBREV_q31 q31_t
|
||||
#define TYPE_ABBREV_q15 q15_t
|
||||
#define TYPE_ABBREV_q7 q7_t
|
||||
|
||||
#define TYPE_SUFFIX_float64_t f64
|
||||
#define TYPE_SUFFIX_float32_t f32
|
||||
#define TYPE_SUFFIX_q31_t q31
|
||||
#define TYPE_SUFFIX_q15_t q15
|
||||
#define TYPE_SUFFIX_q7_t q7
|
||||
|
||||
#endif /* _TYPE_ABBREV_H_ */
|
||||
Reference in New Issue
Block a user