Simplify distribution definitions and add testing

Author: sethrj

doc/modules/random.rst

@@ -76,7 +76,7 @@ normal_distribution
 
 Fill the given array with Gaussian-distributed numbers generated using the
 given random number engine about the given mean value with the given standard
-deviation, which defaults to 1.
+deviation.
 
 uniform_int_distribution
 ------------------------

include/flc_random.i

@@ -43,45 +43,53 @@ class GENERATOR
  * RNG distribution routines
  * ------------------------------------------------------------------------- */
 
-%define %flc_random_dist1(NAME, TYPE, GENERATOR, ARG1)
-%inline {
-static void NAME##_distribution(TYPE ARG1,
-                     std::GENERATOR& g,
-                     TYPE *DATA, size_t DATASIZE) {
-    std::NAME##_distribution<TYPE> dist(ARG1);
-    TYPE *end = DATA + DATASIZE;
-    while (DATA != end) {
-        *DATA++ = dist(g);
-    }
+%{
+template<class D, class G, class T>
+static inline void flc_generate(D dist, G& g, T* data, size_t size) {
+  T* const end = data + size;
+  while (data != end) {
+    *data++ = dist(g);
+  }
 }
+%}
+
+%apply (const SWIGTYPE *DATA, size_t SIZE) {
+       (SWIGTYPE const *WEIGHTS, size_t WEIGHTSIZE) };
+
+%inline %{
+template<class T, class G>
+static void uniform_int_distribution(T left, T right,
+                                     G& engine, T* DATA, size_t DATASIZE) {
+  flc_generate(std::uniform_int_distribution<T>(left, right),
+               engine, DATA, DATASIZE);
 }
-%enddef
 
-%define %flc_random_dist2(NAME, TYPE, GENERATOR, ARG1, ARG2)
-%inline {
-static void NAME##_distribution(TYPE ARG1, TYPE ARG2,
-                     std::GENERATOR& g,
-                     TYPE *DATA, size_t DATASIZE) {
-    std::NAME##_distribution<TYPE> dist(ARG1, ARG2);
-    TYPE *end = DATA + DATASIZE;
-    while (DATA != end) {
-        *DATA++ = dist(g);
-    }
+template<class T, class G>
+static void uniform_real_distribution(T left, T right,
+                                      G& engine, T* DATA, size_t DATASIZE) {
+  flc_generate(std::uniform_real_distribution<T>(left, right),
+               engine, DATA, DATASIZE);
 }
+
+template<class T, class G>
+static void normal_distribution(T mean, T stddev,
+                                G& engine, T* DATA, size_t DATASIZE) {
+  flc_generate(std::normal_distribution<T>(mean, stddev),
+               engine, DATA, DATASIZE);
 }
-%enddef
+%}
 
-#define FLC_DEFAULT_ENGINE mt19937
+%define %flc_distribution(NAME, STDENGINE, TYPE)
+%template(NAME##_distribution) NAME##_distribution< TYPE, std::STDENGINE >;
+%enddef
 
 // Engines
 %flc_random_engine(MersenneEngine4, mt19937,    int32_t)
 %flc_random_engine(MersenneEngine8, mt19937_64, int64_t)
 
-// Uniform distributions
-%flc_random_dist2(uniform_int, int32_t, FLC_DEFAULT_ENGINE, left, right)
-%flc_random_dist2(uniform_int, int64_t, FLC_DEFAULT_ENGINE, left, right)
-%flc_random_dist2(uniform_real, double, FLC_DEFAULT_ENGINE, left, right)
+#define FLC_DEFAULT_ENGINE mt19937
+%flc_distribution(uniform_int,  FLC_DEFAULT_ENGINE, int32_t)
+%flc_distribution(uniform_int,  FLC_DEFAULT_ENGINE, int64_t)
+%flc_distribution(uniform_real, FLC_DEFAULT_ENGINE, double)
 
-// Gaussian distribution
-%flc_random_dist1(normal, double, FLC_DEFAULT_ENGINE, mean)
-%flc_random_dist2(normal, double, FLC_DEFAULT_ENGINE, mean, stddev)
+%flc_distribution(normal, FLC_DEFAULT_ENGINE, double)

src/flc_random.f90

@@ -57,14 +57,11 @@ module flc_random
   integer(C_SIZE_T), public :: size = 0
  end type
  public :: uniform_real_distribution
+ public :: normal_distribution
  interface uniform_int_distribution
-  module procedure swigf_uniform_int_distribution__SWIG_0, swigf_uniform_int_distribution__SWIG_1
+  module procedure swigf_uniform_int_distribution__SWIG_1, swigf_uniform_int_distribution__SWIG_2
  end interface
  public :: uniform_int_distribution
- interface normal_distribution
-  module procedure swigf_normal_distribution__SWIG_0, swigf_normal_distribution__SWIG_1
- end interface
- public :: normal_distribution
 
 ! WRAPPER DECLARATIONS
 interface
@@ -182,8 +179,8 @@ subroutine swigc_MersenneEngine8_op_assign__(farg1, farg2) &
 type(SwigClassWrapper) :: farg2
 end subroutine
 
-subroutine swigc_uniform_int_distribution__SWIG_0(farg1, farg2, farg3, farg4) &
-bind(C, name="_wrap_uniform_int_distribution__SWIG_0")
+subroutine swigc_uniform_int_distribution__SWIG_1(farg1, farg2, farg3, farg4) &
+bind(C, name="_wrap_uniform_int_distribution__SWIG_1")
 use, intrinsic :: ISO_C_BINDING
 import :: swigclasswrapper
 import :: swigarraywrapper
@@ -193,8 +190,8 @@ subroutine swigc_uniform_int_distribution__SWIG_0(farg1, farg2, farg3, farg4) &
 type(SwigArrayWrapper) :: farg4
 end subroutine
 
-subroutine swigc_uniform_int_distribution__SWIG_1(farg1, farg2, farg3, farg4) &
-bind(C, name="_wrap_uniform_int_distribution__SWIG_1")
+subroutine swigc_uniform_int_distribution__SWIG_2(farg1, farg2, farg3, farg4) &
+bind(C, name="_wrap_uniform_int_distribution__SWIG_2")
 use, intrinsic :: ISO_C_BINDING
 import :: swigclasswrapper
 import :: swigarraywrapper
@@ -215,18 +212,8 @@ subroutine swigc_uniform_real_distribution(farg1, farg2, farg3, farg4) &
 type(SwigArrayWrapper) :: farg4
 end subroutine
 
-subroutine swigc_normal_distribution__SWIG_0(farg1, farg2, farg3) &
-bind(C, name="_wrap_normal_distribution__SWIG_0")
-use, intrinsic :: ISO_C_BINDING
-import :: swigclasswrapper
-import :: swigarraywrapper
-real(C_DOUBLE), intent(in) :: farg1
-type(SwigClassWrapper) :: farg2
-type(SwigArrayWrapper) :: farg3
-end subroutine
-
-subroutine swigc_normal_distribution__SWIG_1(farg1, farg2, farg3, farg4) &
-bind(C, name="_wrap_normal_distribution__SWIG_1")
+subroutine swigc_normal_distribution(farg1, farg2, farg3, farg4) &
+bind(C, name="_wrap_normal_distribution")
 use, intrinsic :: ISO_C_BINDING
 import :: swigclasswrapper
 import :: swigarraywrapper
@@ -431,11 +418,11 @@ subroutine SWIGTM_fin_int32_t_Sb__SB_(finp, iminp)
   end if
   iminp%size = sz
 end subroutine
-subroutine swigf_uniform_int_distribution__SWIG_0(left, right, g, data)
+subroutine swigf_uniform_int_distribution__SWIG_1(left, right, engine, data)
 use, intrinsic :: ISO_C_BINDING
 integer(C_INT32_T), intent(in) :: left
 integer(C_INT32_T), intent(in) :: right
-class(MersenneEngine4), intent(in) :: g
+class(MersenneEngine4), intent(in) :: engine
 integer(C_INT32_T), dimension(:), target :: data
 integer(C_INT32_T) :: farg1 
 integer(C_INT32_T) :: farg2 
@@ -444,9 +431,9 @@ subroutine swigf_uniform_int_distribution__SWIG_0(left, right, g, data)
 
 farg1 = left
 farg2 = right
-farg3 = g%swigdata
+farg3 = engine%swigdata
 call SWIGTM_fin_int32_t_Sb__SB_(data, farg4)
-call swigc_uniform_int_distribution__SWIG_0(farg1, farg2, farg3, farg4)
+call swigc_uniform_int_distribution__SWIG_1(farg1, farg2, farg3, farg4)
 end subroutine
 
 subroutine SWIGTM_fin_int64_t_Sb__SB_(finp, iminp)
@@ -465,11 +452,11 @@ subroutine SWIGTM_fin_int64_t_Sb__SB_(finp, iminp)
   end if
   iminp%size = sz
 end subroutine
-subroutine swigf_uniform_int_distribution__SWIG_1(left, right, g, data)
+subroutine swigf_uniform_int_distribution__SWIG_2(left, right, engine, data)
 use, intrinsic :: ISO_C_BINDING
 integer(C_INT64_T), intent(in) :: left
 integer(C_INT64_T), intent(in) :: right
-class(MersenneEngine4), intent(in) :: g
+class(MersenneEngine4), intent(in) :: engine
 integer(C_INT64_T), dimension(:), target :: data
 integer(C_INT64_T) :: farg1 
 integer(C_INT64_T) :: farg2 
@@ -478,9 +465,9 @@ subroutine swigf_uniform_int_distribution__SWIG_1(left, right, g, data)
 
 farg1 = left
 farg2 = right
-farg3 = g%swigdata
+farg3 = engine%swigdata
 call SWIGTM_fin_int64_t_Sb__SB_(data, farg4)
-call swigc_uniform_int_distribution__SWIG_1(farg1, farg2, farg3, farg4)
+call swigc_uniform_int_distribution__SWIG_2(farg1, farg2, farg3, farg4)
 end subroutine
 
 subroutine SWIGTM_fin_double_Sb__SB_(finp, iminp)
@@ -499,11 +486,11 @@ subroutine SWIGTM_fin_double_Sb__SB_(finp, iminp)
   end if
   iminp%size = sz
 end subroutine
-subroutine uniform_real_distribution(left, right, g, data)
+subroutine uniform_real_distribution(left, right, engine, data)
 use, intrinsic :: ISO_C_BINDING
 real(C_DOUBLE), intent(in) :: left
 real(C_DOUBLE), intent(in) :: right
-class(MersenneEngine4), intent(in) :: g
+class(MersenneEngine4), intent(in) :: engine
 real(C_DOUBLE), dimension(:), target :: data
 real(C_DOUBLE) :: farg1 
 real(C_DOUBLE) :: farg2 
@@ -512,31 +499,16 @@ subroutine uniform_real_distribution(left, right, g, data)
 
 farg1 = left
 farg2 = right
-farg3 = g%swigdata
+farg3 = engine%swigdata
 call SWIGTM_fin_double_Sb__SB_(data, farg4)
 call swigc_uniform_real_distribution(farg1, farg2, farg3, farg4)
 end subroutine
 
-subroutine swigf_normal_distribution__SWIG_0(mean, g, data)
-use, intrinsic :: ISO_C_BINDING
-real(C_DOUBLE), intent(in) :: mean
-class(MersenneEngine4), intent(in) :: g
-real(C_DOUBLE), dimension(:), target :: data
-real(C_DOUBLE) :: farg1 
-type(SwigClassWrapper) :: farg2 
-type(SwigArrayWrapper) :: farg3 
-
-farg1 = mean
-farg2 = g%swigdata
-call SWIGTM_fin_double_Sb__SB_(data, farg3)
-call swigc_normal_distribution__SWIG_0(farg1, farg2, farg3)
-end subroutine
-
-subroutine swigf_normal_distribution__SWIG_1(mean, stddev, g, data)
+subroutine normal_distribution(mean, stddev, engine, data)
 use, intrinsic :: ISO_C_BINDING
 real(C_DOUBLE), intent(in) :: mean
 real(C_DOUBLE), intent(in) :: stddev
-class(MersenneEngine4), intent(in) :: g
+class(MersenneEngine4), intent(in) :: engine
 real(C_DOUBLE), dimension(:), target :: data
 real(C_DOUBLE) :: farg1 
 real(C_DOUBLE) :: farg2 
@@ -545,9 +517,9 @@ subroutine swigf_normal_distribution__SWIG_1(mean, stddev, g, data)
 
 farg1 = mean
 farg2 = stddev
-farg3 = g%swigdata
+farg3 = engine%swigdata
 call SWIGTM_fin_double_Sb__SB_(data, farg4)
-call swigc_normal_distribution__SWIG_1(farg1, farg2, farg3, farg4)
+call swigc_normal_distribution(farg1, farg2, farg3, farg4)
 end subroutine