songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
Sébastien Loriot 2019-03-20 09:46:29 +01:00
parent 1d908c1c0b
commit ce126b87c6
117 changed files with 229 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AABB_tree/test/AABB_tree/aabb_any_all_benchmark.cpp
View File

@ -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;

4
AABB_tree/test/AABB_tree/aabb_test_ray_intersection.cpp
View File

@ -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));
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(v1));
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;

2
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Interval_evaluate_1.h
View File

@ -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));

2
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Interval_evaluate_2.h
View File

@ -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);

2
Alpha_shapes_2/examples/Alpha_shapes_2/ex_alpha_projection_traits.cpp
View File

@ -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;
}

2
Alpha_shapes_2/examples/Alpha_shapes_2/ex_alpha_shapes_2.cpp
View File

@ -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;
}

2
Alpha_shapes_2/examples/Alpha_shapes_2/ex_periodic_alpha_shapes_2.cpp
View File

@ -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;
}

2
Alpha_shapes_2/test/Alpha_shapes_2/test_alpha.cpp
View File

@ -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;
}

4
BGL/test/BGL/test_Euler_operations.cpp
View File

@ -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 h2 = *CGAL::cpp11::next(boost::begin(halfedges(g)), j);
halfedge_descriptor h1 = *std::next(boost::begin(halfedges(g)), i);
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));
}

2
Barycentric_coordinates_2/examples/Barycentric_coordinates_2/Wachspress_coordinates_example.cpp
View File

@ -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.

2
Boolean_set_operations_2/archive/demo/Boolean_set_operations_2_GraphicsView/boolean_operations_2.cpp
View File

@ -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
)

2
Boolean_set_operations_2/examples/Boolean_set_operations_2/bezier_traits_adapter2.cpp
View File

@ -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);
}

2
Bounding_volumes/examples/Rectangular_p_center_2/rectangular_p_center_2.cpp
View File

@ -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);

2
Bounding_volumes/test/Bounding_volumes/rectangular_p_center_2_random1_test.cpp
View File

@ -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));

2
Bounding_volumes/test/Bounding_volumes/rectangular_p_center_2_random2_test.cpp
View File

@ -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));

6
CGAL_ipelets/demo/CGAL_ipelets/generator.cpp
View File

@ -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;
};

2
Convex_hull_2/benchmark/Convex_hull_2/static_ch2.cpp
View File

