Fix discrete_distribution and add Windows workaround (#15)

Visual Studio 2012 lacks the iterator constructor for
discrete_distribution. This made me realize that the iterator
constructor is actually supposed to take doubles, not the result_type.
So I fixed the 'weights' signature and added a workaround that uses the
initializer_list constructor.

Author: sethrj

doc/modules/random.rst

@@ -97,14 +97,14 @@ The discrete distribution is constructed with an array of :math:`N` weights:
 the probability that an index in the range :math:`[1, N]` will be selected.
 ::
 
-   integer(C_INT), dimension(4), parameter :: weights = [1, 1, 2, 4]
+   real(C_DOUBLE), dimension(4), parameter :: weights &
+      = [.125d0, .125d0, .25d0, .5d0]
    integer(C_INT), dimension(1024) :: sampled
    call discrete_distribution(weights, Engine(), sampled)
 
-In the above example, ``1`` and ``2`` will be present in the ``sampled`` array
-about the same number of times since those indices have equal weight; ``3``
-will be present about twice as often as ``1`` and ``4`` will be present about
-four times as often.
+In the above example, ``1`` and ``2`` will are expected to each occupy an
+eighth of the ``sampled`` array, approximately a quarter of the ``sampled``
+array's values will be ``3``, and about a half will be ``4``.
 
 .. note:: The C++ distribution returns values in :math:`[0, N)`, so in
    accordance with Flibcpp's :ref:`indexing convention <conventions_indexing>`

include/flc_random.i

@@ -11,6 +11,11 @@
 
 %{
 #include <random>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// Visual studio 2012's standard library lacks iterator constructors for
+// std::discrete_distribution
+#define FLC_MISSING_DISCRETE_ITER
+#endif
 %}
 
 /* -------------------------------------------------------------------------
@@ -54,8 +59,7 @@ static inline void flc_generate(D dist, G& g, T* data, size_t size) {
 %}
 
 %apply (const SWIGTYPE *DATA, size_t SIZE) {
-       (const int32_t *WEIGHTS, size_t WEIGHTSIZE),
-       (const int64_t *WEIGHTS, size_t WEIGHTSIZE) };
+       (const double *WEIGHTS, size_t WEIGHTSIZE) };
 
 %inline %{
 template<class T, class G>
@@ -80,9 +84,14 @@ static void normal_distribution(T mean, T stddev,
 }
 
 template<class T, class G>
-static void discrete_distribution(const T* WEIGHTS, size_t WEIGHTSIZE,
+static void discrete_distribution(const double* WEIGHTS, size_t WEIGHTSIZE,
                                   G& engine, T* DATA, size_t DATASIZE) {
+#ifndef FLC_MISSING_DISCRETE_ITER
   std::discrete_distribution<T> dist(WEIGHTS, WEIGHTS + WEIGHTSIZE);
+#else
+  std::discrete_distribution<T> dist(
+      std::initializer_list<double>(WEIGHTS, WEIGHTS + WEIGHTSIZE));
+#endif
   T* const end = DATA + DATASIZE;
   while (DATA != end) {
     *DATA++ = dist(engine) + 1; // Note: transform to Fortran 1-offset

src/flc_random.f90

@@ -548,29 +548,29 @@ subroutine normal_distribution(mean, stddev, engine, data)
 
 subroutine swigf_discrete_distribution__SWIG_1(weights, engine, data)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT32_T), dimension(:), intent(in), target :: weights
+real(C_DOUBLE), dimension(:), intent(in), target :: weights
 class(MersenneEngine4), intent(in) :: engine
 integer(C_INT32_T), dimension(:), target :: data
 type(SwigArrayWrapper) :: farg1 
 type(SwigClassWrapper) :: farg3 
 type(SwigArrayWrapper) :: farg4 
 
-call SWIGTM_fin_int32_t_Sb__SB_(weights, farg1)
+call SWIGTM_fin_double_Sb__SB_(weights, farg1)
 farg3 = engine%swigdata
 call SWIGTM_fin_int32_t_Sb__SB_(data, farg4)
 call swigc_discrete_distribution__SWIG_1(farg1, farg3, farg4)
 end subroutine
 
 subroutine swigf_discrete_distribution__SWIG_2(weights, engine, data)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT64_T), dimension(:), intent(in), target :: weights
+real(C_DOUBLE), dimension(:), intent(in), target :: weights
 class(MersenneEngine4), intent(in) :: engine
 integer(C_INT64_T), dimension(:), target :: data
 type(SwigArrayWrapper) :: farg1 
 type(SwigClassWrapper) :: farg3 
 type(SwigArrayWrapper) :: farg4 
 
-call SWIGTM_fin_int64_t_Sb__SB_(weights, farg1)
+call SWIGTM_fin_double_Sb__SB_(weights, farg1)
 farg3 = engine%swigdata
 call SWIGTM_fin_int64_t_Sb__SB_(data, farg4)
 call swigc_discrete_distribution__SWIG_2(farg1, farg3, farg4)

src/flc_randomFORTRAN_wrap.cxx

@@ -257,6 +257,11 @@ enum AssignmentType {
 
 
 #include <random>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// Visual studio 2012's standard library lacks iterator constructors for
+// std::discrete_distribution
+#define FLC_MISSING_DISCRETE_ITER
+#endif
 
 
 template<class D, class G, class T>
@@ -290,9 +295,14 @@ static void normal_distribution(T mean, T stddev,
 }
 
 template<class T, class G>
-static void discrete_distribution(const T* WEIGHTS, size_t WEIGHTSIZE,
+static void discrete_distribution(const double* WEIGHTS, size_t WEIGHTSIZE,
                                   G& engine, T* DATA, size_t DATASIZE) {
+#ifndef FLC_MISSING_DISCRETE_ITER
   std::discrete_distribution<T> dist(WEIGHTS, WEIGHTS + WEIGHTSIZE);
+#else
+  std::discrete_distribution<T> dist(
+      std::initializer_list<double>(WEIGHTS, WEIGHTS + WEIGHTSIZE));
+#endif
   T* const end = DATA + DATASIZE;
   while (DATA != end) {
     *DATA++ = dist(engine) + 1; // Note: transform to Fortran 1-offset
@@ -685,37 +695,37 @@ SWIGEXPORT void _wrap_normal_distribution(double const *farg1, double const *far
 
 
 SWIGEXPORT void _wrap_discrete_distribution__SWIG_1(SwigArrayWrapper *farg1, SwigClassWrapper *farg3, SwigArrayWrapper *farg4) {
-  int32_t *arg1 = (int32_t *) 0 ;
+  double *arg1 = (double *) 0 ;
   size_t arg2 ;
   std::mt19937 *arg3 = 0 ;
   int32_t *arg4 = (int32_t *) 0 ;
   size_t arg5 ;
 
-  arg1 = (int32_t *)farg1->data;
+  arg1 = (double *)farg1->data;
   arg2 = farg1->size;
-  SWIG_check_nonnull(*farg3, "std::mt19937 &", "MersenneEngine4", "discrete_distribution< int32_t,std::mt19937 >(int32_t const *,size_t,std::mt19937 &,int32_t *,size_t)", return );
+  SWIG_check_nonnull(*farg3, "std::mt19937 &", "MersenneEngine4", "discrete_distribution< int32_t,std::mt19937 >(double const *,size_t,std::mt19937 &,int32_t *,size_t)", return );
   arg3 = (std::mt19937 *)farg3->cptr;
   arg4 = (int32_t *)farg4->data;
   arg5 = farg4->size;
-  discrete_distribution< int32_t,std::mt19937 >((int32_t const *)arg1,arg2,*arg3,arg4,arg5);
+  discrete_distribution< int32_t,std::mt19937 >((double const *)arg1,arg2,*arg3,arg4,arg5);
   SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
 SWIGEXPORT void _wrap_discrete_distribution__SWIG_2(SwigArrayWrapper *farg1, SwigClassWrapper *farg3, SwigArrayWrapper *farg4) {
-  int64_t *arg1 = (int64_t *) 0 ;
+  double *arg1 = (double *) 0 ;
   size_t arg2 ;
   std::mt19937 *arg3 = 0 ;
   int64_t *arg4 = (int64_t *) 0 ;
   size_t arg5 ;
 
-  arg1 = (int64_t *)farg1->data;
+  arg1 = (double *)farg1->data;
   arg2 = farg1->size;
-  SWIG_check_nonnull(*farg3, "std::mt19937 &", "MersenneEngine4", "discrete_distribution< int64_t,std::mt19937 >(int64_t const *,size_t,std::mt19937 &,int64_t *,size_t)", return );
+  SWIG_check_nonnull(*farg3, "std::mt19937 &", "MersenneEngine4", "discrete_distribution< int64_t,std::mt19937 >(double const *,size_t,std::mt19937 &,int64_t *,size_t)", return );
   arg3 = (std::mt19937 *)farg3->cptr;
   arg4 = (int64_t *)farg4->data;
   arg5 = farg4->size;
-  discrete_distribution< int64_t,std::mt19937 >((int64_t const *)arg1,arg2,*arg3,arg4,arg5);
+  discrete_distribution< int64_t,std::mt19937 >((double const *)arg1,arg2,*arg3,arg4,arg5);
   SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 

test/test_random.F90

@@ -110,7 +110,8 @@ subroutine test_discrete_distribution()
   use, intrinsic :: ISO_C_BINDING
   use flc_random, only : Engine => MersenneEngine4, discrete_distribution
   implicit none
-  integer(C_INT), dimension(4), parameter :: weights = [1, 1, 2, 4]
+  real(C_DOUBLE), dimension(4), parameter :: weights &
+      = [.125d0, .125d0, .25d0, .5d0]
   integer(C_INT), dimension(1024) :: sampled
   integer(C_INT), dimension(4) :: tallied = 0
   integer(C_INT), dimension(4), parameter :: gold_result = [130, 127, 267, 500]