Replace/remove boost/random code

Author: afabri

Apollonius_graph_2/include/CGAL/Apollonius_graph_2/Apollonius_graph_hierarchy_2_impl.h

@@ -15,7 +15,7 @@
 
 #include <CGAL/license/Apollonius_graph_2.h>
 
-
+#include <random>
 
 // class implementation
 //---------------------
@@ -425,10 +425,9 @@ int
 Apollonius_graph_hierarchy_2<Gt,Agds,LTag>::
 random_level()
 {
-  boost::geometric_distribution<> proba(1.0/ag_hierarchy_2__ratio);
-  boost::variate_generator<boost::rand48&, boost::geometric_distribution<> > die(random, proba);
+  std::geometric_distribution<> proba(1.0/ag_hierarchy_2__ratio);
 
-  return (std::min)(die(), (int)ag_hierarchy_2__maxlevel)-1;
+  return (std::min)(proba(random), (int)ag_hierarchy_2__maxlevel)-1;
 }
 
 template<class Gt, class Agds, class LTag>

Apollonius_graph_2/include/CGAL/Apollonius_graph_hierarchy_2.h

@@ -17,10 +17,7 @@
 
 
 #include <map>
-
-#include <boost/random/linear_congruential.hpp>
-#include <boost/random/geometric_distribution.hpp>
-#include <boost/random/variate_generator.hpp>
+#include <random>
 
 #include <CGAL/Apollonius_graph_2.h>
 #include <CGAL/Triangulation_data_structure_2.h>
@@ -210,7 +207,7 @@ class Apollonius_graph_hierarchy_2
   // class variables
   // here is the stack of graphs which form the hierarchy
   Apollonius_graph_base*   hierarchy[ag_hierarchy_2__maxlevel];
-  boost::rand48  random; // random generator
+  std::mt19937  random; // random generator
 
 public:
   template<class OutputItFaces, class OutputItBoundaryEdges,

Bounding_volumes/include/CGAL/Approximate_min_ellipsoid_d/Approximate_min_ellipsoid_d_debug.h

@@ -21,6 +21,7 @@
 #include <iostream>
 #include <fstream>
 #include <sstream>
