Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
Stokhos_SacadoMPVectorUnitTest_MaskTraits.cpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Stokhos Package
5 // Copyright (2009) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Eric T. Phipps (etphipp@sandia.gov).
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 #include "Teuchos_UnitTestHarness.hpp"
43 #include "Teuchos_TestingHelpers.hpp"
44 #include "Teuchos_UnitTestRepository.hpp"
45 #include "Teuchos_GlobalMPISession.hpp"
46 
47 #include "Stokhos_MP_Vector_MaskTraits.hpp"
48 
49 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Create_8)
50 {
51  constexpr int ensemble_size = 8;
52 
53  typedef Kokkos::DefaultExecutionSpace execution_space;
54  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
55  typedef Sacado::MP::Vector<storage_type> scalar;
56 
57  scalar a = (scalar) 1.;
58  a[0] = 2.5;
59  a[2] = 2.5;
60  scalar b = (scalar) 2.0;
61 
62  auto m1 = a>b;
63  std::cout << std::endl;
64  std::cout << a << std::endl;
65  std::cout << b << std::endl;
66  std::cout << m1 << std::endl;
67  TEST_EQUALITY( m1.getSize(), ensemble_size );
68  TEST_EQUALITY( m1[0], true );
69  TEST_EQUALITY( m1[1], false );
70  TEST_EQUALITY( m1[2], true );
71  for (auto i=3; i<ensemble_size; ++i)
72  TEST_EQUALITY( m1[i], false );
73 
74  TEST_EQUALITY( (double) m1, 2./ensemble_size );
75 }
76 
77 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Create_16)
78 {
79  constexpr int ensemble_size = 16;
80 
81  typedef Kokkos::DefaultExecutionSpace execution_space;
82  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
83  typedef Sacado::MP::Vector<storage_type> scalar;
84 
85  scalar a = (scalar) 1.;
86  a[0] = 2.5;
87  a[2] = 2.5;
88  scalar b = (scalar) 2.0;
89 
90  auto m1 = a>b;
91  std::cout << std::endl;
92  std::cout << a << std::endl;
93  std::cout << b << std::endl;
94  std::cout << m1 << std::endl;
95  TEST_EQUALITY( m1.getSize(), ensemble_size );
96  TEST_EQUALITY( m1[0], true );
97  TEST_EQUALITY( m1[1], false );
98  TEST_EQUALITY( m1[2], true );
99  for (auto i=3; i<ensemble_size; ++i)
100  TEST_EQUALITY( m1[i], false );
101 
102  TEST_EQUALITY( (double) m1, 2./ensemble_size );
103 }
104 
105 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Not_8)
106 {
107  constexpr int ensemble_size = 8;
108 
109  typedef Kokkos::DefaultExecutionSpace execution_space;
110  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
111  typedef Sacado::MP::Vector<storage_type> scalar;
112 
113  scalar a = (scalar) 1.;
114  a[0] = 2.5;
115  a[2] = 2.5;
116  scalar b = (scalar) 2.0;
117 
118  auto m1 = a>b;
119  auto m2 = !m1;
120  std::cout << m1 << std::endl;
121  std::cout << m2 << std::endl;
122  for (auto i=0; i<ensemble_size; ++i)
123  TEST_EQUALITY( m2[i], !m1[i] );
124 }
125 
126 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Multiplication_8)
127 {
128  constexpr int ensemble_size = 8;
129 
130  typedef Kokkos::DefaultExecutionSpace execution_space;
131  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
132  typedef Sacado::MP::Vector<storage_type> scalar;
133 
134  scalar a = (scalar) 1.0;
135  a[0] = 2.5;
136  a[2] = 2.5;
137  scalar b = (scalar) 2.0;
138 
139  auto m1 = a>b;
140  scalar mul = m1*a;
141 
142  scalar mul2 = m1*b;
143  scalar mul3 = b*m1;
144 
145  std::cout << m1 << std::endl;
146  std::cout << mul << std::endl;
147 
148  std::cout << mul2 << std::endl;
149  std::cout << mul3 << std::endl;
150 
151  TEST_EQUALITY( mul[0], 2.5 );
152  TEST_EQUALITY( mul[1], 0.0 );
153  TEST_EQUALITY( mul[2], 2.5 );
154  for (auto i=3; i<ensemble_size; ++i)
155  TEST_EQUALITY( mul[i], 0.0 );
156 
157  TEST_EQUALITY( mul2, mul3 );
158 }
159 
160 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Multiplication_16)
161 {
162  constexpr int ensemble_size = 16;
163 
164  typedef Kokkos::DefaultExecutionSpace execution_space;
165  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
166  typedef Sacado::MP::Vector<storage_type> scalar;
167 
168  scalar a = (scalar) 1.0;
169  a[0] = 2.5;
170  a[2] = 2.5;
171  scalar b = (scalar) 2.0;
172 
173  auto m1 = a>b;
174  scalar mul = m1*a;
175  std::cout << m1 << std::endl;
176  std::cout << mul << std::endl;
177 
178  TEST_EQUALITY( mul[0], 2.5 );
179  TEST_EQUALITY( mul[1], 0.0 );
180  TEST_EQUALITY( mul[2], 2.5 );
181  for (auto i=3; i<ensemble_size; ++i)
182  TEST_EQUALITY( mul[i], 0. );
183 }
184 
185 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mul_Add_8)
186 {
187  constexpr int ensemble_size = 8;
188 
189  typedef Kokkos::DefaultExecutionSpace execution_space;
190  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
191  typedef Sacado::MP::Vector<storage_type> scalar;
192 
193  scalar a = (scalar) 1.0;
194  a[0] = 2.5;
195  a[2] = 2.5;
196  scalar b = (scalar) 2.0;
197 
198  auto m1 = a>b;
199  scalar mul = m1*a + !m1*b;
200  scalar mul2 = a*m1 + !m1*b;
201  std::cout << m1 << std::endl;
202  std::cout << mul << std::endl;
203  std::cout << mul2 << std::endl;
204 
205  TEST_EQUALITY( mul[0], 2.5 );
206  TEST_EQUALITY( mul[1], 2.0 );
207  TEST_EQUALITY( mul[2], 2.5 );
208  for (auto i=3; i<ensemble_size; ++i)
209  TEST_EQUALITY( mul[i], 2.0 );
210 
211  TEST_EQUALITY( mul, mul2 );
212 }
213 
214 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_DEFAULT)
215 {
216  constexpr int ensemble_size = 8;
217 
218  typedef Kokkos::DefaultExecutionSpace execution_space;
219  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
220  typedef Sacado::MP::Vector<storage_type> scalar;
221 
222  using namespace MaskLogic;
223 
224  scalar a = (scalar) 1.0;
225  a[1] = 2.5;
226  a[2] = 2.5;
227  scalar b = (scalar) 2.0;
228 
229  auto m1 = a>b;
230  auto m2 = a>(scalar) 0.0;
231  auto m3 = a> 0.0;
232  auto m4 = 0.0<a;
233  std::cout << m1 << std::endl;
234  std::cout << m2 << std::endl;
235  std::cout << m3<< std::endl;
236  std::cout << m4<< std::endl;
237 
238  if (m1)
239  {TEST_EQUALITY( true, false );}
240  else
241  {TEST_EQUALITY( true, true );}
242 
243  TEST_EQUALITY((bool) m1, false );
244  TEST_EQUALITY((bool) !m1, true );
245 
246  if (m2)
247  {TEST_EQUALITY( true, true );}
248  else
249  {TEST_EQUALITY( true, false );}
250 
251  TEST_EQUALITY((bool) m2, true );
252  TEST_EQUALITY((bool) !m2, false );
253 
254  TEST_EQUALITY( m2, m3 );
255  TEST_EQUALITY( m2, m4 );
256 }
257 
258 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_AND)
259 {
260  constexpr int ensemble_size = 8;
261 
262  typedef Kokkos::DefaultExecutionSpace execution_space;
263  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
264  typedef Sacado::MP::Vector<storage_type> scalar;
265 
266  using namespace MaskLogic;
267 
268  scalar a = (scalar) 1.0;
269  a[0] = 2.5;
270  a[2] = 2.5;
271  scalar b = (scalar) 2.0;
272 
273  auto m1 = a>b;
274  auto m2 = a>0.0;
275  std::cout << m1 << std::endl;
276  std::cout << m2 << std::endl;
277 
278 
279  TEST_EQUALITY( (AND) true, true );
280  TEST_EQUALITY( (AND) false, false );
281  TEST_EQUALITY( (AND) m1, false );
282  TEST_EQUALITY( (AND) !m1, false );
283  TEST_EQUALITY( (AND) m2, true );
284  TEST_EQUALITY( (AND) !m2, false );
285 }
286 
287 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_OR)
288 {
289  constexpr int ensemble_size = 8;
290 
291  typedef Kokkos::DefaultExecutionSpace execution_space;
292  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
293  typedef Sacado::MP::Vector<storage_type> scalar;
294 
295  using namespace MaskLogic;
296 
297  scalar a = (scalar) 1.0;
298  a[0] = 2.5;
299  a[2] = 2.5;
300  scalar b = (scalar) 2.0;
301 
302  auto m1 = a>b;
303  auto m2 = a>0.0;
304  std::cout << m1 << std::endl;
305  std::cout << m2 << std::endl;
306 
307 
308  TEST_EQUALITY( (OR) true, true );
309  TEST_EQUALITY( (OR) false, false );
310  TEST_EQUALITY( (OR) m1, true );
311  TEST_EQUALITY( (OR) !m1, true );
312  TEST_EQUALITY( (OR) m2, true );
313  TEST_EQUALITY( (OR) !m2, false );
314 }
315 
316 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_XOR)
317 {
318  constexpr int ensemble_size = 8;
319 
320  typedef Kokkos::DefaultExecutionSpace execution_space;
321  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
322  typedef Sacado::MP::Vector<storage_type> scalar;
323 
324  using namespace MaskLogic;
325 
326  scalar a = (scalar) 1.0;
327  a[2] = 2.5;
328  scalar b = (scalar) 2.0;
329 
330  auto m1 = a>b;
331  auto m2 = a>0.0;
332  std::cout << m1 << std::endl;
333  std::cout << m2 << std::endl;
334 
335 
336  TEST_EQUALITY( (XOR) true, true );
337  TEST_EQUALITY( (XOR) false, false );
338  TEST_EQUALITY( (XOR) m1, true );
339  TEST_EQUALITY( (XOR) !m1, false );
340  TEST_EQUALITY( (XOR) m2, false );
341  TEST_EQUALITY( (XOR) !m2, false );
342 }
343 
344 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_compared_to_double)
345 {
346  constexpr int ensemble_size = 8;
347 
348  typedef Kokkos::DefaultExecutionSpace execution_space;
349  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
350  typedef Sacado::MP::Vector<storage_type> scalar;
351 
352  scalar a = (scalar) 1.0;
353  a[2] = 2.5;
354  scalar b = (scalar) 2.0;
355 
356  auto m1 = a>b;
357  auto m2 = a>0.0;
358 
359  std::cout << m1 << std::endl;
360  std::cout << m2 << std::endl;
361 
362  TEST_EQUALITY((double) m1,1./ensemble_size);
363  TEST_EQUALITY((double) m2,1.);
364 
365  TEST_EQUALITY(m1==1.,false);
366  TEST_EQUALITY(m1!=1.,true);
367  TEST_EQUALITY(m1==0.,false);
368  TEST_EQUALITY(m1!=0.,true);
369 
370  TEST_EQUALITY(m1>=0.5,false);
371  TEST_EQUALITY(m1<=0.5,true);
372  TEST_EQUALITY(m1>0.5,false);
373  TEST_EQUALITY(m1<0.5,true);
374 
375  TEST_EQUALITY(m2==1.,true);
376  TEST_EQUALITY(m2!=1.,false);
377  TEST_EQUALITY(m2==0.,false);
378  TEST_EQUALITY(m2!=0.,true);
379 
380  TEST_EQUALITY(m2>=0.5,true);
381  TEST_EQUALITY(m2<=0.5,false);
382  TEST_EQUALITY(m2>0.5,true);
383  TEST_EQUALITY(m2<0.5,false);
384 }
385 
386 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_AND_Mask)
387 {
388  constexpr int ensemble_size = 8;
389 
390  typedef Kokkos::DefaultExecutionSpace execution_space;
391  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
392  typedef Sacado::MP::Vector<storage_type> scalar;
393 
394  scalar a = (scalar) 1.0;
395  a[2] = 2.5;
396  scalar b = (scalar) 2.0;
397 
398  auto m1 = a>b;
399  auto m2 = a>0.;
400 
401  auto m3 = m1 && m2;
402  std::cout << m1 << std::endl;
403  std::cout << m2 << std::endl;
404  std::cout << m3 << std::endl;
405  TEST_EQUALITY(m3,m1);
406 }
407 
408 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_OR_Mask)
409 {
410  constexpr int ensemble_size = 8;
411 
412  typedef Kokkos::DefaultExecutionSpace execution_space;
413  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
414  typedef Sacado::MP::Vector<storage_type> scalar;
415 
416  scalar a = (scalar) 1.0;
417  a[2] = 2.5;
418  scalar b = (scalar) 2.0;
419 
420  auto m1 = a>b;
421  auto m2 = a>0.;
422 
423  auto m3 = m1 || m2;
424  std::cout << m1 << std::endl;
425  std::cout << m2 << std::endl;
426  std::cout << m3 << std::endl;
427  TEST_EQUALITY(m3,m2);
428 }
429 
430 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_ADD_Mask)
431 {
432  constexpr int ensemble_size = 8;
433 
434  typedef Kokkos::DefaultExecutionSpace execution_space;
435  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
436  typedef Sacado::MP::Vector<storage_type> scalar;
437 
438  scalar a = (scalar) 1.;
439  a[2] = 2.5;
440  scalar b = (scalar) 2.0;
441 
442  std::cout << a << std::endl;
443  std::cout << b << std::endl;
444 
445  auto m1 = a>b;
446  auto m2 = a>0.;
447  //std::cout << m1 << std::endl;
448  //std::cout << m2 << std::endl;
449  auto m3 = m1 + m2;
450 
451  std::cout << m3 << std::endl;
452  TEST_EQUALITY(m3,m2);
453 }
454 
455 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_SUB_Mask)
456 {
457  constexpr int ensemble_size = 8;
458 
459  typedef Kokkos::DefaultExecutionSpace execution_space;
460  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
461  typedef Sacado::MP::Vector<storage_type> scalar;
462 
463  scalar a = (scalar) 1.;
464  a[2] = 2.5;
465  scalar b = (scalar) 2.0;
466 
467  auto m1 = a>b;
468  auto m2 = a>0.;
469  std::cout << m1 << std::endl;
470  std::cout << m2 << std::endl;
471  auto m3 = (a>0.) - (a>b);
472  std::cout << m3 << std::endl;
473  TEST_EQUALITY(m3,!m1);
474 }
475 
476 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_signbit_v)
477 {
478  constexpr int ensemble_size = 8;
479 
480  typedef Kokkos::DefaultExecutionSpace execution_space;
481  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
482  typedef Sacado::MP::Vector<storage_type> scalar;
483  typedef Mask<scalar> mask;
484 
485  scalar a = (scalar) 1.;
486  a[2] = -2.5;
487 
488  auto m1 = signbit_v(a);
489  mask m2;
490  m2[2] = true;
491  TEST_EQUALITY(m1,m2);
492 }
493 
494 TEUCHOS_UNIT_TEST( MP_Vector_MaskTraits, Mask_copysign)
495 {
496  constexpr int ensemble_size = 8;
497 
498  typedef Kokkos::DefaultExecutionSpace execution_space;
499  typedef Stokhos::StaticFixedStorage<int,double,ensemble_size,execution_space> storage_type;
500  typedef Sacado::MP::Vector<storage_type> scalar;
501  typedef Mask<scalar> mask;
502 
503  scalar a = (scalar) 1.;
504  a[2] = -2.5;
505 
506  scalar b = (scalar) 2.;
507 
508  using std::copysign;
509 
510  std::cout << std::endl;
511  std::cout << a << std::endl;
512  std::cout << b << std::endl;
513  b = copysign(b,a);
514  std::cout << a << std::endl;
515  std::cout << b << std::endl;
516  TEST_EQUALITY(b[2],-2.);
517 }
518 
519 
520 int main( int argc, char* argv[] ) {
521  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
522 
523  Kokkos::initialize();
524 // Kokkos::HostSpace::execution_space::initialize();
525 // if (!Kokkos::DefaultExecutionSpace::is_initialized())
526 // Kokkos::DefaultExecutionSpace::initialize();
527 
528  int res = Teuchos::UnitTestRepository::runUnitTestsFromMain(argc, argv);
529 
530  Kokkos::finalize();
531 // Kokkos::HostSpace::execution_space::finalize();
532 // if (Kokkos::DefaultExecutionSpace::is_initialized())
533 // Kokkos::DefaultExecutionSpace::finalize();
534 
535  return res;
536 }
Teuchos_TestingHelpers.hpp
signbit_v
Mask< Sacado::MP::Vector< S > > signbit_v(const Sacado::MP::Vector< S > &a1)
Definition: Stokhos_MP_Vector_MaskTraits.hpp:310
Sacado::MP::Vector
Definition: Belos_SolverManager_MP_Vector.hpp:48
MaskLogic::XOR
Definition: Stokhos_MP_Vector_MaskTraits.hpp:473
MaskLogic::OR
Definition: Stokhos_MP_Vector_MaskTraits.hpp:449
Teuchos::GlobalMPISession
TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(MP_Vector_MaskTraits, Create_8)
Definition: Stokhos_SacadoMPVectorUnitTest_MaskTraits.cpp:49
Teuchos_UnitTestHarness.hpp
Teuchos_UnitTestRepository.hpp
main
int main(int argc, char *argv[])
Definition: Stokhos_SacadoMPVectorUnitTest_MaskTraits.cpp:520
Sacado::MP::copysign
Vector< S > copysign(const Vector< S > &a1, const Vector< S > &a2)
Definition: Stokhos_MP_Vector_MaskTraits.hpp:293
Mask
Definition: Stokhos_MP_Vector_MaskTraits.hpp:69
MaskLogic
Definition: Stokhos_MP_Vector_MaskTraits.hpp:447
Teuchos_GlobalMPISession.hpp
DynamicVecTest::execution_space
Kokkos::DefaultExecutionSpace execution_space
Definition: Stokhos_SacadoMPVectorCommTests.cpp:682
MaskLogic::AND
Definition: Stokhos_MP_Vector_MaskTraits.hpp:497
storage_type
Stokhos::StandardStorage< int, double > storage_type
Definition: Stokhos_SacadoETPCEUnitTest.cpp:50
Teuchos::UnitTestRepository::runUnitTestsFromMain
static int runUnitTestsFromMain(int argc, char *argv[])
Stokhos::StaticFixedStorage
Statically allocated storage class.
Definition: Stokhos_StaticFixedStorage.hpp:59
TEST_EQUALITY
TEST_EQUALITY(rcp_dynamic_cast< const EnhancedNumberValidator< double > >(castedDep1->getValuesAndValidators().find("val1") ->second, true) ->getMax(), double1Vali->getMax())
argv
char * argv[]
Definition: Stokhos_HouseTriDiagUnitTest.cpp:286
Stokhos_MP_Vector_MaskTraits.hpp
Generated by   doxygen 1.8.16