1 #include "DistanceTestsF16.h"
2 #include <stdio.h>
3 #include "Error.h"
4 #include "Test.h"
5 
6 #define REL_ERROR (5e-3)
7 
8 #define REL_JS_ERROR (3e-2)
9 
10 #define REL_MK_ERROR (1e-2)
11 
12 
test_braycurtis_distance_f16()13     void DistanceTestsF16::test_braycurtis_distance_f16()
14     {
15        const float16_t *inpA = inputA.ptr();
16        const float16_t *inpB = inputB.ptr();
17 
18        float16_t *outp = output.ptr();
19 
20        for(int i=0; i < this->nbPatterns ; i ++)
21        {
22           *outp = arm_braycurtis_distance_f16(inpA, inpB, this->vecDim);
23 
24           inpA += this->vecDim;
25           inpB += this->vecDim;
26           outp ++;
27        }
28 
29         ASSERT_REL_ERROR(output,ref,REL_ERROR);
30     }
31 
test_canberra_distance_f16()32     void DistanceTestsF16::test_canberra_distance_f16()
33     {
34        const float16_t *inpA = inputA.ptr();
35        const float16_t *inpB = inputB.ptr();
36 
37        float16_t *outp = output.ptr();
38 
39        for(int i=0; i < this->nbPatterns ; i ++)
40        {
41           *outp = arm_canberra_distance_f16(inpA, inpB, this->vecDim);
42 
43           inpA += this->vecDim;
44           inpB += this->vecDim;
45           outp ++;
46        }
47 
48         ASSERT_REL_ERROR(output,ref,REL_ERROR);
49     }
50 
test_chebyshev_distance_f16()51     void DistanceTestsF16::test_chebyshev_distance_f16()
52     {
53        const float16_t *inpA = inputA.ptr();
54        const float16_t *inpB = inputB.ptr();
55 
56        float16_t *outp = output.ptr();
57 
58        for(int i=0; i < this->nbPatterns ; i ++)
59        {
60           *outp = arm_chebyshev_distance_f16(inpA, inpB, this->vecDim);
61 
62           inpA += this->vecDim;
63           inpB += this->vecDim;
64           outp ++;
65        }
66 
67         ASSERT_REL_ERROR(output,ref,REL_ERROR);
68     }
69 
test_cityblock_distance_f16()70     void DistanceTestsF16::test_cityblock_distance_f16()
71     {
72        const float16_t *inpA = inputA.ptr();
73        const float16_t *inpB = inputB.ptr();
74 
75        float16_t *outp = output.ptr();
76 
77        for(int i=0; i < this->nbPatterns ; i ++)
78        {
79           *outp = arm_cityblock_distance_f16(inpA, inpB, this->vecDim);
80 
81           inpA += this->vecDim;
82           inpB += this->vecDim;
83           outp ++;
84        }
85 
86         ASSERT_REL_ERROR(output,ref,REL_ERROR);
87     }
88 
test_correlation_distance_f16()89     void DistanceTestsF16::test_correlation_distance_f16()
90     {
91        const float16_t *inpA = inputA.ptr();
92        const float16_t *inpB = inputB.ptr();
93 
94        float16_t *tmpap = tmpA.ptr();
95        float16_t *tmpbp = tmpB.ptr();
96 
97        float16_t *outp = output.ptr();
98 
99        for(int i=0; i < this->nbPatterns ; i ++)
100        {
101           memcpy(tmpap, inpA, sizeof(float16_t) * this->vecDim);
102           memcpy(tmpbp, inpB, sizeof(float16_t) * this->vecDim);
103 
104           *outp = arm_correlation_distance_f16(tmpap, tmpbp, this->vecDim);
105 
106           inpA += this->vecDim;
107           inpB += this->vecDim;
108           outp ++;
109        }
110 
111         ASSERT_REL_ERROR(output,ref,REL_ERROR);
112     }
113 
test_cosine_distance_f16()114     void DistanceTestsF16::test_cosine_distance_f16()
115     {
116        const float16_t *inpA = inputA.ptr();
117        const float16_t *inpB = inputB.ptr();
118 
119        float16_t *outp = output.ptr();
120 
121        for(int i=0; i < this->nbPatterns ; i ++)
122        {
123           *outp = arm_cosine_distance_f16(inpA, inpB, this->vecDim);
124 
125           inpA += this->vecDim;
126           inpB += this->vecDim;
127           outp ++;
128        }
129 
130         ASSERT_REL_ERROR(output,ref,REL_ERROR);
131     }
132 
test_euclidean_distance_f16()133     void DistanceTestsF16::test_euclidean_distance_f16()
134     {
135        const float16_t *inpA = inputA.ptr();
136        const float16_t *inpB = inputB.ptr();
137 
138        float16_t *outp = output.ptr();
139 
140        for(int i=0; i < this->nbPatterns ; i ++)
141        {
142           *outp = arm_euclidean_distance_f16(inpA, inpB, this->vecDim);
143 
144           inpA += this->vecDim;
145           inpB += this->vecDim;
146           outp ++;
147        }
148 
149         ASSERT_REL_ERROR(output,ref,REL_ERROR);
150     }
151 
test_jensenshannon_distance_f16()152     void DistanceTestsF16::test_jensenshannon_distance_f16()
153     {
154        const float16_t *inpA = inputA.ptr();
155        const float16_t *inpB = inputB.ptr();
156 
157        float16_t *outp = output.ptr();
158 
159 
160 
161        for(int i=0; i < this->nbPatterns ; i ++)
162        {
163           *outp = arm_jensenshannon_distance_f16(inpA, inpB, this->vecDim);
164 
165           inpA += this->vecDim;
166           inpB += this->vecDim;
167           outp ++;
168        }
169 
170         ASSERT_REL_ERROR(output,ref,REL_JS_ERROR);
171     }
172 
test_minkowski_distance_f16()173     void DistanceTestsF16::test_minkowski_distance_f16()
174     {
175        const float16_t *inpA = inputA.ptr();
176        const float16_t *inpB = inputB.ptr();
177        const int16_t   *dimsp= dims.ptr();
178        dimsp += 2;
179 
180        float16_t *outp = output.ptr();
181 
182        for(int i=0; i < this->nbPatterns ; i ++)
183        {
184           *outp = arm_minkowski_distance_f16(inpA, inpB, *dimsp,this->vecDim);
185 
186           inpA += this->vecDim;
187           inpB += this->vecDim;
188           outp ++;
189           dimsp ++;
190        }
191 
192         ASSERT_REL_ERROR(output,ref,REL_MK_ERROR);
193     }
194 
195 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & paramsArgs,Client::PatternMgr * mgr)196     void DistanceTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
197     {
198 
199         (void)paramsArgs;
200         if ((id != DistanceTestsF16::TEST_MINKOWSKI_DISTANCE_F16_9) && (id != DistanceTestsF16::TEST_JENSENSHANNON_DISTANCE_F16_8))
201         {
202             inputA.reload(DistanceTestsF16::INPUTA_F16_ID,mgr);
203             inputB.reload(DistanceTestsF16::INPUTB_F16_ID,mgr);
204             dims.reload(DistanceTestsF16::DIMS_S16_ID,mgr);
205 
206             const int16_t   *dimsp = dims.ptr();
207 
208             this->nbPatterns=dimsp[0];
209             this->vecDim=dimsp[1];
210             output.create(this->nbPatterns,DistanceTestsF16::OUT_F16_ID,mgr);
211         }
212 
213         switch(id)
214         {
215             case DistanceTestsF16::TEST_BRAYCURTIS_DISTANCE_F16_1:
216             {
217               ref.reload(DistanceTestsF16::REF1_F16_ID,mgr);
218             }
219             break;
220 
221             case DistanceTestsF16::TEST_CANBERRA_DISTANCE_F16_2:
222             {
223               ref.reload(DistanceTestsF16::REF2_F16_ID,mgr);
224             }
225             break;
226 
227             case DistanceTestsF16::TEST_CHEBYSHEV_DISTANCE_F16_3:
228             {
229               ref.reload(DistanceTestsF16::REF3_F16_ID,mgr);
230             }
231             break;
232 
233             case DistanceTestsF16::TEST_CITYBLOCK_DISTANCE_F16_4:
234             {
235               ref.reload(DistanceTestsF16::REF4_F16_ID,mgr);
236             }
237             break;
238 
239             case DistanceTestsF16::TEST_CORRELATION_DISTANCE_F16_5:
240             {
241               ref.reload(DistanceTestsF16::REF5_F16_ID,mgr);
242               tmpA.create(this->vecDim,DistanceTestsF16::TMPA_F16_ID,mgr);
243               tmpB.create(this->vecDim,DistanceTestsF16::TMPB_F16_ID,mgr);
244             }
245             break;
246 
247             case DistanceTestsF16::TEST_COSINE_DISTANCE_F16_6:
248             {
249               ref.reload(DistanceTestsF16::REF6_F16_ID,mgr);
250             }
251             break;
252 
253             case DistanceTestsF16::TEST_EUCLIDEAN_DISTANCE_F16_7:
254             {
255               ref.reload(DistanceTestsF16::REF7_F16_ID,mgr);
256             }
257             break;
258 
259             case DistanceTestsF16::TEST_JENSENSHANNON_DISTANCE_F16_8:
260             {
261               inputA.reload(DistanceTestsF16::INPUTA_JEN_F16_ID,mgr);
262               inputB.reload(DistanceTestsF16::INPUTB_JEN_F16_ID,mgr);
263               dims.reload(DistanceTestsF16::DIMS_S16_ID,mgr);
264 
265               const int16_t   *dimsp = dims.ptr();
266 
267               this->nbPatterns=dimsp[0];
268               this->vecDim=dimsp[1];
269               output.create(this->nbPatterns,DistanceTestsF16::OUT_F16_ID,mgr);
270 
271               ref.reload(DistanceTestsF16::REF8_F16_ID,mgr);
272             }
273             break;
274 
275             case DistanceTestsF16::TEST_MINKOWSKI_DISTANCE_F16_9:
276             {
277               inputA.reload(DistanceTestsF16::INPUTA_F16_ID,mgr);
278               inputB.reload(DistanceTestsF16::INPUTB_F16_ID,mgr);
279               dims.reload(DistanceTestsF16::DIMS_MINKOWSKI_S16_ID,mgr);
280 
281               const int16_t   *dimsp = dims.ptr();
282 
283               this->nbPatterns=dimsp[0];
284               this->vecDim=dimsp[1];
285               output.create(this->nbPatterns,DistanceTestsF16::OUT_F16_ID,mgr);
286 
287               ref.reload(DistanceTestsF16::REF9_F16_ID,mgr);
288             }
289             break;
290 
291         }
292 
293 
294 
295 
296 
297     }
298 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)299     void DistanceTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
300     {
301        (void)id;
302        output.dump(mgr);
303     }
304