remove cpp11::copy_n, cpp11::prev, and cpp11::next and use std instead

AABB_tree/test/AABB_tree/aabb_any_all_benchmark.cpp

@@ -78,7 +78,7 @@ boost::tuple<std::size_t, std::size_t, std::size_t, long> test(const char* name)
   
   std::vector<Point> points;
   points.reserve(elements * 2);
-  CGAL::cpp11::copy_n(g, elements * 2, std::back_inserter(points));
+  std::copy_n(g, elements * 2, std::back_inserter(points));
   
   // generate a bunch of happy random primitives
   std::vector<Line> lines;

AABB_tree/test/AABB_tree/aabb_test_ray_intersection.cpp

@@ -109,8 +109,8 @@ int main()
   const double r = max_extent / 2;
   // Generate NB_RAYS*2 points that lie on a sphere of radius r, centered around bbox_center
   CGAL::Random rand = CGAL::Random(23); // fix the seed to yield the same results each run
-  CGAL::cpp11::copy_n(CGAL::Random_points_on_sphere_3<Point>(r, rand), NB_RAYS, std::back_inserter(v1));
+  std::copy_n(CGAL::Random_points_on_sphere_3<Point>(r, rand), NB_RAYS, std::back_inserter(v1));
-  CGAL::cpp11::copy_n(CGAL::Random_points_on_sphere_3<Point>(r, rand), NB_RAYS, std::back_inserter(v2));
+  std::copy_n(CGAL::Random_points_on_sphere_3<Point>(r, rand), NB_RAYS, std::back_inserter(v2));
 
   for(std::vector<Point>::iterator it = v1.begin(); it != v1.end(); ++it) {
     *it = *it + bbox_center;

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Interval_evaluate_1.h

@@ -79,7 +79,7 @@ struct Interval_evaluate_1 : public CGAL::cpp98::binary_function
     Coefficient_const_iterator_range range = 
       typename PT_1::Construct_coefficient_const_iterator_range()(p);
     
-    Coefficient_const_iterator it = CGAL::cpp11::prev(range.second);
+    Coefficient_const_iterator it = std::prev(range.second);
     
     Coercion_interval res(cast(*it));
     

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Interval_evaluate_2.h

@@ -87,7 +87,7 @@ public:
     Coefficient_const_iterator_range range =
       typename PT_2::Construct_coefficient_const_iterator_range()(p);
     
-    Coefficient_const_iterator it = CGAL::cpp11::prev(range.second);
+    Coefficient_const_iterator it = std::prev(range.second);
     
     Interval_result_type initial_pair = interval_evaluate_1(*it,x_pair);
     Coercion_interval res(initial_pair.first,initial_pair.second);

Alpha_shapes_2/examples/Alpha_shapes_2/ex_alpha_projection_traits.cpp

@@ -107,7 +107,7 @@ bool file_input(OutputIterator out)
   int n;
   is >> n;
   std::cout << "Reading " << n << " points from file" << std::endl;
-  CGAL::cpp11::copy_n(std::istream_iterator<Point>(is), n, out);
+  std::copy_n(std::istream_iterator<Point>(is), n, out);
 
   return true;
 }

Alpha_shapes_2/examples/Alpha_shapes_2/ex_alpha_shapes_2.cpp

@@ -50,7 +50,7 @@ bool file_input(OutputIterator out)
   int n;
   is >> n;
   std::cout << "Reading " << n << " points from file" << std::endl;
-  CGAL::cpp11::copy_n(std::istream_iterator<Point>(is), n, out);
+  std::copy_n(std::istream_iterator<Point>(is), n, out);
 
   return true;
 }

Alpha_shapes_2/examples/Alpha_shapes_2/ex_periodic_alpha_shapes_2.cpp

@@ -52,7 +52,7 @@ bool file_input(OutputIterator out)
   int n;
   is >> n;
   std::cout << "Reading " << n << " points from file" << std::endl;
-  CGAL::cpp11::copy_n(std::istream_iterator<Point>(is), n, out);
+  std::copy_n(std::istream_iterator<Point>(is), n, out);
 
   return true;
 }

Alpha_shapes_2/test/Alpha_shapes_2/test_alpha.cpp

@@ -97,7 +97,7 @@ file_input(OutputIterator out)
   int n;
   is >> n;
   std::cout << "Reading " << n << " points from file" << std::endl;
-  CGAL::cpp11::copy_n(std::istream_iterator<Point>(is), n, out);
+  std::copy_n(std::istream_iterator<Point>(is), n, out);
 
   return true;
 }

BGL/test/BGL/test_Euler_operations.cpp

@@ -394,8 +394,8 @@ test_swap_edges()
     {
       Graph g;
       CGAL::make_tetrahedron(pt,pt,pt,pt,g);
-      halfedge_descriptor h1 = *CGAL::cpp11::next(boost::begin(halfedges(g)), i);
+      halfedge_descriptor h1 = *std::next(boost::begin(halfedges(g)), i);
-      halfedge_descriptor h2 = *CGAL::cpp11::next(boost::begin(halfedges(g)), j);
+      halfedge_descriptor h2 = *std::next(boost::begin(halfedges(g)), j);
       CGAL::internal::swap_edges(h1, h2, g);
       CGAL_assertion(CGAL::is_valid_polygon_mesh(g));
     }

Barycentric_coordinates_2/examples/Barycentric_coordinates_2/Wachspress_coordinates_example.cpp

@@ -30,7 +30,7 @@ int main()
 
     // Generate a set of random points.
     CGAL::Random_points_in_square_2<Point,Creator> point_generator(1.0);
-    CGAL::cpp11::copy_n(point_generator, number_of_points, std::back_inserter(points));
+    std::copy_n(point_generator, number_of_points, std::back_inserter(points));
 
     // Find the convex hull of the generated set of points.
     // This convex hull gives the vertices of a convex polygon that contains all the generated points.

Boolean_set_operations_2/archive/demo/Boolean_set_operations_2_GraphicsView/boolean_operations_2.cpp

