1 #include "BasicTestsF64.h"
2 #include <stdio.h>
3 #include "Error.h"
4 
5 #define SNR_THRESHOLD 250
6 
7 /*
8 
9 Reference patterns are generated with
10 a double precision computation.
11 
12 */
13 #define REL_ERROR (2.0e-13)
14 
15 #define GET_F64_PTR() \
16 const float64_t *inp1=input1.ptr(); \
17 const float64_t *inp2=input2.ptr(); \
18 float64_t *outp=output.ptr();
19 
test_add_f64()20     void BasicTestsF64::test_add_f64()
21     {
22         GET_F64_PTR();
23 
24         arm_add_f64(inp1,inp2,outp,input1.nbSamples());
25 
26         ASSERT_EMPTY_TAIL(output);
27 
28         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
29 
30         ASSERT_REL_ERROR(output,ref,REL_ERROR);
31 
32     }
33 
34 /*
35     void BasicTestsF64::test_clip_f64()
36     {
37         const float64_t *inp=input1.ptr();
38         float64_t *outp=output.ptr();
39 
40         arm_clip_f64(inp,outp,this->min, this->max,input1.nbSamples());
41 
42         ASSERT_EMPTY_TAIL(output);
43 
44         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
45 
46         ASSERT_REL_ERROR(output,ref,REL_ERROR);
47 
48     }
49 */
test_sub_f64()50     void BasicTestsF64::test_sub_f64()
51     {
52         GET_F64_PTR();
53 
54         arm_sub_f64(inp1,inp2,outp,input1.nbSamples());
55 
56         ASSERT_EMPTY_TAIL(output);
57 
58         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
59 
60         ASSERT_REL_ERROR(output,ref,REL_ERROR);
61 
62     }
63 
test_mult_f64()64     void BasicTestsF64::test_mult_f64()
65     {
66         GET_F64_PTR();
67 
68         arm_mult_f64(inp1,inp2,outp,input1.nbSamples());
69 
70         ASSERT_EMPTY_TAIL(output);
71 
72         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
73 
74         ASSERT_REL_ERROR(output,ref,REL_ERROR);
75 
76     }
77 
test_negate_f64()78     void BasicTestsF64::test_negate_f64()
79     {
80         GET_F64_PTR();
81 
82         (void)inp2;
83 
84         arm_negate_f64(inp1,outp,input1.nbSamples());
85 
86         ASSERT_EMPTY_TAIL(output);
87 
88         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
89 
90         ASSERT_REL_ERROR(output,ref,REL_ERROR);
91 
92     }
93 
test_offset_f64()94     void BasicTestsF64::test_offset_f64()
95     {
96         GET_F64_PTR();
97 
98         (void)inp2;
99 
100         arm_offset_f64(inp1,0.5,outp,input1.nbSamples());
101 
102         ASSERT_EMPTY_TAIL(output);
103 
104         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
105 
106         ASSERT_REL_ERROR(output,ref,REL_ERROR);
107 
108     }
109 
test_scale_f64()110     void BasicTestsF64::test_scale_f64()
111     {
112         GET_F64_PTR();
113 
114         (void)inp2;
115 
116         arm_scale_f64(inp1,0.5,outp,input1.nbSamples());
117 
118         ASSERT_EMPTY_TAIL(output);
119 
120         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
121 
122         ASSERT_REL_ERROR(output,ref,REL_ERROR);
123 
124     }
125 
test_dot_prod_f64()126     void BasicTestsF64::test_dot_prod_f64()
127     {
128         float64_t r;
129 
130         GET_F64_PTR();
131 
132         arm_dot_prod_f64(inp1,inp2,input1.nbSamples(),&r);
133 
134         outp[0] = r;
135 
136         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
137 
138         ASSERT_REL_ERROR(output,ref,REL_ERROR);
139 
140         ASSERT_EMPTY_TAIL(output);
141 
142 
143     }
144 
test_abs_f64()145     void BasicTestsF64::test_abs_f64()
146     {
147         GET_F64_PTR();
148 
149         (void)inp2;
150 
151         arm_abs_f64(inp1,outp,input1.nbSamples());
152 
153         ASSERT_EMPTY_TAIL(output);
154 
155         ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
156 
157         ASSERT_REL_ERROR(output,ref,REL_ERROR);
158 
159     }
160 
161 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & params,Client::PatternMgr * mgr)162     void BasicTestsF64::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
163     {
164 
165        (void)params;
166 
167        Testing::nbSamples_t nb=MAX_NB_SAMPLES;
168 
169 
170        switch(id)
171        {
172         case BasicTestsF64::TEST_ADD_F64_1:
173           nb = 2;
174           ref.reload(BasicTestsF64::REF_ADD_F64_ID,mgr,nb);
175           break;
176         case BasicTestsF64::TEST_ADD_F64_2:
177           nb = 4;
178           ref.reload(BasicTestsF64::REF_ADD_F64_ID,mgr,nb);
179           break;
180         case BasicTestsF64::TEST_ADD_F64_3:
181           nb = 5;
182           ref.reload(BasicTestsF64::REF_ADD_F64_ID,mgr,nb);
183           break;
184 
185 
186         case BasicTestsF64::TEST_SUB_F64_4:
187           nb = 2;
188           ref.reload(BasicTestsF64::REF_SUB_F64_ID,mgr,nb);
189           break;
190         case BasicTestsF64::TEST_SUB_F64_5:
191           nb = 4;
192           ref.reload(BasicTestsF64::REF_SUB_F64_ID,mgr,nb);
193           break;
194         case BasicTestsF64::TEST_SUB_F64_6:
195           nb = 5;
196           ref.reload(BasicTestsF64::REF_SUB_F64_ID,mgr,nb);
197           break;
198 
199         case BasicTestsF64::TEST_MULT_F64_7:
200           nb = 2;
201           ref.reload(BasicTestsF64::REF_MULT_F64_ID,mgr,nb);
202           break;
203         case BasicTestsF64::TEST_MULT_F64_8:
204           nb = 4;
205           ref.reload(BasicTestsF64::REF_MULT_F64_ID,mgr,nb);
206           break;
207         case BasicTestsF64::TEST_MULT_F64_9:
208           nb = 5;
209           ref.reload(BasicTestsF64::REF_MULT_F64_ID,mgr,nb);
210           break;
211 
212         case BasicTestsF64::TEST_NEGATE_F64_10:
213           nb = 2;
214           ref.reload(BasicTestsF64::REF_NEGATE_F64_ID,mgr,nb);
215           break;
216         case BasicTestsF64::TEST_NEGATE_F64_11:
217           nb = 4;
218           ref.reload(BasicTestsF64::REF_NEGATE_F64_ID,mgr,nb);
219           break;
220         case BasicTestsF64::TEST_NEGATE_F64_12:
221           nb = 5;
222           ref.reload(BasicTestsF64::REF_NEGATE_F64_ID,mgr,nb);
223           break;
224 
225         case BasicTestsF64::TEST_OFFSET_F64_13:
226           nb = 2;
227           ref.reload(BasicTestsF64::REF_OFFSET_F64_ID,mgr,nb);
228           break;
229         case BasicTestsF64::TEST_OFFSET_F64_14:
230           nb = 4;
231           ref.reload(BasicTestsF64::REF_OFFSET_F64_ID,mgr,nb);
232           break;
233         case BasicTestsF64::TEST_OFFSET_F64_15:
234           nb = 5;
235           ref.reload(BasicTestsF64::REF_OFFSET_F64_ID,mgr,nb);
236           break;
237 
238         case BasicTestsF64::TEST_SCALE_F64_16:
239           nb = 2;
240           ref.reload(BasicTestsF64::REF_SCALE_F64_ID,mgr,nb);
241           break;
242         case BasicTestsF64::TEST_SCALE_F64_17:
243           nb = 4;
244           ref.reload(BasicTestsF64::REF_SCALE_F64_ID,mgr,nb);
245           break;
246         case BasicTestsF64::TEST_SCALE_F64_18:
247           nb = 5;
248           ref.reload(BasicTestsF64::REF_SCALE_F64_ID,mgr,nb);
249           break;
250 
251         case BasicTestsF64::TEST_DOT_PROD_F64_19:
252           nb = 2;
253           ref.reload(BasicTestsF64::REF_DOT_3_F64_ID,mgr);
254           break;
255         case BasicTestsF64::TEST_DOT_PROD_F64_20:
256           nb = 4;
257           ref.reload(BasicTestsF64::REF_DOT_4N_F64_ID,mgr);
258           break;
259         case BasicTestsF64::TEST_DOT_PROD_F64_21:
260           nb = 5;
261           ref.reload(BasicTestsF64::REF_DOT_4N1_F64_ID,mgr);
262           break;
263 
264         case BasicTestsF64::TEST_ABS_F64_22:
265           nb = 2;
266           ref.reload(BasicTestsF64::REF_ABS_F64_ID,mgr,nb);
267           break;
268         case BasicTestsF64::TEST_ABS_F64_23:
269           nb = 4;
270           ref.reload(BasicTestsF64::REF_ABS_F64_ID,mgr,nb);
271           break;
272         case BasicTestsF64::TEST_ABS_F64_24:
273           nb = 5;
274           ref.reload(BasicTestsF64::REF_ABS_F64_ID,mgr,nb);
275           break;
276 
277         case BasicTestsF64::TEST_ADD_F64_25:
278           ref.reload(BasicTestsF64::REF_ADD_F64_ID,mgr,nb);
279         break;
280 
281         case BasicTestsF64::TEST_SUB_F64_26:
282           ref.reload(BasicTestsF64::REF_SUB_F64_ID,mgr,nb);
283         break;
284 
285         case BasicTestsF64::TEST_MULT_F64_27:
286           ref.reload(BasicTestsF64::REF_MULT_F64_ID,mgr,nb);
287         break;
288 
289         case BasicTestsF64::TEST_NEGATE_F64_28:
290           ref.reload(BasicTestsF64::REF_NEGATE_F64_ID,mgr,nb);
291         break;
292 
293         case BasicTestsF64::TEST_OFFSET_F64_29:
294           ref.reload(BasicTestsF64::REF_OFFSET_F64_ID,mgr,nb);
295         break;
296 
297         case BasicTestsF64::TEST_SCALE_F64_30:
298           ref.reload(BasicTestsF64::REF_SCALE_F64_ID,mgr,nb);
299         break;
300 
301         case BasicTestsF64::TEST_DOT_PROD_F64_31:
302           ref.reload(BasicTestsF64::REF_DOT_LONG_F64_ID,mgr);
303         break;
304 
305         case BasicTestsF64::TEST_ABS_F64_32:
306           ref.reload(BasicTestsF64::REF_ABS_F64_ID,mgr,nb);
307         break;
308 
309         case BasicTestsF64::TEST_CLIP_F64_33:
310           ref.reload(BasicTestsF64::REF_CLIP1_F64_ID,mgr);
311           input1.reload(BasicTestsF64::INPUT_CLIP_F64_ID,mgr,ref.nbSamples());
312 
313           // Must be coherent with Python script used to generate test patterns
314           this->min=-0.5;
315           this->max=-0.1;
316         break;
317 
318         case BasicTestsF64::TEST_CLIP_F64_34:
319           ref.reload(BasicTestsF64::REF_CLIP2_F64_ID,mgr);
320           input1.reload(BasicTestsF64::INPUT_CLIP_F64_ID,mgr,ref.nbSamples());
321           // Must be coherent with Python script used to generate test patterns
322           this->min=-0.5;
323           this->max=0.5;
324         break;
325 
326         case BasicTestsF64::TEST_CLIP_F64_35:
327           ref.reload(BasicTestsF64::REF_CLIP3_F64_ID,mgr);
328           input1.reload(BasicTestsF64::INPUT_CLIP_F64_ID,mgr,ref.nbSamples());
329           // Must be coherent with Python script used to generate test patterns
330           this->min=0.1;
331           this->max=0.5;
332         break;
333 
334        }
335 
336 
337        if (id < TEST_CLIP_F64_33)
338        {
339          input1.reload(BasicTestsF64::INPUT1_F64_ID,mgr,nb);
340          input2.reload(BasicTestsF64::INPUT2_F64_ID,mgr,nb);
341        }
342 
343        output.create(ref.nbSamples(),BasicTestsF64::OUT_SAMPLES_F64_ID,mgr);
344     }
345 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)346     void BasicTestsF64::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
347     {
348         (void)id;
349         output.dump(mgr);
350     }
351