@ -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
/*

24
Convex_hull_2/include/CGAL/Convex_hull_2/ch_akl_toussaint_impl.h
View File

@ -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(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(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(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<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<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<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<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) )

10
Convex_hull_2/include/CGAL/Convex_hull_2/ch_bykat_impl.h
View File

@ -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());
Pend = cpp11::prev(P.end());
Pbegin = std::next(P.begin());
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;

8
Convex_hull_2/include/CGAL/Convex_hull_2/ch_eddy_impl.h
View File

@ -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);
}

4
Convex_hull_2/include/CGAL/Convex_hull_2/ch_graham_andrew_impl.h
View File

@ -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) );

4
Convex_hull_2/include/CGAL/Convex_hull_2/convexity_check_2_impl.h
View File

@ -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;

2
Convex_hull_2/include/CGAL/segment_intersection_points_2.h
View File

@ -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();

2
Convex_hull_3/benchmark/Convex_hull_3/compare_different_approach.cpp
View File

@ -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{

2
Convex_hull_3/benchmark/Convex_hull_3/is_on_positive_side.cpp
View File

@ -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);

2
Convex_hull_3/demo/Convex_hull_3/quickhull_3_demo.cpp
View File

@ -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;

2
Convex_hull_3/examples/Convex_hull_3/dynamic_hull_3.cpp
View File

@ -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());

2
Convex_hull_3/examples/Convex_hull_3/dynamic_hull_LCC_3.cpp
View File

@ -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());

2
Convex_hull_3/examples/Convex_hull_3/dynamic_hull_OM_3.cpp
View File

@ -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());

2
Convex_hull_3/examples/Convex_hull_3/dynamic_hull_SM_3.cpp
View File

@ -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());

4
Convex_hull_3/include/CGAL/Convex_hull_3/dual/halfspace_intersection_3.h
View File

@ -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() &&

2
Convex_hull_3/test/Convex_hull_3/quickhull_degenerate_test_3.cpp
View File

@ -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));

2
Convex_hull_3/test/Convex_hull_3/quickhull_test_3.cpp
View File

@ -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);

2
Filtered_kernel/benchmark/Filtered_kernel/orientation_3.cpp
View File

@ -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();

18
Generator/doc/Generator/CGAL/point_generators_2.h
View File

@ -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>`

20
Generator/doc/Generator/CGAL/point_generators_3.h
View File

@ -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>`

6
Generator/doc/Generator/CGAL/point_generators_d.h
View File

@ -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>`

2
Generator/examples/Generator/random_degenerate_point_set.cpp
View File

@ -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());

2
Generator/examples/Generator/random_grid.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_in_tetrahedral_mesh_3.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_in_triangles_2.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_in_triangles_3.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_on_tetrahedral_mesh_3.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_on_triangle_mesh_2.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_on_triangle_mesh_3.cpp
View File

@ -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);

4
Generator/examples/Generator/random_points_tetrahedron_and_triangle_3.cpp
View File

@ -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);

2
Generator/examples/Generator/random_points_triangle_2.cpp
View File

@ -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);

2
Generator/examples/Generator/random_segments1.cpp
View File

@ -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++){

2
Generator/include/CGAL/random_convex_hull_in_disc_2.h
View File

@ -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

4
Generator/include/CGAL/random_convex_set_2.h
View File

@ -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 );

12
Generator/test/Generator/generic_random_test.cpp
View File

@ -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];

30
Generator/test/Generator/test_generators.cpp
View File

@ -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));
CGAL::cpp11::copy_n( g3, 100, std::back_inserter(points));
CGAL::cpp11::copy_n( g4, 100, std::back_inserter(points));
CGAL::cpp11::copy_n( g5, 50, std::back_inserter(points));
CGAL::cpp11::copy_n( g5a, 50, std::back_inserter(points));
std::copy_n( g2, 100, std::back_inserter(points));
std::copy_n( g3, 100, std::back_inserter(points));
std::copy_n( g4, 100, std::back_inserter(points));
std::copy_n( g5, 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));
CGAL::cpp11::copy_n( g3, 100, std::back_inserter(points));
CGAL::cpp11::copy_n( g4, 100, std::back_inserter(points));
std::copy_n( g2, 100, std::back_inserter(points));
std::copy_n( g3, 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);

6
Generator/test/Generator/test_tetrahedron_3.cpp
View File

@ -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()));
}

6
Generator/test/Generator/test_triangle_2.cpp
View File

@ -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()));
}

6
Generator/test/Generator/test_triangle_3.cpp
View File

@ -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()));
}

2
GraphicsView/demo/Generator/Generator_2.cpp
View File

@ -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());
}

4
Interpolation/demo/Interpolation/surface_voronoi.cpp
View File

@ -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;

2
Interpolation/examples/Interpolation/interpolation_2.cpp
View File

@ -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;

2
Interpolation/examples/Interpolation/interpolation_vertex_with_info_2.cpp
View File

@ -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;

2
Interpolation/examples/Interpolation/surface_neighbor_coordinates_3.cpp
View File

@ -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);

4
Interpolation/test/Interpolation/include/CGAL/_test_interpolation_functions_2.cpp
View File

@ -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;

6
Interpolation/test/Interpolation/include/CGAL/_test_surface_neighbors_3.cpp
View File

@ -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++)

2
Kernel_23/examples/Kernel_23/intersections.cpp
View File

@ -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

2
Nef_3/include/CGAL/boost/graph/convert_nef_polyhedron_to_polygon_mesh.h
View File

@ -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)

2
NewKernel_d/include/CGAL/NewKernel_d/Lazy_cartesian.h
View File

@ -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;

2
Optimal_transportation_reconstruction_2/examples/Optimal_transportation_reconstruction_2/otr2_simplest_example.cpp
View File

@ -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);

2
Optimal_transportation_reconstruction_2/examples/Optimal_transportation_reconstruction_2/otr2_simplest_example_with_tolerance.cpp
View File

@ -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);

2
Optimal_transportation_reconstruction_2/test/Optimal_transportation_reconstruction_2/otr2_epeck.cpp
View File

@ -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

2
Periodic_2_triangulation_2/examples/Periodic_2_triangulation_2/p2t2_hierarchy.cpp
View File

@ -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;

2
Periodic_4_hyperbolic_triangulation_2/examples/Periodic_4_hyperbolic_triangulation_2/p4ht2_example_insertion.cpp
View File

@ -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;

2
Point_set_2/test/Point_set_2/range_search_fcn.cpp
View File

@ -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);

2
Point_set_2/test/Point_set_2/test_range_search.cpp
View File

@ -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);

2
Point_set_processing_3/examples/Point_set_processing_3/callback_example.cpp
View File

@ -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>

2
Point_set_processing_3/include/CGAL/Point_set_processing_3/internal/Voronoi_covariance_3/voronoi_covariance_3.h
View File

@ -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)
{

4
Polygon/include/CGAL/Polygon_2.h
View File

@ -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)); }
/// @}

2
Polygon/include/CGAL/Polygon_2/Polygon_2_algorithms_impl.h
View File

@ -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;

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h
View File

@ -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

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
View File

@ -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);
}
}

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Face_graph_output_builder.h
View File

@ -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();
}

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersection_impl.h
View File

@ -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() &&
cpp11::next(it_seg3)->first.first == it_seg3->first.first)
if (std::next(it_seg3)!=f_to_node.end() &&
std::next(it_seg3)->first.first == it_seg3->first.first)
{
while(true)
{

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h
View File

@ -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);

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h
View File

@ -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

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h
View File

@ -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;

16
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h
View File

@ -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()),
it_pt_end = cpp11::prev(sorted_points.end());
typename Sorted_point_set::iterator it_pt = std::next(sorted_points.begin()),
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);

2
Polyhedron/demo/Polyhedron/Plugins/PMP/Distance_plugin.cpp
View File

@ -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);

67
STL_Extension/doc/STL_Extension/CGAL/algorithm.h
View File

@ -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 {
/*!

6
STL_Extension/doc/STL_Extension/PackageDescription.txt
View File

@ -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`
- `CGAL::cpp11::prev`
- `std::next`
- `std::prev`
- `CGAL::predecessor`
- `CGAL::successor`

70
STL_Extension/include/CGAL/algorithm.h
View File

@ -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

6
STL_Extension/test/STL_Extension/test_namespaces.cpp
View File

@ -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;
}

4
STL_Extension/test/STL_Extension/test_stl_extension.cpp
View File

@ -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()));
}

2
Spatial_searching/test/Spatial_searching/Building_kd_tree_with_ddim_points.cpp
View File

@ -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;

4
Spatial_searching/test/Spatial_searching/Orthogonal_incremental_neighbor_search.cpp
View File

@ -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>()),

2
Spatial_searching/test/Spatial_searching/Splitters.cpp
View File

@ -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;

2
Straight_skeleton_2/include/CGAL/IO/Dxf_writer.h
View File

@ -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 ) ;

2
Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_2_impl.h
View File

@ -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 ;

6
Straight_skeleton_2/include/CGAL/compute_outer_frame_margin.h
View File

@ -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 lNext = ( lCurr == lLast ? aBegin : CGAL::cpp11::next (lCurr) ) ;
ForwardPointIterator lPrev = ( lCurr == aBegin ? lLast : std::prev (lCurr) ) ;
ForwardPointIterator lNext = ( lCurr == lLast ? aBegin : std::next (lCurr) ) ;
if ( !equal(*lPrev,*lCurr) && !equal(*lCurr,*lNext) && !collinear(*lPrev,*lCurr,*lNext) )
{

6
Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example.cpp
View File

@ -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_2 = *CGAL::cpp11::next(vb, 157);
vertex_descriptor control_1 = *std::next(vb, 213);
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

6
Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_Surface_mesh.cpp
View File

@ -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_2 = *CGAL::cpp11::next(vb, 157);
vertex_descriptor control_1 = *std::next(vb, 213);
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

6
Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_custom_polyhedron.cpp
View File

@ -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_2 = *CGAL::cpp11::next(vb, 157);
vertex_descriptor control_1 = *std::next(vb, 213);
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

6
Surface_mesh_deformation/examples/Surface_mesh_deformation/all_roi_assign_example_with_OpenMesh.cpp
View File

@ -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_2 = *CGAL::cpp11::next(vb, 157);
vertex_descriptor control_1 = *std::next(vb, 213);
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

Some files were not shown because too many files have changed in this diff Show More