From 74e4d89cbc1d53619cfe799a842df0b8c6df10e1 Mon Sep 17 00:00:00 2001 From: Andreas Fabri Date: Tue, 27 Sep 2022 10:42:05 +0100 Subject: [PATCH] Optimisation --- Bounding_volumes/include/CGAL/Min_annulus_d.h | 32 +- Bounding_volumes/include/CGAL/Min_circle_2.h | 8 +- .../Min_circle_2/Min_circle_2_adapterC2.h | 4 +- .../Min_circle_2/Min_circle_2_adapterH2.h | 4 +- .../CGAL/Min_circle_2/Min_circle_2_impl.h | 4 +- .../Min_circle_2/Optimisation_circle_2_impl.h | 6 +- Bounding_volumes/include/CGAL/Min_ellipse_2.h | 12 +- .../Min_ellipse_2/Min_ellipse_2_adapterC2.h | 10 +- .../Min_ellipse_2/Min_ellipse_2_adapterH2.h | 10 +- .../CGAL/Min_ellipse_2/Min_ellipse_2_impl.h | 4 +- .../Min_ellipse_2/Optimisation_ellipse_2.h | 38 +-- .../Optimisation_ellipse_2_impl.h | 4 +- .../include/CGAL/Min_quadrilateral_traits_2.h | 18 +- Bounding_volumes/include/CGAL/Min_sphere_d.h | 22 +- .../CGAL/Min_sphere_d/Min_sphere_d_impl.h | 4 +- .../CGAL/Min_sphere_d/Optimisation_sphere_d.h | 8 +- .../CGAL/Rectangular_p_center_traits_2.h | 12 +- .../include/CGAL/min_quadrilateral_2.h | 12 +- .../include/CGAL/pierce_rectangles_2.h | 44 +-- .../include/CGAL/rectangular_3_center_2.h | 44 +-- .../include/CGAL/rectangular_p_center_2.h | 22 +- .../include/CGAL/Extremal_polygon_traits_2.h | 10 +- .../include/CGAL/extremal_polygon_2.h | 92 ++--- Matrix_search/include/CGAL/Cartesian_matrix.h | 6 +- Matrix_search/include/CGAL/Dynamic_matrix.h | 14 +- .../include/CGAL/Transform_iterator.h | 1 - .../include/CGAL/monotone_matrix_search.h | 14 +- .../include/CGAL/sorted_matrix_search.h | 16 +- .../include/CGAL/Optimisation/assertions.h | 323 ------------------ .../include/CGAL/Optimisation/basic.h | 1 - .../include/CGAL/Polytope_distance_d.h | 38 +-- .../include/CGAL/all_furthest_neighbors_2.h | 16 +- 32 files changed, 264 insertions(+), 589 deletions(-) delete mode 100644 Optimisation_basic/include/CGAL/Optimisation/assertions.h diff --git a/Bounding_volumes/include/CGAL/Min_annulus_d.h b/Bounding_volumes/include/CGAL/Min_annulus_d.h index 8dae7e73d26..eb7435ef1f8 100644 --- a/Bounding_volumes/include/CGAL/Min_annulus_d.h +++ b/Bounding_volumes/include/CGAL/Min_annulus_d.h @@ -325,7 +325,7 @@ public: Support_point_iterator support_points_begin() const { - CGAL_optimisation_assertion_msg(number_of_points() >= 2, + CGAL_assertion_msg(number_of_points() >= 2, "support_points_begin: not enough points"); return Support_point_iterator( solver->basic_original_variable_indices_begin(), @@ -334,7 +334,7 @@ public: Support_point_iterator support_points_end() const { - CGAL_optimisation_assertion_msg(number_of_points() >= 2, + CGAL_assertion_msg(number_of_points() >= 2, "support_points_begin: not enough points"); return Support_point_iterator( solver->basic_original_variable_indices_end(), @@ -401,27 +401,27 @@ public: // NOTE: an implicit conversion from ET to RT must be available! Point center( ) const - { CGAL_optimisation_precondition( ! is_empty()); + { CGAL_precondition( ! is_empty()); return tco.construct_point_d_object()( ambient_dimension(), center_coordinates_begin(), center_coordinates_end()); } FT squared_inner_radius( ) const - { CGAL_optimisation_precondition( ! is_empty()); + { CGAL_precondition( ! is_empty()); return FT( squared_inner_radius_numerator()) / FT( squared_radii_denominator()); } FT squared_outer_radius( ) const - { CGAL_optimisation_precondition( ! is_empty()); + { CGAL_precondition( ! is_empty()); return FT( squared_outer_radius_numerator()) / FT( squared_radii_denominator()); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const - { CGAL_optimisation_precondition( + { CGAL_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); ET h_p_sqr = da_coord(p)[d] * da_coord(p)[d]; @@ -431,7 +431,7 @@ public: bool has_on_bounded_side( const Point& p) const - { CGAL_optimisation_precondition( + { CGAL_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); ET h_p_sqr = da_coord(p)[d] * da_coord(p)[d]; @@ -440,7 +440,7 @@ public: bool has_on_boundary( const Point& p) const - { CGAL_optimisation_precondition( + { CGAL_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); ET h_p_sqr = da_coord(p)[d] * da_coord(p)[d]; @@ -449,7 +449,7 @@ public: bool has_on_unbounded_side( const Point& p) const - { CGAL_optimisation_precondition( + { CGAL_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); ET h_p_sqr(da_coord(p)[d]); @@ -468,14 +468,14 @@ public: { if ( points.size() > 0) points.erase( points.begin(), points.end()); std::copy( first, last, std::back_inserter( points)); set_dimension(); - CGAL_optimisation_precondition_msg( check_dimension(), + CGAL_precondition_msg( check_dimension(), "Not all points have the same dimension."); compute_min_annulus(); } void insert( const Point& p) { if ( is_empty()) d = tco.access_dimension_d_object()( p); - CGAL_optimisation_precondition( + CGAL_precondition( tco.access_dimension_d_object()( p) == d); points.push_back( p); compute_min_annulus(); } @@ -483,10 +483,10 @@ public: template < class InputIterator > void insert( InputIterator first, InputIterator last) - { CGAL_optimisation_precondition_code( std::size_t old_n = points.size()); + { CGAL_precondition_code( std::size_t old_n = points.size()); points.insert( points.end(), first, last); set_dimension(); - CGAL_optimisation_precondition_msg( check_dimension( old_n), + CGAL_precondition_msg( check_dimension( old_n), "Not all points have the same dimension."); compute_min_annulus(); } @@ -645,7 +645,7 @@ private: options.set_pricing_strategy(pricing_strategy(NT())); delete solver; solver = new Solver(lp, options); - CGAL_optimisation_assertion(solver->status() == QP_OPTIMAL); + CGAL_assertion(solver->status() == QP_OPTIMAL); // compute center and squared radius ET sqr_sum = 0; @@ -829,7 +829,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -858,7 +858,7 @@ operator >> ( std::istream& is, CGAL::Min_annulus_d& min_annulus) break; default: - CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); diff --git a/Bounding_volumes/include/CGAL/Min_circle_2.h b/Bounding_volumes/include/CGAL/Min_circle_2.h index 759eb9195ef..ee36071ce21 100644 --- a/Bounding_volumes/include/CGAL/Min_circle_2.h +++ b/Bounding_volumes/include/CGAL/Min_circle_2.h @@ -191,7 +191,7 @@ class Min_circle_2 { const Point& support_point( std::size_t i) const { - CGAL_optimisation_precondition(i < number_of_support_points()); + CGAL_precondition(i < number_of_support_points()); return( support_points[ i]); } // circle @@ -256,7 +256,7 @@ class Min_circle_2 { tco.circle.set( ); break; default: - CGAL_optimisation_assertion( n_support_points <= 3 ); } + CGAL_assertion( n_support_points <= 3 ); } } void @@ -334,7 +334,7 @@ class Min_circle_2 { // initialize circle tco.circle.set(); - CGAL_optimisation_postcondition( is_empty()); + CGAL_postcondition( is_empty()); } // constructor for one point @@ -349,7 +349,7 @@ class Min_circle_2 { support_points[ 0] = p; tco.circle.set( p); - CGAL_optimisation_postcondition( is_degenerate()); + CGAL_postcondition( is_degenerate()); } // constructor for two points diff --git a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterC2.h b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterC2.h index 47d93bb8288..5121c02919c 100644 --- a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterC2.h +++ b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterC2.h @@ -293,7 +293,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -323,7 +323,7 @@ operator >> ( std::istream& is, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterH2.h b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterH2.h index 43b90b757d0..cc5bbbf4164 100644 --- a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterH2.h +++ b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_adapterH2.h @@ -332,7 +332,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -363,7 +363,7 @@ operator >> ( std::istream& is, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_impl.h b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_impl.h index ccb2d79af91..114a59a297a 100644 --- a/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_impl.h +++ b/Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_impl.h @@ -60,7 +60,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -89,7 +89,7 @@ operator >> ( std::istream& is, CGAL::Min_circle_2& min_circle) break; default: - CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); diff --git a/Bounding_volumes/include/CGAL/Min_circle_2/Optimisation_circle_2_impl.h b/Bounding_volumes/include/CGAL/Min_circle_2/Optimisation_circle_2_impl.h index 33cf439dd26..f2e94333b61 100644 --- a/Bounding_volumes/include/CGAL/Min_circle_2/Optimisation_circle_2_impl.h +++ b/Bounding_volumes/include/CGAL/Min_circle_2/Optimisation_circle_2_impl.h @@ -11,7 +11,7 @@ // Author(s) : Sven Schoenherr , Bernd Gaertner // includes -# include +# include namespace CGAL { @@ -42,7 +42,7 @@ operator << ( std::ostream& os, const CGAL::Optimisation_circle_2& c) break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -79,7 +79,7 @@ operator >> ( std::istream& is, CGAL::Optimisation_circle_2& c) break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( is) invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2.h b/Bounding_volumes/include/CGAL/Min_ellipse_2.h index 3421a2de847..b8b35130a50 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2.h @@ -203,7 +203,7 @@ class Min_ellipse_2 { const Point& support_point( std::size_t i) const { - CGAL_optimisation_precondition(i < number_of_support_points()); + CGAL_precondition(i < number_of_support_points()); return( support_points[ i]); } // ellipse @@ -281,7 +281,7 @@ class Min_ellipse_2 { tco.ellipse.set( ); break; default: - CGAL_optimisation_assertion( ( n_support_points >= 0) && + CGAL_assertion( ( n_support_points >= 0) && ( n_support_points <= 5) ); } } @@ -360,7 +360,7 @@ class Min_ellipse_2 { // initialize ellipse tco.ellipse.set(); - CGAL_optimisation_postcondition( is_empty()); + CGAL_postcondition( is_empty()); } inline @@ -373,7 +373,7 @@ class Min_ellipse_2 { // initialize ellipse tco.ellipse.set(); - CGAL_optimisation_postcondition( is_empty()); + CGAL_postcondition( is_empty()); } // constructor for one point @@ -388,7 +388,7 @@ class Min_ellipse_2 { support_points[ 0] = p; tco.ellipse.set( p); - CGAL_optimisation_postcondition( is_degenerate()); + CGAL_postcondition( is_degenerate()); } // constructor for two points @@ -409,7 +409,7 @@ class Min_ellipse_2 { // compute me me( points.end(), 0); - CGAL_optimisation_postcondition( is_degenerate()); + CGAL_postcondition( is_degenerate()); } // constructor for three points diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterC2.h b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterC2.h index e2fad6bc1bb..be22328dfb4 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterC2.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterC2.h @@ -18,7 +18,7 @@ // includes # include -# include +# include namespace CGAL { @@ -235,7 +235,7 @@ class _Min_ellipse_2_adapterC2__Ellipse { int tau_star = c.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) && + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); @@ -298,7 +298,7 @@ class _Min_ellipse_2_adapterC2__Ellipse { || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); @@ -341,7 +341,7 @@ operator << ( std::ostream& os, case CGAL::IO::BINARY: break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -405,7 +405,7 @@ operator >> ( std::istream& is, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterH2.h b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterH2.h index f971e915fc4..22c12492b8d 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterH2.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_adapterH2.h @@ -18,7 +18,7 @@ // includes # include -# include +# include namespace CGAL { @@ -243,7 +243,7 @@ class _Min_ellipse_2_adapterH2__Ellipse { int tau_star = c.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) && + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); @@ -306,7 +306,7 @@ class _Min_ellipse_2_adapterH2__Ellipse { || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); @@ -349,7 +349,7 @@ operator << ( std::ostream& os, case CGAL::IO::BINARY: break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -413,7 +413,7 @@ operator >> ( std::istream& is, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_impl.h b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_impl.h index 708c6644d9c..d7bd821350e 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_impl.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_impl.h @@ -60,7 +60,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -89,7 +89,7 @@ operator >> ( std::istream& is, CGAL::Min_ellipse_2& min_ellipse) break; default: - CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); + CGAL_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2.h b/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2.h index ef343d86c91..54c72de0678 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2.h @@ -17,7 +17,7 @@ #include -#include +#include #include @@ -131,7 +131,7 @@ class Optimisation_ellipse_2 { set( const Point& p, const Point& q) { n_boundary_points = 2; - CGAL_optimisation_precondition(boundary_point1 == p); CGAL_USE(p); + CGAL_precondition(boundary_point1 == p); CGAL_USE(p); boundary_point2 = q; } @@ -139,20 +139,20 @@ class Optimisation_ellipse_2 { set( const Point& p1, const Point& p2, const Point& p3) { n_boundary_points = 3; - CGAL_optimisation_precondition(boundary_point1 == p1); - CGAL_optimisation_precondition(boundary_point2 == p2); + CGAL_precondition(boundary_point1 == p1); + CGAL_precondition(boundary_point2 == p2); boundary_point3 = p3; helper_conic.set_ellipse( p1, p2, p3); - CGAL_optimisation_assertion(helper_conic.is_ellipse()); + CGAL_assertion(helper_conic.is_ellipse()); } void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4) { n_boundary_points = 4; - CGAL_optimisation_precondition(boundary_point1 == p1); - CGAL_optimisation_precondition(boundary_point2 == p2); - CGAL_optimisation_precondition(boundary_point3 == p3); + CGAL_precondition(boundary_point1 == p1); + CGAL_precondition(boundary_point2 == p2); + CGAL_precondition(boundary_point3 == p3); boundary_point4 = p4; Conic::set_two_linepairs( p1, p2, p3, p4, conic1, conic2); @@ -195,7 +195,7 @@ class Optimisation_ellipse_2 { if (!helper_ellipse_set) { helper_ellipse.set_ellipse( conic1, conic2); helper_ellipse.analyse(); - CGAL_optimisation_assertion (helper_ellipse.is_ellipse()); + CGAL_assertion (helper_ellipse.is_ellipse()); helper_ellipse_set= true; } } @@ -211,14 +211,14 @@ class Optimisation_ellipse_2 { // In that case, helper_conic is already correct, // but in general, this optimization is NOT valid. n_boundary_points = 5; - CGAL_optimisation_assertion(helper_conic.is_ellipse()); + CGAL_assertion(helper_conic.is_ellipse()); // the following assertion is too strict if we run under // double (which is sometimes the case, e.g. in demos) - // CGAL_optimisation_assertion(helper_conic.has_on_boundary(p5)); - CGAL_optimisation_precondition(boundary_point1 == p1); - CGAL_optimisation_precondition(boundary_point2 == p2); - CGAL_optimisation_precondition(boundary_point3 == p3); - CGAL_optimisation_precondition(boundary_point4 == p4); + // CGAL_assertion(helper_conic.has_on_boundary(p5)); + CGAL_precondition(boundary_point1 == p1); + CGAL_precondition(boundary_point2 == p2); + CGAL_precondition(boundary_point3 == p3); + CGAL_precondition(boundary_point4 == p4); CGAL_USE(p1); CGAL_USE(p2); CGAL_USE(p3); CGAL_USE(p4); boundary_point5 = p5; } @@ -247,7 +247,7 @@ class Optimisation_ellipse_2 { double &u, double &v, double &w) const { // just like double_conic, but we only get the coefficients - CGAL_optimisation_precondition( ! is_degenerate()); + CGAL_precondition( ! is_degenerate()); if ( n_boundary_points == 4) { set_e_values(); @@ -297,7 +297,7 @@ class Optimisation_ellipse_2 { || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); @@ -343,7 +343,7 @@ class Optimisation_ellipse_2 { helper_conic.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) && + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); @@ -416,7 +416,7 @@ class Optimisation_ellipse_2 { return (CGAL::ZERO == (c.vol_derivative(dr, ds, dt, du, dv, dw))); } default: - CGAL_optimisation_assertion( ( n_boundary_points >= 0) && + CGAL_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); return false; } diff --git a/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2_impl.h b/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2_impl.h index f2b1d2e8e87..4f94bbe4047 100644 --- a/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2_impl.h +++ b/Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2_impl.h @@ -43,7 +43,7 @@ operator << ( std::ostream& os, const CGAL::Optimisation_ellipse_2& e) case CGAL::IO::BINARY: break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } @@ -106,7 +106,7 @@ operator >> ( std::istream& is, CGAL::Optimisation_ellipse_2& e) break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( is) invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_quadrilateral_traits_2.h b/Bounding_volumes/include/CGAL/Min_quadrilateral_traits_2.h index 9fd4c66ec0b..d3ad2595068 100644 --- a/Bounding_volumes/include/CGAL/Min_quadrilateral_traits_2.h +++ b/Bounding_volumes/include/CGAL/Min_quadrilateral_traits_2.h @@ -18,7 +18,7 @@ #include -#include +#include #include #include #include @@ -303,36 +303,36 @@ public: if (assign(tmp, tmpo)) { *o++ = tmp; } else { - CGAL_optimisation_assertion_code(bool test1 =) + CGAL_assertion_code(bool test1 =) assign(tmpl, tmpo); - CGAL_optimisation_assertion(test1); + CGAL_assertion(test1); *o++ = r.p1; } tmpo = isec(line(r.p3, r.d1), line(r.p2, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { - CGAL_optimisation_assertion_code(bool test1 =) + CGAL_assertion_code(bool test1 =) assign(tmpl, tmpo); - CGAL_optimisation_assertion(test1); + CGAL_assertion(test1); *o++ = r.p2; } tmpo = isec(line(r.p3, r.d1), line(r.p4, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { - CGAL_optimisation_assertion_code(bool test1 =) + CGAL_assertion_code(bool test1 =) assign(tmpl, tmpo); - CGAL_optimisation_assertion(test1); + CGAL_assertion(test1); *o++ = r.p3; } tmpo = isec(line(r.p1, r.d1), line(r.p4, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { - CGAL_optimisation_assertion_code(bool test1 =) + CGAL_assertion_code(bool test1 =) assign(tmpl, tmpo); - CGAL_optimisation_assertion(test1); + CGAL_assertion(test1); *o++ = r.p3; } return o; diff --git a/Bounding_volumes/include/CGAL/Min_sphere_d.h b/Bounding_volumes/include/CGAL/Min_sphere_d.h index 96d11c86368..e76b989b39a 100644 --- a/Bounding_volumes/include/CGAL/Min_sphere_d.h +++ b/Bounding_volumes/include/CGAL/Min_sphere_d.h @@ -26,7 +26,7 @@ # include -# include +# include # include @@ -110,7 +110,7 @@ public: #endif if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); - CGAL_optimisation_precondition ((d>=0) && all_points_have_dim(d)); + CGAL_precondition ((d>=0) && all_points_have_dim(d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } @@ -137,7 +137,7 @@ public: #endif if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); - CGAL_optimisation_precondition ((d>=0) && all_points_have_dim(d)); + CGAL_precondition ((d>=0) && all_points_have_dim(d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } @@ -211,13 +211,13 @@ public: Point center () const { - CGAL_optimisation_precondition (!is_empty()); + CGAL_precondition (!is_empty()); return ms_basis.get_sphere(Rep_tag()).center(); } FT squared_radius () const { - CGAL_optimisation_precondition (!is_empty()); + CGAL_precondition (!is_empty()); return ms_basis.get_sphere(Rep_tag()).squared_radius(); } @@ -227,7 +227,7 @@ public: if (d == -1) return ON_UNBOUNDED_SIDE; else { - CGAL_optimisation_precondition + CGAL_precondition (d == tco.access_dimension_d_object()(p)); return (Bounded_side (-CGAL::sign (ms_basis.get_sphere(Rep_tag()).excess (p)))); @@ -239,7 +239,7 @@ public: if (d == -1) return false; else { - CGAL_optimisation_precondition + CGAL_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_negative (ms_basis.get_sphere(Rep_tag()).excess (p))); } @@ -250,7 +250,7 @@ public: if (d == -1) return true; else { - CGAL_optimisation_precondition + CGAL_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_positive (ms_basis.get_sphere(Rep_tag()).excess (p))); } @@ -261,7 +261,7 @@ public: if (d == -1) return false; else { - CGAL_optimisation_precondition + CGAL_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_zero (ms_basis.get_sphere(Rep_tag()).excess (p))); } @@ -296,7 +296,7 @@ public: support_end = points.begin(); if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); - CGAL_optimisation_precondition ((d>=0) && all_points_have_dim (d)); + CGAL_precondition ((d>=0) && all_points_have_dim (d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } else { @@ -310,7 +310,7 @@ public: if (has_on_unbounded_side (p)) { if (is_empty()) { d = tco.access_dimension_d_object() (p); - CGAL_optimisation_precondition (d>=0); + CGAL_precondition (d>=0); ms_basis.get_sphere(Rep_tag()).set_size (d); } // ensure precondition of pivot_ms diff --git a/Bounding_volumes/include/CGAL/Min_sphere_d/Min_sphere_d_impl.h b/Bounding_volumes/include/CGAL/Min_sphere_d/Min_sphere_d_impl.h index 0415adbf47f..17231e575e4 100644 --- a/Bounding_volumes/include/CGAL/Min_sphere_d/Min_sphere_d_impl.h +++ b/Bounding_volumes/include/CGAL/Min_sphere_d/Min_sphere_d_impl.h @@ -62,7 +62,7 @@ operator << ( std::ostream& os, const Min_sphere_d& min_sphere) break; default: - CGAL_optimisation_assertion_msg + CGAL_assertion_msg ( false, "IO::get_mode( os) invalid!"); break; } @@ -93,7 +93,7 @@ operator >> ( std::istream& is, Min_sphere_d& min_sphere) } break; default: - CGAL_optimisation_assertion_msg( false, "IO::mode invalid!"); + CGAL_assertion_msg( false, "IO::mode invalid!"); break; } diff --git a/Bounding_volumes/include/CGAL/Min_sphere_d/Optimisation_sphere_d.h b/Bounding_volumes/include/CGAL/Min_sphere_d/Optimisation_sphere_d.h index 02c554f9610..8e10f2b499c 100644 --- a/Bounding_volumes/include/CGAL/Min_sphere_d/Optimisation_sphere_d.h +++ b/Bounding_volumes/include/CGAL/Min_sphere_d/Optimisation_sphere_d.h @@ -42,7 +42,7 @@ class Optimisation_sphere_d; #include - #include + #include namespace CGAL { @@ -188,7 +188,7 @@ class Optimisation_sphere_d; // compute z FT z = FT_(2)*v_basis[m+1] - prod(v,x,m+1); - CGAL_optimisation_assertion (!CGAL_NTS is_zero (z)); + CGAL_assertion (!CGAL_NTS is_zero (z)); FT inv_z = FT_(1)/z; // set up A^{-1}_{B^m} @@ -461,7 +461,7 @@ class Optimisation_sphere_d; // compute \tilde{z} RT old_denom = denom[m-1]; RT z = old_denom*RT_(2)*sqr_q_m - prod(v,x,m+1); - CGAL_optimisation_assertion (!CGAL_NTS is_zero (z)); + CGAL_assertion (!CGAL_NTS is_zero (z)); // set up \tilde{A}^{-1}_{B^m} RT** M = inv[m-1]; // \tilde{A}^{-1}_B, old matrix @@ -503,7 +503,7 @@ class Optimisation_sphere_d; // get h_p RT h_p = *(i++); - CGAL_optimisation_precondition (!CGAL_NTS is_zero (h_p)); + CGAL_precondition (!CGAL_NTS is_zero (h_p)); // compute (h_p h D)^2 (c-p)^2 RT sqr_dist(RT(0)); diff --git a/Bounding_volumes/include/CGAL/Rectangular_p_center_traits_2.h b/Bounding_volumes/include/CGAL/Rectangular_p_center_traits_2.h index bc93c75bf74..d096b37c88f 100644 --- a/Bounding_volumes/include/CGAL/Rectangular_p_center_traits_2.h +++ b/Bounding_volumes/include/CGAL/Rectangular_p_center_traits_2.h @@ -20,7 +20,7 @@ #include #include #include -#include +#include namespace CGAL { @@ -228,21 +228,21 @@ struct Rectangular_p_center_matrix_search_traits_2 { bool operator()(FT v) { - CGAL_optimisation_assertion(ld.size() == ld_size); + CGAL_assertion(ld.size() == ld_size); ld.r = v / FT(2); bool ok; pf(ld, Wastebasket< Point_2 >(), ok); - CGAL_optimisation_assertion(ld.size() == ld_size); + CGAL_assertion(ld.size() == ld_size); return ok; } template < class OutputIterator > OutputIterator operator()(FT v, OutputIterator o, bool& ok) { - CGAL_optimisation_assertion(ld.size() == ld_size); + CGAL_assertion(ld.size() == ld_size); ld.r = v / FT(2); OutputIterator n = pf(ld, o, ok); - CGAL_optimisation_assertion(ld.size() == ld_size); + CGAL_assertion(ld.size() == ld_size); return n; //pf(ld, o, ok); } @@ -250,7 +250,7 @@ protected: // data members: LD ld; PiercingFunction pf; - CGAL_optimisation_assertion_code(typename LD::size_type ld_size;) + CGAL_assertion_code(typename LD::size_type ld_size;) // copying this would be too inefficient Rectangular_p_center_matrix_search_traits_2( diff --git a/Bounding_volumes/include/CGAL/min_quadrilateral_2.h b/Bounding_volumes/include/CGAL/min_quadrilateral_2.h index dfa0eb1e30c..081520c0846 100644 --- a/Bounding_volumes/include/CGAL/min_quadrilateral_2.h +++ b/Bounding_volumes/include/CGAL/min_quadrilateral_2.h @@ -18,7 +18,7 @@ #include -#include +#include #include #include @@ -346,8 +346,8 @@ min_rectangle_2( { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); - CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition(is_convex_2(f, l, t)); + CGAL_expensive_precondition( orientation_2(f, l, t) == COUNTERCLOCKWISE); // check for trivial cases @@ -395,7 +395,7 @@ min_rectangle_2( int yet_to_finish = 0; for (int i1 = 0; i1 < 4; ++i1) { - CGAL_optimisation_assertion(limit[i1] != l); + CGAL_assertion(limit[i1] != l); if (curr[i1] != limit[i1]) ++yet_to_finish; } @@ -448,7 +448,7 @@ min_parallelogram_2(ForwardIterator f, { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); - CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); + CGAL_expensive_precondition(is_convex_2(f, l, t)); // types from the traits class typedef typename Traits::Direction_2 Direction_2; @@ -630,7 +630,7 @@ min_strip_2(ForwardIterator f, { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); - CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); + CGAL_expensive_precondition(is_convex_2(f, l, t)); // types from the traits class typedef typename Traits::Direction_2 Direction_2; diff --git a/Bounding_volumes/include/CGAL/pierce_rectangles_2.h b/Bounding_volumes/include/CGAL/pierce_rectangles_2.h index ebaf8081e1c..8a7f3560a38 100644 --- a/Bounding_volumes/include/CGAL/pierce_rectangles_2.h +++ b/Bounding_volumes/include/CGAL/pierce_rectangles_2.h @@ -16,7 +16,7 @@ #include -#include +#include #include #include #include @@ -75,7 +75,7 @@ struct Loc_domain { void update(int j, Citerator i) { - CGAL_optimisation_precondition(j >= 0 && j < 4); + CGAL_precondition(j >= 0 && j < 4); if (j < 2) if (j == 0) { if (traits.less_x_2_object()(*i, minx)) minx = *i; @@ -106,9 +106,9 @@ struct Loc_domain { maxy(pts.front()), traits(t) { - CGAL_optimisation_precondition(b != e); + CGAL_precondition(b != e); Iterator i = pts.begin(); - CGAL_optimisation_assertion(i != pts.end()); + CGAL_assertion(i != pts.end()); while (++i != pts.end()) { if (traits.less_x_2_object()(*i, minx)) minx = *i; if (traits.less_x_2_object()(maxx, *i)) maxx = *i; @@ -124,7 +124,7 @@ struct Loc_domain { operator[](int i) const // return corner points (0 <-> bottom-left, 1 <-> bottom-right) { - CGAL_optimisation_precondition(i >= 0 && i < 4); + CGAL_precondition(i >= 0 && i < 4); if (i == 0) return traits.construct_point_2_above_right_implicit_point_2_object()( minx, miny, r); @@ -142,7 +142,7 @@ struct Loc_domain { extreme(int i) const // return extreme points (0 <-> left, 1 <-> bottom) { - CGAL_optimisation_precondition(i >= 0 && i < 4); + CGAL_precondition(i >= 0 && i < 4); if (i > 1) return i == 2 ? maxx : maxy; return i == 0 ? minx : miny; } @@ -151,7 +151,7 @@ struct Loc_domain { extreme(int i) // return extreme points (0 <-> left, 1 <-> bottom) { - CGAL_optimisation_precondition(i >= 0 && i < 4); + CGAL_precondition(i >= 0 && i < 4); if (i > 1) return i == 2 ? maxx : maxy; return i == 0 ? minx : miny; } @@ -177,13 +177,13 @@ struct Loc_domain { void check() const { - CGAL_optimisation_expensive_assertion_code( + CGAL_expensive_assertion_code( Iterator i = pts.begin(); do { - CGAL_optimisation_assertion(!traits.less_x_2_object()(*i, minx)); - CGAL_optimisation_assertion(!traits.less_x_2_object()(maxx, *i)); - CGAL_optimisation_assertion(!traits.less_y_2_object()(*i, miny)); - CGAL_optimisation_assertion(!traits.less_y_2_object()(maxy, *i)); + CGAL_assertion(!traits.less_x_2_object()(*i, minx)); + CGAL_assertion(!traits.less_x_2_object()(maxx, *i)); + CGAL_assertion(!traits.less_y_2_object()(*i, miny)); + CGAL_assertion(!traits.less_y_2_object()(maxy, *i)); } while (++i != end); ) } @@ -463,7 +463,7 @@ inline OutputIterator two_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { - CGAL_optimisation_precondition(f != l); + CGAL_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); @@ -475,7 +475,7 @@ inline OutputIterator three_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { - CGAL_optimisation_precondition(f != l); + CGAL_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); @@ -487,7 +487,7 @@ inline OutputIterator four_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { - CGAL_optimisation_precondition(f != l); + CGAL_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); @@ -562,7 +562,7 @@ three_cover_points( using std::less; using std::iter_swap; - CGAL_optimisation_precondition(!d.empty()); + CGAL_precondition(!d.empty()); // typedefs: typedef typename Traits::Point_2 Point_2; @@ -583,7 +583,7 @@ three_cover_points( // are all points already covered? if (i == d.end()) { - CGAL_optimisation_assertion(k == 0); + CGAL_assertion(k == 0); *o++ = d[0]; ok = true; return o; @@ -620,11 +620,11 @@ three_cover_points( // check disjoint for two-pierceability: - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( save_end == find_if(d.end(), save_end, [&d, &dist, &corner](const Point_2& p) { return d.r < dist(corner, p); })); - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( d.end() == find_if(d.begin(), d.end(), [&d,&dist, &corner](const Point_2& p) { return d.r >= dist(corner, p); })); @@ -721,7 +721,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok) // are all points already covered? if (i == d.end()) { - CGAL_optimisation_assertion(k == 0); + CGAL_assertion(k == 0); *o++ = d[0]; ok = true; return o; @@ -758,11 +758,11 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok) // check disjoint for two-pierceability: - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( save_end == find_if(d.end(), save_end, [&d,&dist,&corner](const Point_2& p) { return d.r < dist(corner, p); })); - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( d.end() == find_if(d.begin(), d.end(), [&d,&dist,&corner](const Point_2& p) { return d.r >= dist(corner, p); })); diff --git a/Bounding_volumes/include/CGAL/rectangular_3_center_2.h b/Bounding_volumes/include/CGAL/rectangular_3_center_2.h index cd3a1f14bee..a75118764b7 100644 --- a/Bounding_volumes/include/CGAL/rectangular_3_center_2.h +++ b/Bounding_volumes/include/CGAL/rectangular_3_center_2.h @@ -17,7 +17,7 @@ #include -#include +#include #include #include #include @@ -965,7 +965,7 @@ rectangular_3_center_2_type2( (Q_r_empty || op.compute_y_distance(q_r, Q_r) <= op.delta()(*m))) { boost::function1 greater_delta_m = boost::bind(less< FT >(), op.delta()(*m)); - CGAL_optimisation_assertion_code(RandomAccessIterator iii =) + CGAL_assertion_code(RandomAccessIterator iii =) find_if(e, l, boost::bind(logical_and< bool >(), @@ -973,7 +973,7 @@ rectangular_3_center_2_type2( boost::bind(op.distance(), q_t, _1)), boost::bind(greater_delta_m, boost::bind(op.distance(), q_r, _1)))); - CGAL_optimisation_assertion(iii == l); + CGAL_assertion(iii == l); } // check whether the points in [f,s) are covered { @@ -985,7 +985,7 @@ rectangular_3_center_2_type2( boost::bind(le_delta_m, boost::bind(op.distance(), q_t, _1))); iii = partition(iii, s, boost::bind(le_delta_m, boost::bind(op.distance(), q_r, _1))); - CGAL_optimisation_assertion(iii == s); + CGAL_assertion(iii == s); } #endif // CGAL_3COVER_CHECK @@ -1052,7 +1052,7 @@ rectangular_3_center_2_type2( } // step (e) [not enough points in G] - CGAL_optimisation_assertion(b1 - (m + 1) >= 5 * cutoff); + CGAL_assertion(b1 - (m + 1) >= 5 * cutoff); // compute the four cutting lines for R std::nth_element(m + 1, m + 1 + cutoff, b1, less_x_2); @@ -1113,7 +1113,7 @@ rectangular_3_center_2_type2( // now s_b corresponds to the first moment in [s, m+1) // where q_t and q_r cover B - CGAL_optimisation_assertion_code(bool loopcheck = false;) + CGAL_assertion_code(bool loopcheck = false;) CGAL_3CENTER_REPEAT_CHECK: // place q_t and q_r q_t = op.place_x_square(q_t_afap, r, op.delta()(*s_b)); @@ -1142,9 +1142,9 @@ CGAL_3CENTER_REPEAT_CHECK: // in degenerate situations it can happen that the number of // points in R is too small => decrease radius and check again --s_b; - CGAL_optimisation_assertion(!loopcheck); - CGAL_optimisation_assertion(s != s_b); - CGAL_optimisation_assertion_code(loopcheck = true;) + CGAL_assertion(!loopcheck); + CGAL_assertion(s != s_b); + CGAL_assertion_code(loopcheck = true;) goto CGAL_3CENTER_REPEAT_CHECK; } s = b1; @@ -1166,7 +1166,7 @@ CGAL_3CENTER_REPEAT_CHECK: // we still have a covering if (s_b == s) { - CGAL_optimisation_expensive_assertion_code( + CGAL_expensive_assertion_code( std::vector< Point > tmppts(f, l); RandomAccessIterator ii = partition(tmppts.begin(), tmppts.end(), @@ -1174,9 +1174,9 @@ CGAL_3CENTER_REPEAT_CHECK: IP tmppos = min_max_element(ii, tmppts.end(), op.compare_x(), op.compare_y()); ) - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( !op.compare_x()(*tmppos.first, q_t)); - CGAL_optimisation_expensive_assertion( + CGAL_expensive_assertion( !op.compare_y()(q_r, *tmppos.second)); // we are done @@ -1219,7 +1219,7 @@ CGAL_3CENTER_REPEAT_CHECK: [&op, s_b](const Point& p){ return op.delta()(*s_b) != op.delta()(p); }); rho_max = op.delta()(*s_b); q_t_at_rho_max = q_t, q_r_at_rho_max = q_r; - CGAL_optimisation_assertion(op.delta()(*next) < op.delta()(*s_b)); + CGAL_assertion(op.delta()(*next) < op.delta()(*s_b)); q_t_afap = op.update_x_square(q_t_afap, *s_b); q_r_afap = op.update_y_square(q_r_afap, *s_b); q_t = op.place_x_square(q_t_afap, r, op.delta()(*next)); @@ -1255,7 +1255,7 @@ CGAL_3CENTER_REPEAT_CHECK: } - CGAL_optimisation_assertion(b3 - b1 >= cutoff); + CGAL_assertion(b3 - b1 >= cutoff); e = b1; // adjust Q_t if (b1 != b2) { @@ -1299,7 +1299,7 @@ CGAL_3CENTER_REPEAT_CHECK: rho_max = max BOOST_PREVENT_MACRO_SUBSTITUTION (op.compute_x_distance(q_t, Q_t), op.compute_y_distance(q_r, Q_r)); #ifndef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST - CGAL_optimisation_assertion(rho_max <= rad); + CGAL_assertion(rho_max <= rad); #endif // ! CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rad = rho_max; *o++ = op.construct_corner_square(r, rad / FT(2)); @@ -1307,7 +1307,7 @@ CGAL_3CENTER_REPEAT_CHECK: *o++ = op.construct_y_square(q_r, rad / FT(2)); return o; } - CGAL_optimisation_assertion(s != e); + CGAL_assertion(s != e); // find the first diameter where covering is possible for (;;) { @@ -1324,7 +1324,7 @@ CGAL_3CENTER_REPEAT_CHECK: // try the next possible diameter value FT try_rho = op.delta()(*t); - CGAL_optimisation_assertion(t == s || try_rho < rho_max); + CGAL_assertion(t == s || try_rho < rho_max); q_t = op.place_x_square(q_t_afap, r, try_rho); q_r = op.place_y_square(q_r_afap, r, try_rho); @@ -1370,8 +1370,8 @@ CGAL_3CENTER_REPEAT_CHECK: // - q_r_at_rho_max is the corr. position of q_r. // try rho_min - CGAL_optimisation_assertion(rho_min <= rho_max); - CGAL_optimisation_assertion(rho_min >= 0); + CGAL_assertion(rho_min <= rho_max); + CGAL_assertion(rho_min >= 0); FT rad_2 = q_t_q_r_cover_at_rho_min; if (s_at_rho_min != e_at_rho_min) { auto mydist = [&q_t_at_rho_min, &q_r_at_rho_min, &op](const Point& p) @@ -1384,7 +1384,7 @@ CGAL_3CENTER_REPEAT_CHECK: [&mydist](const Point& p1, const Point& p2) { return mydist(p1) < mydist(p2); }))); } - CGAL_optimisation_assertion(rad_2 == 0 || rad_2 > rho_min); + CGAL_assertion(rad_2 == 0 || rad_2 > rho_min); // if a covering with rho == 0 is possible, // it will be catched in the type1 functions @@ -1397,7 +1397,7 @@ CGAL_3CENTER_REPEAT_CHECK: q_t = q_t_at_rho_min, q_r = q_r_at_rho_min; #ifndef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST - CGAL_optimisation_assertion(rad_2 <= rad); + CGAL_assertion(rad_2 <= rad); #endif // ! CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rad = rad_2; *o++ = op.construct_corner_square(r, rad / FT(2)); @@ -1414,7 +1414,7 @@ rectangular_3_center_2( typename Traits::FT& r, Traits& t) { - CGAL_optimisation_precondition(f != l); + CGAL_precondition(f != l); typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point; typedef typename Traits::Iso_rectangle_2 Rectangle; diff --git a/Bounding_volumes/include/CGAL/rectangular_p_center_2.h b/Bounding_volumes/include/CGAL/rectangular_p_center_2.h index 1d680e9572f..78ec4b6e9cb 100644 --- a/Bounding_volumes/include/CGAL/rectangular_p_center_2.h +++ b/Bounding_volumes/include/CGAL/rectangular_p_center_2.h @@ -72,8 +72,8 @@ public: Value operator()( int r, int c) const { - CGAL_optimisation_precondition( r >= 0 && r < number_of_rows()); - CGAL_optimisation_precondition( c >= 0 && c < number_of_columns()); + CGAL_precondition( r >= 0 && r < number_of_rows()); + CGAL_precondition( c >= 0 && c < number_of_columns()); return Base::operator()( r, number_of_columns() - 1 - c); } }; @@ -145,7 +145,7 @@ rectangular_p_center_2_binary_search( // -------------- // { - CGAL_optimisation_precondition( f != l); + CGAL_precondition( f != l); // typedefs: typedef typename Traits::FT FT; @@ -171,7 +171,7 @@ rectangular_p_center_2_binary_search( c_diffs.push_back( CGAL_NTS abs( i->x() - j->x())); c_diffs.push_back( CGAL_NTS abs( i->y() - j->y())); } - CGAL_optimisation_assertion( + CGAL_assertion( c_diffs.size() == pierce_it.number_of_points() * (pierce_it.number_of_points() - 1)); @@ -195,12 +195,12 @@ rectangular_p_center_2_binary_search( b = c + 1; } } // while ( e > b) - CGAL_optimisation_assertion( e == b); + CGAL_assertion( e == b); // return the result: r = c_diffs[e]; OutputIterator o_return( pierce_it( r, o, ok)); - CGAL_optimisation_assertion( ok); + CGAL_assertion( ok); return o_return; } // rectangular_p_center_2_binary_search( ... ) @@ -221,7 +221,7 @@ rectangular_p_center_2_matrix_search( const MatrixOperator& mop) { std::size_t number_of_points( iterator_distance( f, l)); - CGAL_optimisation_precondition( number_of_points > 0); + CGAL_precondition( number_of_points > 0); using std::minus; using std::sort; @@ -296,7 +296,7 @@ rectangular_p_center_2_matrix_search( // return result: OutputIterator o_return(pierce_it(r, o, ok)); - CGAL_optimisation_assertion(ok); + CGAL_assertion(ok); return o_return; } // P_center_matrix_search @@ -341,7 +341,7 @@ rectangular_p_center_matrix_search_2( FT& r, int p) { - CGAL_optimisation_precondition(p >= 2 && p < 5); + CGAL_precondition(p >= 2 && p < 5); typename std::iterator_traits::value_type::R t; if (p == 2) return rectangular_p_center_2_matrix_search( @@ -401,7 +401,7 @@ rectangular_p_center_2(ForwardIterator f, int p, Traits& t) { - CGAL_optimisation_precondition(p >= 2 && p < 5); + CGAL_precondition(p >= 2 && p < 5); r=0; if ( !internal::is_distance_greater_than_p(f,l,p) ) return std::copy(f,l,o); @@ -422,7 +422,7 @@ rectangular_p_center_2(ForwardIterator f, FT& r, int p) { - CGAL_optimisation_precondition(p >= 2 && p < 5); + CGAL_precondition(p >= 2 && p < 5); typedef typename std::iterator_traits< ForwardIterator >::value_type::R R; Rectangular_p_center_default_traits_2< R > t; diff --git a/Inscribed_areas/include/CGAL/Extremal_polygon_traits_2.h b/Inscribed_areas/include/CGAL/Extremal_polygon_traits_2.h index a85e9a76f47..9c4cb0a113f 100644 --- a/Inscribed_areas/include/CGAL/Extremal_polygon_traits_2.h +++ b/Inscribed_areas/include/CGAL/Extremal_polygon_traits_2.h @@ -16,7 +16,7 @@ #include -#include +#include #include #include #include @@ -83,7 +83,7 @@ struct Extremal_polygon_area_traits_2 { int number_of_points( static_cast(iterator_distance( points_begin, points_end))); - CGAL_optimisation_precondition( number_of_points > min_k()); + CGAL_precondition( number_of_points > min_k()); // this gives the area of the triangle of two points with // the root: @@ -136,7 +136,7 @@ protected: }; } //namespace CGAL -#include + #include #ifdef CGAL_USE_LEDA #include @@ -221,11 +221,11 @@ struct Extremal_polygon_perimeter_traits_2 { using std::less; using std::max_element; - CGAL_optimisation_precondition_code( + CGAL_precondition_code( int number_of_points( static_cast(iterator_distance( points_begin, points_end)));) - CGAL_optimisation_precondition( number_of_points > min_k()); + CGAL_precondition( number_of_points > min_k()); // kind of messy, but first we have to have something // like Distance (function object) ... diff --git a/Inscribed_areas/include/CGAL/extremal_polygon_2.h b/Inscribed_areas/include/CGAL/extremal_polygon_2.h index 2cd09fdd7c0..e1543637f53 100644 --- a/Inscribed_areas/include/CGAL/extremal_polygon_2.h +++ b/Inscribed_areas/include/CGAL/extremal_polygon_2.h @@ -16,7 +16,7 @@ #include -#include +#include #include #include #include @@ -76,7 +76,7 @@ public: RandomAccessIC_object begin_col, RandomAccessIC_object end_col, RandomAccessIC_value begin_value, - RandomAccessIC_value CGAL_optimisation_precondition_code(end_value), + RandomAccessIC_value CGAL_precondition_code(end_value), const Operation& o) // initialization with two ranges [begin_row, end_row) and // [begin_col, end_col) of Objects, a range [begin_value, end_value) @@ -92,9 +92,9 @@ public: n_rows( static_cast(iterator_distance( begin_row, end_row))), n_cols( static_cast(iterator_distance( begin_col, end_col))) { - CGAL_optimisation_precondition( + CGAL_precondition( iterator_distance( begin_value, end_value) == n_cols); - CGAL_optimisation_assertion( n_rows > 0 && n_cols > 0); + CGAL_assertion( n_rows > 0 && n_cols > 0); } int @@ -108,8 +108,8 @@ public: Value operator()( int r, int c) const { - CGAL_optimisation_precondition( r >= 0 && r < n_rows); - CGAL_optimisation_precondition( c >= 0 && c < n_cols); + CGAL_precondition( r >= 0 && r < n_rows); + CGAL_precondition( c >= 0 && c < n_cols); return begin_value_[c] + op( begin_row_[r], begin_col_[c]); } @@ -181,11 +181,11 @@ CGAL_maximum_inscribed_rooted_k_gon_2( // returns the past-the-end iterator of that sequence. { // check preconditions: - CGAL_optimisation_precondition( k >= t.min_k()); + CGAL_precondition( k >= t.min_k()); int number_of_points( static_cast(iterator_distance( points_begin, points_end))); - CGAL_optimisation_precondition( number_of_points > k); + CGAL_precondition( number_of_points > k); typedef std::vector< int > Index_cont; @@ -203,7 +203,7 @@ CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, max_area, gon.rbegin() + k + 1 - i); for (;;) { - CGAL_optimisation_assertion( gon[0] == 0); + CGAL_assertion( gon[0] == 0); gon[i] = number_of_points - 1; if ( ++i >= k) break; @@ -243,7 +243,7 @@ CGAL_maximum_inscribed_rooted_k_gon_2( RandomAccessIC_point points_end, int root, RandomAccessIC_int left_c_begin, - RandomAccessIC_int CGAL_optimisation_precondition_code(left_c_end), + RandomAccessIC_int CGAL_precondition_code(left_c_end), RandomAccessIC_int right_c_begin, RandomAccessIC_int right_c_end, typename Traits::FT& max_area, @@ -294,26 +294,26 @@ CGAL_maximum_inscribed_rooted_k_gon_2( right_c_end)); // check preconditions: - CGAL_optimisation_precondition( number_of_points > t.min_k()); - CGAL_optimisation_precondition( size_of_gon >= t.min_k() - 1); - CGAL_optimisation_precondition( + CGAL_precondition( number_of_points > t.min_k()); + CGAL_precondition( size_of_gon >= t.min_k() - 1); + CGAL_precondition( iterator_distance( left_c_begin, left_c_end) == iterator_distance( right_c_begin, right_c_end)); - CGAL_optimisation_precondition( left_c_begin[0] >= 0); - CGAL_optimisation_precondition( right_c_begin[0] >= 0); - CGAL_optimisation_precondition( + CGAL_precondition( left_c_begin[0] >= 0); + CGAL_precondition( right_c_begin[0] >= 0); + CGAL_precondition( left_c_begin[size_of_gon-1] < number_of_points); - CGAL_optimisation_precondition( + CGAL_precondition( right_c_begin[size_of_gon-1] < number_of_points); - CGAL_optimisation_expensive_precondition_code( + CGAL_expensive_precondition_code( for ( i = 0; i < size_of_gon; ++i) { - CGAL_optimisation_expensive_precondition( left_c_begin[i] >= 0); - CGAL_optimisation_expensive_precondition( right_c_begin[i] >= 0); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( left_c_begin[i] >= 0); + CGAL_expensive_precondition( right_c_begin[i] >= 0); + CGAL_expensive_precondition( left_c_begin[i] < number_of_points); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( right_c_begin[i] < number_of_points); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( left_c_begin[i] <= right_c_begin[i]); }) @@ -426,12 +426,12 @@ extremal_polygon_2( // returns the past-the-end iterator of that sequence. { // check preconditions: - CGAL_optimisation_precondition_code( + CGAL_precondition_code( int number_of_points( static_cast(iterator_distance( points_begin, points_end)));) - CGAL_optimisation_precondition( number_of_points >= t.min_k()); - CGAL_optimisation_expensive_precondition( + CGAL_precondition( number_of_points >= t.min_k()); + CGAL_expensive_precondition( is_convex_2( points_begin, points_end, t)); typedef typename Traits::Point_2 Point_2; @@ -491,11 +491,11 @@ CGAL_maximum_inscribed_k_gon_2( // returns the past-the-end iterator of that sequence. { // check preconditions: - CGAL_optimisation_precondition( k >= t.min_k()); + CGAL_precondition( k >= t.min_k()); int number_of_points( static_cast(iterator_distance( points_begin, points_end))); - CGAL_optimisation_precondition( number_of_points > 0); + CGAL_precondition( number_of_points > 0); using std::copy; @@ -518,7 +518,7 @@ CGAL_maximum_inscribed_k_gon_2( P_0.rbegin() + 1, t); P_0[k] = number_of_points - 1; - CGAL_optimisation_assertion( P_0[0] == 0); + CGAL_assertion( P_0[0] == 0); // compute k-gon rooted at points_begin[P_0[1]] Index_cont P_1( k); FT area_1; @@ -535,7 +535,7 @@ CGAL_maximum_inscribed_k_gon_2( P_1.rbegin(), t); - CGAL_optimisation_assertion( P_1[0] == P_0[1]); + CGAL_assertion( P_1[0] == P_0[1]); // start recursive computation: @@ -630,29 +630,29 @@ CGAL_maximum_inscribed_k_gon_2( using std::copy; // check preconditions: - CGAL_optimisation_precondition( k >= t.min_k()); - CGAL_optimisation_precondition( left_index <= right_index); - CGAL_optimisation_precondition( left_index >= 0); - CGAL_optimisation_precondition( right_index >= 0); - CGAL_optimisation_precondition_code( + CGAL_precondition( k >= t.min_k()); + CGAL_precondition( left_index <= right_index); + CGAL_precondition( left_index >= 0); + CGAL_precondition( right_index >= 0); + CGAL_precondition_code( int number_of_points( static_cast(iterator_distance( points_begin, points_end)));) - CGAL_optimisation_precondition( left_index < number_of_points); - CGAL_optimisation_precondition( right_index < number_of_points); - CGAL_optimisation_precondition( + CGAL_precondition( left_index < number_of_points); + CGAL_precondition( right_index < number_of_points); + CGAL_precondition( iterator_distance( left_c_begin, left_c_end) == k - 1); - CGAL_optimisation_precondition( + CGAL_precondition( iterator_distance( right_c_begin, right_c_end) == k - 1); - CGAL_optimisation_expensive_precondition_code( + CGAL_expensive_precondition_code( for ( int i( 0); i < k - 1; ++i) { - CGAL_optimisation_expensive_precondition( left_c_begin[i] >= 0); - CGAL_optimisation_expensive_precondition( right_c_begin[i] >= 0); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( left_c_begin[i] >= 0); + CGAL_expensive_precondition( right_c_begin[i] >= 0); + CGAL_expensive_precondition( left_c_begin[i] < number_of_points); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( right_c_begin[i] < number_of_points); - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( left_c_begin[i] <= right_c_begin[i]); }) @@ -671,7 +671,7 @@ CGAL_maximum_inscribed_k_gon_2( area_middle, P_m.rbegin(), t); - CGAL_optimisation_assertion( P_m[0] == middle_index); + CGAL_assertion( P_m[0] == middle_index); // left recursive branch: FT area_left( 0); Index_cont P_l( k); diff --git a/Matrix_search/include/CGAL/Cartesian_matrix.h b/Matrix_search/include/CGAL/Cartesian_matrix.h index d3ad276a715..1aa192ab2c8 100644 --- a/Matrix_search/include/CGAL/Cartesian_matrix.h +++ b/Matrix_search/include/CGAL/Cartesian_matrix.h @@ -17,7 +17,7 @@ #include -#include +#include #include namespace CGAL { @@ -67,8 +67,8 @@ public: Value operator()(int r, int c) const { - CGAL_optimisation_precondition(r >= 0 && r < number_of_rows()); - CGAL_optimisation_precondition(c >= 0 && c < number_of_columns()); + CGAL_precondition(r >= 0 && r < number_of_rows()); + CGAL_precondition(c >= 0 && c < number_of_columns()); return op(row_vec[r], column_vec[c]); } diff --git a/Matrix_search/include/CGAL/Dynamic_matrix.h b/Matrix_search/include/CGAL/Dynamic_matrix.h index 83b9063cf3e..2ae86317ebb 100644 --- a/Matrix_search/include/CGAL/Dynamic_matrix.h +++ b/Matrix_search/include/CGAL/Dynamic_matrix.h @@ -18,7 +18,7 @@ #include #include -#include +#include namespace CGAL { @@ -56,8 +56,8 @@ public: Value operator()( int r, int c) const { - CGAL_optimisation_precondition( r >= 0 && r < number_of_rows()); - CGAL_optimisation_precondition( c >= 0 && c < number_of_columns()); + CGAL_precondition( r >= 0 && r < number_of_rows()); + CGAL_precondition( c >= 0 && c < number_of_columns()); return (*matrix)( r << row_power, column_indices[c]); } @@ -70,18 +70,18 @@ public: void replace_column( int o, int n) { - CGAL_optimisation_precondition( o >= 0 && o < number_of_columns()); - CGAL_optimisation_precondition( n >= 0 && n < number_of_columns()); + CGAL_precondition( o >= 0 && o < number_of_columns()); + CGAL_precondition( n >= 0 && n < number_of_columns()); column_indices[o] = column_indices[n]; } void shrink_to_quadratic_size() { - CGAL_optimisation_precondition( number_of_columns() >= number_of_rows()); + CGAL_precondition( number_of_columns() >= number_of_rows()); column_indices.erase( column_indices.begin() + number_of_rows(), column_indices.end()); - CGAL_optimisation_postcondition( number_of_columns() == number_of_rows()); + CGAL_postcondition( number_of_columns() == number_of_rows()); } private: diff --git a/Matrix_search/include/CGAL/Transform_iterator.h b/Matrix_search/include/CGAL/Transform_iterator.h index c3ab6e8c437..18d4f9986ab 100644 --- a/Matrix_search/include/CGAL/Transform_iterator.h +++ b/Matrix_search/include/CGAL/Transform_iterator.h @@ -16,7 +16,6 @@ #include -#include #include #include diff --git a/Matrix_search/include/CGAL/monotone_matrix_search.h b/Matrix_search/include/CGAL/monotone_matrix_search.h index 4f527634e70..ae1bd6f4ce9 100644 --- a/Matrix_search/include/CGAL/monotone_matrix_search.h +++ b/Matrix_search/include/CGAL/monotone_matrix_search.h @@ -16,7 +16,7 @@ #include -#include +#include #include #include @@ -57,9 +57,9 @@ monotone_matrix_search( // ------ // get even rows of M: Matrix* M_new = M.extract_all_even_rows(); - CGAL_optimisation_assertion( + CGAL_assertion( M_new->number_of_columns() == M.number_of_columns()); - CGAL_optimisation_assertion( + CGAL_assertion( M_new->number_of_rows() == 0 || M_new->number_of_rows() == ( M.number_of_rows() + 1) >> 1); @@ -75,7 +75,7 @@ monotone_matrix_search( reduction_table[M_new->number_of_rows()] = M.number_of_columns() - 1; _reduce_matrix( *M_new, reduction_table, compare_strictly); - CGAL_optimisation_assertion( + CGAL_assertion( M_new->number_of_columns() == M_new->number_of_rows()); } // if ( M_new->number_of_rows() < M_new->number_of_columns()) @@ -92,7 +92,7 @@ monotone_matrix_search( // recursion: - CGAL_optimisation_assertion( + CGAL_assertion( M_new->number_of_rows() >= M_new->number_of_columns()); // table to store the rmax values of M_new: @@ -160,7 +160,7 @@ _reduce_matrix( // and returns for each column of the resulting // matrix its column index in the original matrix { - CGAL_optimisation_precondition( + CGAL_precondition( M.number_of_columns() >= M.number_of_rows()); // active columns are 0, ..., j1, j2, ..., M.x_dim()-1 int j1( 0), j2( 1); @@ -191,7 +191,7 @@ _reduce_matrix( // have been deleted, now move columns // j2 .. M.number_of_columns()-1 to the first part while ( j1 < M.number_of_rows() - 1) { - CGAL_optimisation_assertion( j2 < M.number_of_columns()); + CGAL_assertion( j2 < M.number_of_columns()); M.replace_column( ++j1, j2); *(t+j1) = j2++; } diff --git a/Matrix_search/include/CGAL/sorted_matrix_search.h b/Matrix_search/include/CGAL/sorted_matrix_search.h index dd21234b4f5..d481ce8c07a 100644 --- a/Matrix_search/include/CGAL/sorted_matrix_search.h +++ b/Matrix_search/include/CGAL/sorted_matrix_search.h @@ -17,7 +17,7 @@ #include -#include +#include #include #include #include @@ -159,13 +159,13 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t) Cell_container active_cells; // set of input matrices must not be empty: - CGAL_optimisation_precondition( f != l); + CGAL_precondition( f != l); // for each input matrix insert a cell into active_cells: InputIterator i( f); int maxdim( -1); while ( i != l) { - CGAL_optimisation_expensive_precondition( + CGAL_expensive_precondition( PaddedMatrix( *i).is_sorted()); active_cells.push_back( Cell( PaddedMatrix( *i))); maxdim = max BOOST_PREVENT_MACRO_SUBSTITUTION ( max BOOST_PREVENT_MACRO_SUBSTITUTION ( (*i).number_of_columns(), @@ -173,7 +173,7 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t) maxdim); ++i; } - CGAL_optimisation_precondition( maxdim > 0); + CGAL_precondition( maxdim > 0); // current cell dimension: @@ -239,7 +239,7 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t) break; // there has to be at least one cell left: - CGAL_optimisation_assertion( active_cells.size() > 0); + CGAL_assertion( active_cells.size() > 0); // ------------------------------------------------------ // compute medians of smallest and largest elements: @@ -285,7 +285,7 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t) { return equal_to< Value >()(lower_median, Cell_min< Cell >()(c)); }); - CGAL_optimisation_assertion(lower_median_cell != active_cells.end()); + CGAL_assertion(lower_median_cell != active_cells.end()); // ------------------------------------------------------ // test feasibility of medians and remove cells accordingly: Cell_iterator new_end; @@ -385,8 +385,8 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t) } // for (;;) // there must be only one cell left: - CGAL_optimisation_assertion( active_cells.size() == 1); - CGAL_optimisation_assertion( ccd == 1); + CGAL_assertion( active_cells.size() == 1); + CGAL_assertion( ccd == 1); return ((*active_cells.begin()).min)(); } diff --git a/Optimisation_basic/include/CGAL/Optimisation/assertions.h b/Optimisation_basic/include/CGAL/Optimisation/assertions.h deleted file mode 100644 index 7186d883d15..00000000000 --- a/Optimisation_basic/include/CGAL/Optimisation/assertions.h +++ /dev/null @@ -1,323 +0,0 @@ -// Copyright (c) 1997-2001 -// Utrecht University (The Netherlands), -// ETH Zurich (Switzerland), -// INRIA Sophia-Antipolis (France), -// Max-Planck-Institute Saarbruecken (Germany), -// and Tel-Aviv University (Israel). All rights reserved. -// -// This file is part of CGAL (www.cgal.org) -// -// $URL$ -// $Id$ -// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial -// -// -// Author(s) : Geert-Jan Giezeman, Sven Schoenherr - -#ifndef CGAL_OPTIMISATION_ASSERTIONS_H -#define CGAL_OPTIMISATION_ASSERTIONS_H - -#include - -// macro definitions -// ================= - -// assertions -// ---------- -#if ( defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ - || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) -# define CGAL_optimisation_assertion(EX) ((void)0) -# define CGAL_optimisation_assertion_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_assertion_code(CODE) -# undef CGAL_OPTIMISATION_ASSERTION_TAG -#else -# define CGAL_optimisation_assertion(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_assertion_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_assertion_code(CODE) CODE -# define CGAL_OPTIMISATION_ASSERTION_TAG 1 -#endif // optimisation assertions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXACTNESS) ) \ - || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ - || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) -# define CGAL_optimisation_exactness_assertion(EX) ((void)0) -# define CGAL_optimisation_exactness_assertion_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_exactness_assertion_code(CODE) -# undef CGAL_OPTIMISATION_EXACTNESS_ASSERTION_TAG -#else -# define CGAL_optimisation_exactness_assertion(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_exactness_assertion_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_exactness_assertion_code(CODE) CODE -# define CGAL_OPTIMISATION_EXACTNESS_ASSERTION_TAG 1 -#endif // optimisation exactness assertions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ - || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_assertion(EX) ((void)0) -# define CGAL_optimisation_expensive_assertion_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_expensive_assertion_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_ASSERTION_TAG -#else -# define CGAL_optimisation_expensive_assertion(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_assertion_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_assertion_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_ASSERTION_TAG 1 -#endif // optimisation expensive assertions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ - || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_exactness_assertion(EX) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_assertion_msg(EX,MSG) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_assertion_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_ASSERTION_TAG -#else -# define CGAL_optimisation_expensive_exactness_assertion(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_exactness_assertion_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_exactness_assertion_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_ASSERTION_TAG 1 -#endif // optimisation expensive exactness assertions - - - -// preconditions -// ------------- -#if ( defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ - || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_precondition(EX) ((void)0) -# define CGAL_optimisation_precondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_precondition_code(CODE) -# undef CGAL_OPTIMISATION_PRECONDITION_TAG -#else -# define CGAL_optimisation_precondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_precondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_precondition_code(CODE) CODE -# define CGAL_OPTIMISATION_PRECONDITION_TAG 1 -#endif // optimisation preconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXACTNESS) ) \ - || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ - || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_exactness_precondition(EX) ((void)0) -# define CGAL_optimisation_exactness_precondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_exactness_precondition_code(CODE) -# undef CGAL_OPTIMISATION_EXACTNESS_PRECONDITION_TAG -#else -# define CGAL_optimisation_exactness_precondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_exactness_precondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_exactness_precondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXACTNESS_PRECONDITION_TAG 1 -#endif // optimisation exactness preconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ - || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_precondition(EX) ((void)0) -# define CGAL_optimisation_expensive_precondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_expensive_precondition_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG -#else -# define CGAL_optimisation_expensive_precondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_precondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_precondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG 1 -#endif // optimisation expensive preconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ - || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_exactness_precondition(EX) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_precondition_msg(EX,MSG) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_precondition_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_PRECONDITION_TAG -#else -# define CGAL_optimisation_expensive_exactness_precondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_exactness_precondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_exactness_precondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_PRECONDITION_TAG 1 -#endif // optimisation expensive exactness preconditions - - - -// postconditions -// -------------- -#if ( defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ - || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_postcondition(EX) ((void)0) -# define CGAL_optimisation_postcondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_postcondition_code(CODE) -# undef CGAL_OPTIMISATION_POSTCONDITION_TAG -#else -# define CGAL_optimisation_postcondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_postcondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_postcondition_code(CODE) CODE -# define CGAL_OPTIMISATION_POSTCONDITION_TAG 1 -#endif // optimisation postconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXACTNESS) ) \ - || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ - || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_exactness_postcondition(EX) ((void)0) -# define CGAL_optimisation_exactness_postcondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_exactness_postcondition_code(CODE) -# undef CGAL_OPTIMISATION_EXACTNESS_POSTCONDITION_TAG -#else -# define CGAL_optimisation_exactness_postcondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_exactness_postcondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_exactness_postcondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXACTNESS_POSTCONDITION_TAG 1 -#endif // optimisation exactness postconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ - || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_postcondition(EX) ((void)0) -# define CGAL_optimisation_expensive_postcondition_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_expensive_postcondition_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_POSTCONDITION_TAG -#else -# define CGAL_optimisation_expensive_postcondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_postcondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_postcondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_POSTCONDITION_TAG 1 -#endif // optimisation expensive postconditions - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ - || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_exactness_postcondition(EX) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_postcondition_msg(EX,MSG) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_postcondition_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_POSTCONDITION_TAG -#else -# define CGAL_optimisation_expensive_exactness_postcondition(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_exactness_postcondition_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_exactness_postcondition_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_POSTCONDITION_TAG 1 -#endif // optimisation expensive exactness postconditions - - - -// warnings -// -------- -#if ( defined( CGAL_OPTIMISATION_NO_WARNINGS) \ - || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) -# define CGAL_optimisation_warning(EX) ((void)0) -# define CGAL_optimisation_warning_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_warning_code(CODE) -# undef CGAL_OPTIMISATION_WARNING_TAG -#else -# define CGAL_optimisation_warning(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_warning_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_warning_code(CODE) CODE -# define CGAL_OPTIMISATION_WARNING_TAG 1 -#endif // optimisation warnings - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXACTNESS) ) \ - || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ - || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) -# define CGAL_optimisation_exactness_warning(EX) ((void)0) -# define CGAL_optimisation_exactness_warning_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_exactness_warning_code(CODE) -# undef CGAL_OPTIMISATION_EXACTNESS_WARNING_TAG -#else -# define CGAL_optimisation_exactness_warning(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_exactness_warning_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_exactness_warning_code(CODE) CODE -# define CGAL_OPTIMISATION_EXACTNESS_WARNING_TAG 1 -#endif // optimisation exactness warnings - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ - || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_warning(EX) ((void)0) -# define CGAL_optimisation_expensive_warning_msg(EX,MSG) ((void)0) -# define CGAL_optimisation_expensive_warning_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_WARNING_TAG -#else -# define CGAL_optimisation_expensive_warning(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_warning_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_warning_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_WARNING_TAG 1 -#endif // optimisation expensive warnings - -#if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ - || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ - || defined( CGAL_CHECK_EXACTNESS) \ - || defined( CGAL_CHECK_EXPENSIVE) ) \ - || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ - || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) -# define CGAL_optimisation_expensive_exactness_warning(EX) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_warning_msg(EX,MSG) \ - ((void)0) -# define CGAL_optimisation_expensive_exactness_warning_code(CODE) -# undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_WARNING_TAG -#else -# define CGAL_optimisation_expensive_exactness_warning(EX) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__)) -# define CGAL_optimisation_expensive_exactness_warning_msg(EX,MSG) \ - (CGAL::possibly(EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) -# define CGAL_optimisation_expensive_exactness_warning_code(CODE) CODE -# define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_WARNING_TAG 1 -#endif // optimisation expensive exactness warnings - - - -#endif // CGAL_OPTIMISATION_ASSERTIONS_H - -// ===== EOF ================================================================== diff --git a/Optimisation_basic/include/CGAL/Optimisation/basic.h b/Optimisation_basic/include/CGAL/Optimisation/basic.h index 6e8dd5f511c..900b0cac964 100644 --- a/Optimisation_basic/include/CGAL/Optimisation/basic.h +++ b/Optimisation_basic/include/CGAL/Optimisation/basic.h @@ -19,7 +19,6 @@ // includes #include -#include #include #include diff --git a/Polytope_distance_d/include/CGAL/Polytope_distance_d.h b/Polytope_distance_d/include/CGAL/Polytope_distance_d.h index ede3b47aa92..e58d94539f9 100644 --- a/Polytope_distance_d/include/CGAL/Polytope_distance_d.h +++ b/Polytope_distance_d/include/CGAL/Polytope_distance_d.h @@ -473,7 +473,7 @@ public: // NOTE: an implicit conversion from ET to RT must be available! Point realizing_point_p( ) const - { CGAL_optimisation_precondition( is_finite()); + { CGAL_precondition( is_finite()); return tco.construct_point_d_object() ( ambient_dimension(), realizing_point_p_coordinates_begin(), @@ -481,7 +481,7 @@ public: Point realizing_point_q( ) const - { CGAL_optimisation_precondition( is_finite()); + { CGAL_precondition( is_finite()); return tco.construct_point_d_object() ( ambient_dimension(), realizing_point_q_coordinates_begin(), @@ -512,7 +512,7 @@ public: std::copy( p_first, p_last, std::back_inserter( p_points)); std::copy( q_first, q_last, std::back_inserter( q_points)); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( p_points.begin(), p_points.end()) && check_dimension( q_points.begin(), q_points.end()), "Not all points have the same dimension."); @@ -527,7 +527,7 @@ public: p_points.clear(); std::copy( p_first, p_last, std::back_inserter( p_points)); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( p_points.begin(), p_points.end()), "Not all points have the same dimension."); @@ -541,7 +541,7 @@ public: q_points.clear(); std::copy( q_first, q_last, std::back_inserter( q_points)); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( q_points.begin(), q_points.end()), "Not all points have the same dimension."); @@ -551,7 +551,7 @@ public: void insert_p( const Point& p) { - CGAL_optimisation_precondition + CGAL_precondition ( ( ! is_finite()) || ( tco.access_dimension_d_object()( p) == d)); p_points.push_back( p); @@ -562,7 +562,7 @@ public: void insert_q( const Point& q) { - CGAL_optimisation_precondition + CGAL_precondition ( ( ! is_finite()) || ( tco.access_dimension_d_object()( q) == d)); q_points.push_back( q); @@ -575,12 +575,12 @@ public: insert( InputIterator1 p_first, InputIterator1 p_last, InputIterator2 q_first, InputIterator2 q_last) { - CGAL_optimisation_precondition_code(int old_r = static_cast(p_points.size())); - CGAL_optimisation_precondition_code(int old_s = static_cast(q_points.size())); + CGAL_precondition_code(int old_r = static_cast(p_points.size())); + CGAL_precondition_code(int old_s = static_cast(q_points.size())); p_points.insert( p_points.end(), p_first, p_last); q_points.insert( q_points.end(), q_first, q_last); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( p_points.begin()+old_r, p_points.end()) && check_dimension( q_points.begin()+old_s, q_points.end()), "Not all points have the same dimension."); @@ -591,10 +591,10 @@ public: void insert_p( InputIterator p_first, InputIterator p_last) { - CGAL_optimisation_precondition_code(int old_r = static_cast(p_points.size())); + CGAL_precondition_code(int old_r = static_cast(p_points.size())); p_points.insert( p_points.end(), p_first, p_last); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( p_points.begin()+old_r, p_points.end()), "Not all points have the same dimension."); compute_distance(); @@ -604,10 +604,10 @@ public: void insert_q( InputIterator q_first, InputIterator q_last) { - CGAL_optimisation_precondition_code( int old_s = static_cast(q_points.size())); + CGAL_precondition_code( int old_s = static_cast(q_points.size())); q_points.insert( q_points.end(), q_first, q_last); set_dimension(); - CGAL_optimisation_precondition_msg + CGAL_precondition_msg (check_dimension( q_points.begin()+old_s, q_points.end()), "Not all points have the same dimension."); compute_distance(); @@ -681,7 +681,7 @@ private: // construct program int n = 2 * d + static_cast(p_points.size() + q_points.size()); int m = d + 2; - CGAL_optimisation_precondition (p_points.size() > 0); + CGAL_precondition (p_points.size() > 0); QP qp (n, m, A_iterator (boost::counting_iterator(0), @@ -696,7 +696,7 @@ private: Quadratic_program_options options; options.set_pricing_strategy(pricing_strategy(NT())); solver = new Solver(qp, options); - CGAL_optimisation_assertion(solver->status() == QP_OPTIMAL); + CGAL_assertion(solver->status() == QP_OPTIMAL); // compute support and realizing points ET et_0 = 0; int r = static_cast(p_points.size()); @@ -773,8 +773,8 @@ is_valid( bool verbose, int level) const // compute normal vector ET_vector normal( d), diff( d); ET et_0 = 0, den = p_coords[d]; - CGAL_optimisation_assertion (den > et_0); - CGAL_optimisation_assertion (den == q_coords[d]); + CGAL_assertion (den > et_0); + CGAL_assertion (den == q_coords[d]); int i, j; for ( j = 0; j < d; ++j) normal[ j] = p_coords[ j] - q_coords[ j]; @@ -917,7 +917,7 @@ operator << ( std::ostream& os, break; default: - CGAL_optimisation_assertion_msg( false, + CGAL_assertion_msg( false, "CGAL::IO::get_mode( os) invalid!"); break; } diff --git a/Polytope_distance_d/include/CGAL/all_furthest_neighbors_2.h b/Polytope_distance_d/include/CGAL/all_furthest_neighbors_2.h index d2927f43d6b..4c2b6ae4039 100644 --- a/Polytope_distance_d/include/CGAL/all_furthest_neighbors_2.h +++ b/Polytope_distance_d/include/CGAL/all_furthest_neighbors_2.h @@ -16,7 +16,7 @@ #include -#include +#include #include #include #include @@ -53,8 +53,8 @@ public: Value operator()( int r, int c) const { - CGAL_optimisation_precondition(r >= 0 && r < number_of_rows()); - CGAL_optimisation_precondition(c >= 0 && c < number_of_columns()); + CGAL_precondition(r >= 0 && r < number_of_rows()); + CGAL_precondition(c >= 0 && c < number_of_columns()); if (c <= r) return Value(c - r); else if (c >= r + number_of_rows()) @@ -93,8 +93,8 @@ all_furthest_neighbors_2( RandomAccessIC points_begin, // check preconditions: int number_of_points( static_cast(iterator_distance( points_begin, points_end))); - CGAL_optimisation_precondition( number_of_points > 0); - CGAL_optimisation_expensive_precondition( + CGAL_precondition( number_of_points > 0); + CGAL_expensive_precondition( is_convex_2( points_begin, points_end, t)); // prepare random access container: @@ -125,7 +125,7 @@ all_furthest_neighbors_2( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o, const Traits& - CGAL_optimisation_expensive_precondition_code(t), + CGAL_expensive_precondition_code(t), std::random_access_iterator_tag) { typedef All_furthest_neighbor_matrix< @@ -135,8 +135,8 @@ all_furthest_neighbors_2( RandomAccessIC points_begin, // check preconditions: int number_of_points( static_cast(iterator_distance( points_begin, points_end))); - CGAL_optimisation_precondition( number_of_points > 0); - CGAL_optimisation_expensive_precondition( + CGAL_precondition( number_of_points > 0); + CGAL_expensive_precondition( is_convex_2( points_begin, points_end, t)); // compute maxima: