Line data Source code
1 : ///////////////////////////////////////////////////////////////////////////
2 : // Inastemp - Berenger Bramas MPCDF - 2016
3 : // Under MIT Licence, please you must read the LICENCE file.
4 : ///////////////////////////////////////////////////////////////////////////
5 : #ifndef CORETESTALL_HPP
6 : #define CORETESTALL_HPP
7 :
8 : #include "InastempGlobal.h"
9 : #include "UTester.hpp"
10 :
11 : #include <cmath>
12 : #include <cstring>
13 : #include <cassert>
14 :
15 : #ifdef __NEC__
16 : #define default_alignas
17 : #else
18 : #define default_alignas alignas(512)
19 : #endif
20 :
21 : inline constexpr size_t MaxTestValues(const size_t inSizeOfOneValue){
22 : return 2048/inSizeOfOneValue;
23 : }
24 :
25 : template <class VecType, int RemainingVec>
26 : struct MultiHorizontalSumTester{
27 : template <class ... Params>
28 6842 : static void addToTest(typename VecType::RealType res[], typename VecType::RealType good_res[],
29 : const int my_idx, Params... params){
30 : std::array<typename VecType::RealType, MaxTestValues(sizeof(typename VecType::RealType))> values;
31 32410 : for(size_t idx = 0 ; idx < size_t(VecType::GetVecLength()) ; ++idx){
32 50400 : values[idx] = typename VecType::RealType(size_t(VecType::GetVecLength()*my_idx)+idx);
33 : }
34 14112 : VecType v(&values[0]);
35 :
36 7726 : MultiHorizontalSumTester<VecType, RemainingVec-1>::addToTest(res, good_res, my_idx+1, params..., v);
37 :
38 13776 : good_res[my_idx] = v.horizontalSum();
39 6842 : }
40 : };
41 :
42 : template <class VecType>
43 : struct MultiHorizontalSumTester<VecType,0>{
44 : template <class ... Params>
45 120 : static void addToTest(typename VecType::RealType res[], typename VecType::RealType /*good_res*/[],
46 : const int /*my_idx*/, Params... params){
47 672 : VecType::MultiHorizontalSum(res, params...);
48 120 : }
49 : };
50 :
51 :
52 : template < class VecType >
53 168 : class TestAll : public UTester< TestAll< VecType > > {
54 : using Parent = UTester< TestAll< VecType > >;
55 :
56 : using RealType = typename VecType::RealType;
57 : using MaskType = typename VecType::MaskType;
58 :
59 2646 : void equalToVecType(const VecType vec,
60 : const VecType inReal) {
61 12096 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()); ++idx) {
62 75348 : UASSERTEEQUAL(vec.at(int(idx)), inReal.at(int(idx)));
63 : }
64 :
65 : RealType reals[VecType::GetVecLength()];
66 2268 : vec.storeInArray( reals);
67 :
68 : RealType realsReals[VecType::GetVecLength()];
69 2268 : inReal.storeInArray( realsReals);
70 :
71 12474 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
72 56700 : UASSERTEEQUAL(reals[idx], realsReals[idx]);
73 : }
74 :
75 : default_alignas RealType realsalign[VecType::GetVecLength()];
76 2268 : vec.storeInAlignedArray( realsalign);
77 :
78 : default_alignas RealType realsRealsalign[VecType::GetVecLength()];
79 2268 : inReal.storeInArray( realsRealsalign);
80 :
81 12474 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
82 56700 : UASSERTEEQUAL(realsalign[idx], realsRealsalign[idx]);
83 : }
84 2646 : }
85 :
86 5790 : void equalToScalar(const VecType vec,
87 : const RealType inReal) {
88 27420 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
89 151160 : UASSERTEEQUAL(vec.at(int(idx)), inReal);
90 : }
91 :
92 : RealType reals[VecType::GetVecLength()];
93 5040 : vec.storeInArray( reals);
94 :
95 28170 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
96 129780 : UASSERTEEQUAL(reals[idx], inReal);
97 : }
98 :
99 : default_alignas RealType realsalign[VecType::GetVecLength()];
100 5040 : vec.storeInAlignedArray( realsalign);
101 :
102 28170 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
103 129780 : UASSERTEEQUAL(realsalign[idx], inReal);
104 : }
105 5790 : }
106 :
107 : void equalToScalarMask(const MaskType vec,
108 : const MaskType inReal) {
109 5300 : VecType vecval = VecType::IfTrue(vec, VecType(1));
110 6000 : VecType realval = VecType::IfTrue(inReal, VecType(1));
111 2100 : equalToVecType(vecval, realval);
112 : }
113 :
114 2238 : void equalToArray(const VecType vec,
115 : const RealType inReals[]) {
116 11472 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
117 64584 : UASSERTEEQUAL(vec.at(int(idx)), inReals[idx]);
118 : }
119 :
120 : RealType reals[VecType::GetVecLength()];
121 2076 : vec.storeInArray( reals);
122 :
123 11634 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
124 55404 : UASSERTEEQUAL(reals[idx], inReals[idx]);
125 : }
126 :
127 : default_alignas RealType realsalign[VecType::GetVecLength()];
128 2076 : vec.storeInAlignedArray( realsalign);
129 :
130 11634 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
131 36936 : UASSERTEEQUAL(realsalign[idx], inReals[idx]);
132 : }
133 :
134 : default_alignas char reals_forcena_buffer[VecType::GetVecLength()*sizeof(RealType)+1];
135 2238 : RealType* reals_forcena = reinterpret_cast<RealType*>(&reals_forcena_buffer[1]);
136 2238 : vec.storeInArray( reals_forcena);
137 :
138 11472 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
139 46170 : UASSERTEEQUAL(reals_forcena[idx], inReals[idx]);
140 : }
141 2238 : }
142 :
143 : bool approxEqual(const float v1, const float v2) {
144 4158 : return (std::abs(v1 - v2) / v2) <= 9.9999999999E-6f;
145 : }
146 :
147 : bool approxEqual(const double v1, const double v2) {
148 2142 : return (std::abs(v1 - v2) / v2) <= 9.999999999999999E-12;
149 : }
150 :
151 : bool approxEqualLowAcc(const float v1, const float v2) {
152 1188 : return (std::abs(v1 - v2) / v2) <= 9.9999999999E-2f;
153 : }
154 :
155 : bool approxEqualLowAcc(const double v1, const double v2) {
156 612 : return (std::abs(v1 - v2) / v2) <= 9.999999999999999E-5;
157 : }
158 :
159 42 : void approxEqualToScalar(const VecType vec,
160 : const RealType inReal) {
161 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
162 1198 : UASSERTETRUE(approxEqual(vec.at(int(idx)), inReal));
163 : }
164 :
165 : RealType reals[VecType::GetVecLength()];
166 36 : vec.storeInArray( reals);
167 :
168 198 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
169 1050 : UASSERTETRUE(approxEqual(reals[idx], inReal));
170 : }
171 :
172 : default_alignas RealType realsalign[VecType::GetVecLength()];
173 36 : vec.storeInAlignedArray( realsalign);
174 :
175 198 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
176 1050 : UASSERTETRUE(approxEqual(realsalign[idx], inReal));
177 : }
178 42 : }
179 :
180 252 : void approxEqualToArray(const VecType vec,
181 : const RealType inReals[]) {
182 1152 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
183 7188 : UASSERTETRUE(approxEqual(vec.at(int(idx)), inReals[idx]));
184 : }
185 :
186 : RealType reals[VecType::GetVecLength()];
187 216 : vec.storeInArray( reals);
188 :
189 1188 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
190 6300 : UASSERTETRUE(approxEqual(reals[idx], inReals[idx]));
191 : }
192 :
193 : default_alignas RealType realsalign[VecType::GetVecLength()];
194 216 : vec.storeInAlignedArray( realsalign);
195 :
196 1188 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
197 6300 : UASSERTETRUE(approxEqual(realsalign[idx], inReals[idx]));
198 : }
199 252 : }
200 :
201 84 : void approxLowAccEqualToArray(const VecType vec,
202 : const RealType inReals[]) {
203 384 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
204 2396 : UASSERTETRUE(approxEqualLowAcc(vec.at(int(idx)), inReals[idx]));
205 : }
206 :
207 : RealType reals[VecType::GetVecLength()];
208 72 : vec.storeInArray( reals);
209 :
210 396 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
211 2100 : UASSERTETRUE(approxEqualLowAcc(reals[idx], inReals[idx]));
212 : }
213 :
214 : default_alignas RealType realsalign[VecType::GetVecLength()];
215 72 : vec.storeInAlignedArray( realsalign);
216 :
217 396 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
218 2100 : UASSERTETRUE(approxEqualLowAcc(realsalign[idx], inReals[idx]));
219 : }
220 84 : }
221 :
222 42 : void TestBasic() {
223 42 : equalToScalar(VecType(1), 1);
224 42 : equalToScalar(VecType(RealType(0)), 0);
225 :
226 : {
227 : RealType reals[VecType::GetVecLength()];
228 186 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
229 144 : reals[idx] = 1;
230 : }
231 42 : equalToScalar(VecType(reals), 1);
232 : }
233 :
234 : {
235 : assert(VecType::GetVecLength() <= 256);
236 42 : const RealType rv = 0;
237 84 : VecType vconstruct {{rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
238 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
239 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
240 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
241 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
242 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
243 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
244 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
245 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
246 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
247 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
248 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
249 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
250 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
251 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
252 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv}};
253 84 : VecType vcopyconstruct = {{rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
254 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
255 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
256 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
257 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
258 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
259 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
260 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
261 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
262 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
263 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
264 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
265 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
266 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
267 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
268 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv}};
269 42 : VecType vcopyop;
270 84 : vcopyop = VecType{{rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
271 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
272 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
273 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
274 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
275 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
276 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
277 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
278 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
279 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
280 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
281 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
282 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
283 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
284 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv,
285 : rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv, rv}};
286 84 : vcopyop += vconstruct * vcopyconstruct; // unused
287 : }
288 :
289 :
290 : {
291 : default_alignas RealType reals[VecType::GetVecLength()];
292 : #ifndef __NEC__
293 : default_alignas char buffer[VecType::GetVecLength()*sizeof(RealType)+8];
294 42 : RealType* realsna = reinterpret_cast<RealType*>(buffer+8);
295 : #else
296 : default_alignas RealType buffer[VecType::GetVecLength()+1];
297 : RealType* realsna = reinterpret_cast<RealType*>(buffer+1);
298 : #endif
299 :
300 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
301 150 : reals[idx] = RealType(idx+1);
302 150 : realsna[idx] = reals[idx];
303 : }
304 :
305 42 : VecType vec_no_fal(reals);
306 42 : equalToArray(vec_no_fal, reals);
307 42 : equalToArray(vec_no_fal, realsna);
308 :
309 42 : VecType vec_no_fna(realsna);
310 42 : equalToArray(vec_no_fna, reals);
311 42 : equalToArray(vec_no_fna, realsna);
312 :
313 42 : VecType vec_no_fal2;
314 48 : vec_no_fal2.setFromArray(reals);
315 42 : equalToArray(vec_no_fal2, reals);
316 42 : equalToArray(vec_no_fal2, realsna);
317 :
318 42 : VecType vec_no_fna2;
319 48 : vec_no_fna2.setFromArray(realsna);
320 42 : equalToArray(vec_no_fna2, reals);
321 42 : equalToArray(vec_no_fna2, realsna);
322 :
323 42 : VecType vec_al_fal;
324 48 : vec_al_fal.setFromAlignedArray(reals);
325 42 : equalToArray(vec_al_fal, reals);
326 42 : equalToArray(vec_al_fal, realsna);
327 :
328 342 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
329 448 : equalToScalar(vec_no_fal.at(int(idx)), RealType(idx+1));
330 448 : equalToScalar(vec_no_fna.at(int(idx)), RealType(idx+1));
331 448 : equalToScalar(vec_no_fal2.at(int(idx)), RealType(idx+1));
332 448 : equalToScalar(vec_no_fna2.at(int(idx)), RealType(idx+1));
333 448 : equalToScalar(vec_al_fal.at(int(idx)), RealType(idx+1));
334 : }
335 : }
336 :
337 : {
338 42 : RealType real = 1;
339 : int indirect[VecType::GetVecLength()];
340 186 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
341 144 : indirect[idx] = 0;
342 : }
343 118 : equalToScalar(VecType().setFromIndirectArray(&real, indirect), 1);
344 : }
345 :
346 : {
347 : RealType reals[VecType::GetVecLength()];
348 : int indirect[VecType::GetVecLength()];
349 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
350 150 : indirect[idx] = int(idx);
351 150 : reals[idx] = RealType(idx);
352 : }
353 118 : equalToArray(VecType().setFromIndirectArray(reals, indirect), reals);
354 : }
355 :
356 : {
357 42 : const size_t limiteOffsetIn = std::min(32UL, sizeof(RealType)*size_t(VecType::GetVecLength()));
358 846 : for(size_t idxOffsetIn = 0 ; idxOffsetIn < limiteOffsetIn ; ++idxOffsetIn){
359 : unsigned char* bufferIn[sizeof(RealType)*VecType::GetVecLength()*2];
360 804 : RealType* realsIn = reinterpret_cast<RealType*>(&bufferIn[idxOffsetIn]);
361 4296 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
362 3492 : realsIn[idx] = RealType(idx);
363 : }
364 :
365 804 : VecType vec(realsIn);
366 804 : equalToArray(vec, realsIn);
367 :
368 840 : vec.setFromArray(realsIn);
369 804 : equalToArray(vec, realsIn);
370 :
371 38148 : for(size_t idxOffsetOut = 0 ; idxOffsetOut < sizeof(RealType)*size_t(VecType::GetVecLength()) ; ++idxOffsetOut){
372 : unsigned char* bufferOut[sizeof(RealType)*VecType::GetVecLength()*2];
373 18672 : RealType* realsOut = reinterpret_cast<RealType*>(&bufferOut[idxOffsetOut]);
374 :
375 18672 : vec.storeInArray(realsOut);
376 111072 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
377 554400 : UASSERTEEQUAL(realsOut[idx], realsIn[idx]);
378 : }
379 : }
380 : }
381 : }
382 :
383 : {
384 : RealType reals[VecType::GetVecLength()];
385 : int indirect[VecType::GetVecLength()];
386 342 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
387 150 : indirect[idx] = int(idx);
388 150 : reals[idx] = RealType(idx);
389 : }
390 118 : equalToArray(VecType().setFromIndirectArray(reals, indirect), reals);
391 : }
392 :
393 : {
394 42 : RealType real = 1;
395 : int indirect[VecType::GetVecLength()];
396 186 : for (int idx = 0; idx < (VecType::GetVecLength()) ; ++idx) {
397 144 : indirect[idx] = 0;
398 : }
399 112 : equalToScalar(VecType().setFromIndirect2DArray(&real, indirect, 0, indirect), 1);
400 : }
401 :
402 : {
403 : RealType reals[VecType::GetVecLength() * 2];
404 : int indirect1[VecType::GetVecLength()];
405 : int indirect2[VecType::GetVecLength()];
406 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
407 150 : indirect1[idx] = int(idx);
408 150 : indirect2[idx] = 1;
409 150 : reals[idx] = RealType(idx);
410 150 : reals[idx + size_t(VecType::GetVecLength())] = RealType(idx * 2);
411 : }
412 112 : equalToArray(VecType().setFromIndirect2DArray(reals, indirect1, 0, indirect1), reals);
413 112 : equalToArray(VecType().setFromIndirect2DArray(reals, indirect2, VecType::GetVecLength(), indirect1), &reals[VecType::GetVecLength()]);
414 : }
415 :
416 : {
417 332 : UASSERTEEQUAL(VecType(1).horizontalSum(), RealType(VecType::GetVecLength()));
418 332 : UASSERTEEQUAL(VecType(10).horizontalSum(), RealType(10 * VecType::GetVecLength()));
419 :
420 332 : UASSERTEEQUAL(VecType(1).horizontalMul(), RealType(1));
421 374 : UASSERTEEQUAL(VecType(10).horizontalMul(), RealType(pow(10, VecType::GetVecLength())));
422 : }
423 :
424 : {
425 160 : equalToScalar(VecType::Min(VecType(1),
426 : VecType(1)), RealType(1));
427 160 : equalToScalar(VecType::Min(VecType(RealType(0)),
428 : VecType(1)), RealType(0));
429 160 : equalToScalar(VecType::Min(VecType(1),
430 : VecType(RealType(0))), RealType(0));
431 :
432 160 : equalToScalar(VecType::Max(VecType(1),
433 : VecType(1)), RealType(1));
434 160 : equalToScalar(VecType::Max(VecType(RealType(0)),
435 : VecType(1)), RealType(1));
436 160 : equalToScalar(VecType::Max(VecType(1),
437 : VecType(RealType(0))), RealType(1));
438 :
439 120 : equalToScalar(VecType(1).abs(), RealType(1));
440 120 : equalToScalar(VecType(-1).abs(), RealType(1));
441 120 : equalToScalar(VecType(RealType(0)).abs(), RealType(0));
442 : }
443 :
444 : {
445 : RealType reals[VecType::GetVecLength()];
446 36 : RealType sum = 0;
447 36 : RealType mul = 1;
448 212 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
449 150 : reals[idx] = RealType(idx);
450 150 : sum += reals[idx];
451 150 : mul *= reals[idx];
452 : }
453 332 : UASSERTEEQUAL(VecType(reals).horizontalSum(), sum);
454 332 : UASSERTEEQUAL(VecType(reals).horizontalMul(), mul);
455 : }
456 :
457 : {
458 78 : equalToScalar(VecType::GetZero(), 0);
459 78 : equalToScalar(VecType::GetOne(), 1);
460 : }
461 :
462 : {
463 : RealType reals[VecType::GetVecLength()];
464 : RealType expres[VecType::GetVecLength()];
465 : RealType expreslowacc[VecType::GetVecLength()];
466 : RealType sqrtres[VecType::GetVecLength()];
467 : RealType rsqrtres[VecType::GetVecLength()];
468 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
469 150 : reals[idx] = RealType((idx%10) + 1);
470 150 : expres[idx] = RealType(exp(reals[idx]));
471 150 : expreslowacc[idx] = RealType(exp(reals[idx]));
472 150 : sqrtres[idx] = RealType(sqrt(reals[idx]));
473 150 : rsqrtres[idx] = RealType(1 / sqrt(reals[idx]));
474 : }
475 :
476 92 : approxEqualToArray(VecType(reals).exp(), expres);
477 97 : approxLowAccEqualToArray(VecType(reals).expLowAcc(), expreslowacc);
478 120 : approxEqualToArray(VecType(reals).sqrt(), sqrtres);
479 120 : approxEqualToArray(VecType(reals).rsqrt(), rsqrtres);
480 :
481 92 : approxEqualToScalar(VecType(RealType(0)).exp(), std::exp(RealType(0)));
482 : }
483 :
484 :
485 :
486 : {
487 : default_alignas RealType reals[VecType::GetVecLength()];
488 : default_alignas RealType expres[VecType::GetVecLength()];
489 : default_alignas RealType expreslowacc[VecType::GetVecLength()];
490 : default_alignas RealType sqrtres[VecType::GetVecLength()];
491 : default_alignas RealType rsqrtres[VecType::GetVecLength()];
492 192 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
493 150 : reals[idx] = RealType((idx%10) + 1);
494 150 : expres[idx] = RealType(exp(reals[idx]));
495 150 : expreslowacc[idx] = RealType(exp(reals[idx]));
496 150 : sqrtres[idx] = RealType(sqrt(reals[idx]));
497 150 : rsqrtres[idx] = RealType(1 / sqrt(reals[idx]));
498 : }
499 :
500 124 : approxEqualToArray(VecType().setFromAlignedArray(reals).exp(), expres);
501 134 : approxLowAccEqualToArray(VecType().setFromAlignedArray(reals).expLowAcc(), expreslowacc);
502 160 : approxEqualToArray(VecType().setFromAlignedArray(reals).sqrt(), sqrtres);
503 160 : approxEqualToArray(VecType().setFromAlignedArray(reals).rsqrt(), rsqrtres);
504 : }
505 :
506 : {
507 120 : equalToScalar(VecType(RealType(0)).signOf(), 0);
508 120 : equalToScalar(VecType(-1).signOf(), -1);
509 120 : equalToScalar(VecType(1).signOf(), 1);
510 120 : equalToScalar(VecType(-10).signOf(), -1);
511 120 : equalToScalar(VecType(10).signOf(), 1);
512 :
513 120 : equalToScalar(VecType(RealType(0)).isPositive(), 1);
514 120 : equalToScalar(VecType(-1).isPositive(), 0);
515 120 : equalToScalar(VecType(1).isPositive(), 1);
516 120 : equalToScalar(VecType(-10).isPositive(), 0);
517 120 : equalToScalar(VecType(10).isPositive(), 1);
518 :
519 120 : equalToScalar(VecType(RealType(0)).isNegative(), 1);
520 120 : equalToScalar(VecType(-1).isNegative(), 1);
521 120 : equalToScalar(VecType(1).isNegative(), 0);
522 120 : equalToScalar(VecType(-10).isNegative(), 1);
523 120 : equalToScalar(VecType(10).isNegative(), 0);
524 :
525 120 : equalToScalar(VecType(RealType(0)).isPositiveStrict(), 0);
526 120 : equalToScalar(VecType(-1).isPositiveStrict(), 0);
527 120 : equalToScalar(VecType(1).isPositiveStrict(), 1);
528 120 : equalToScalar(VecType(-10).isPositiveStrict(), 0);
529 120 : equalToScalar(VecType(10).isPositiveStrict(), 1);
530 :
531 120 : equalToScalar(VecType(RealType(0)).isNegativeStrict(), 0);
532 120 : equalToScalar(VecType(-1).isNegativeStrict(), 1);
533 120 : equalToScalar(VecType(1).isNegativeStrict(), 0);
534 120 : equalToScalar(VecType(-10).isNegativeStrict(), 1);
535 120 : equalToScalar(VecType(10).isNegativeStrict(), 0);
536 :
537 :
538 120 : equalToScalar(VecType(RealType(0)).isZero(), 1);
539 120 : equalToScalar(VecType(RealType(0)).isNotZero(), 0);
540 :
541 120 : equalToScalar(VecType(1).isZero(), 0);
542 120 : equalToScalar(VecType(1).isNotZero(), 1);
543 120 : equalToScalar(VecType(1).isZero(), 0);
544 120 : equalToScalar(VecType(1).isNotZero(), 1);
545 : }
546 : {
547 160 : equalToScalar(VecType::IsLowerOrEqual(VecType(RealType(0)),
548 : VecType(RealType(0))),
549 : 1);
550 160 : equalToScalar(VecType::IsLowerOrEqual(VecType(-1),
551 : VecType(-1)),
552 : 1);
553 160 : equalToScalar(VecType::IsLowerOrEqual(VecType(-1),
554 : VecType(1)),
555 : 1);
556 160 : equalToScalar(VecType::IsLowerOrEqual(VecType(1),
557 : VecType(-1)),
558 : 0);
559 :
560 160 : equalToScalar(VecType::IsLower(VecType(RealType(0)),
561 : VecType(RealType(0))),
562 : 0);
563 160 : equalToScalar(VecType::IsLower(VecType(-1),
564 : VecType(-1)),
565 : 0);
566 160 : equalToScalar(VecType::IsLower(VecType(-1),
567 : VecType(1)),
568 : 1);
569 160 : equalToScalar(VecType::IsLower(VecType(1),
570 : VecType(-1)),
571 : 0);
572 :
573 160 : equalToScalar(VecType::IsGreaterOrEqual(VecType(RealType(0)),
574 : VecType(RealType(0))),
575 : 1);
576 160 : equalToScalar(VecType::IsGreaterOrEqual(VecType(-1),
577 : VecType(-1)),
578 : 1);
579 160 : equalToScalar(VecType::IsGreaterOrEqual(VecType(-1),
580 : VecType(1)),
581 : 0);
582 160 : equalToScalar(VecType::IsGreaterOrEqual(VecType(1),
583 : VecType(-1)),
584 : 1);
585 :
586 160 : equalToScalar(VecType::IsGreater(VecType(RealType(0)),
587 : VecType(RealType(0))),
588 : 0);
589 160 : equalToScalar(VecType::IsGreater(VecType(-1),
590 : VecType(-1)),
591 : 0);
592 160 : equalToScalar(VecType::IsGreater(VecType(-1),
593 : VecType(1)),
594 : 0);
595 160 : equalToScalar(VecType::IsGreater(VecType(1),
596 : VecType(-1)),
597 : 1);
598 :
599 160 : equalToScalar(VecType::IsEqual(VecType(RealType(0)),
600 : VecType(RealType(0))),
601 : 1);
602 160 : equalToScalar(VecType::IsEqual(VecType(-1),
603 : VecType(-1)),
604 : 1);
605 160 : equalToScalar(VecType::IsEqual(VecType(-1),
606 : VecType(1)),
607 : 0);
608 160 : equalToScalar(VecType::IsEqual(VecType(1),
609 : VecType(-1)),
610 : 0);
611 :
612 160 : equalToScalar(VecType::IsNotEqual(VecType(RealType(0)),
613 : VecType(RealType(0))),
614 : 0);
615 160 : equalToScalar(VecType::IsNotEqual(VecType(-1),
616 : VecType(-1)),
617 : 0);
618 160 : equalToScalar(VecType::IsNotEqual(VecType(-1),
619 : VecType(1)),
620 : 1);
621 160 : equalToScalar(VecType::IsNotEqual(VecType(1),
622 : VecType(-1)),
623 : 1);
624 : }
625 : {
626 42 : const MaskType trueMask(true);
627 42 : const MaskType falseMask(false);
628 :
629 126 : equalToScalarMask(VecType(RealType(0)).isPositiveMask(), trueMask);
630 126 : equalToScalarMask(VecType(-1).isPositiveMask(), falseMask);
631 126 : equalToScalarMask(VecType(1).isPositiveMask(), trueMask);
632 126 : equalToScalarMask(VecType(-10).isPositiveMask(), falseMask);
633 126 : equalToScalarMask(VecType(10).isPositiveMask(), trueMask);
634 :
635 126 : equalToScalarMask(VecType(RealType(0)).isNegativeMask(), trueMask);
636 126 : equalToScalarMask(VecType(-1).isNegativeMask(), trueMask);
637 126 : equalToScalarMask(VecType(1).isNegativeMask(), falseMask);
638 126 : equalToScalarMask(VecType(-10).isNegativeMask(), trueMask);
639 126 : equalToScalarMask(VecType(10).isNegativeMask(), falseMask);
640 :
641 126 : equalToScalarMask(VecType(RealType(0)).isPositiveStrictMask(), falseMask);
642 126 : equalToScalarMask(VecType(-1).isPositiveStrictMask(), falseMask);
643 126 : equalToScalarMask(VecType(1).isPositiveStrictMask(), trueMask);
644 126 : equalToScalarMask(VecType(-10).isPositiveStrictMask(), falseMask);
645 126 : equalToScalarMask(VecType(10).isPositiveStrictMask(), trueMask);
646 :
647 126 : equalToScalarMask(VecType(RealType(0)).isNegativeStrictMask(), falseMask);
648 126 : equalToScalarMask(VecType(-1).isNegativeStrictMask(), trueMask);
649 126 : equalToScalarMask(VecType(1).isNegativeStrictMask(), falseMask);
650 126 : equalToScalarMask(VecType(-10).isNegativeStrictMask(), trueMask);
651 126 : equalToScalarMask(VecType(10).isNegativeStrictMask(), falseMask);
652 :
653 :
654 126 : equalToScalarMask(VecType(RealType(0)).isZeroMask(), trueMask);
655 126 : equalToScalarMask(VecType(RealType(0)).isNotZeroMask(), falseMask);
656 :
657 126 : equalToScalarMask(VecType(1).isZeroMask(), falseMask);
658 126 : equalToScalarMask(VecType(1).isNotZeroMask(), trueMask);
659 126 : equalToScalarMask(VecType(1).isZeroMask(), falseMask);
660 126 : equalToScalarMask(VecType(1).isNotZeroMask(), trueMask);
661 : }
662 :
663 : {
664 42 : const MaskType trueMask(true);
665 42 : const MaskType falseMask(false);
666 :
667 166 : equalToScalarMask(VecType::IsLowerOrEqualMask(VecType(RealType(0)),
668 : VecType(RealType(0))),
669 : trueMask);
670 166 : equalToScalarMask(VecType::IsLowerOrEqualMask(VecType(-1),
671 : VecType(-1)),
672 : trueMask);
673 166 : equalToScalarMask(VecType::IsLowerOrEqualMask(VecType(-1),
674 : VecType(1)),
675 : trueMask);
676 166 : equalToScalarMask(VecType::IsLowerOrEqualMask(VecType(1),
677 : VecType(-1)),
678 : falseMask);
679 :
680 166 : equalToScalarMask(VecType::IsLowerMask(VecType(RealType(0)),
681 : VecType(RealType(0))),
682 : falseMask);
683 166 : equalToScalarMask(VecType::IsLowerMask(VecType(-1),
684 : VecType(-1)),
685 : falseMask);
686 166 : equalToScalarMask(VecType::IsLowerMask(VecType(-1),
687 : VecType(1)),
688 : trueMask);
689 166 : equalToScalarMask(VecType::IsLowerMask(VecType(1),
690 : VecType(-1)),
691 : falseMask);
692 :
693 166 : equalToScalarMask(VecType::IsGreaterOrEqualMask(VecType(RealType(0)),
694 : VecType(RealType(0))),
695 : trueMask);
696 166 : equalToScalarMask(VecType::IsGreaterOrEqualMask(VecType(-1),
697 : VecType(-1)),
698 : trueMask);
699 166 : equalToScalarMask(VecType::IsGreaterOrEqualMask(VecType(-1),
700 : VecType(1)),
701 : falseMask);
702 166 : equalToScalarMask(VecType::IsGreaterOrEqualMask(VecType(1),
703 : VecType(-1)),
704 : trueMask);
705 :
706 166 : equalToScalarMask(VecType::IsGreaterMask(VecType(RealType(0)),
707 : VecType(RealType(0))),
708 : falseMask);
709 166 : equalToScalarMask(VecType::IsGreaterMask(VecType(-1),
710 : VecType(-1)),
711 : falseMask);
712 166 : equalToScalarMask(VecType::IsGreaterMask(VecType(-1),
713 : VecType(1)),
714 : falseMask);
715 166 : equalToScalarMask(VecType::IsGreaterMask(VecType(1),
716 : VecType(-1)),
717 : trueMask);
718 :
719 166 : equalToScalarMask(VecType::IsEqualMask(VecType(RealType(0)),
720 : VecType(RealType(0))),
721 : trueMask);
722 166 : equalToScalarMask(VecType::IsEqualMask(VecType(-1),
723 : VecType(-1)),
724 : trueMask);
725 166 : equalToScalarMask(VecType::IsEqualMask(VecType(-1),
726 : VecType(1)),
727 : falseMask);
728 166 : equalToScalarMask(VecType::IsEqualMask(VecType(1),
729 : VecType(-1)),
730 : falseMask);
731 :
732 166 : equalToScalarMask(VecType::IsNotEqualMask(VecType(RealType(0)),
733 : VecType(RealType(0))),
734 : falseMask);
735 166 : equalToScalarMask(VecType::IsNotEqualMask(VecType(-1),
736 : VecType(-1)),
737 : falseMask);
738 166 : equalToScalarMask(VecType::IsNotEqualMask(VecType(-1),
739 : VecType(1)),
740 : trueMask);
741 166 : equalToScalarMask(VecType::IsNotEqualMask(VecType(1),
742 : VecType(-1)),
743 : trueMask);
744 : }
745 :
746 : {
747 114 : equalToScalar(VecType(RealType(1)).floor(), std::floor(RealType(1)));
748 114 : equalToScalar(VecType(RealType(1.5)).floor(), std::floor(RealType(1.5)));
749 114 : equalToScalar(VecType(RealType(1.9)).floor(), std::floor(RealType(1.9)));
750 114 : equalToScalar(VecType(RealType(100000.9999)).floor(), std::floor(RealType(100000.9999)));
751 114 : equalToScalar(VecType(RealType(-1000.99)).floor(), std::floor(RealType(-1000.99)));
752 : }
753 : {
754 42 : const VecType trueMask(1);
755 42 : const VecType falseMask(RealType(0));
756 :
757 78 : equalToVecType(VecType::BitsOr(falseMask,
758 : falseMask),
759 : falseMask);
760 78 : equalToVecType(VecType::BitsOr(trueMask,
761 : falseMask),
762 : trueMask);
763 78 : equalToVecType(VecType::BitsOr(trueMask,
764 : trueMask),
765 : trueMask);
766 :
767 78 : equalToVecType(VecType::BitsAnd(falseMask,
768 : falseMask),
769 : falseMask);
770 78 : equalToVecType(VecType::BitsAnd(trueMask,
771 : falseMask),
772 : falseMask);
773 78 : equalToVecType(VecType::BitsAnd(trueMask,
774 : trueMask),
775 : trueMask);
776 :
777 :
778 78 : equalToVecType(VecType::BitsXor(falseMask,
779 : falseMask),
780 : falseMask);
781 78 : equalToVecType(VecType::BitsXor(trueMask,
782 : falseMask),
783 : trueMask);
784 78 : equalToVecType(VecType::BitsXor(trueMask,
785 : trueMask),
786 : falseMask);
787 :
788 :
789 78 : equalToVecType(VecType::BitsNotAnd(falseMask,
790 : falseMask),
791 : falseMask);
792 78 : equalToVecType(VecType::BitsNotAnd(trueMask,
793 : falseMask),
794 : falseMask);
795 78 : equalToVecType(VecType::BitsNotAnd(trueMask,
796 : trueMask),
797 : falseMask);
798 78 : equalToVecType(VecType::BitsNotAnd(falseMask,trueMask),
799 : trueMask);
800 : }
801 : {
802 132 : equalToScalar(VecType(0.) + VecType(0.),0);
803 132 : equalToScalar(VecType(0.) + VecType(10.),10);
804 132 : equalToScalar(VecType(10.) + VecType(10.),20);
805 132 : equalToScalar(VecType(10.) + VecType(0.),10);
806 :
807 132 : equalToScalar(VecType(0.) - VecType(0.),0);
808 132 : equalToScalar(VecType(0.) - VecType(10.),-10);
809 132 : equalToScalar(VecType(10.) - VecType(10.),0);
810 132 : equalToScalar(VecType(10.) - VecType(0.),10);
811 :
812 132 : equalToScalar(VecType(0.) * VecType(0.),0);
813 132 : equalToScalar(VecType(0.) * VecType(10.),0);
814 132 : equalToScalar(VecType(10.) * VecType(10.),100);
815 132 : equalToScalar(VecType(10.) * VecType(0.),0);
816 :
817 132 : equalToScalar(VecType(0.) / VecType(10.),0);
818 132 : equalToScalar(VecType(10.) / VecType(10.),1);
819 : }
820 : {
821 158 : equalToScalar(VecType(0.) += VecType(0.),0);
822 158 : equalToScalar(VecType(0.) += VecType(10.),10);
823 158 : equalToScalar(VecType(10.) += VecType(10.),20);
824 158 : equalToScalar(VecType(10.) += VecType(0.),10);
825 :
826 158 : equalToScalar(VecType(0.) -= VecType(0.),0);
827 158 : equalToScalar(VecType(0.) -= VecType(10.),-10);
828 158 : equalToScalar(VecType(10.) -= VecType(10.),0);
829 158 : equalToScalar(VecType(10.) -= VecType(0.),10);
830 :
831 158 : equalToScalar(VecType(0.) *= VecType(0.),0);
832 158 : equalToScalar(VecType(0.) *= VecType(10.),0);
833 158 : equalToScalar(VecType(10.) *= VecType(10.),100);
834 158 : equalToScalar(VecType(10.) *= VecType(0.),0);
835 :
836 158 : equalToScalar(VecType(0.) /= VecType(10.),0);
837 158 : equalToScalar(VecType(10.) /= VecType(10.),1);
838 : }
839 : {
840 120 : equalToScalar(-VecType(-4.),4.);
841 120 : equalToScalar(-VecType(4.),-4.);
842 42 : VecType a = 1.;
843 78 : equalToScalar(-a,-1.);
844 120 : equalToScalar((-1.) * a,-1.);
845 42 : a = VecType(-1.);
846 78 : equalToScalar(-a,1.);
847 120 : equalToScalar((-1.) * a,1.);
848 : }
849 :
850 : {
851 106 : equalToScalar(VecType(1.).pow(0),1.);
852 100 : equalToScalar(VecType(1.).pow(1),1.);
853 100 : equalToScalar(VecType(1.).pow(2),1.);
854 :
855 100 : equalToScalar(VecType(2.).pow(2),4.);
856 :
857 100 : equalToScalar(VecType(5.).pow(10),RealType(std::pow(5., 10)));
858 100 : equalToScalar(VecType(2.).pow(12),RealType(std::pow(2., 12)));
859 : }
860 :
861 : {
862 42 : VecType::MultiHorizontalSum(nullptr); // Should compile
863 :
864 42 : RealType res = 0;
865 84 : VecType::MultiHorizontalSum(&res, VecType(1));
866 332 : UASSERTEEQUAL(VecType(1).horizontalSum(), res);
867 :
868 42 : res = 0;
869 84 : VecType::MultiHorizontalSum(&res, VecType(10));
870 332 : UASSERTEEQUAL(VecType(10).horizontalSum(), res);
871 : }
872 : {
873 42 : RealType res[2] = {0};
874 42 : VecType v1(1);
875 42 : VecType v2(10);
876 :
877 42 : VecType::MultiHorizontalSum(res, v1, v2);
878 :
879 292 : UASSERTEEQUAL(v1.horizontalSum(), res[0]);
880 292 : UASSERTEEQUAL(v2.horizontalSum(), res[1]);
881 : }
882 : {
883 42 : RealType res[3] = {0};
884 42 : VecType v1(1);
885 42 : VecType v2(10);
886 42 : VecType v3(100);
887 :
888 42 : VecType::MultiHorizontalSum(res, v1, v2, v3);
889 :
890 292 : UASSERTEEQUAL(v1.horizontalSum(), res[0]);
891 292 : UASSERTEEQUAL(v2.horizontalSum(), res[1]);
892 292 : UASSERTEEQUAL(v3.horizontalSum(), res[2]);
893 : }
894 : {
895 42 : RealType res[4] = {0};
896 42 : VecType v1(1);
897 42 : VecType v2(10);
898 42 : VecType v3(100);
899 42 : VecType v4(1000);
900 :
901 42 : VecType::MultiHorizontalSum(res, v1, v2, v3, v4);
902 :
903 292 : UASSERTEEQUAL(v1.horizontalSum(), res[0]);
904 292 : UASSERTEEQUAL(v2.horizontalSum(), res[1]);
905 292 : UASSERTEEQUAL(v3.horizontalSum(), res[2]);
906 292 : UASSERTEEQUAL(v4.horizontalSum(), res[3]);
907 : }
908 : {
909 42 : RealType res[5] = {0};
910 42 : VecType v1(1);
911 42 : VecType v2(10);
912 42 : VecType v3(100);
913 42 : VecType v4(1000);
914 42 : VecType v5(10000);
915 :
916 42 : VecType::MultiHorizontalSum(res, v1, v2, v3, v4, v5);
917 :
918 292 : UASSERTEEQUAL(v1.horizontalSum(), res[0]);
919 292 : UASSERTEEQUAL(v2.horizontalSum(), res[1]);
920 292 : UASSERTEEQUAL(v3.horizontalSum(), res[2]);
921 292 : UASSERTEEQUAL(v4.horizontalSum(), res[3]);
922 292 : UASSERTEEQUAL(v5.horizontalSum(), res[4]);
923 : }
924 : {
925 42 : const int nb_vec_test = 3;
926 42 : RealType res[nb_vec_test] = {0};
927 42 : RealType good_res[nb_vec_test] = {0};
928 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
929 276 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
930 756 : UASSERTEEQUAL(good_res[idx], res[idx]);
931 : }
932 : }
933 : {
934 42 : const int nb_vec_test = 4;
935 42 : RealType res[nb_vec_test] = {0};
936 42 : RealType good_res[nb_vec_test] = {0};
937 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
938 354 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
939 1008 : UASSERTEEQUAL(good_res[idx], res[idx]);
940 : }
941 : }
942 : {
943 42 : const int nb_vec_test = 5;
944 42 : RealType res[nb_vec_test] = {0};
945 42 : RealType good_res[nb_vec_test] = {0};
946 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
947 432 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
948 1260 : UASSERTEEQUAL(good_res[idx], res[idx]);
949 : }
950 : }
951 : {
952 42 : const int nb_vec_test = 6;
953 42 : RealType res[nb_vec_test] = {0};
954 42 : RealType good_res[nb_vec_test] = {0};
955 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
956 510 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
957 1512 : UASSERTEEQUAL(good_res[idx], res[idx]);
958 : }
959 : }
960 : {
961 42 : const int nb_vec_test = 7;
962 42 : RealType res[nb_vec_test] = {0};
963 42 : RealType good_res[nb_vec_test] = {0};
964 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
965 588 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
966 1764 : UASSERTEEQUAL(good_res[idx], res[idx]);
967 : }
968 : }
969 : {
970 42 : const int nb_vec_test = 8;
971 42 : RealType res[nb_vec_test] = {0};
972 42 : RealType good_res[nb_vec_test] = {0};
973 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
974 666 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
975 2016 : UASSERTEEQUAL(good_res[idx], res[idx]);
976 : }
977 : }
978 : {
979 42 : const int nb_vec_test = 9;
980 42 : RealType res[nb_vec_test] = {0};
981 42 : RealType good_res[nb_vec_test] = {0};
982 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
983 744 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
984 2268 : UASSERTEEQUAL(good_res[idx], res[idx]);
985 : }
986 : }
987 : {
988 42 : const int nb_vec_test = 10;
989 42 : RealType res[nb_vec_test] = {0};
990 42 : RealType good_res[nb_vec_test] = {0};
991 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
992 822 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
993 2520 : UASSERTEEQUAL(good_res[idx], res[idx]);
994 : }
995 : }
996 : {
997 42 : const int nb_vec_test = 11;
998 42 : RealType res[nb_vec_test] = {0};
999 42 : RealType good_res[nb_vec_test] = {0};
1000 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1001 900 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1002 2772 : UASSERTEEQUAL(good_res[idx], res[idx]);
1003 : }
1004 : }
1005 : {
1006 42 : const int nb_vec_test = 12;
1007 42 : RealType res[nb_vec_test] = {0};
1008 42 : RealType good_res[nb_vec_test] = {0};
1009 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1010 978 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1011 3024 : UASSERTEEQUAL(good_res[idx], res[idx]);
1012 : }
1013 : }
1014 : {
1015 42 : const int nb_vec_test = 13;
1016 42 : RealType res[nb_vec_test] = {0};
1017 42 : RealType good_res[nb_vec_test] = {0};
1018 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1019 1056 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1020 3276 : UASSERTEEQUAL(good_res[idx], res[idx]);
1021 : }
1022 : }
1023 : {
1024 42 : const int nb_vec_test = 14;
1025 42 : RealType res[nb_vec_test] = {0};
1026 42 : RealType good_res[nb_vec_test] = {0};
1027 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1028 1134 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1029 3528 : UASSERTEEQUAL(good_res[idx], res[idx]);
1030 : }
1031 : }
1032 : {
1033 42 : const int nb_vec_test = 15;
1034 42 : RealType res[nb_vec_test] = {0};
1035 42 : RealType good_res[nb_vec_test] = {0};
1036 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1037 1212 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1038 3780 : UASSERTEEQUAL(good_res[idx], res[idx]);
1039 : }
1040 : }
1041 : {
1042 42 : const int nb_vec_test = 16;
1043 42 : RealType res[nb_vec_test] = {0};
1044 42 : RealType good_res[nb_vec_test] = {0};
1045 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1046 1290 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1047 4032 : UASSERTEEQUAL(good_res[idx], res[idx]);
1048 : }
1049 : }
1050 : {
1051 42 : const int nb_vec_test = 17;
1052 42 : RealType res[nb_vec_test] = {0};
1053 42 : RealType good_res[nb_vec_test] = {0};
1054 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1055 1368 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1056 4284 : UASSERTEEQUAL(good_res[idx], res[idx]);
1057 : }
1058 : }
1059 : {
1060 42 : const int nb_vec_test = 18;
1061 42 : RealType res[nb_vec_test] = {0};
1062 42 : RealType good_res[nb_vec_test] = {0};
1063 42 : MultiHorizontalSumTester<VecType,nb_vec_test>::addToTest(res, good_res, 0);
1064 1446 : for(int idx = 0 ; idx < nb_vec_test ; ++idx){
1065 4536 : UASSERTEEQUAL(good_res[idx], res[idx]);
1066 : }
1067 : }
1068 :
1069 :
1070 : {
1071 : RealType reals[VecType::GetVecLength()];
1072 192 : for (size_t idx1 = 0; idx1 < size_t(VecType::GetVecLength()) ; ++idx1) {
1073 : {
1074 1596 : for (size_t idx2 = 0; idx2 < size_t(VecType::GetVecLength()) ; ++idx2) {
1075 720 : reals[idx2] = (idx1 == idx2 ? 10 : 0);
1076 : }
1077 150 : VecType vec(reals);
1078 : if(VecType::GetVecLength() == 1){
1079 40 : UASSERTEEQUAL(vec.minInVec(), RealType(10));
1080 40 : UASSERTEEQUAL(vec.maxInVec(), RealType(10));
1081 : }
1082 : else{
1083 1008 : UASSERTEEQUAL(vec.minInVec(), RealType(0));
1084 1008 : UASSERTEEQUAL(vec.maxInVec(), RealType(10));
1085 : }
1086 : }
1087 : {
1088 870 : for (size_t idx2 = 0; idx2 < size_t(VecType::GetVecLength()) ; ++idx2) {
1089 720 : reals[idx2] = (idx1 == idx2 ? -10 : 0);
1090 : }
1091 150 : VecType vec(reals);
1092 : if(VecType::GetVecLength() == 1){
1093 40 : UASSERTEEQUAL(vec.minInVec(), RealType(-10));
1094 40 : UASSERTEEQUAL(vec.maxInVec(), RealType(-10));
1095 : }
1096 : else{
1097 1008 : UASSERTEEQUAL(vec.minInVec(), RealType(-10));
1098 1008 : UASSERTEEQUAL(vec.maxInVec(), RealType(0));
1099 : }
1100 : }
1101 : }
1102 : }
1103 :
1104 : {
1105 42 : const VecType zero(RealType(0));
1106 42 : const VecType one(RealType(1));
1107 78 : equalToScalar(VecType::Fma(zero, zero, zero), RealType(0));
1108 78 : equalToScalar(VecType::Fma(one, zero, zero), RealType(1));
1109 78 : equalToScalar(VecType::Fma(zero, one, one), RealType(1));
1110 78 : equalToScalar(VecType::Fma(one, one, one), RealType(2));
1111 :
1112 : RealType a[VecType::GetVecLength()];
1113 : RealType b[VecType::GetVecLength()];
1114 : RealType c[VecType::GetVecLength()];
1115 212 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
1116 150 : a[idx] = RealType(idx+1);
1117 150 : b[idx] = RealType(idx*10);
1118 150 : c[idx] = RealType(idx)+RealType(1.3);
1119 : }
1120 :
1121 : RealType res[VecType::GetVecLength()];
1122 342 : for (size_t idx = 0; idx < size_t(VecType::GetVecLength()) ; ++idx) {
1123 150 : res[idx] = a[idx] + (b[idx] * c[idx]);
1124 : }
1125 200 : equalToArray(VecType::Fma(VecType(a), VecType(b), VecType(c)), res);
1126 : }
1127 42 : }
1128 :
1129 42 : void SetTests() {
1130 126 : Parent::AddTest(&TestAll::TestBasic, "Basic test for vec type");
1131 42 : }
1132 : };
1133 :
1134 : #endif
|