@@ -946,7 +946,7 @@ bool read_bezier ( QString aFileName, Bezier_polygon_set& rSet, Bezier_region_so
           
           if ( bezier_polygons.size() > 1 )
           {
-            for ( Bezier_polygon_vector::const_iterator it = CGAL::cpp11::next(bezier_polygons.begin())
+            for ( Bezier_polygon_vector::const_iterator it = std::next(bezier_polygons.begin())
                 ; it != bezier_polygons.end()
                 ; ++ it 
                 )

Boolean_set_operations_2/examples/Boolean_set_operations_2/bezier_traits_adapter2.cpp

@@ -147,7 +147,7 @@ bool read_bezier(char const* aFileName, Bezier_polygon_set& rSet)
 
           if (polygons.size() > 1) {
             Bezier_polygon_vector::const_iterator it;
-            for (it = CGAL::cpp11::next(polygons.begin());
+            for (it = std::next(polygons.begin());
                  it != polygons.end(); ++it)
               pwh.add_hole(*it);
           }

Bounding_volumes/examples/Rectangular_p_center_2/rectangular_p_center_2.cpp

@@ -24,7 +24,7 @@ int main()
   CGAL::set_pretty_mode(std::cout);
 
   Cont points;
-  CGAL::cpp11::copy_n(Generator(1), n, std::back_inserter(points));
+  std::copy_n(Generator(1), n, std::back_inserter(points));
   std::cout << "Generated Point Set:\n";
   std::copy(points.begin(), points.end(), cout_ip);
 

Bounding_volumes/test/Bounding_volumes/rectangular_p_center_2_random1_test.cpp

@@ -175,7 +175,7 @@ main(int argc, char* argv[])
   cerr << "random seed is " << random_seed << endl;
 #endif // CGAL_PCENTER_NO_OUTPUT
   PCont input_points;
-  CGAL::cpp11::copy_n(Point_generator(1, rnd),
+  std::copy_n(Point_generator(1, rnd),
                 number_of_points,
                 back_inserter(input_points));
 

Bounding_volumes/test/Bounding_volumes/rectangular_p_center_2_random2_test.cpp

@@ -198,7 +198,7 @@ main(int argc, char* argv[])
 
       // generate a random cluster of size number_of_points:
       PCont input_points;
-      CGAL::cpp11::copy_n(ptgen,
+      std::copy_n(ptgen,
                    number_of_points,
                    back_inserter(input_points));
 

CGAL_ipelets/demo/CGAL_ipelets/generator.cpp

@@ -128,7 +128,7 @@ void generator::protected_run(int fn)
   switch(fn){
     case 0:{//random point in a circle
       CGAL::Random_points_in_disc_2<Point_2,Creator> gs( size);
-      CGAL::cpp11::copy_n( gs, nbelements, std::back_inserter(points));
+      std::copy_n( gs, nbelements, std::back_inserter(points));
       }
     break;
     
@@ -139,7 +139,7 @@ void generator::protected_run(int fn)
     case 6:
     case 2://points in a square : side =   
     {CGAL::Random_points_in_square_2<Point_2, Creator> gc (size);
-    CGAL::cpp11::copy_n( gc, nbelements, std::back_inserter(points));
+    std::copy_n( gc, nbelements, std::back_inserter(points));
     }
     break;
     
@@ -166,7 +166,7 @@ void generator::protected_run(int fn)
     typedef CGAL::Creator_uniform_2< Point_2, Segment_2> Seg_creator;
     typedef CGAL::Join_input_iterator_2< P1, P2, Seg_creator> Seg_iterator;
     Seg_iterator g( p1, p2);
-    CGAL::cpp11::copy_n( g, nbelements, std::back_inserter(segments) );
+    std::copy_n( g, nbelements, std::back_inserter(segments) );
     break;
   };
   

Convex_hull_2/benchmark/Convex_hull_2/static_ch2.cpp

@@ -48,7 +48,7 @@ int main(int argc, char** argv)
   
   CGAL::Random r(seed);
   CGAL::Random_points_in_disc_2<Point_2,Creator> g( 150.0,r);
-  CGAL::cpp11::copy_n( g, nbpts, std::back_inserter(points));
+  std::copy_n( g, nbpts, std::back_inserter(points));
   
   //the following code is for testing when there is only two extreme points, affine hull is 2D
   /*

Convex_hull_2/include/CGAL/Convex_hull_2/ch_akl_toussaint_impl.h

@@ -276,22 +276,22 @@ ch_akl_toussaint(ForwardIterator first, ForwardIterator last,
     internal::ch_akl_toussaint_assign_points_to_regions_deg(first,cpp11::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
     
     if ( cpp11::get<0>(ranges)!=cpp11::get<1>(ranges) )
-      internal::ch_akl_toussaint_assign_points_to_regions_deg(cpp11::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
+      internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
     
     if ( cpp11::get<1>(ranges)!=cpp11::get<2>(ranges) )
-      internal::ch_akl_toussaint_assign_points_to_regions_deg(cpp11::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
+      internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
     
     if ( cpp11::get<2>(ranges)!=cpp11::get<3>(ranges) )
-      internal::ch_akl_toussaint_assign_points_to_regions_deg(cpp11::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
+      internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
     
-    internal::ch_akl_toussaint_assign_points_to_regions_deg(cpp11::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
+    internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
   }
   else{
     internal::ch_akl_toussaint_assign_points_to_regions(first,cpp11::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
-    internal::ch_akl_toussaint_assign_points_to_regions(cpp11::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
+    internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
-    internal::ch_akl_toussaint_assign_points_to_regions(cpp11::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
+    internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
-    internal::ch_akl_toussaint_assign_points_to_regions(cpp11::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
+    internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
-    internal::ch_akl_toussaint_assign_points_to_regions(cpp11::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
+    internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
   }
   
   #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
@@ -300,13 +300,13 @@ ch_akl_toussaint(ForwardIterator first, ForwardIterator last,
   #else
   Tee_for_output_iterator<OutputIterator,Point_2> res(result);
   #endif // no postconditions ...
-  std::sort( cpp11::next(region1.begin() ), region1.end(), 
+  std::sort( std::next(region1.begin() ), region1.end(), 
              ch_traits.less_xy_2_object() );
-  std::sort( cpp11::next(region2.begin() ), region2.end(), 
+  std::sort( std::next(region2.begin() ), region2.end(), 
              ch_traits.less_xy_2_object() );
-  std::sort( cpp11::next(region3.begin() ), region3.end(),
+  std::sort( std::next(region3.begin() ), region3.end(),
              boost::bind(ch_traits.less_xy_2_object(), _2, _1) );
-  std::sort( cpp11::next(region4.begin() ), region4.end(), 
+  std::sort( std::next(region4.begin() ), region4.end(), 
              boost::bind(ch_traits.less_xy_2_object(), _2, _1) );
 
   if (! equal_points(*w,*s) )

Convex_hull_2/include/CGAL/Convex_hull_2/ch_bykat_impl.h

@@ -163,8 +163,8 @@ ch_bykat_with_threshold(InputIterator   first, InputIterator last,
   P.push_back(Point_2() );
   std::copy(first,last,std::back_inserter(P));
   P.push_back(Point_2() );
-  Pbegin = cpp11::next(P.begin());
+  Pbegin = std::next(P.begin());
-  Pend   = cpp11::prev(P.end());
+  Pend   = std::prev(P.end());
   ch_we_point(Pbegin, Pend, l, r, ch_traits);
   Point_2 a = *l;
   Point_2 b = *r;
@@ -205,15 +205,15 @@ ch_bykat_with_threshold(InputIterator   first, InputIterator last,
               std::swap( b, *++r);
               if ( ch_traits.less_xy_2_object()(*l,*r) )
               {
-		std::sort(cpp11::next(l), r, 
+		std::sort(std::next(l), r, 
 			  ch_traits.less_xy_2_object() );
               }
               else
               {
-		std::sort(cpp11::next(l), r, 
+		std::sort(std::next(l), r, 
                             boost::bind(ch_traits.less_xy_2_object(), _2, _1) );
               }
-              ch__ref_graham_andrew_scan(l, cpp11::next(r), res, ch_traits);
+              ch__ref_graham_andrew_scan(l, std::next(r), res, ch_traits);
               std::swap( a, *l);
               std::swap( b, *r);
               if ( L.empty() ) break;

Convex_hull_2/include/CGAL/Convex_hull_2/ch_eddy_impl.h

@@ -58,7 +58,7 @@ ch__recursive_eddy(List& L,
     != b_it );
 
 
-  ListIterator f_it = cpp11::next(a_it);
+  ListIterator f_it = std::next(a_it);
   Less_dist less_dist = ch_traits.less_signed_distance_to_line_2_object();
   ListIterator 
       c_it = std::min_element( f_it, b_it,  // max before
@@ -70,11 +70,11 @@ ch__recursive_eddy(List& L,
   c_it = L.insert(c_it, c);
   L.erase( f_it, b_it );
 
-  if ( cpp11::next(a_it) != c_it )
+  if ( std::next(a_it) != c_it )
   {
       ch__recursive_eddy( L, a_it, c_it, ch_traits);
   }
-  if ( cpp11::next(c_it) != b_it )
+  if ( std::next(c_it) != b_it )
   {
       ch__recursive_eddy( L, c_it, b_it, ch_traits);
   }
@@ -117,7 +117,7 @@ ch_eddy(InputIterator first, InputIterator last,
   L.push_front(wp);
   e = L.insert(e, ep);
 
-  if ( cpp11::next(L.begin()) != e )
+  if ( std::next(L.begin()) != e )
   {
       ch__recursive_eddy( L, L.begin(), e, ch_traits);
   }

Convex_hull_2/include/CGAL/Convex_hull_2/ch_graham_andrew_impl.h

@@ -52,7 +52,7 @@ ch_graham_andrew_scan( BidirectionalIterator first,
   BidirectionalIterator              beta;
   BidirectionalIterator              iter;
   CGAL_ch_precondition( first != last );
-  CGAL_ch_precondition( cpp11::next(first) != last );
+  CGAL_ch_precondition( std::next(first) != last );
 
   --last;
   CGAL_ch_precondition( *first != *last );
@@ -146,7 +146,7 @@ ch__ref_graham_andrew_scan( BidirectionalIterator first,
   BidirectionalIterator              beta;
   BidirectionalIterator              iter;
   CGAL_ch_precondition( first != last );
-  CGAL_ch_precondition( cpp11::next(first) != last );
+  CGAL_ch_precondition( std::next(first) != last );
 
   --last;
   CGAL_ch_precondition(! equal_points(*first,*last) );

Convex_hull_2/include/CGAL/Convex_hull_2/convexity_check_2_impl.h

@@ -159,7 +159,7 @@ ch_brute_force_check_2(ForwardIterator1 first1, ForwardIterator1 last1,
 
   if ( first2 == last2) return false;
 
-  if ( cpp11::next(first2) == last2 )
+  if ( std::next(first2) == last2 )
   {
       while (first1 != last1)
       {
@@ -204,7 +204,7 @@ ch_brute_force_chain_check_2(ForwardIterator1 first1,
 
   if ( first2 == last2) return false;
 
-  if ( cpp11::next(first2) == last2 ) return true;
+  if ( std::next(first2) == last2 ) return true;
 
   Left_turn_2  left_turn = ch_traits.left_turn_2_object();
   iter22 = first2;

Convex_hull_2/include/CGAL/segment_intersection_points_2.h

@@ -66,7 +66,7 @@ si_brute_force_II(ForwardIterator first, ForwardIterator last,
   Orientation orientation = traits.orientation_2_object();
 
   for ( ForwardIterator outer = first; outer != last; ++outer)
-    for ( ForwardIterator inner = cpp11::next(outer); inner != last; ++inner)
+    for ( ForwardIterator inner = std::next(outer); inner != last; ++inner)
       {
           Point s1 = (*outer).source();
           Point e1 = (*outer).target();

Convex_hull_3/benchmark/Convex_hull_3/compare_different_approach.cpp

@@ -43,7 +43,7 @@ int main(int argc,char** argv)
   if (argc==1){
     CGAL::Random_points_in_sphere_3<Point_3, PointCreator> gen(1.0);
     int nbpt=1000000;
-    CGAL::cpp11::copy_n( gen, nbpt, std::back_inserter(points) );
+    std::copy_n( gen, nbpt, std::back_inserter(points) );
     std::cout << "Using " << 1000000 << " random points in the unit ball\n";
   }
   else{

Convex_hull_3/benchmark/Convex_hull_3/is_on_positive_side.cpp

@@ -157,7 +157,7 @@ int main()
   points.reserve(nb_pts);
   
   K::Point_3 p=*gen++,q=*gen++,r=*gen++;
-  CGAL::cpp11::copy_n(gen,nb_pts,std::back_inserter(points));
+  std::copy_n(gen,nb_pts,std::back_inserter(points));
   
   std::vector<bool> res0; res0.reserve(nb_pts);
   std::vector<bool> res1; res1.reserve(nb_pts);

Convex_hull_3/demo/Convex_hull_3/quickhull_3_demo.cpp

@@ -117,7 +117,7 @@ int main(int argc, char* argv[])
   Generator gen(100.0);
 
   // generate num points and copy them to a vector
-  CGAL::cpp11::copy_n( gen, num, std::back_inserter(points) );
+  std::copy_n( gen, num, std::back_inserter(points) );
 
   // define object to hold convex hull
   CGAL::Object ch_object;

Convex_hull_3/examples/Convex_hull_3/dynamic_hull_3.cpp

@@ -20,7 +20,7 @@ int main()
 
   // generate 250 points randomly in a sphere of radius 100.0
   // and insert them into the triangulation
-  CGAL::cpp11::copy_n(gen, 250, std::back_inserter(points) );
+  std::copy_n(gen, 250, std::back_inserter(points) );
   Delaunay T;
   T.insert(points.begin(), points.end());
 

Convex_hull_3/examples/Convex_hull_3/dynamic_hull_LCC_3.cpp

@@ -22,7 +22,7 @@ int main()
 
   // generate 250 points randomly in a sphere of radius 100.0
   // and insert them into the triangulation
-  CGAL::cpp11::copy_n(gen, 250, std::back_inserter(points) );
+  std::copy_n(gen, 250, std::back_inserter(points) );
   Delaunay T;
   T.insert(points.begin(), points.end());
 

Convex_hull_3/examples/Convex_hull_3/dynamic_hull_OM_3.cpp

@@ -26,7 +26,7 @@ int main()
 
   // generate 250 points randomly in a sphere of radius 100.0
   // and insert them into the triangulation
-  CGAL::cpp11::copy_n(gen, 250, std::back_inserter(points) );
+  std::copy_n(gen, 250, std::back_inserter(points) );
   Delaunay T;
   T.insert(points.begin(), points.end());
 

Convex_hull_3/examples/Convex_hull_3/dynamic_hull_SM_3.cpp

@@ -21,7 +21,7 @@ int main()
 
   // generate 250 points randomly in a sphere of radius 100.0
   // and insert them into the triangulation
-  CGAL::cpp11::copy_n(gen, 250, std::back_inserter(points) );
+  std::copy_n(gen, 250, std::back_inserter(points) );
   Delaunay T;
   T.insert(points.begin(), points.end());
 

Convex_hull_3/include/CGAL/Convex_hull_3/dual/halfspace_intersection_3.h

@@ -209,7 +209,7 @@ namespace CGAL
 
                 // Look for two non-parallel planes
                 PlaneIterator plane1_it = planes.begin();
-                PlaneIterator plane2_it = cpp11::next(planes.begin());
+                PlaneIterator plane2_it = std::next(planes.begin());
 
                 while (plane2_it != planes.end() &&
                        collinear_plane(*plane1_it, *plane2_it)) {
@@ -218,7 +218,7 @@ namespace CGAL
 
                 if (plane2_it == planes.end()) return false;
 
-                PlaneIterator plane3_it = cpp11::next(plane2_it);
+                PlaneIterator plane3_it = std::next(plane2_it);
 
                 // Look for a triple of planes intersecting in a point
                 while (plane3_it != planes.end() &&

Convex_hull_3/test/Convex_hull_3/quickhull_degenerate_test_3.cpp

@@ -132,7 +132,7 @@ void test_collinear()
 
   // generate 100 points on the segment with endpoints (0,0) and (1,0)
   CGAL::Random_points_on_segment_2<Point_2>    g(Point_2(0,0), Point_2(1,0));
-  CGAL::cpp11::copy_n(g, 100, std::back_inserter(point_2_list));
+  std::copy_n(g, 100, std::back_inserter(point_2_list));
 
   std::list<Point_2>::iterator point_it = point_2_list.begin();
   point_3_list.push_back(Point_3(0,0,0));

Convex_hull_3/test/Convex_hull_3/quickhull_test_3.cpp

@@ -138,7 +138,7 @@ int main()
   std::cerr << "Testing 500 random points" << std::endl;
   std::vector<Point_3> points;
   Generator g(500);
-  CGAL::cpp11::copy_n( g, num, std::back_inserter(points));
+  std::copy_n( g, num, std::back_inserter(points));
 
   assert(points.size() == num);
 

Filtered_kernel/benchmark/Filtered_kernel/orientation_3.cpp

@@ -31,7 +31,7 @@ int main()
   std::vector<Point_3> points;
   points.reserve(N);
   CGAL::Random_points_in_sphere_3<Point_3> g( 100.0);
-  CGAL::cpp11::copy_n( g, N, std::back_inserter(points));
+  std::copy_n( g, N, std::back_inserter(points));
   timer.stop();
   std::cout << "Fill vector: " << timer.time() << " sec" << std::endl;
   timer.reset();

Generator/doc/Generator/CGAL/point_generators_2.h

@@ -146,7 +146,7 @@ distributed in an open disc. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_square_2<Point_2, Creator>`
@@ -214,7 +214,7 @@ distributed in a half-open square. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_triangle_2<Point_2, Creator>`
@@ -283,7 +283,7 @@ distributed inside a triangle. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -360,7 +360,7 @@ typedef const Point_2& reference;
  \cgalModels `InputIterator`
  \cgalModels `PointGenerator`
 
- \sa `CGAL::cpp11::copy_n()`
+ \sa `std::copy_n()`
  \sa `CGAL::Counting_iterator`
  \sa `CGAL::Points_on_segment_2<Point_2>`
  \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -432,7 +432,7 @@ get_default_random() );
  \cgalModels `InputIterator`
  \cgalModels `PointGenerator`
 
- \sa `CGAL::cpp11::copy_n()`
+ \sa `std::copy_n()`
  \sa `CGAL::Counting_iterator`
  \sa `CGAL::Points_on_segment_2<Point_2>`
  \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -506,7 +506,7 @@ rounding errors.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -577,7 +577,7 @@ distributed on a segment. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -647,7 +647,7 @@ distributed on the boundary of a square. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Points_on_segment_2<Point_2>`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
@@ -717,7 +717,7 @@ endpoints are specified upon construction. The points are equally spaced.
 
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::points_on_segment<Point_2>`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`

Generator/doc/Generator/CGAL/point_generators_3.h

@@ -44,7 +44,7 @@ distributed in a half-open cube. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_square_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_sphere_3<Point_3, Creator>`
@@ -113,7 +113,7 @@ distributed strictly inside a sphere. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -182,7 +182,7 @@ distributed inside a 3D triangle. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -260,7 +260,7 @@ distributed on a segment. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `std::random_shuffle`
 
@@ -326,7 +326,7 @@ distributed inside a tetrahedron. The default `Creator` is
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
 \sa `CGAL::Random_points_in_triangle_3<Point_3, Creator>`
@@ -405,7 +405,7 @@ The triangle range must be valid and unchanged while the iterator is used.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
 \sa `CGAL::Random_points_in_triangle_3<Point_3, Creator>`
@@ -476,7 +476,7 @@ The triangle mesh must be valid and unchanged while the iterator is used.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -559,7 +559,7 @@ The tetrahedral mesh must be valid and unchanged while the iterator is used.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -637,7 +637,7 @@ The tetrahedral mesh must be valid and unchanged while the iterator is used.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -715,7 +715,7 @@ rounding errors.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_on_circle_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`

Generator/doc/Generator/CGAL/point_generators_d.h

@@ -43,7 +43,7 @@ distributed in an open ball in any dimension.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_disc_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_sphere_3<Point_3, Creator>`
@@ -112,7 +112,7 @@ distributed in an half-open cube.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_in_square_2<Point_2, Creator>`
 \sa `CGAL::Random_points_in_cube_3<Point_3, Creator>`
@@ -187,7 +187,7 @@ rounding errors.
 \cgalModels `InputIterator`
 \cgalModels `PointGenerator`
 
-\sa `CGAL::cpp11::copy_n()`
+\sa `std::copy_n()`
 \sa `CGAL::Counting_iterator`
 \sa `CGAL::Random_points_on_circle_2<Point_2, Creator>`
 \sa `CGAL::Random_points_on_sphere_3<Point_3, Creator>`

Generator/examples/Generator/random_degenerate_point_set.cpp

@@ -20,7 +20,7 @@ int main() {
 
     // Create 600 points within a disc of radius 150.
     Random_points_in_disc_2<Point,Creator> g( 150.0);
-    CGAL::cpp11::copy_n( g, 600, std::back_inserter(points));
+    std::copy_n( g, 600, std::back_inserter(points));
 
     // Create 200 points from a 15 x 15 grid.
     points_on_square_grid_2( 250.0, 200, std::back_inserter(points),Creator());

Generator/examples/Generator/random_grid.cpp

@@ -31,7 +31,7 @@ int main() {
 
     // Create 250 points within a disc of radius 150.
     Random_points_in_disc_2<Point,Creator> g( 150.0);
-    CGAL::cpp11::copy_n( g, 250, std::back_inserter(points));
+    std::copy_n( g, 250, std::back_inserter(points));
 
     // Check that we have really created 500 points.
     assert( points.size() == 500);

Generator/examples/Generator/random_points_in_tetrahedral_mesh_3.cpp

@@ -56,7 +56,7 @@ int main()
   // Create the generator, input is the C3t3 c3t3
   Random_points_in_tetrahedral_mesh_3<C3t3> g(c3t3);
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n( g, 100, std::back_inserter(points));
+  std::copy_n( g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 100);

Generator/examples/Generator/random_points_in_triangles_2.cpp

@@ -22,7 +22,7 @@ int main()
   // Create the generator, input is the vector of Triangle_2
   Random_points_in_triangles_2<Point> g(triangles);
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n(g, 1000, std::back_inserter(points));
+  std::copy_n(g, 1000, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 1000);

Generator/examples/Generator/random_points_in_triangles_3.cpp

@@ -22,7 +22,7 @@ int main()
   // Create the generator, input is the vector of Triangle_3
   Random_points_in_triangles_3<Point> g(triangles);
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n(g, 1000, std::back_inserter(points));
+  std::copy_n(g, 1000, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 1000);

Generator/examples/Generator/random_points_on_tetrahedral_mesh_3.cpp

@@ -55,7 +55,7 @@ int main()
   // Create the generator, input is the C3t3 c3t3
   Random_points_in_tetrahedral_mesh_boundary_3<C3t3> g(c3t3);
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n( g, 100, std::back_inserter(points));
+  std::copy_n( g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 100);

Generator/examples/Generator/random_points_on_triangle_mesh_2.cpp

@@ -50,7 +50,7 @@ int main()
   Random_points_in_triangle_mesh_2<Point, CDT> g(cdt);
 
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n(g, 100, std::back_inserter(points));
+  std::copy_n(g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert(points.size() == 100);

Generator/examples/Generator/random_points_on_triangle_mesh_3.cpp

@@ -24,7 +24,7 @@ int main()
       g(polyhedron);
 
   // Get 100 random points in cdt
-  CGAL::cpp11::copy_n(g, 100, std::back_inserter(points));
+  std::copy_n(g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 100);

Generator/examples/Generator/random_points_tetrahedron_and_triangle_3.cpp

@@ -29,10 +29,10 @@ int main() {
 	Point_generator_ii g_ii(tet);
 	
 	// get 100 random points in tri
-	CGAL::cpp11::copy_n(g_i, 100, std::back_inserter(points_in_tri));
+	std::copy_n(g_i, 100, std::back_inserter(points_in_tri));
 	
 	// get 100 random points in tet
-	CGAL::cpp11::copy_n(g_ii, 100, std::back_inserter(points_in_tet));
+	std::copy_n(g_ii, 100, std::back_inserter(points_in_tet));
 	
 	// Check that we have really created 100 points.
 	assert( points_in_tri.size() == 100);

Generator/examples/Generator/random_points_triangle_2.cpp

@@ -22,7 +22,7 @@ int main() {
 	Point_generator g(tri);
 	
 	// get 100 random points in tri
-	CGAL::cpp11::copy_n(g, 100, std::back_inserter(points));
+	std::copy_n(g, 100, std::back_inserter(points));
 	
 	// Check that we have really created 100 points.
 	assert( points.size() == 100);

Generator/examples/Generator/random_segments1.cpp

@@ -35,7 +35,7 @@ int main() {
     typedef Creator_uniform_2< Point, Segment> Seg_creator;
     typedef Join_input_iterator_2< P1, P2, Seg_creator> Seg_iterator;
     Seg_iterator g( p1, p2);
-    CGAL::cpp11::copy_n( g, 200, std::back_inserter(segs));
+    std::copy_n( g, 200, std::back_inserter(segs));
 
     assert( segs.size() == 200);
     for ( Vector::iterator i = segs.begin(); i != segs.end(); i++){

Generator/include/CGAL/random_convex_hull_in_disc_2.h

@@ -273,7 +273,7 @@ void random_convex_hull_in_disc_2(std::size_t n, double radius, Generator& gen,
   typedef typename Traits::Point_2 Points;
   std::list<Points> l;
   internal::random_convex_hull_in_disc_2(n, radius, l, gen, traits, fast);
-  cpp11::copy_n(l.begin(),l.size(),it);
+  std::copy_n(l.begin(),l.size(),it);
 }
 
 }  // namespace CGAL

Generator/include/CGAL/random_convex_set_2.h

@@ -53,7 +53,7 @@ random_convex_set_2( std::size_t n,
   using std::partial_sum;
   using std::less;
   using std::max_element;
-  using CGAL::cpp11::copy_n;
+  using std::copy_n;
 
   typedef typename Traits::Point_2         Point_2;
   typedef typename Traits::FT              FT;
@@ -72,7 +72,7 @@ random_convex_set_2( std::size_t n,
   // build random point set:
   Container points;
   points.reserve( n);
-  CGAL::cpp11::copy_n( pg, n, back_inserter( points));
+  std::copy_n( pg, n, back_inserter( points));
 
   // compute centroid of points:
   // Point_2 centroid = CGAL::centroid( points.begin(), points.end(), t );

Generator/test/Generator/generic_random_test.cpp

@@ -72,7 +72,7 @@ int test_triangles_2(const FT eps)
   CGAL::Random_points_in_triangles_2<Point_2> g(triangles);
 
   // Get 100 random points in triangle range
-  CGAL::cpp11::copy_n(g, 100, std::back_inserter(points));
+  std::copy_n(g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert( points.size() == 100);
@@ -109,7 +109,7 @@ int test_triangles_3(const FT eps)
   CGAL::Random_points_in_triangles_3<Point_3> g(triangles);
 
   // Get 100 random points in triangle range
-  CGAL::cpp11::copy_n(g, 100, std::back_inserter(points));
+  std::copy_n(g, 100, std::back_inserter(points));
 
   // Check that we have really created 100 points.
   assert(points.size() == 100);
@@ -160,7 +160,7 @@ int test_T2(const FT eps)
   CGAL::refine_Delaunay_mesh_2(cdt, Mesh_2_criteria(0.125, 0.5));
 
   CGAL::Random_points_in_triangle_mesh_2<Point_2, CDT> g(cdt);
-  CGAL::cpp11::copy_n(g, 300, std::back_inserter(points));
+  std::copy_n(g, 300, std::back_inserter(points));
   for(std::size_t i=0; i<points.size(); ++i)
   {
     Point_2 p = points[i];
@@ -194,7 +194,7 @@ int test_volume_mesh(Polyhedron& polyhedron, const FT eps)
 
   std::vector<Point_3> points;
   CGAL::Random_points_in_triangle_mesh_3<Polyhedron> g(polyhedron);
-  CGAL::cpp11::copy_n(g, 300, std::back_inserter(points));
+  std::copy_n(g, 300, std::back_inserter(points));
   for(std::size_t i=0; i<points.size(); ++i)
   {
     Point_3 p = points[i];
@@ -229,7 +229,7 @@ int test_on_c3t3(const Polyhedron& polyhedron, const FT eps)
   C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude());
 
   CGAL::Random_points_in_tetrahedral_mesh_boundary_3<C3t3> g(c3t3);
-  CGAL::cpp11::copy_n(g, 300, std::back_inserter(points));
+  std::copy_n(g, 300, std::back_inserter(points));
   for(std::size_t i=0; i<points.size(); ++i)
   {
     Point_3 p = points[i];
@@ -264,7 +264,7 @@ int test_in_c3t3(const Polyhedron& polyhedron, const FT eps)
   C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude());
 
   CGAL::Random_points_in_tetrahedral_mesh_3<C3t3> g(c3t3);
-  CGAL::cpp11::copy_n(g, 300, std::back_inserter(points));
+  std::copy_n(g, 300, std::back_inserter(points));
   for(std::size_t i=0; i<points.size(); ++i)
   {
     Point_3 p = points[i];

Generator/test/Generator/test_generators.cpp

@@ -54,7 +54,7 @@ void test_point_generators_2() {
     std::vector<Point_2> points;
     points.reserve(1000);
     Random_points_in_disc_2<Point_2,Creator>     g1( 100.0);
-    CGAL::cpp11::copy_n( g1, 100, std::back_inserter(points));
+    std::copy_n( g1, 100, std::back_inserter(points));
     Random_points_on_circle_2<Point_2,Creator>   g2( 100.0);
     Random_points_in_square_2<Point_2,Creator>   g3( 100.0);
     Random_points_on_square_2<Point_2,Creator>   g4( 100.0);
@@ -63,11 +63,11 @@ void test_point_generators_2() {
     Points_on_segment_2<Point_2>                g5a( Point_2( 50,-50),
                                                     Point_2(-50, 50),
                                                    50);
-    CGAL::cpp11::copy_n( g2, 100, std::back_inserter(points));
+    std::copy_n( g2, 100, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g3, 100, std::back_inserter(points));
+    std::copy_n( g3, 100, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g4, 100, std::back_inserter(points));
+    std::copy_n( g4, 100, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g5,  50, std::back_inserter(points));
+    std::copy_n( g5,  50, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g5a, 50, std::back_inserter(points));
+    std::copy_n( g5a, 50, std::back_inserter(points));
     points_on_square_grid_2( 50.0, (std::size_t)1,
                              std::back_inserter(points), Creator());
     points_on_square_grid_2( 50.0, (std::size_t)2,
@@ -88,7 +88,7 @@ void test_point_generators_2() {
     // the 100 x 100 square. 10 pixel perturbation allowed.
     Random_points_in_square_2<Point_2,Creator>   g6( 90.0);
     int count = 100 ;
-    CGAL::cpp11::copy_n( g6, count, std::back_inserter(points));
+    std::copy_n( g6, count, std::back_inserter(points));
     std::vector<Point_2>::iterator i2 = points.end();
     std::vector<Point_2>::iterator i1 = i2 ;
     std::advance(i1,-count);
@@ -115,14 +115,14 @@ void test_point_generators_3() {
     std::vector<Point_3> points;
     points.reserve(600);
     Random_points_in_sphere_3<Point_3,Creator>      g1( 100.0);
-    CGAL::cpp11::copy_n( g1, 100, std::back_inserter(points));
+    std::copy_n( g1, 100, std::back_inserter(points));
     Random_points_on_sphere_3<Point_3,Creator>      g2( 100.0);
     Random_points_in_cube_3<Point_3,Creator>        g3( 100.0);
     Random_points_on_segment_3<Point_3,Creator>     g4( Point_3(-100,-100, -100),
                                                         Point_3( 100, 100, 100));
-    CGAL::cpp11::copy_n( g2, 100, std::back_inserter(points));
+    std::copy_n( g2, 100, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g3, 100, std::back_inserter(points));
+    std::copy_n( g3, 100, std::back_inserter(points));
-    CGAL::cpp11::copy_n( g4, 100, std::back_inserter(points));
+    std::copy_n( g4, 100, std::back_inserter(points));
     points_on_cube_grid_3( 50.0, (std::size_t)1,
                            std::back_inserter(points), Creator());
     points_on_cube_grid_3( 50.0, (std::size_t)2,
@@ -160,7 +160,7 @@ void test_point_generators_d()
     // 100 random points in dim 36
       std::cout<<"    cube dim 36"<<std::flush;
       CGAL::Random_points_in_cube_d<Point> gen (36, 1.0);
-      CGAL::cpp11::copy_n( gen, 100, std::back_inserter(points));
+      std::copy_n( gen, 100, std::back_inserter(points));
       i+=100;
       std::cout<<" done"<<std::endl;
     }
@@ -170,7 +170,7 @@ void test_point_generators_d()
       std::cout<<"    in ball 4D"<<std::flush;
       Point o4(4,o,o+4);
       CGAL::Random_points_in_ball_d<Point> gen (4, 100.0);
-      CGAL::cpp11::copy_n( gen, 100, std::back_inserter(points));
+      std::copy_n( gen, 100, std::back_inserter(points));
       std::cout<<" done"<<std::flush;
       for(ii=i+100; i<ii; ++i)
 	assert( CGAL::squared_distance(o4,points[i]) <= 10000.0);
@@ -182,7 +182,7 @@ void test_point_generators_d()
       Point o3(3,o,o+3);
       Point g=o3;
       CGAL::Random_points_in_ball_d<Point> gen (3, 1.0);
-      CGAL::cpp11::copy_n( gen, nb_g, std::back_inserter(points));
+      std::copy_n( gen, nb_g, std::back_inserter(points));
       std::cout<<" done"<<std::flush;
       for(ii=i+nb_g; i<ii; ++i){
 	assert( CGAL::squared_distance(o3,points[i]) <= 1.0);
@@ -197,7 +197,7 @@ void test_point_generators_d()
       std::cout<<"    on sphere 26D"<<std::flush;
       Point o26(26,o,o+26);
       CGAL::Random_points_on_sphere_d<Point> gen (26, 1.0);
-      CGAL::cpp11::copy_n( gen, 100, std::back_inserter(points));
+      std::copy_n( gen, 100, std::back_inserter(points));
       std::cout<<" done"<<std::flush;
       for(ii=i+100; i<ii; ++i) {
 	assert( CGAL::squared_distance(o26,points[i]) - 1.0 <= 0.1);

Generator/test/Generator/test_tetrahedron_3.cpp

@@ -56,17 +56,17 @@ int main() {
 		Point_generator g3( g1 );
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g1, number_points,
+		std::copy_n( g1, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_tetrahedron(tet,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g2, number_points,
+		std::copy_n( g2, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_tetrahedron(tet,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g3, number_points,
+		std::copy_n( g3, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_tetrahedron(tet,point_set.begin(),point_set.end()));
 	}

Generator/test/Generator/test_triangle_2.cpp

@@ -49,17 +49,17 @@ int main() {
 		Point_generator g3( g1 );
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g1, number_points,
+		std::copy_n( g1, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g2, number_points,
+		std::copy_n( g2, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g3, number_points,
+		std::copy_n( g3, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 	}

Generator/test/Generator/test_triangle_3.cpp

@@ -57,17 +57,17 @@ int main() {
 		Point_generator g3( g1 );
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g1, number_points,
+		std::copy_n( g1, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g2, number_points,
+		std::copy_n( g2, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 
 		point_set.clear();
-		CGAL::cpp11::copy_n( g3, number_points,
+		std::copy_n( g3, number_points,
 		               std::back_inserter(point_set));
 		assert(inside_or_close_to_triangle(tri,point_set.begin(),point_set.end()));
 	}

GraphicsView/demo/Generator/Generator_2.cpp

@@ -233,7 +233,7 @@ MainWindow::on_actionGenerateSegments_triggered()
   typedef CGAL::Creator_uniform_2< Point_2, Segment_2> Seg_creator;
   typedef CGAL::Join_input_iterator_2< Rpos_generator, Rpoc_generator, Seg_creator> Seg_iterator;
   Seg_iterator g( rpos, rpoc);
-  CGAL::cpp11::copy_n( g, 200, std::back_inserter(segments));
+  std::copy_n( g, 200, std::back_inserter(segments));
   
   Q_EMIT( changed());
 }

Interpolation/demo/Interpolation/surface_voronoi.cpp

@@ -94,7 +94,7 @@ void generate_sphere_points(const int& n,
 			    //the test point + normal
 			    Point &p, Vector &normal){
   CGAL::Random_points_on_sphere_3<Point> g(r);
-  CGAL::cpp11::copy_n( g, n, std::back_inserter(points));
+  std::copy_n( g, n, std::back_inserter(points));
   p = Point(0,0, r);
   normal = Vector(p - CGAL::ORIGIN);
 }
@@ -110,7 +110,7 @@ void generate_cylinder_points(const int& n,
   Point_2_vector points_2;
   points_2.reserve(n);
   CGAL::Random_points_on_circle_2<Point_2> g(r);
-  CGAL::cpp11::copy_n( g, n , std::back_inserter(points_2));
+  std::copy_n( g, n , std::back_inserter(points_2));
   CGAL::Random random;
 
   double h;

Interpolation/examples/Interpolation/interpolation_2.cpp

@@ -51,7 +51,7 @@ int main()
   CGAL::Random rng(1513114263);
 
   CGAL::Random_points_in_disc_2<Point> g(r_d,rng );
-  CGAL::cpp11::copy_n( g, n+m, std::back_inserter(points));
+  std::copy_n( g, n+m, std::back_inserter(points));
 
   Delaunay_triangulation T;
 

Interpolation/examples/Interpolation/interpolation_vertex_with_info_2.cpp

@@ -90,7 +90,7 @@ int main()
   double r_d = 3;
   CGAL::Random rng(1513114263);
   CGAL::Random_points_in_disc_2<Point> g(r_d, rng);
-  CGAL::cpp11::copy_n( g, n+m, std::back_inserter(points));
+  std::copy_n( g, n+m, std::back_inserter(points));
 
   Delaunay_triangulation T;
 

Interpolation/examples/Interpolation/surface_neighbor_coordinates_3.cpp

@@ -26,7 +26,7 @@ int main()
 
   std::cout << "Generate " << n << " random points on a sphere." << std::endl;
   CGAL::Random_points_on_sphere_3<Point_3> g(1);
-  CGAL::cpp11::copy_n(g, n, std::back_inserter(points));
+  std::copy_n(g, n, std::back_inserter(points));
 
   Point_3 p(1, 0, 0);
   Vector_3 normal(p - CGAL::ORIGIN);

Interpolation/test/Interpolation/include/CGAL/_test_interpolation_functions_2.cpp

@@ -288,7 +288,7 @@ void _test_interpolation_functions_2_Delaunay_without_OutputFunctor(const Dt&, c
 
   // Create n+m-4 points within a disc of radius 2
   CGAL::Random_points_in_square_2<Point> g(r);
-  CGAL::cpp11::copy_n(g, n+m, std::back_inserter(points));
+  std::copy_n(g, n+m, std::back_inserter(points));
 
   CGAL::Random random;
 
@@ -467,7 +467,7 @@ void _test_interpolation_functions_2_Delaunay_with_OutputFunctor(const Dt&, cons
 
   // Create n+m-4 points within a disc of radius 2
   CGAL::Random_points_in_square_2<Point> g(r);
-  CGAL::cpp11::copy_n(g, n+m, std::back_inserter(points));
+  std::copy_n(g, n+m, std::back_inserter(points));
 
   CGAL::Random random;
 

Interpolation/test/Interpolation/include/CGAL/_test_surface_neighbors_3.cpp

@@ -303,7 +303,7 @@ _test_surface_neighbors_3_sphere( const Tr & )
 
   // Create n+m-4 points on a sphere of radius 2
   CGAL::Random_points_on_sphere_3<Point> g(r);
-  CGAL::cpp11::copy_n( g, n+m, std::back_inserter(points));
+  std::copy_n( g, n+m, std::back_inserter(points));
 
   for(int i=0; i<n ; i++)
     T.insert(points[i]);
@@ -349,7 +349,7 @@ _test_surface_neighbors_3_cube(const Tr &, const Transformation&
   else
   {
     CGAL::Random_points_in_square_2<Point_2> g(r);
-    CGAL::cpp11::copy_n(g, n, std::back_inserter(points_2_data));
+    std::copy_n(g, n, std::back_inserter(points_2_data));
   }
   for(int i=0; i < n; i++)
   {
@@ -365,7 +365,7 @@ _test_surface_neighbors_3_cube(const Tr &, const Transformation&
   std::vector<Point_2> points_2_test;
   points_2_test.reserve(m);
   CGAL::Random_points_in_square_2<Point_2> g2(r-1.0);
-  CGAL::cpp11::copy_n(g2, m, std::back_inserter(points_2_test));
+  std::copy_n(g2, m, std::back_inserter(points_2_test));
 
   int k=0;
   for(int i=0;i<m;i++)

Kernel_23/examples/Kernel_23/intersections.cpp

@@ -40,7 +40,7 @@ int main()
 
   // Create segments.
   Seg_iterator g( p1, p2);
-  CGAL::cpp11::copy_n( g, 200, std::back_inserter(input));
+  std::copy_n( g, 200, std::back_inserter(input));
 
 
   // splitting results with Dispatch_output_iterator

Nef_3/include/CGAL/boost/graph/convert_nef_polyhedron_to_polygon_mesh.h

@@ -118,7 +118,7 @@ struct Shell_polygons_visitor
 
     typename Nef_polyhedron::Halffacet_const_handle f = opposite_facet->twin();
 
-    if (cpp11::next(f->facet_cycles_begin())==f->facet_cycles_end())
+    if (std::next(f->facet_cycles_begin())==f->facet_cycles_end())
     {
       std::size_t cycle_length = 3;
       if (triangulate_all_faces)

NewKernel_d/include/CGAL/NewKernel_d/Lazy_cartesian.h

@@ -38,7 +38,7 @@ struct Nth_iterator_element : private Store_kernel<K> {
   typedef typename Get_type<K, typename iterator_tag_traits<T>::value_tag>::type result_type;
   template<class U> result_type operator()(CGAL_FORWARDABLE(U) u, int i) const {
     typename Get_functor<K, Construct_ttag<T> >::type ci(this->kernel());
-    return *cpp0x::next(ci(CGAL_FORWARD(U,u),Begin_tag()),i);
+    return *std::next(ci(CGAL_FORWARD(U,u),Begin_tag()),i);
   }
 };
       //typedef typename Functor<typename iterator_tag_traits<T>::nth_element>::type nth_elem;

Optimal_transportation_reconstruction_2/examples/Optimal_transportation_reconstruction_2/otr2_simplest_example.cpp

@@ -19,7 +19,7 @@ int main ()
   // Generate a set of random points on the boundary of a square.
   std::vector<Point> points;
   CGAL::Random_points_on_square_2<Point> point_generator(1.);
-  CGAL::cpp11::copy_n(point_generator, 100, std::back_inserter(points));
+  std::copy_n(point_generator, 100, std::back_inserter(points));
 
   Otr otr(points);
 

Optimal_transportation_reconstruction_2/examples/Optimal_transportation_reconstruction_2/otr2_simplest_example_with_tolerance.cpp

@@ -20,7 +20,7 @@ int main ()
   // Generate 100 random points on the boundary of a square.
   std::vector<Point> points;
   CGAL::Random_points_on_square_2<Point> point_generator(1.);
-  CGAL::cpp11::copy_n(point_generator, 100, std::back_inserter(points));
+  std::copy_n(point_generator, 100, std::back_inserter(points));
 
   Otr otr(points); // no mass given, one unit mass per point assumed
   otr.run_under_wasserstein_tolerance(0.1);

Optimal_transportation_reconstruction_2/test/Optimal_transportation_reconstruction_2/otr2_epeck.cpp

@@ -19,7 +19,7 @@ int main ()
   // Generate a set of random points on the boundary of a square.
   std::vector<Point> points;
   CGAL::Random_points_on_square_2<Point> point_generator(1.);
-  CGAL::cpp11::copy_n(point_generator, 100, std::back_inserter(points));
+  std::copy_n(point_generator, 100, std::back_inserter(points));
 
   Otr otr(points);
   otr.run(100); // 100 steps

Periodic_2_triangulation_2/examples/Periodic_2_triangulation_2/p2t2_hierarchy.cpp

@@ -31,7 +31,7 @@ int main( )
   std::cout << "insertion of 1000 random points" << std::endl;
   Triangulation t(Iso_rectangle(-1,-1, 1,1));
   CGAL::Random_points_in_square_2<Point, Creator> g(1.);
-  CGAL::cpp11::copy_n(g, 1000, std::back_inserter(t));
+  std::copy_n(g, 1000, std::back_inserter(t));
 
   //verbose mode of is_valid ; shows the number of vertices at each  level
   std::cout << "The number of vertices at successive levels" << std::endl;

Periodic_4_hyperbolic_triangulation_2/examples/Periodic_4_hyperbolic_triangulation_2/p4ht2_example_insertion.cpp

@@ -32,7 +32,7 @@ int main(int argc, char** argv)
   // Some of the points will be outside the octagon, so they will not be inserted.
   std::vector<Point> pts;
   CGAL::Random_points_in_disc_2<Point,Creator> g(0.85);
-  CGAL::cpp11::copy_n(g, N1, std::back_inserter(pts));
+  std::copy_n(g, N1, std::back_inserter(pts));
 
   // The triangulation is automatically initialized with the dummy points.
   Triangulation tr;

Point_set_2/test/Point_set_2/range_search_fcn.cpp

@@ -45,7 +45,7 @@ int main()
   std::list<Point_2> points;
   std::list<Vertex_handle> LV;
   
-  CGAL::cpp11::copy_n(rpg, 1000, std::back_inserter(points));
+  std::copy_n(rpg, 1000, std::back_inserter(points));
   PSet.insert(points.begin(), points.end()); 
 
   Point_2 p(10, 10), q(50, 10), r(50, 50), s(10, 50);

Point_set_2/test/Point_set_2/test_range_search.cpp

@@ -42,7 +42,7 @@ int main()
   std::list<Point_2> points;
   std::list<Vertex_handle> LV;
   
-  CGAL::cpp11::copy_n(rpg, 1000, std::back_inserter(points));
+  std::copy_n(rpg, 1000, std::back_inserter(points));
   PSet.insert(points.begin(), points.end()); 
 
   Point_2 p(10, 10), q(50, 10), r(50, 50), s(10, 50);

Point_set_processing_3/examples/Point_set_processing_3/callback_example.cpp

@@ -74,7 +74,7 @@ int main (int argc, char* argv[])
   std::vector<Point> points;
   points.reserve (N);
   Generator generator(100.);
-  CGAL::cpp11::copy_n (generator, N, std::back_inserter(points));
+  std::copy_n (generator, N, std::back_inserter(points));
 
   // Compute average spacing
   FT average_spacing = CGAL::compute_average_spacing<Concurrency_tag>

Point_set_processing_3/include/CGAL/Point_set_processing_3/internal/Voronoi_covariance_3/voronoi_covariance_3.h

@@ -181,7 +181,7 @@ namespace CGAL {
                     for(typename boost::graph_traits<Polyhedron>::face_descriptor fd : faces(P))
                     {
                       Halfedge_around_face_circulator<Polyhedron>
-                        h0(halfedge(fd,P),P), hf = h0--, hs = cpp11::next(hf);
+                        h0(halfedge(fd,P),P), hf = h0--, hs = std::next(hf);
 
                         while(hs != h0)
                         {

Polygon/include/CGAL/Polygon_2.h

@@ -438,7 +438,7 @@ class Polygon_2 {
     const Point_2& vertex(std::size_t i) const
       {
         CGAL_precondition( i < d_container.size() );
-        return *(cpp11::next(d_container.begin(), i));
+        return *(std::next(d_container.begin(), i));
       }
 
 
@@ -448,7 +448,7 @@ class Polygon_2 {
 
     /// Returns the `i`-th edge.
     Segment_2 edge(std::size_t i) const
-      { return *(cpp11::next(edges_begin(), i)); }
+      { return *(std::next(edges_begin(), i)); }
 
     /// @}
 

Polygon/include/CGAL/Polygon_2/Polygon_2_algorithms_impl.h

@@ -74,7 +74,7 @@ OutputForwardIterator filter_collinear_points(InputForwardIterator first,
   typedef typename K::FT                              FT;
   typedef typename K::Point_2                         Point;
 
-  InputForwardIterator last = cpp11::prev(beyond);
+  InputForwardIterator last = std::prev(beyond);
 
   InputForwardIterator vit = first, vit_next = vit, vit_next_2 = vit, vend = vit;
   ++vit_next;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h

@@ -113,7 +113,7 @@ namespace Polygon_mesh_processing {
                          boost::true_type>::value)
       {
         typename boost::range_iterator<const FaceRange>::type it = boost::const_begin(faces);
-        if (get(fmap, *it) == get(fmap, *cpp11::next(it)))
+        if (get(fmap, *it) == get(fmap, *std::next(it)))
         {
           std::cerr << "WARNING : the internal property map for CGAL::face_index_t" << std::endl
                     << "          is not properly initialized." << std::endl

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h

@@ -455,7 +455,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
         // sample the triangle face
         Random_points_in_triangle_3<typename Geom_traits::Point_3, Creator>
           g(points[0], points[1], points[2]);
-        out=CGAL::cpp11::copy_n(g, nb_points, out);
+        out=std::copy_n(g, nb_points, out);
       }
     }
     // sample edges
@@ -477,7 +477,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
         // now do the sampling of the edge
         Random_points_on_segment_3<typename Geom_traits::Point_3, Creator>
           g(get(pmap, source(ed,tm)), get(pmap, target(ed,tm)));
-        out=CGAL::cpp11::copy_n(g, nb_points, out);
+        out=std::copy_n(g, nb_points, out);
       }
     }
   }
@@ -498,7 +498,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
           nb_points = static_cast<std::size_t>(
             std::ceil(g.mesh_area()*nb_pts_a_u) );
       }
-      out = CGAL::cpp11::copy_n(g, nb_points, out);
+      out = std::copy_n(g, nb_points, out);
     }
     // sample edges
     if (smpl_dgs)
@@ -514,7 +514,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
           nb_points = static_cast<std::size_t>(
             std::ceil( g.mesh_length()*nb_pts_a_u) );
       }
-      out = CGAL::cpp11::copy_n(g, nb_points, out);
+      out = std::copy_n(g, nb_points, out);
     }
   }
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Face_graph_output_builder.h

@@ -1579,7 +1579,7 @@ public:
               for(Hedge_iterator it : to_rm)
               {
                 patches_of_tm1[i].interior_edges.push_back(*it);
-                if (it!=cpp11::prev(patches_of_tm1[i].shared_edges.end()))
+                if (it!=std::prev(patches_of_tm1[i].shared_edges.end()))
                   std::swap(patches_of_tm1[i].shared_edges.back(), *it);
                 patches_of_tm1[i].shared_edges.pop_back();
               }

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersection_impl.h

@@ -705,7 +705,7 @@ class Intersection_of_triangle_meshes
         CGAL_precondition(all_edges[0]==h_1 || all_edges[0]==opposite(h_1,tm1));
 
         // #ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
-        // check_coplanar_edges(cpp11::next(all_edges.begin()),
+        // check_coplanar_edges(std::next(all_edges.begin()),
         //                      all_edges.end(),CGAL::cpp11::get<1>(res),type);
         // #endif
 
@@ -981,8 +981,8 @@ class Intersection_of_triangle_meshes
                   // with the point found.
                   typename Faces_to_nodes_map::iterator it_seg3 = find_it;
                   // first check if there is only one such edge (no test is needed then)
-                  if (cpp11::next(it_seg3)!=f_to_node.end() &&
+                  if (std::next(it_seg3)!=f_to_node.end() &&
-                      cpp11::next(it_seg3)->first.first == it_seg3->first.first)
+                      std::next(it_seg3)->first.first == it_seg3->first.first)
                   {
                     while(true)
                     {

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h

@@ -122,10 +122,10 @@ void detect_identical_mergeable_vertices(
   if (hedges_with_identical_point_target.empty()) return;
   std::set< std::pair<std::size_t, std::size_t> >::iterator it1 = intervals.begin(),
                                                             end2 = intervals.end(),
-                                                            end1 = cpp11::prev(end2),
+                                                            end1 = std::prev(end2),
                                                             it2;
   for (; it1!=end1; ++it1)
-    for(it2=cpp11::next(it1); it2!= end2; ++it2 )
+    for(it2=std::next(it1); it2!= end2; ++it2 )
     {
       CGAL_assertion(it1->first<it2->first);
       CGAL_assertion(it1->first < it1->second && it2->first < it2->second);

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h

@@ -197,7 +197,7 @@ bool is_outward_oriented(const PolygonMesh& pmesh,
   internal::Compare_vertex_points_z_3<GT, VPMap> less_z(vpmap, gt);
   typename boost::graph_traits<PolygonMesh>::vertex_descriptor v_max = *(vertices(pmesh).first);
   for (typename boost::graph_traits<PolygonMesh>::vertex_iterator
-          vit=cpp11::next(vertices(pmesh).first), vit_end = vertices(pmesh).second;
+          vit=std::next(vertices(pmesh).first), vit_end = vertices(pmesh).second;
           vit!=vit_end; ++vit)
   {
     // skip isolated vertices

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h

@@ -163,7 +163,7 @@ public:
       if (nb_edges<3) return false;
 
       std::set<V_ID> polygon_vertices;
-      V_ID prev= *cpp11::prev(boost::end(polygon));
+      V_ID prev= *std::prev(boost::end(polygon));
       for(V_ID id : polygon)
       {
         if (max_id<id) max_id=id;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h

@@ -1322,10 +1322,10 @@ bool remove_degenerate_faces(      TriangleMesh& tmesh,
                                                         sorted_points.end()).size());
 
       CGAL_assertion( get( vpmap, *ref_vertices.first)==*sorted_points.begin() );
-      CGAL_assertion( get( vpmap, *ref_vertices.second)==*cpp11::prev(sorted_points.end()) );
+      CGAL_assertion( get( vpmap, *ref_vertices.second)==*std::prev(sorted_points.end()) );
 
       const typename Traits::Point_3& xtrm1 = *sorted_points.begin();
-      const typename Traits::Point_3& xtrm2 = *cpp11::prev(sorted_points.end());
+      const typename Traits::Point_3& xtrm2 = *std::prev(sorted_points.end());
 
       // recover halfedges on the hole, bounded by the reference vertices
       std::vector<halfedge_descriptor> side_one, side_two;
@@ -1440,8 +1440,8 @@ bool remove_degenerate_faces(      TriangleMesh& tmesh,
       CGAL_assertion( target(side_one.back(), tmesh) == *ref_vertices.second );
       CGAL_assertion( target(side_two.back(), tmesh) == *ref_vertices.second );
 
-      typename Sorted_point_set::iterator it_pt = cpp11::next(sorted_points.begin()),
+      typename Sorted_point_set::iterator it_pt = std::next(sorted_points.begin()),
-                                          it_pt_end = cpp11::prev(sorted_points.end());
+                                          it_pt_end = std::prev(sorted_points.end());
 
       bool non_collapsable = false;
       typename std::vector<halfedge_descriptor>::iterator side_one_it = side_one.begin();
@@ -1530,10 +1530,10 @@ bool remove_degenerate_faces(      TriangleMesh& tmesh,
       // now split each side to contains the same sequence of points
       //    first side
       int hi=0;
-      for (typename Sorted_point_set::iterator it=cpp11::next(sorted_points.begin()),
+      for (typename Sorted_point_set::iterator it=std::next(sorted_points.begin()),
                                                it_end=sorted_points.end(); it!=it_end; ++it)
       {
-        CGAL_assertion( *cpp11::prev(it) == get(vpmap, source(side_one[hi], tmesh) ) );
+        CGAL_assertion( *std::prev(it) == get(vpmap, source(side_one[hi], tmesh) ) );
         if( *it != get(vpmap, target(side_one[hi], tmesh) ) ){
           // split the edge and update the point
           halfedge_descriptor h1 = next(opposite(side_one[hi], tmesh), tmesh);
@@ -1554,10 +1554,10 @@ bool remove_degenerate_faces(      TriangleMesh& tmesh,
       }
       //    second side
       hi=0;
-      for (typename Sorted_point_set::iterator it=cpp11::next(sorted_points.begin()),
+      for (typename Sorted_point_set::iterator it=std::next(sorted_points.begin()),
                                                it_end=sorted_points.end(); it!=it_end; ++it)
       {
-        CGAL_assertion( *cpp11::prev(it) == get(vpmap, source(side_two[hi], tmesh) ) );
+        CGAL_assertion( *std::prev(it) == get(vpmap, source(side_two[hi], tmesh) ) );
         if( *it != get(vpmap, target(side_two[hi], tmesh) ) ){
           // split the edge and update the point
           halfedge_descriptor h2 = Euler::split_edge(side_two[hi], tmesh);

Polyhedron/demo/Polyhedron/Plugins/PMP/Distance_plugin.cpp

@@ -222,7 +222,7 @@ private:
         Kernel::Point_3 &q = get(vpmap,target(next(halfedge(f,*poly),*poly),*poly));
         Kernel::Point_3 &r = get(vpmap,target(next(next(halfedge(f,*poly),*poly),*poly),*poly));
         CGAL::Random_points_in_triangle_3<Kernel::Point_3> g(p, q, r);
-        CGAL::cpp11::copy_n(g, nb_points, std::back_inserter(sampled_points));
+        std::copy_n(g, nb_points, std::back_inserter(sampled_points));
         sampled_points.push_back(p);
         sampled_points.push_back(q);
         sampled_points.push_back(r);

STL_Extension/doc/STL_Extension/CGAL/algorithm.h

@@ -7,7 +7,7 @@ namespace CGAL {
 /*!
 \ingroup STLAlgos
 
-\deprecated This function is deprecated, CGAL::cpp11::copy_n should be
+\deprecated This function is deprecated, std::copy_n should be
 used instead.
 
 Copies the first `n` items from `first` to `result`.
@@ -95,7 +95,7 @@ namespace CGAL {
 /*!
 \ingroup STLAlgos
 
-\deprecated This function is deprecated. `CGAL::cpp11::prev` should be used
+\deprecated This function is deprecated. `std::prev` should be used
 instead.
 
 Returns the previous iterator,
@@ -115,7 +115,7 @@ namespace CGAL {
 /*!
 \ingroup STLAlgos
 
-\deprecated This function is deprecated. `CGAL::cpp11::next` should be used
+\deprecated This function is deprecated. `std::next` should be used
 instead.
 
 
@@ -130,67 +130,6 @@ the result of `operator++` on a forward iterator.
 template <class ForwardIterator>
 ForwardIterator successor(ForwardIterator it);
 
-namespace cpp11 {
-
-/*!
-\ingroup STLAlgos
-
-The function returns the result of `operator++` on a
-`ForwardIterator`. The exact behaviour is described in Paragraph 24.4.4
-of the C++ standard draft
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf">N3242</a>.
-
-\note There is actually no function in namespace `CGAL::cpp11` with this
-name, but a using declaration which imports a function from another
-namespace. By order of priority: the one in namespace `std` is used
-(provided by C++0x), if not found, then the one in namespace `boost`
-is used.
-
-
-
-\sa <a href="https://www.boost.org/doc/libs/1_46_1/libs/utility/utility.htm#functions_next_prior">boost::next</a>
-\sa `CGAL::cpp11::prev()`
-
-*/
-template <typename ForwardIterator>
-Iterator next(ForwardIterator it);
-
-/*!
-\ingroup STLAlgos
-
-The function returns the result of `operator--` on
-a `BidirectionalIterator`. The exact behaviour is described in
-Paragraph 24.4.4 of the C++ standard draft
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf">N3242</a>.
-
-\note If C++0x is available the function `std::prev` is imported into
-the namespace `CGAL::cpp11`, otherwise `CGAL::cpp11::prev` is declared with the
-signature as given in Paragraph 24.4.4 of the ISO C++ Standard
-and forwarded to `boost::prior`.
-*/
-template <typename BidirectionalIterator>
-Iterator prev(BidirectionalIterator it);
-
-
-/*!
-\ingroup STLAlgos
-
-Copies `n` items from an
-input iterator to an output iterator. Its exact behaviour is defined
-in Paragraph 25.3.1 of the C++ standard draft
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf">N3242</a>.
-
-\note This provides an implementation of the standard function
-`copy_n` from the C++0x standard. If `copy_n` is available
-in the `std::` namespace a using declaration is used, otherwise
-an alternative implementation from \cgal is used.
-*/
-
-template< class InputIterator, class Size, class OutputIterator>
-OutputIterator copy_n(InputIterator first, Size count, OutputIterator result);
-
-} /* namespace cpp11 */
-
 namespace cpp98 {
 
 /*!

STL_Extension/doc/STL_Extension/PackageDescription.txt

@@ -41,11 +41,11 @@
 - `CGAL::Multiset<Type,Compare,Allocator>`
 
 \cgalCRPSection{Generic Algorithms}
-- `CGAL::cpp11::copy_n`
+- `std::copy_n`
 - `CGAL::copy_n`
 - `CGAL::min_max_element`
-- `CGAL::cpp11::next`
+- `std::next`
-- `CGAL::cpp11::prev`
+- `std::prev`
 - `CGAL::predecessor`
 - `CGAL::successor`
 

STL_Extension/include/CGAL/algorithm.h

@@ -39,78 +39,8 @@
 #include <boost/random.hpp>
 #include <boost/random/linear_congruential.hpp>
 
-#ifdef CGAL_CFG_NO_CPP0X_NEXT_PREV
-#  include <boost/next_prior.hpp>
-#endif
-
 namespace CGAL {
 
-namespace cpp11 {
-#ifndef CGAL_CFG_NO_CPP0X_NEXT_PREV
-  using std::next;
-  using std::prev;
-#else
-  using boost::next;
-
-  // boost provides prior, we go with the standard declaration as
-  // described in $24.4.4 and forward it to boost prior
-  template<typename BidirectionalIterator>
-  BidirectionalIterator prev( BidirectionalIterator x, 
-			      typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1)
-  {
-    return boost::prior(x, n);
-  }
-#endif
-} // namespace cpp11
-
-namespace cpp0x = cpp11;
-
-// copy_n is usually in the STL as well, but not in the official
-// standard. We provide our own copy_n.  It is planned for C++0x. 
-// Our own version is declared deprecated, if std::copy_n is
-// available.
-
-#ifndef CGAL_CFG_NO_CPP0X_COPY_N
-#ifndef CGAL_NO_DEPRECATED_CODE
-template <class InputIterator, class Size, class OutputIterator>
-CGAL_DEPRECATED OutputIterator copy_n( InputIterator first, Size n, OutputIterator result )
-{
-  // copies the first `n' items from `first' to `result'. Returns
-  // the value of `result' after inserting the `n' items.
-  while( n--) {
-    *result = *first;
-    first++;
-    result++;
-  }
-  return result;
-}
-#endif // no CGAL_NO_DEPRECATED_CODE
-#else // CGAL_CFG_NO_CPP0X_COPY_N
-template <class InputIterator, class Size, class OutputIterator>
-OutputIterator copy_n( InputIterator first, Size n, OutputIterator result )
-{
-  // copies the first `n' items from `first' to `result'. Returns
-  // the value of `result' after inserting the `n' items.
-  while( n--) {
-    *result = *first;
-    first++;
-    result++;
-  }
-  return result;
-}
-#endif // CGAL_CFG_NO_CPP0X_COPY_N
-
-namespace cpp11 {
-#ifndef CGAL_CFG_NO_CPP0X_COPY_N
-  using std::copy_n;
-#else
-  using CGAL::copy_n;
-#endif
-} // cpp11
-
-namespace cpp0x = cpp11;
-
-
 // Not documented
 template <class T> inline
 bool

STL_Extension/test/STL_Extension/test_namespaces.cpp

@@ -25,11 +25,11 @@ int main()
   CGAL::copy_n(arr.begin(), 3, arr2.begin());
 
   CGAL::cpp0x::copy_n(arr.begin(), 3, arr2.begin());
-  CGAL::cpp11::copy_n(arr.begin(), 3, arr2.begin());
+  std::copy_n(arr.begin(), 3, arr2.begin());
   
   CGAL::cpp0x::prev(arr.end());
-  CGAL::cpp11::prev(arr.end());
+  std::prev(arr.end());
   CGAL::cpp0x::next(arr.begin());
-  CGAL::cpp11::next(arr.begin());
+  std::next(arr.begin());
   return 0;
 }

STL_Extension/test/STL_Extension/test_stl_extension.cpp

@@ -8156,7 +8156,7 @@ void test_prev_next()
   V.push_back(2);
   V.push_back(3);
 
-  assert(cpp11::next(cpp11::next(V.begin())) == cpp11::prev(V.end()));
+  assert(std::next(std::next(V.begin())) == std::prev(V.end()));
 }
 
 void test_copy_n() {
@@ -8165,7 +8165,7 @@ void test_copy_n() {
     V.push_back(i);
 
   std::vector<int> V2(5);
-  cpp11::copy_n(V.begin(), 5, V2.begin());
+  std::copy_n(V.begin(), 5, V2.begin());
   
   assert(std::equal(V2.begin(), V2.end(), V.begin()));
 }

Spatial_searching/test/Spatial_searching/Building_kd_tree_with_ddim_points.cpp

@@ -97,7 +97,7 @@ int main() {
   std::vector<Point> points;
   
   Point_generator g(3);
-  CGAL::cpp11::copy_n( g, N, std::back_inserter(points));
+  std::copy_n( g, N, std::back_inserter(points));
   g++;
   Point query = *g;
 

Spatial_searching/test/Spatial_searching/Orthogonal_incremental_neighbor_search.cpp

@@ -57,7 +57,7 @@ void run()
   // in a register with a distance in memory
   CGAL::Set_ieee_double_precision pfr;
 
-  CGAL::cpp11::copy_n( g, 1000, std::back_inserter(points));
+  std::copy_n( g, 1000, std::back_inserter(points));
 
   typename K_search::Tree t(
     boost::make_transform_iterator(points.begin(),Create_point_with_info<typename K_search::Point_d>()),
@@ -108,7 +108,7 @@ bool search(bool nearest)
 {
   std::vector<Point> points;
   Random_points g(1);
-  CGAL::cpp11::copy_n( g, 1000, std::back_inserter(points));
+  std::copy_n( g, 1000, std::back_inserter(points));
 
   typename K_search::Tree tree(
     boost::make_transform_iterator(points.begin(),Create_point_with_info<typename K_search::Point_d>()),

Spatial_searching/test/Spatial_searching/Splitters.cpp

@@ -92,7 +92,7 @@ main() {
 
   Vector points;
   Random_points g( 150.0);
-  CGAL::cpp11::copy_n( g, 1000, std::back_inserter(points));
+  std::copy_n( g, 1000, std::back_inserter(points));
     
   g++;
   Point query = *g;

Straight_skeleton_2/include/CGAL/IO/Dxf_writer.h

@@ -126,7 +126,7 @@ public:
         
         while ( lCurrVertex != aVerticesEnd )
         {
-          XY_Iterator lNextVertex = ( lCurrVertex == lLastVertex ? lFirstVertex : CGAL::cpp11::next(lCurrVertex) ) ;
+          XY_Iterator lNextVertex = ( lCurrVertex == lLastVertex ? lFirstVertex : std::next(lCurrVertex) ) ;
           
           add_segment_2 ( *lCurrVertex, *lNextVertex, aLayer, aColor ) ;
           

Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_2_impl.h

@@ -1492,7 +1492,7 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::RelinkBisectorsAroundMultinode( Verte
   
   first_he->HBase_base::set_vertex(v0);
   
-  for ( typename Halfedge_handle_vector::iterator i = cpp11::next(aLinks.begin()), ei = aLinks.end(); i != ei ; ++ i )
+  for ( typename Halfedge_handle_vector::iterator i = std::next(aLinks.begin()), ei = aLinks.end(); i != ei ; ++ i )
   {
     Halfedge_handle he = *i ;
 

Straight_skeleton_2/include/CGAL/compute_outer_frame_margin.h

@@ -58,14 +58,14 @@ boost::optional< typename Traits::FT > compute_outer_frame_margin ( ForwardPoint
   
   FT lMaxSDist(0.0) ;
   
-  ForwardPointIterator lLast = CGAL::cpp11::prev(aEnd) ;
+  ForwardPointIterator lLast = std::prev(aEnd) ;
   
   bool lOverflow = false ;
 
   for ( ForwardPointIterator lCurr = aBegin ; lCurr != aEnd ; ++ lCurr )
   {
-    ForwardPointIterator lPrev = ( lCurr == aBegin ? lLast  : CGAL::cpp11::prev  (lCurr) ) ;
+    ForwardPointIterator lPrev = ( lCurr == aBegin ? lLast  : std::prev  (lCurr) ) ;
-    ForwardPointIterator lNext = ( lCurr == lLast  ? aBegin : CGAL::cpp11::next  (lCurr) ) ;
+    ForwardPointIterator lNext = ( lCurr == lLast  ? aBegin : std::next  (lCurr) ) ;
     
     if ( !equal(*lPrev,*lCurr) && !equal(*lCurr,*lNext) && !collinear(*lPrev,*lCurr,*lNext) )
     {

Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example.cpp

@@ -37,8 +37,8 @@ int main()
   deform_mesh.insert_roi_vertices(vb, ve);
 
   // Select two control vertices ...
-  vertex_descriptor control_1 = *CGAL::cpp11::next(vb, 213);
+  vertex_descriptor control_1 = *std::next(vb, 213);
-  vertex_descriptor control_2 = *CGAL::cpp11::next(vb, 157);
+  vertex_descriptor control_2 = *std::next(vb, 157);
 
   // ... and insert them
   deform_mesh.insert_control_vertex(control_1);
@@ -75,7 +75,7 @@ int main()
   output.close();
 
   // Add another control vertex which requires another call to preprocess
-  vertex_descriptor control_3 = *CGAL::cpp11::next(vb, 92);
+  vertex_descriptor control_3 = *std::next(vb, 92);
   deform_mesh.insert_control_vertex(control_3);
 
   // The prepocessing step is again needed

Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_Surface_mesh.cpp

@@ -27,8 +27,8 @@ int main()
   deform_mesh.insert_roi_vertices(vb, ve);
 
   // Select two control vertices ...
-  vertex_descriptor control_1 = *CGAL::cpp11::next(vb, 213);
+  vertex_descriptor control_1 = *std::next(vb, 213);
-  vertex_descriptor control_2 = *CGAL::cpp11::next(vb, 157);
+  vertex_descriptor control_2 = *std::next(vb, 157);
 
   // ... and insert them
   deform_mesh.insert_control_vertex(control_1);
@@ -64,7 +64,7 @@ int main()
   out1 << mesh;
 
   // Add another control vertex which requires another call to preprocess
-  vertex_descriptor control_3 = *CGAL::cpp11::next(vb, 92);
+  vertex_descriptor control_3 = *std::next(vb, 92);
   deform_mesh.insert_control_vertex(control_3);
 
   // The prepocessing step is again needed

Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_custom_polyhedron.cpp

@@ -95,8 +95,8 @@ int main()
   deform_mesh.insert_roi_vertices(vb, ve);
 
   // Insert two control vertices
-  vertex_descriptor control_1 = *CGAL::cpp11::next(vb, 213);
+  vertex_descriptor control_1 = *std::next(vb, 213);
-  vertex_descriptor control_2 = *CGAL::cpp11::next(vb, 157);
+  vertex_descriptor control_2 = *std::next(vb, 157);
   deform_mesh.insert_control_vertex(control_1);
   deform_mesh.insert_control_vertex(control_2);
 
@@ -131,7 +131,7 @@ int main()
   output.close();
 
   // Add another control vertex
-  vertex_descriptor control_3 = *CGAL::cpp11::next(vb, 92);
+  vertex_descriptor control_3 = *std::next(vb, 92);
   deform_mesh.insert_control_vertex(control_3);
 
   // The prepocessing step is again needed

Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_with_OpenMesh.cpp

@@ -28,8 +28,8 @@ int main()
   deform_mesh.insert_roi_vertices(vb, ve);
 
   // Select two control vertices ...
-  vertex_descriptor control_1 = *CGAL::cpp11::next(vb, 213);
+  vertex_descriptor control_1 = *std::next(vb, 213);
-  vertex_descriptor control_2 = *CGAL::cpp11::next(vb, 157);
+  vertex_descriptor control_2 = *std::next(vb, 157);
 
   // ... and insert them
   deform_mesh.insert_control_vertex(control_1);
@@ -64,7 +64,7 @@ int main()
   OpenMesh::IO::write_mesh(mesh,"deform_1.off");
 
   // Add another control vertex which requires another call to preprocess
-  vertex_descriptor control_3 = *CGAL::cpp11::next(vb, 92);
+  vertex_descriptor control_3 = *std::next(vb, 92);
   deform_mesh.insert_control_vertex(control_3);
 
   // The prepocessing step is again needed