Merge pull request #127 from boostorg/remove_array

Remove Heavy Dependencies

Author: mborland

CMakeLists.txt

@@ -17,14 +17,12 @@ target_include_directories(boost_random PUBLIC include)
 
 target_link_libraries(boost_random
   PUBLIC
-    Boost::array
     Boost::assert
     Boost::config
     Boost::core
     Boost::dynamic_bitset
     Boost::integer
     Boost::io
-    Boost::range
     Boost::static_assert
     Boost::system
     Boost::throw_exception
@@ -51,4 +49,3 @@ if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
   add_subdirectory(test)
 
 endif()
-

build.jam

@@ -6,14 +6,12 @@
 require-b2 5.2 ;
 
 constant boost_dependencies :
-    /boost/array//boost_array
     /boost/assert//boost_assert
     /boost/config//boost_config
     /boost/core//boost_core
     /boost/dynamic_bitset//boost_dynamic_bitset
     /boost/integer//boost_integer
     /boost/io//boost_io
-    /boost/range//boost_range
     /boost/static_assert//boost_static_assert
     /boost/system//boost_system
     /boost/throw_exception//boost_throw_exception
@@ -33,4 +31,3 @@ explicit
 call-if : boost-library random
     : install boost_random
     ;
-

include/boost/random/detail/size.hpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright Matt Borland 2025.
+ * Distributed under the Boost Software License, Version 1.0. (See
+        * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id$
+ */
+
+#include <iterator>
+#include <cstddef>
+
+namespace boost {
+namespace random {
+namespace detail {
+
+#if defined (__cpp_lib_nonmember_container_access) && __cpp_lib_nonmember_container_access >= 201411L
+
+using std::size;
+
+#else
+
+template <typename C>
+constexpr auto size(const C& c) -> decltype(c.size())
+{
+    return c.size();
+}
+
+template <typename T, std::size_t N>
+constexpr std::size_t size(const T (&array)[N]) noexcept
+{
+    return N;
+}
+
+#endif
+
+} // namespace detail
+} // namespace random
+} // namespace boost

include/boost/random/discrete_distribution.hpp

@@ -29,9 +29,6 @@
 #include <initializer_list>
 #endif
 
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
 #include <boost/random/detail/disable_warnings.hpp>
 
 namespace boost {
@@ -268,7 +265,7 @@ class discrete_distribution {
          */
         template<class Range>
         explicit param_type(const Range& range)
-          : _probabilities(boost::begin(range), boost::end(range))
+          : _probabilities(std::begin(range), std::end(range))
         {
             normalize();
         }
@@ -308,7 +305,7 @@ class discrete_distribution {
             detail::print_vector(os, parm._probabilities);
             return os;
         }
-        
+
         /** Reads the parameters from a @c std::istream. */
         BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
         {
@@ -389,7 +386,7 @@ class discrete_distribution {
     template<class Range>
     explicit discrete_distribution(const Range& range)
     {
-        init(boost::begin(range), boost::end(range));
+        init(std::begin(range), std::end(range));
     }
     /**
      * Constructs a discrete_distribution that approximates a function.
@@ -440,7 +437,7 @@ class discrete_distribution {
             return(_impl._alias_table[static_cast<std::size_t>(result)].second);
         }
     }
-    
+
     /**
      * Returns a value distributed according to the parameters
      * specified by param.
@@ -472,7 +469,7 @@ class discrete_distribution {
             return discrete_distribution(parm)(urng);
         }
     }
-    
+
     /** Returns the smallest value that the distribution can produce. */
     result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
     /** Returns the largest value that the distribution can produce. */
@@ -520,7 +517,7 @@ class discrete_distribution {
     {
         init(parm._probabilities.begin(), parm._probabilities.end());
     }
-    
+
     /**
      * Effects: Subsequent uses of the distribution do not depend
      * on values produced by any engine prior to invoking reset.
@@ -576,7 +573,7 @@ class discrete_distribution {
         std::vector<std::pair<WeightType, IntType> > above_average;
         below_average.reserve(input_size);
         above_average.reserve(input_size);
-        
+
         WeightType weight_average = _impl.init_average(first, last);
         WeightType normalized_average = _impl.get_weight(0);
         std::size_t i = 0;

include/boost/random/hyperexponential_distribution.hpp

@@ -23,11 +23,9 @@
 #include <boost/core/cmath.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/vector_io.hpp>
+#include <boost/random/detail/size.hpp>
 #include <boost/random/discrete_distribution.hpp>
 #include <boost/random/exponential_distribution.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/size.hpp>
 #include <boost/type_traits/has_pre_increment.hpp>
 #include <cmath>
 #include <cstddef>
@@ -294,8 +292,8 @@ class hyperexponential_distribution
                 param_type(ProbRangeT const& prob_range,
                            RateRangeT const& rate_range,
                            typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
-        : probs_(boost::begin(prob_range), boost::end(prob_range)),
-          rates_(boost::begin(rate_range), boost::end(rate_range))
+        : probs_(std::begin(prob_range), std::end(prob_range)),
+          rates_(std::begin(rate_range), std::end(rate_range))
         {
             hyperexp_detail::normalize(probs_);
 
@@ -330,8 +328,8 @@ class hyperexponential_distribution
         //  We SFINAE this out of existance if the argument type is
         //  incrementable as in that case the type is probably an iterator.
         public: template <typename RateIterT>
-                param_type(RateIterT rate_first, 
-                           RateIterT rate_last,  
+                param_type(RateIterT rate_first,
+                           RateIterT rate_last,
                            typename boost::enable_if_c<boost::has_pre_increment<RateIterT>::value>::type* = 0)
         : probs_(std::distance(rate_first, rate_last), 1), // will be normalized below
           rates_(rate_first, rate_last)
@@ -355,8 +353,8 @@ class hyperexponential_distribution
          */
         public: template <typename RateRangeT>
                 param_type(RateRangeT const& rate_range)
-        : probs_(boost::size(rate_range), 1), // Will be normalized below
-          rates_(boost::begin(rate_range), boost::end(rate_range))
+        : probs_(boost::random::detail::size(rate_range), 1), // Will be normalized below
+          rates_(std::begin(rate_range), std::end(rate_range))
         {
             hyperexp_detail::normalize(probs_);
 
@@ -529,7 +527,7 @@ class hyperexponential_distribution
             return lhs.probs_ == rhs.probs_
                    && lhs.rates_ == rhs.rates_;
         }
-        
+
         /** Returns true if the two sets of parameters are the different. */
         public: BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
 
@@ -608,7 +606,7 @@ class hyperexponential_distribution
                                           RateRangeT const& rate_range,
                                           typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
     : dd_(prob_range),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
+      rates_(std::begin(rate_range), std::end(rate_range))
     {
         BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
@@ -667,8 +665,8 @@ class hyperexponential_distribution
      */
     public: template <typename RateRangeT>
             hyperexponential_distribution(RateRangeT const& rate_range)
-    : dd_(std::vector<RealT>(boost::size(rate_range), 1)),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
+    : dd_(std::vector<RealT>(boost::random::detail::size(rate_range), 1)),
+      rates_(std::begin(rate_range), std::end(rate_range))
     {
         BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
@@ -854,7 +852,7 @@ class hyperexponential_distribution
         return lhs.dd_ == rhs.dd_
                && lhs.rates_ == rhs.rates_;
     }
-    
+
     /**
      * Returns true if the two instances of @c hyperexponential_distribution will
      * return different sequences of values given equal generators.