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