1 #include "DistanceTestsU32.h"
2 #include <stdio.h>
3 #include "Error.h"
4 #include "Test.h"
5 
6 #define ERROR_THRESHOLD 1e-8
7 
test_dice_distance()8     void DistanceTestsU32::test_dice_distance()
9     {
10        const uint32_t *inpA = inputA.ptr();
11        const uint32_t *inpB = inputB.ptr();
12 
13        float32_t *outp = output.ptr();
14 
15        for(int i=0; i < this->nbPatterns ; i ++)
16        {
17           *outp = arm_dice_distance(inpA, inpB,this->vecDim);
18 
19           inpA += this->bitVecDim ;
20           inpB += this->bitVecDim ;
21           outp ++;
22        }
23 
24         ASSERT_REL_ERROR(output,ref,(float32_t)ERROR_THRESHOLD);
25     }
26 
test_hamming_distance()27     void DistanceTestsU32::test_hamming_distance()
28     {
29        const uint32_t *inpA = inputA.ptr();
30        const uint32_t *inpB = inputB.ptr();
31 
32        float32_t *outp = output.ptr();
33 
34        for(int i=0; i < this->nbPatterns ; i ++)
35        {
36           *outp = arm_hamming_distance(inpA, inpB,this->vecDim);
37 
38           inpA += this->bitVecDim ;
39           inpB += this->bitVecDim ;
40           outp ++;
41        }
42 
43         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
44     }
45 
test_jaccard_distance()46     void DistanceTestsU32::test_jaccard_distance()
47     {
48        const uint32_t *inpA = inputA.ptr();
49        const uint32_t *inpB = inputB.ptr();
50 
51        float32_t *outp = output.ptr();
52 
53        for(int i=0; i < this->nbPatterns ; i ++)
54        {
55           *outp = arm_jaccard_distance(inpA, inpB,this->vecDim);
56 
57           inpA += this->bitVecDim ;
58           inpB += this->bitVecDim ;
59           outp ++;
60        }
61 
62         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
63     }
64 
test_kulsinski_distance()65     void DistanceTestsU32::test_kulsinski_distance()
66     {
67        const uint32_t *inpA = inputA.ptr();
68        const uint32_t *inpB = inputB.ptr();
69 
70        float32_t *outp = output.ptr();
71 
72        for(int i=0; i < this->nbPatterns ; i ++)
73        {
74           *outp = arm_kulsinski_distance(inpA, inpB,this->vecDim);
75 
76           inpA += this->bitVecDim ;
77           inpB += this->bitVecDim ;
78           outp ++;
79        }
80 
81         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
82     }
83 
test_rogerstanimoto_distance()84     void DistanceTestsU32::test_rogerstanimoto_distance()
85     {
86        const uint32_t *inpA = inputA.ptr();
87        const uint32_t *inpB = inputB.ptr();
88 
89        float32_t *outp = output.ptr();
90 
91        for(int i=0; i < this->nbPatterns ; i ++)
92        {
93           *outp = arm_rogerstanimoto_distance(inpA, inpB,this->vecDim);
94 
95           inpA += this->bitVecDim ;
96           inpB += this->bitVecDim ;
97           outp ++;
98        }
99 
100         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
101     }
102 
test_russellrao_distance()103     void DistanceTestsU32::test_russellrao_distance()
104     {
105        const uint32_t *inpA = inputA.ptr();
106        const uint32_t *inpB = inputB.ptr();
107 
108        float32_t *outp = output.ptr();
109 
110        for(int i=0; i < this->nbPatterns ; i ++)
111        {
112           *outp = arm_russellrao_distance(inpA, inpB,this->vecDim);
113 
114           inpA += this->bitVecDim ;
115           inpB += this->bitVecDim ;
116           outp ++;
117        }
118 
119         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
120     }
121 
test_sokalmichener_distance()122     void DistanceTestsU32::test_sokalmichener_distance()
123     {
124        const uint32_t *inpA = inputA.ptr();
125        const uint32_t *inpB = inputB.ptr();
126 
127        float32_t *outp = output.ptr();
128 
129        for(int i=0; i < this->nbPatterns ; i ++)
130        {
131           *outp = arm_sokalmichener_distance(inpA, inpB,this->vecDim);
132 
133           inpA += this->bitVecDim ;
134           inpB += this->bitVecDim ;
135           outp ++;
136        }
137 
138         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
139     }
140 
test_sokalsneath_distance()141     void DistanceTestsU32::test_sokalsneath_distance()
142     {
143        const uint32_t *inpA = inputA.ptr();
144        const uint32_t *inpB = inputB.ptr();
145 
146        float32_t *outp = output.ptr();
147 
148        for(int i=0; i < this->nbPatterns ; i ++)
149        {
150           *outp = arm_sokalsneath_distance(inpA, inpB,this->vecDim);
151 
152           inpA += this->bitVecDim ;
153           inpB += this->bitVecDim ;
154           outp ++;
155        }
156 
157         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
158     }
159 
test_yule_distance()160     void DistanceTestsU32::test_yule_distance()
161     {
162        const uint32_t *inpA = inputA.ptr();
163        const uint32_t *inpB = inputB.ptr();
164 
165        float32_t *outp = output.ptr();
166 
167        for(int i=0; i < this->nbPatterns ; i ++)
168        {
169           *outp = arm_yule_distance(inpA, inpB,this->vecDim);
170 
171           inpA += this->bitVecDim ;
172           inpB += this->bitVecDim ;
173           outp ++;
174        }
175 
176         ASSERT_NEAR_EQ(output,ref,(float32_t)ERROR_THRESHOLD);
177     }
178 
179 
180 
181 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & paramsArgs,Client::PatternMgr * mgr)182     void DistanceTestsU32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
183     {
184 
185         (void)paramsArgs;
186         inputA.reload(DistanceTestsU32::INPUTA_U32_ID,mgr);
187         inputB.reload(DistanceTestsU32::INPUTB_U32_ID,mgr);
188         dims.reload(DistanceTestsU32::DIMS_S16_ID,mgr);
189 
190         const int16_t   *dimsp = dims.ptr();
191 
192         this->nbPatterns=dimsp[0];
193         this->vecDim=dimsp[1];
194         this->bitVecDim=dimsp[2];
195         //printf("%d %d %d\n",dimsp[0],dimsp[1],dimsp[2]);
196         output.create(this->nbPatterns,DistanceTestsU32::OUT_F32_ID,mgr);
197 
198         switch(id)
199         {
200             case DistanceTestsU32::TEST_DICE_DISTANCE_1:
201             {
202               ref.reload(DistanceTestsU32::REF1_F32_ID,mgr);
203             }
204             break;
205 
206             case DistanceTestsU32::TEST_HAMMING_DISTANCE_2:
207             {
208               ref.reload(DistanceTestsU32::REF2_F32_ID,mgr);
209             }
210             break;
211 
212             case DistanceTestsU32::TEST_JACCARD_DISTANCE_3:
213             {
214               ref.reload(DistanceTestsU32::REF3_F32_ID,mgr);
215             }
216             break;
217 
218             case DistanceTestsU32::TEST_KULSINSKI_DISTANCE_4:
219             {
220               ref.reload(DistanceTestsU32::REF4_F32_ID,mgr);
221             }
222             break;
223 
224             case DistanceTestsU32::TEST_ROGERSTANIMOTO_DISTANCE_5:
225             {
226               ref.reload(DistanceTestsU32::REF5_F32_ID,mgr);
227             }
228             break;
229 
230             case DistanceTestsU32::TEST_RUSSELLRAO_DISTANCE_6:
231             {
232               ref.reload(DistanceTestsU32::REF6_F32_ID,mgr);
233             }
234             break;
235 
236             case DistanceTestsU32::TEST_SOKALMICHENER_DISTANCE_7:
237             {
238               ref.reload(DistanceTestsU32::REF7_F32_ID,mgr);
239             }
240             break;
241 
242             case DistanceTestsU32::TEST_SOKALSNEATH_DISTANCE_8:
243             {
244               ref.reload(DistanceTestsU32::REF8_F32_ID,mgr);
245             }
246             break;
247 
248             case DistanceTestsU32::TEST_YULE_DISTANCE_9:
249             {
250               ref.reload(DistanceTestsU32::REF9_F32_ID,mgr);
251             }
252             break;
253 
254         }
255 
256 
257     }
258 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)259     void DistanceTestsU32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
260     {
261        (void)id;
262        output.dump(mgr);
263     }
264