+#include <random>
 #include <boost/random/linear_congruential.hpp>
 
 namespace CGAL {
@@ -271,7 +272,7 @@ namespace CGAL {
       bool adjust_bb;
       double zoom;
       std::string filename;
-      boost::rand48 rng;
+      std::mt19937 rng;
 
     public: // construction and destruction:
 

Bounding_volumes/include/CGAL/Min_sphere_of_spheres_d.h

@@ -22,6 +22,7 @@
 #include <cmath>
 #include <vector>
 #include <iostream>
+#include <random>
 
 #include <CGAL/Min_sphere_of_spheres_d/Min_sphere_of_spheres_d_pair.h>
 #include <CGAL/Min_sphere_of_spheres_d/Min_sphere_of_spheres_d_support_set.h>
@@ -59,7 +60,7 @@ namespace CGAL_MINIBALL_NAMESPACE {
     // ball has been respected in the miniball computation.
     bool is_up_to_date;
 
-    boost::rand48 rng;
+    std::mt19937 rng;
 
   public: // iterators:
     typedef const Result *Cartesian_const_iterator; // coordinate iterator

Box_intersection_d/include/CGAL/Box_intersection_d/segment_tree.h

@@ -21,7 +21,6 @@
 
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/uniform_int.hpp>
-#include <boost/random/variate_generator.hpp>
 
 #include <algorithm>
 #include <iterator>
@@ -30,6 +29,7 @@
 #include <cmath>
 #include <climits>
 #include <cstddef>
+#include <random>
 
 namespace CGAL {
 
@@ -242,9 +242,10 @@ RandomAccessIter
 iterative_radon( RandomAccessIter begin, RandomAccessIter end,
                  Predicate_traits traits, int dim, int num_levels )
 {
-  typedef typename boost::variate_generator<boost::rand48&, boost::uniform_int<std::ptrdiff_t> > Generator;
-  boost::rand48 rng;
-  Generator generator(rng, boost::uniform_int<std::ptrdiff_t>(0, (end-begin)-1));
+  std::mt19937 rng;
+  // Generator generator(rng, boost::uniform_int<std::ptrdiff_t>(0, (end-begin)-1));
+  auto generator = std::bind( std::uniform_int<std::ptrdiff_t>(0, (end-begin)-1), rng);
+  using Generator = decltype(generator);
   Iterative_radon<RandomAccessIter, Predicate_traits, Generator> IR(begin, traits, dim, generator);
   return IR(num_levels);
 }

Generator/doc/Generator/CGAL/Random.h

@@ -23,7 +23,7 @@ the same time, even if a fixed seed has been chosen.
 
 \cgalHeading{Implementation}
 
-We use the boost random library function `boost::rand48()` to generate the random
+We use the standard library function `std::mt19937()` to generate the random
 numbers.
 
 \sa `CGAL::get_default_random()`

Generator/include/CGAL/random_convex_hull_in_disc_2.h

@@ -59,8 +59,6 @@ void generate_points_annulus(long n, double a, double b, double small_radius,
                              GEN& gen) {  // generate n points between a and b
   if (n > 1) {
     std::binomial_distribution<long> bin_distribution(n, .5);
-    //boost::variate_generator<GEN&, std::binomial_distribution<long> >
-    //    g(gen, bin_distribution);
     long nb = bin_distribution(gen);
     generate_points_annulus(nb, a, (a + b) / 2.0, small_radius, big_radius, l,
                             gen);
@@ -73,11 +71,7 @@ void generate_points_annulus(long n, double a, double b, double small_radius,
         small_radius * small_radius / (big_radius * big_radius), 1);
 
     std::uniform_real_distribution<double> random_angle_distribution(a, b);
-    //boost::random::variate_generator<
-     //   GEN&, std::uniform_real_distribution<double> > random_angle(gen, random_angle_distribution);
-    //boost::random::variate_generator<
-     //   GEN&, std::uniform_real_distribution<double> > random_squared_radius(gen, random_squared_radius_distribution);
-
+    
     double alpha = random_angle_distribution(gen);
     double r = big_radius * std::sqrt(random_squared_radius_distribution(gen));
     typedef  Creator_uniform_2<double, P> Creator;
@@ -219,8 +213,6 @@ void random_convex_hull_in_disc_2(std::size_t n, double radius, std::list<typena
       nb = static_cast<long>((std::min)(T, n - simulated_points));
     }
     std::binomial_distribution<long> dbin(nb, to_double(p_disc));
-    //boost::variate_generator<
-    //    GEN&, std::binomial_distribution<long> > bin(gen, dbin);
 
     // How many points are falling in the small disc and won't be generated:
     long k_disc = dbin(gen);

GraphicsView/demo/Apollonius_graph_2/Apollonius_graph_2.cpp

@@ -1,4 +1,6 @@
 #include <fstream>
+#include <random>
+
 #include <boost/config.hpp>
 #include <boost/version.hpp>
 // CGAL headers
@@ -197,12 +199,11 @@ MainWindow::on_actionInsertRandomPoints_triggered()
   QApplication::setOverrideCursor(Qt::WaitCursor);
   std::vector<Apollonius_site_2> points;
   points.reserve(number_of_points);
-  boost::rand48 rng;
+  std::mt19937 rng;
   boost::uniform_real<> dist(0.005*width, 0.05*width);
-  boost::variate_generator<boost::rand48&, boost::uniform_real<> > radius(rng,dist);
-
+  
   for(int i = 0; i < number_of_points; ++i){
-    points.push_back(Apollonius_site_2(*pg++,radius()));
+    points.push_back(Apollonius_site_2(*pg++,dist(rng)));
   }
       ag.insert(points.begin(), points.end());
   // default cursor

Hash_map/benchmark/Hash_map/hm.cpp

@@ -4,6 +4,7 @@
 #include <fstream>
 #include <map>
 #include <algorithm>
+#include <random>
 
 #include <CGAL/Surface_mesh.h>
 #include <CGAL/Simple_cartesian.h>
@@ -44,8 +45,8 @@ run(const G& g)
     V2.push_back(vd);
   }
 
-  boost::rand48 random;
-  boost::random_number_generator<boost::rand48> rng(random);
+  std::mt19937 random;
+  boost::random_number_generator<std::mt19937> rng(random);
   std::random_shuffle(V.begin(), V.end(), rng);
 
   Timer t;

Interval_skip_list/include/CGAL/Interval_skip_list.h

@@ -20,11 +20,9 @@
 #include <CGAL/basic.h>
 #include <list>
 #include <iostream>
+#include <random>
 
 #include <boost/random/linear_congruential.hpp>
-#include <boost/random/geometric_distribution.hpp>
-#include <boost/random/variate_generator.hpp>
-
 
 //#define CGAL_ISL_USE_CCC
 #define CGAL_ISL_USE_LIST
@@ -125,7 +123,7 @@ class Interval_for_container : public Interval_
   private:
     typedef Interval_ Interval;
     typedef typename Interval::Value Value;
-    boost::rand48 random;
+    std::mt19937 random;
 
 #ifdef CGAL_ISL_USE_LIST
     std::list<Interval> container;
@@ -1194,10 +1192,8 @@ template <class Interval>
   int
   Interval_skip_list<Interval>::randomLevel()
   {
-    boost::geometric_distribution<> proba(0.5);
-    boost::variate_generator<boost::rand48&, boost::geometric_distribution<> > die(random, proba);
-
-    return (std::min)(die(), (int)maxLevel)+1;
+    std::geometric_distribution<> proba(0.5);
+    return (std::min)(proba(random), (int)maxLevel)+1;
 }