1 #include "BasicTestsF32.h"
2 #include <stdio.h>
3 #include "Error.h"
4 
5 #define SNR_THRESHOLD 120
6 
7 /*
8 
9 Reference patterns are generated with
10 a double precision computation.
11 
12 */
13 #define REL_ERROR (5.0e-5)
14 
15 #define GET_F32_PTR() \
16 const float32_t *inp1=input1.ptr(); \
17 const float32_t *inp2=input2.ptr(); \
18 float32_t *outp=output.ptr();
19 
test_add_f32()20     void BasicTestsF32::test_add_f32()
21     {
22         GET_F32_PTR();
23 
24         arm_add_f32(inp1,inp2,outp,input1.nbSamples());
25 
26         ASSERT_EMPTY_TAIL(output);
27 
28         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
29 
30         ASSERT_REL_ERROR(output,ref,REL_ERROR);
31 
32     }
33 
test_clip_f32()34     void BasicTestsF32::test_clip_f32()
35     {
36         const float32_t *inp=input1.ptr();
37         float32_t *outp=output.ptr();
38 
39         arm_clip_f32(inp,outp,this->min, this->max,input1.nbSamples());
40 
41         ASSERT_EMPTY_TAIL(output);
42 
43         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
44 
45         ASSERT_REL_ERROR(output,ref,REL_ERROR);
46 
47     }
48 
test_sub_f32()49     void BasicTestsF32::test_sub_f32()
50     {
51         GET_F32_PTR();
52 
53         arm_sub_f32(inp1,inp2,outp,input1.nbSamples());
54 
55         ASSERT_EMPTY_TAIL(output);
56 
57         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
58 
59         ASSERT_REL_ERROR(output,ref,REL_ERROR);
60 
61     }
62 
test_mult_f32()63     void BasicTestsF32::test_mult_f32()
64     {
65         GET_F32_PTR();
66 
67         arm_mult_f32(inp1,inp2,outp,input1.nbSamples());
68 
69         ASSERT_EMPTY_TAIL(output);
70 
71         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
72 
73         ASSERT_REL_ERROR(output,ref,REL_ERROR);
74 
75     }
76 
test_negate_f32()77     void BasicTestsF32::test_negate_f32()
78     {
79         GET_F32_PTR();
80 
81         (void)inp2;
82 
83         arm_negate_f32(inp1,outp,input1.nbSamples());
84 
85         ASSERT_EMPTY_TAIL(output);
86 
87         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
88 
89         ASSERT_REL_ERROR(output,ref,REL_ERROR);
90 
91     }
92 
test_offset_f32()93     void BasicTestsF32::test_offset_f32()
94     {
95         GET_F32_PTR();
96 
97         (void)inp2;
98 
99         arm_offset_f32(inp1,0.5,outp,input1.nbSamples());
100 
101         ASSERT_EMPTY_TAIL(output);
102 
103         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
104 
105         ASSERT_REL_ERROR(output,ref,REL_ERROR);
106 
107     }
108 
test_scale_f32()109     void BasicTestsF32::test_scale_f32()
110     {
111         GET_F32_PTR();
112 
113         (void)inp2;
114 
115         arm_scale_f32(inp1,0.5,outp,input1.nbSamples());
116 
117         ASSERT_EMPTY_TAIL(output);
118 
119         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
120 
121         ASSERT_REL_ERROR(output,ref,REL_ERROR);
122 
123     }
124 
test_dot_prod_f32()125     void BasicTestsF32::test_dot_prod_f32()
126     {
127         float32_t r;
128 
129         GET_F32_PTR();
130 
131         arm_dot_prod_f32(inp1,inp2,input1.nbSamples(),&r);
132 
133         outp[0] = r;
134 
135         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
136 
137         ASSERT_REL_ERROR(output,ref,REL_ERROR);
138 
139         ASSERT_EMPTY_TAIL(output);
140 
141 
142     }
143 
test_abs_f32()144     void BasicTestsF32::test_abs_f32()
145     {
146         GET_F32_PTR();
147 
148         (void)inp2;
149 
150         arm_abs_f32(inp1,outp,input1.nbSamples());
151 
152         ASSERT_EMPTY_TAIL(output);
153 
154         ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
155 
156         ASSERT_REL_ERROR(output,ref,REL_ERROR);
157 
158     }
159 
160 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & params,Client::PatternMgr * mgr)161     void BasicTestsF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
162     {
163 
164        (void)params;
165 
166        Testing::nbSamples_t nb=MAX_NB_SAMPLES;
167 
168 
169        switch(id)
170        {
171         case BasicTestsF32::TEST_ADD_F32_1:
172           nb = 3;
173           ref.reload(BasicTestsF32::REF_ADD_F32_ID,mgr,nb);
174           break;
175 
176         case BasicTestsF32::TEST_ADD_F32_2:
177           nb = 8;
178           ref.reload(BasicTestsF32::REF_ADD_F32_ID,mgr,nb);
179           break;
180         case BasicTestsF32::TEST_ADD_F32_3:
181           nb = 11;
182           ref.reload(BasicTestsF32::REF_ADD_F32_ID,mgr,nb);
183           break;
184 
185 
186         case BasicTestsF32::TEST_SUB_F32_4:
187           nb = 3;
188           ref.reload(BasicTestsF32::REF_SUB_F32_ID,mgr,nb);
189           break;
190         case BasicTestsF32::TEST_SUB_F32_5:
191           nb = 8;
192           ref.reload(BasicTestsF32::REF_SUB_F32_ID,mgr,nb);
193           break;
194         case BasicTestsF32::TEST_SUB_F32_6:
195           nb = 11;
196           ref.reload(BasicTestsF32::REF_SUB_F32_ID,mgr,nb);
197           break;
198 
199         case BasicTestsF32::TEST_MULT_F32_7:
200           nb = 3;
201           ref.reload(BasicTestsF32::REF_MULT_F32_ID,mgr,nb);
202           break;
203         case BasicTestsF32::TEST_MULT_F32_8:
204           nb = 8;
205           ref.reload(BasicTestsF32::REF_MULT_F32_ID,mgr,nb);
206           break;
207         case BasicTestsF32::TEST_MULT_F32_9:
208           nb = 11;
209           ref.reload(BasicTestsF32::REF_MULT_F32_ID,mgr,nb);
210           break;
211 
212         case BasicTestsF32::TEST_NEGATE_F32_10:
213           nb = 3;
214           ref.reload(BasicTestsF32::REF_NEGATE_F32_ID,mgr,nb);
215           break;
216         case BasicTestsF32::TEST_NEGATE_F32_11:
217           nb = 8;
218           ref.reload(BasicTestsF32::REF_NEGATE_F32_ID,mgr,nb);
219           break;
220         case BasicTestsF32::TEST_NEGATE_F32_12:
221           nb = 11;
222           ref.reload(BasicTestsF32::REF_NEGATE_F32_ID,mgr,nb);
223           break;
224 
225         case BasicTestsF32::TEST_OFFSET_F32_13:
226           nb = 3;
227           ref.reload(BasicTestsF32::REF_OFFSET_F32_ID,mgr,nb);
228           break;
229         case BasicTestsF32::TEST_OFFSET_F32_14:
230           nb = 8;
231           ref.reload(BasicTestsF32::REF_OFFSET_F32_ID,mgr,nb);
232           break;
233         case BasicTestsF32::TEST_OFFSET_F32_15:
234           nb = 11;
235           ref.reload(BasicTestsF32::REF_OFFSET_F32_ID,mgr,nb);
236           break;
237 
238         case BasicTestsF32::TEST_SCALE_F32_16:
239           nb = 3;
240           ref.reload(BasicTestsF32::REF_SCALE_F32_ID,mgr,nb);
241           break;
242         case BasicTestsF32::TEST_SCALE_F32_17:
243           nb = 8;
244           ref.reload(BasicTestsF32::REF_SCALE_F32_ID,mgr,nb);
245           break;
246         case BasicTestsF32::TEST_SCALE_F32_18:
247           nb = 11;
248           ref.reload(BasicTestsF32::REF_SCALE_F32_ID,mgr,nb);
249           break;
250 
251         case BasicTestsF32::TEST_DOT_PROD_F32_19:
252           nb = 3;
253           ref.reload(BasicTestsF32::REF_DOT_3_F32_ID,mgr);
254           break;
255         case BasicTestsF32::TEST_DOT_PROD_F32_20:
256           nb = 8;
257           ref.reload(BasicTestsF32::REF_DOT_4N_F32_ID,mgr);
258           break;
259         case BasicTestsF32::TEST_DOT_PROD_F32_21:
260           nb = 11;
261           ref.reload(BasicTestsF32::REF_DOT_4N1_F32_ID,mgr);
262           break;
263 
264         case BasicTestsF32::TEST_ABS_F32_22:
265           nb = 3;
266           ref.reload(BasicTestsF32::REF_ABS_F32_ID,mgr,nb);
267           break;
268         case BasicTestsF32::TEST_ABS_F32_23:
269           nb = 8;
270           ref.reload(BasicTestsF32::REF_ABS_F32_ID,mgr,nb);
271           break;
272         case BasicTestsF32::TEST_ABS_F32_24:
273           nb = 11;
274           ref.reload(BasicTestsF32::REF_ABS_F32_ID,mgr,nb);
275           break;
276 
277         case BasicTestsF32::TEST_ADD_F32_25:
278           ref.reload(BasicTestsF32::REF_ADD_F32_ID,mgr,nb);
279         break;
280 
281         case BasicTestsF32::TEST_SUB_F32_26:
282           ref.reload(BasicTestsF32::REF_SUB_F32_ID,mgr,nb);
283         break;
284 
285         case BasicTestsF32::TEST_MULT_F32_27:
286           ref.reload(BasicTestsF32::REF_MULT_F32_ID,mgr,nb);
287         break;
288 
289         case BasicTestsF32::TEST_NEGATE_F32_28:
290           ref.reload(BasicTestsF32::REF_NEGATE_F32_ID,mgr,nb);
291         break;
292 
293         case BasicTestsF32::TEST_OFFSET_F32_29:
294           ref.reload(BasicTestsF32::REF_OFFSET_F32_ID,mgr,nb);
295         break;
296 
297         case BasicTestsF32::TEST_SCALE_F32_30:
298           ref.reload(BasicTestsF32::REF_SCALE_F32_ID,mgr,nb);
299         break;
300 
301         case BasicTestsF32::TEST_DOT_PROD_F32_31:
302           ref.reload(BasicTestsF32::REF_DOT_LONG_F32_ID,mgr);
303         break;
304 
305         case BasicTestsF32::TEST_ABS_F32_32:
306           ref.reload(BasicTestsF32::REF_ABS_F32_ID,mgr,nb);
307         break;
308 
309         case BasicTestsF32::TEST_CLIP_F32_33:
310           ref.reload(BasicTestsF32::REF_CLIP1_F32_ID,mgr);
311           input1.reload(BasicTestsF32::INPUT_CLIP_F32_ID,mgr,ref.nbSamples());
312 
313           // Must be coherent with Python script used to generate test patterns
314           this->min=-0.5f;
315           this->max=-0.1f;
316         break;
317 
318         case BasicTestsF32::TEST_CLIP_F32_34:
319           ref.reload(BasicTestsF32::REF_CLIP2_F32_ID,mgr);
320           input1.reload(BasicTestsF32::INPUT_CLIP_F32_ID,mgr,ref.nbSamples());
321           // Must be coherent with Python script used to generate test patterns
322           this->min=-0.5f;
323           this->max=0.5f;
324         break;
325 
326         case BasicTestsF32::TEST_CLIP_F32_35:
327           ref.reload(BasicTestsF32::REF_CLIP3_F32_ID,mgr);
328           input1.reload(BasicTestsF32::INPUT_CLIP_F32_ID,mgr,ref.nbSamples());
329           // Must be coherent with Python script used to generate test patterns
330           this->min=0.1f;
331           this->max=0.5f;
332         break;
333 
334        }
335 
336 
337        if (id < TEST_CLIP_F32_33)
338        {
339          input1.reload(BasicTestsF32::INPUT1_F32_ID,mgr,nb);
340          input2.reload(BasicTestsF32::INPUT2_F32_ID,mgr,nb);
341        }
342 
343        output.create(ref.nbSamples(),BasicTestsF32::OUT_SAMPLES_F32_ID,mgr);
344     }
345 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)346     void BasicTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
347     {
348         (void)id;
349         output.dump(mgr);
350     }
351