Line data    Source code

       1              : //
       2              : // Class PRegion
       3              : //   PRegion represents a (possibly continuous) numeric interval.  It is
       4              : //   similar to Index, with the following differences:
       5              : //      1. It is templated on the data type; Index always uses integers
       6              : //      2. A PRegion is defined between two endpoints A and B; the PRegion
       7              : //         includes values X where A <= X < B (i.e., X in [A,B) )
       8              : //      3. PRegion does not keep track of a base Index, and does not
       9              : //         supply the plugBase operation.  It is not designed for use in
      10              : //         Field operations like Index is, it is meant instead for use in
      11              : //         Particle construction and usage.
      12              : //
      13              : //   PRegion<T>()      --> make a PRegion on [0,1)
      14              : //   PRegion<T>(B)     --> make a PRegion on [0,B)
      15              : //   PRegion<T>(A,B)   --> make a PRegion on [A,B)
      16              : //
      17              : #include <algorithm>
      18              : #include <iostream>
      19              : 
      20              : #include "Utility/PAssert.h"
      21              : 
      22              : namespace ippl {
      23              :     template <typename T>
      24         2268 :     KOKKOS_FUNCTION PRegion<T>::PRegion()
      25         2268 :         : PRegion(0, 1) {}
      26              : 
      27              :     template <typename T>
      28              :     KOKKOS_FUNCTION PRegion<T>::PRegion(T b)
      29              :         : PRegion(0, b) {}
      30              : 
      31              :     template <typename T>
      32         3192 :     KOKKOS_FUNCTION PRegion<T>::PRegion(T a, T b)
      33         3192 :         : a_m(a)
      34         3192 :         , b_m(b) {
      35         3192 :         PAssert(a_m < b_m);
      36         3192 :     }
      37              : 
      38              :     template <typename T>
      39          336 :     KOKKOS_FUNCTION PRegion<T>::PRegion(const PRegion<T>& pregion) {
      40          336 :         a_m = pregion.a_m;
      41          336 :         b_m = pregion.b_m;
      42          336 :     }
      43              : 
      44              :     template <typename T>
      45         2226 :     KOKKOS_INLINE_FUNCTION PRegion<T>& PRegion<T>::operator=(const PRegion<T>& pregion) {
      46         2226 :         a_m = pregion.a_m;
      47         2226 :         b_m = pregion.b_m;
      48         2226 :         return *this;
      49              :     }
      50              : 
      51              :     template <typename T>
      52         5838 :     KOKKOS_INLINE_FUNCTION T PRegion<T>::min() const noexcept {
      53         5838 :         return a_m;
      54              :     }
      55              : 
      56              :     template <typename T>
      57         5838 :     KOKKOS_INLINE_FUNCTION T PRegion<T>::max() const noexcept {
      58         5838 :         return b_m;
      59              :     }
      60              : 
      61              :     template <typename T>
      62          462 :     KOKKOS_INLINE_FUNCTION T PRegion<T>::length() const noexcept {
      63          462 :         return b_m - a_m;
      64              :     }
      65              : 
      66              :     template <typename T>
      67              :     KOKKOS_INLINE_FUNCTION bool PRegion<T>::empty() const noexcept {
      68              :         return (a_m == b_m);
      69              :     }
      70              : 
      71              :     template <typename T>
      72            0 :     KOKKOS_INLINE_FUNCTION PRegion<T>& PRegion<T>::operator+=(T t) noexcept {
      73            0 :         a_m += t;
      74            0 :         b_m += t;
      75            0 :         return *this;
      76              :     }
      77              : 
      78              :     template <typename T>
      79              :     KOKKOS_INLINE_FUNCTION PRegion<T>& PRegion<T>::operator-=(T t) noexcept {
      80              :         a_m -= t;
      81              :         b_m -= t;
      82              :         return *this;
      83              :     }
      84              : 
      85              :     template <typename T>
      86              :     KOKKOS_INLINE_FUNCTION PRegion<T>& PRegion<T>::operator*=(T t) noexcept {
      87              :         a_m *= t;
      88              :         b_m *= t;
      89              :         return *this;
      90              :     }
      91              : 
      92              :     template <typename T>
      93              :     KOKKOS_INLINE_FUNCTION PRegion<T>& PRegion<T>::operator/=(T t) noexcept {
      94              :         if (t != 0) {
      95              :             a_m /= t;
      96              :             b_m /= t;
      97              :         }
      98              :         return *this;
      99              :     }
     100              : 
     101              :     template <typename T>
     102            0 :     inline std::ostream& operator<<(std::ostream& out, const PRegion<T>& r) {
     103            0 :         out << '[' << r.min();
     104            0 :         out << ',' << r.max();
     105            0 :         out << ')';
     106            0 :         return out;
     107              :     }
     108              : }  // namespace ippl