1 #include "DistanceTestsF32.h"
2 #include <stdio.h>
3 #include "Error.h"
4 #include "Test.h"
5 
6 
7 
test_dtw_distance_f32()8     void DistanceTestsF32::test_dtw_distance_f32()
9     {
10        const float32_t *inpA = inputA.ptr();
11        const float32_t *inpB = inputB.ptr();
12        arm_matrix_instance_f32 distances;
13        arm_matrix_instance_f32 costs;
14        arm_matrix_instance_q7 window;
15 
16        distances.numRows=this->queryLength;
17        distances.numCols=this->templateLength;
18        distances.pData = tmpA.ptr();
19 
20        costs.numRows=this->queryLength;
21        costs.numCols=this->templateLength;
22        costs.pData = tmpB.ptr();
23 
24        window.numRows=this->queryLength;
25        window.numCols=this->templateLength;
26        window.pData = tmpC.ptr();
27 
28 
29        float32_t *outp = output.ptr();
30        int16_t *outPathp = outPath.ptr();
31        uint32_t pathLength;
32 
33 
34        for(int i=0; i < this->nbPatterns ; i ++)
35        {
36           float32_t *c = distances.pData;
37           for(int q=0; q < this->queryLength; q++)
38           {
39               for(int t=0; t < this->templateLength; t++)
40               {
41                   *c = fabs(inpA[q] - inpB[t]);
42                   c++;
43               }
44           }
45 
46 
47           arm_status status = arm_dtw_distance_f32(&distances, NULL,&costs,outp);
48           outp++;
49           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
50 
51           arm_dtw_path_f32(&costs,outPathp,&pathLength);
52 
53           /* ARM_DTW_SAKOE_CHIBA_WINDOW 5*/
54           status = arm_dtw_init_window_q7(ARM_DTW_SAKOE_CHIBA_WINDOW,5,&window);
55           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
56 
57           c = distances.pData;
58           for(int q=0; q < this->queryLength; q++)
59           {
60               for(int t=0; t < this->templateLength; t++)
61               {
62                   /* Distance does not have
63                      to be computed outside of
64                      the window */
65                   if (window.pData[q*this->templateLength+t])
66                   {
67                      *c = fabs(inpA[q] - inpB[t]);
68                   }
69                   c++;
70               }
71           }
72 
73           status = arm_dtw_distance_f32(&distances, &window,&costs,outp);
74           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
75           outp++;
76 
77           /* ARM_DTW_SAKOE_CHIBA_WINDOW 3 */
78           status = arm_dtw_init_window_q7(ARM_DTW_SAKOE_CHIBA_WINDOW,3,&window);
79           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
80           status = arm_dtw_distance_f32(&distances, &window,&costs,outp);
81           ASSERT_TRUE(status == ARM_MATH_ARGUMENT_ERROR);
82 
83           /* ARM_DTW_SLANTED_BAND_WINDOW 1*/
84           status = arm_dtw_init_window_q7(ARM_DTW_SLANTED_BAND_WINDOW,1,&window);
85           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
86           /* Here again we could compute the distance matrix
87           only on a subset */
88 
89           status = arm_dtw_distance_f32(&distances, &window,&costs,outp);
90           ASSERT_TRUE(status == ARM_MATH_SUCCESS);
91           outp++;
92 
93 
94           inpA += this->queryLength;
95           inpB += this->templateLength;
96           outPathp += 2*pathLength;
97        }
98 
99         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
100         ASSERT_EQ_PARTIAL(2*pathLength,outPath,refPath);
101 
102     }
103 
test_braycurtis_distance_f32()104     void DistanceTestsF32::test_braycurtis_distance_f32()
105     {
106        const float32_t *inpA = inputA.ptr();
107        const float32_t *inpB = inputB.ptr();
108 
109        float32_t *outp = output.ptr();
110 
111        for(int i=0; i < this->nbPatterns ; i ++)
112        {
113           *outp = arm_braycurtis_distance_f32(inpA, inpB, this->vecDim);
114 
115           inpA += this->vecDim;
116           inpB += this->vecDim;
117           outp ++;
118        }
119 
120         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
121     }
122 
test_canberra_distance_f32()123     void DistanceTestsF32::test_canberra_distance_f32()
124     {
125        const float32_t *inpA = inputA.ptr();
126        const float32_t *inpB = inputB.ptr();
127 
128        float32_t *outp = output.ptr();
129 
130        for(int i=0; i < this->nbPatterns ; i ++)
131        {
132           *outp = arm_canberra_distance_f32(inpA, inpB, this->vecDim);
133 
134           inpA += this->vecDim;
135           inpB += this->vecDim;
136           outp ++;
137        }
138 
139         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
140     }
141 
test_chebyshev_distance_f32()142     void DistanceTestsF32::test_chebyshev_distance_f32()
143     {
144        const float32_t *inpA = inputA.ptr();
145        const float32_t *inpB = inputB.ptr();
146 
147        float32_t *outp = output.ptr();
148 
149        for(int i=0; i < this->nbPatterns ; i ++)
150        {
151           *outp = arm_chebyshev_distance_f32(inpA, inpB, this->vecDim);
152 
153           inpA += this->vecDim;
154           inpB += this->vecDim;
155           outp ++;
156        }
157 
158         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
159     }
160 
test_cityblock_distance_f32()161     void DistanceTestsF32::test_cityblock_distance_f32()
162     {
163        const float32_t *inpA = inputA.ptr();
164        const float32_t *inpB = inputB.ptr();
165 
166        float32_t *outp = output.ptr();
167 
168        for(int i=0; i < this->nbPatterns ; i ++)
169        {
170           *outp = arm_cityblock_distance_f32(inpA, inpB, this->vecDim);
171 
172           inpA += this->vecDim;
173           inpB += this->vecDim;
174           outp ++;
175        }
176 
177         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
178     }
179 
test_correlation_distance_f32()180     void DistanceTestsF32::test_correlation_distance_f32()
181     {
182        const float32_t *inpA = inputA.ptr();
183        const float32_t *inpB = inputB.ptr();
184 
185        float32_t *tmpap = tmpA.ptr();
186        float32_t *tmpbp = tmpB.ptr();
187 
188        float32_t *outp = output.ptr();
189 
190        for(int i=0; i < this->nbPatterns ; i ++)
191        {
192           memcpy(tmpap, inpA, sizeof(float32_t) * this->vecDim);
193           memcpy(tmpbp, inpB, sizeof(float32_t) * this->vecDim);
194 
195           *outp = arm_correlation_distance_f32(tmpap, tmpbp, this->vecDim);
196 
197           inpA += this->vecDim;
198           inpB += this->vecDim;
199           outp ++;
200        }
201 
202         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
203     }
204 
test_cosine_distance_f32()205     void DistanceTestsF32::test_cosine_distance_f32()
206     {
207        const float32_t *inpA = inputA.ptr();
208        const float32_t *inpB = inputB.ptr();
209 
210        float32_t *outp = output.ptr();
211 
212        for(int i=0; i < this->nbPatterns ; i ++)
213        {
214           *outp = arm_cosine_distance_f32(inpA, inpB, this->vecDim);
215 
216           inpA += this->vecDim;
217           inpB += this->vecDim;
218           outp ++;
219        }
220 
221         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
222     }
223 
test_euclidean_distance_f32()224     void DistanceTestsF32::test_euclidean_distance_f32()
225     {
226        const float32_t *inpA = inputA.ptr();
227        const float32_t *inpB = inputB.ptr();
228 
229        float32_t *outp = output.ptr();
230 
231        for(int i=0; i < this->nbPatterns ; i ++)
232        {
233           *outp = arm_euclidean_distance_f32(inpA, inpB, this->vecDim);
234 
235           inpA += this->vecDim;
236           inpB += this->vecDim;
237           outp ++;
238        }
239 
240         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
241     }
242 
test_jensenshannon_distance_f32()243     void DistanceTestsF32::test_jensenshannon_distance_f32()
244     {
245        const float32_t *inpA = inputA.ptr();
246        const float32_t *inpB = inputB.ptr();
247 
248        float32_t *outp = output.ptr();
249 
250 
251 
252        for(int i=0; i < this->nbPatterns ; i ++)
253        {
254           *outp = arm_jensenshannon_distance_f32(inpA, inpB, this->vecDim);
255 
256           inpA += this->vecDim;
257           inpB += this->vecDim;
258           outp ++;
259        }
260 
261         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
262     }
263 
test_minkowski_distance_f32()264     void DistanceTestsF32::test_minkowski_distance_f32()
265     {
266        const float32_t *inpA = inputA.ptr();
267        const float32_t *inpB = inputB.ptr();
268        const int16_t   *dimsp= dims.ptr();
269        dimsp += 2;
270 
271        float32_t *outp = output.ptr();
272 
273        for(int i=0; i < this->nbPatterns ; i ++)
274        {
275           *outp = arm_minkowski_distance_f32(inpA, inpB, *dimsp,this->vecDim);
276 
277           inpA += this->vecDim;
278           inpB += this->vecDim;
279           outp ++;
280           dimsp ++;
281        }
282 
283         ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
284     }
285 
286 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & paramsArgs,Client::PatternMgr * mgr)287     void DistanceTestsF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
288     {
289 
290         (void)paramsArgs;
291         if ((id != DistanceTestsF32::TEST_MINKOWSKI_DISTANCE_F32_9) && (id != DistanceTestsF32::TEST_JENSENSHANNON_DISTANCE_F32_8))
292         {
293             inputA.reload(DistanceTestsF32::INPUTA_F32_ID,mgr);
294             inputB.reload(DistanceTestsF32::INPUTB_F32_ID,mgr);
295             dims.reload(DistanceTestsF32::DIMS_S16_ID,mgr);
296 
297             const int16_t   *dimsp = dims.ptr();
298 
299             this->nbPatterns=dimsp[0];
300             this->vecDim=dimsp[1];
301             output.create(this->nbPatterns,DistanceTestsF32::OUT_F32_ID,mgr);
302         }
303 
304         switch(id)
305         {
306             case DistanceTestsF32::TEST_BRAYCURTIS_DISTANCE_F32_1:
307             {
308               ref.reload(DistanceTestsF32::REF1_F32_ID,mgr);
309             }
310             break;
311 
312             case DistanceTestsF32::TEST_CANBERRA_DISTANCE_F32_2:
313             {
314               ref.reload(DistanceTestsF32::REF2_F32_ID,mgr);
315             }
316             break;
317 
318             case DistanceTestsF32::TEST_CHEBYSHEV_DISTANCE_F32_3:
319             {
320               ref.reload(DistanceTestsF32::REF3_F32_ID,mgr);
321             }
322             break;
323 
324             case DistanceTestsF32::TEST_CITYBLOCK_DISTANCE_F32_4:
325             {
326               ref.reload(DistanceTestsF32::REF4_F32_ID,mgr);
327             }
328             break;
329 
330             case DistanceTestsF32::TEST_CORRELATION_DISTANCE_F32_5:
331             {
332               ref.reload(DistanceTestsF32::REF5_F32_ID,mgr);
333               tmpA.create(this->vecDim,DistanceTestsF32::TMPA_F32_ID,mgr);
334               tmpB.create(this->vecDim,DistanceTestsF32::TMPB_F32_ID,mgr);
335             }
336             break;
337 
338             case DistanceTestsF32::TEST_COSINE_DISTANCE_F32_6:
339             {
340               ref.reload(DistanceTestsF32::REF6_F32_ID,mgr);
341             }
342             break;
343 
344             case DistanceTestsF32::TEST_EUCLIDEAN_DISTANCE_F32_7:
345             {
346               ref.reload(DistanceTestsF32::REF7_F32_ID,mgr);
347             }
348             break;
349 
350             case DistanceTestsF32::TEST_JENSENSHANNON_DISTANCE_F32_8:
351             {
352               inputA.reload(DistanceTestsF32::INPUTA_JEN_F32_ID,mgr);
353               inputB.reload(DistanceTestsF32::INPUTB_JEN_F32_ID,mgr);
354               dims.reload(DistanceTestsF32::DIMS_S16_ID,mgr);
355 
356               const int16_t   *dimsp = dims.ptr();
357 
358               this->nbPatterns=dimsp[0];
359               this->vecDim=dimsp[1];
360               output.create(this->nbPatterns,DistanceTestsF32::OUT_F32_ID,mgr);
361 
362               ref.reload(DistanceTestsF32::REF8_F32_ID,mgr);
363             }
364             break;
365 
366             case DistanceTestsF32::TEST_MINKOWSKI_DISTANCE_F32_9:
367             {
368               inputA.reload(DistanceTestsF32::INPUTA_F32_ID,mgr);
369               inputB.reload(DistanceTestsF32::INPUTB_F32_ID,mgr);
370               dims.reload(DistanceTestsF32::DIMS_MINKOWSKI_S16_ID,mgr);
371 
372               const int16_t   *dimsp = dims.ptr();
373 
374               this->nbPatterns=dimsp[0];
375               this->vecDim=dimsp[1];
376               output.create(this->nbPatterns,DistanceTestsF32::OUT_F32_ID,mgr);
377 
378               ref.reload(DistanceTestsF32::REF9_F32_ID,mgr);
379             }
380             break;
381 
382          case DistanceTestsF32::TEST_DTW_DISTANCE_F32_10:
383             {
384               inputA.reload(DistanceTestsF32::INPUT_QUERY_F32_ID,mgr);
385               inputB.reload(DistanceTestsF32::INPUT_TEMPLATE_F32_ID,mgr);
386 
387 
388               this->nbPatterns=1;
389               this->queryLength=inputA.nbSamples();
390               this->templateLength=inputB.nbSamples();
391               output.create(3*this->nbPatterns,DistanceTestsF32::OUT_F32_ID,mgr);
392               tmpA.create(this->queryLength*this->templateLength,DistanceTestsF32::TMPA_F32_ID,mgr);
393               tmpB.create(this->queryLength*this->templateLength,DistanceTestsF32::TMPB_F32_ID,mgr);
394               tmpC.create(this->queryLength*this->templateLength,DistanceTestsF32::TMPC_Q7_ID,mgr);
395 
396               outPath.create(2*(this->queryLength+this->templateLength),DistanceTestsF32::OUTA_S16_ID,mgr);
397 
398               ref.reload(DistanceTestsF32::REF10_F32_ID,mgr);
399               refPath.reload(DistanceTestsF32::REF10_S16_PATH_ID,mgr);
400 
401             }
402             break;
403 
404         }
405 
406 
407 
408 
409 
410     }
411 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)412     void DistanceTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
413     {
414        (void)id;
415        output.dump(mgr);
416     }
417