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

Merge remote-tracking branch 'cgal/master' into Triangulation_3-CDT_3-lrineau 

# Conflicts:
#	STL_Extension/include/CGAL/iterator.h
#	Triangulation_3/test/Triangulation_3/CMakeLists.txt
This commit is contained in:
Laurent Rineau 2023-07-18 15:37:52 +02:00
parent c423f550e8 829e8095ed
commit 24b9d126da
642 changed files with 21471 additions and 17103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
.github/workflows/reuse.yml vendored Normal file
View File

@ -0,0 +1,35 @@
# SPDX-FileCopyrightText: 2020 Free Software Foundation Europe e.V. <https://fsfe.org>
#
# SPDX-License-Identifier: GPL-3.0-or-later
name: REUSE Compliance Check
on: [push, pull_request]
jobs:
reuse:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: REUSE version
uses: fsfe/reuse-action@v1
with:
args: --version
- name: REUSE lint
uses: fsfe/reuse-action@v1
with:
args: --include-submodules lint
- name: REUSE SPDX SBOM
uses: fsfe/reuse-action@v1
with:
args: spdx
- name: install dependencies
run: sudo apt-get install -y cmake
- name: Create CGAL internal release
run: |
mkdir -p ./release
cmake -DDESTINATION=./release -DCGAL_VERSION=9.9 -P ./Scripts/developer_scripts/cgal_create_release_with_cmake.cmake
- name: REUSE lint release tarball
uses: fsfe/reuse-action@v1
with:
args: --root ./release/CGAL-9.9 --include-submodules lint

12
.reuse/dep5 Normal file
View File

@ -0,0 +1,12 @@
Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: CGAL
Upstream-Contact: CGAL Editorial Board <info@cgal.org>
Source: https://github.com/CGAL/cgal
Files: .* *.cmake *.md .github/* Maintenance/* */TODO */doc/* */deb/* */applications/* */doc_html/* */scripts/* */developer_scripts/* */demo/* */examples/* */src/* */test/* */benchmarks/* */benchmark/* */package_info/* */data/* */cmake/*
Copyright: 1995-2023 The CGAL Project
License: CC0-1.0
Files: CMakeLists.txt GraphicsView/include/CGAL/Qt/ImageInterface.ui GraphicsView/include/CGAL/Qt/resources/qglviewer-icon.xpm Installation/AUTHORS Installation/CMakeLists.txt Installation/README Installation/auxiliary/cgal_create_cmake_script.1 Installation/auxiliary/gmp/README Installation/include/CGAL/license/gpl_package_list.txt MacOSX/auxiliary/cgal_app.icns copyright
Copyright: 1995-2023 The CGAL Project
License: CC0-1.0

3
AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h
View File

@ -24,7 +24,6 @@
#include <iterator>
#include <boost/mpl/and.hpp>
#include <CGAL/type_traits/is_iterator.h>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/mpl/if.hpp>
#include <CGAL/Default.h>
@ -34,7 +33,7 @@ namespace CGAL {
/*!
* \ingroup PkgAABBTreeRef
* Primitive type for a edge of a polyhedral surface.
* Primitive type for an edge of a polyhedral surface.
* It wraps an `edge_descriptor` into a 3D segment.
* The class model of `HalfedgeGraph` from which the primitive is built should not be deleted
* while the AABB tree holding the primitive is in use.

7
AABB_tree/include/CGAL/AABB_tree.h
View File

@ -27,7 +27,6 @@
#include <CGAL/AABB_tree/internal/Has_nested_type_Shared_data.h>
#include <CGAL/AABB_tree/internal/Primitive_helper.h>
#include <boost/optional.hpp>
#include <boost/lambda/lambda.hpp>
#ifdef CGAL_HAS_THREADS
#include <CGAL/mutex.h>
@ -143,7 +142,7 @@ namespace CGAL {
/// An explicit call to `build()` must be made to ensure that the next call to
/// a query function will not trigger the construction of the data structure.
/// A call to `AABBTraits::set_shared_data(t...)` is made using the internally stored traits.
/// This procedure has a complexity of \f$O(n log(n))\f$, where \f$n\f$ is the number of
/// This procedure has a complexity of \cgalBigO{n log(n)}, where \f$n\f$ is the number of
/// primitives of the tree.
template<typename ... T>
void build(T&& ...);
@ -326,7 +325,7 @@ public:
boost::optional< typename Intersection_and_primitive_id<Ray>::Type >
first_intersection(const Ray& query) const
{
return first_intersection(query, boost::lambda::constant(false));
return first_intersection(query, [](Primitive_id){ return false; });
}
/// \endcond
@ -351,7 +350,7 @@ public:
boost::optional<Primitive_id>
first_intersected_primitive(const Ray& query) const
{
return first_intersected_primitive(query, boost::lambda::constant(false));
return first_intersected_primitive(query, [](Primitive_id){ return false; });
}
/// \endcond
///@}

2
AABB_tree/include/CGAL/AABB_tree/internal/AABB_ray_intersection.h
View File

@ -201,7 +201,7 @@ template<typename Ray, typename SkipFunctor>
boost::optional< typename AABB_tree<AABBTraits>::template Intersection_and_primitive_id<Ray>::Type >
AABB_tree<AABBTraits>::first_intersection(const Ray& query,
const SkipFunctor& skip) const {
CGAL_static_assertion_msg((std::is_same<Ray, typename AABBTraits::Ray_3>::value),
static_assert(std::is_same<Ray, typename AABBTraits::Ray_3>::value,
"Ray and Ray_3 must be the same type");
switch(size()) // copy-paste from AABB_tree::traversal

8
AABB_tree/test/AABB_tree/aabb_test_is_ray_intersection_geomtraits.cpp
View File

@ -26,16 +26,16 @@ int main()
{
using namespace CGAL::internal::AABB_tree;
CGAL_static_assertion_msg(
static_assert(
(Is_ray_intersection_geomtraits<CGAL::Epeck>::value),
"CGAL::Epeck should be a RayIntersectionGeomTraits");
CGAL_static_assertion_msg(
static_assert(
(Is_ray_intersection_geomtraits< CGAL::Simple_cartesian<double> >::value),
"CGAL::Epeck should be a RayIntersectionGeomTraits");
CGAL_static_assertion_msg(
static_assert(
(!Is_ray_intersection_geomtraits<AABBGeomTraits>::value),
"Pure AABBGeomTraits shouldn't be a RayIntersectionGeomTraits");
CGAL_static_assertion_msg(
static_assert(
(!Is_ray_intersection_geomtraits<nope>::value),
"The empty struct shouldn't be a RayIntersectionGeomTraits");

1
AABB_tree/test/AABB_tree/aabb_test_multi_mesh.cpp
View File

@ -3,7 +3,6 @@
#include <iterator>
#include <boost/functional/value_factory.hpp>
#include <boost/array.hpp>
#include <CGAL/algorithm.h>
#include <CGAL/point_generators_3.h>

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

@ -3,7 +3,6 @@
#include <iterator>
#include <boost/functional/value_factory.hpp>
#include <boost/array.hpp>
#include <CGAL/assertions.h>
#include <CGAL/algorithm.h>
@ -92,7 +91,7 @@ int main()
Vector bbox_center((bbox.xmin() + bbox.xmax()) / 2,
(bbox.ymin() + bbox.ymax()) / 2,
(bbox.zmin() + bbox.zmax()) / 2);
boost::array<double, 3> extents;
std::array<double, 3> extents;
extents[0] = bbox.xmax() - bbox.xmin();
extents[1] = bbox.ymax() - bbox.ymin();
extents[2] = bbox.zmax() - bbox.zmin();

4
Algebraic_foundations/examples/Algebraic_foundations/fraction_traits.cpp
View File

@ -9,8 +9,8 @@ int main(){
typedef FT::Numerator_type Numerator_type;
typedef FT::Denominator_type Denominator_type;
CGAL_static_assertion((std::is_same<Numerator_type,CGAL::Gmpz>::value));
CGAL_static_assertion((std::is_same<Denominator_type,CGAL::Gmpz>::value));
static_assert(std::is_same<Numerator_type,CGAL::Gmpz>::value);
static_assert(std::is_same<Denominator_type,CGAL::Gmpz>::value);
Numerator_type numerator;
Denominator_type denominator;

2
Algebraic_foundations/examples/Algebraic_foundations/interoperable.cpp
View File

@ -9,7 +9,7 @@ binary_func(const A& a , const B& b){
typedef CGAL::Coercion_traits<A,B> CT;
// check for explicit interoperability
CGAL_static_assertion((CT::Are_explicit_interoperable::value));
static_assert(CT::Are_explicit_interoperable::value);
// CT::Cast is used to to convert both types into the coercion type
typename CT::Cast cast;

3
Algebraic_foundations/include/CGAL/Algebraic_structure_traits.h
View File

@ -353,8 +353,7 @@ class Algebraic_structure_traits_base< Type_,
typedef Coercion_traits< NT1, NT2 > CT;
typedef typename CT::Type Coercion_type_NT1_NT2;
CGAL_USE_TYPE(Coercion_type_NT1_NT2);
CGAL_static_assertion((
::std::is_same<Coercion_type_NT1_NT2 , Type >::value));
static_assert(::std::is_same<Coercion_type_NT1_NT2 , Type >::value);
typename Coercion_traits< NT1, NT2 >::Cast cast;
operator()( cast(x), cast(y), q, r );

4
Algebraic_foundations/include/CGAL/Coercion_traits.h
View File

@ -35,9 +35,9 @@
#define CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR_WITH_RT( NT, Result_type ) \
template < class CT_Type_1, class CT_Type_2 > \
Result_type operator()( const CT_Type_1& x, const CT_Type_2& y ) const { \
CGAL_static_assertion((::std::is_same< \
static_assert(::std::is_same< \
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT \
>::value)); \
>::value) ; \
\
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Cast cast; \
return operator()( cast(x), cast(y) ); \

4
Algebraic_foundations/include/CGAL/Scalar_factor_traits.h
View File

@ -85,13 +85,13 @@ public:
// determine extractable scalar factor
Scalar operator () (const NT& a) {
CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
static_assert(::std::is_same< NT,Scalar >::value);
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
return scalar_factor(a, SAT());
}
// determine extractable scalar factor
Scalar operator () (const NT& a, const Scalar& d) {
CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
static_assert(::std::is_same< NT,Scalar >::value);
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
return scalar_factor(a,d,SAT());
}

62
Algebraic_foundations/include/CGAL/Test/_test_algebraic_structure.h
View File

@ -44,7 +44,7 @@
template <typename AdaptableFunctor, typename ResultType>
void check_result_type(AdaptableFunctor, ResultType){
typedef typename AdaptableFunctor::result_type result_type;
CGAL_static_assertion((::std::is_same<result_type,ResultType>::value));
static_assert(::std::is_same<result_type,ResultType>::value);
CGAL_USE_TYPE(result_type);
}
// check nothing for CGAL::Null_functor
@ -122,12 +122,11 @@ void test_algebraic_structure_intern( const CGAL::Integral_domain_tag& ) {
CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor;
CGAL_static_assertion(
(!::std::is_same< Integral_division, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Divides, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Is_zero, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Is_one, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Square, Null_functor >::value));
static_assert(!::std::is_same< Integral_division, Null_functor >::value);
static_assert(!::std::is_same< Divides, Null_functor >::value);
static_assert(!::std::is_same< Is_zero, Null_functor >::value);
static_assert(!::std::is_same< Is_one, Null_functor >::value);
static_assert(!::std::is_same< Square, Null_functor >::value);
// functor
const Is_zero is_zero = Is_zero();
@ -206,7 +205,7 @@ void test_algebraic_structure_intern(
CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor;
CGAL_static_assertion((!::std::is_same< Gcd, Null_functor>::value));
static_assert(!::std::is_same< Gcd, Null_functor>::value);
const Gcd gcd = Gcd();
assert( gcd( AS ( 0), AS ( 0)) == unit_normal( AS (0) ) );
@ -268,9 +267,9 @@ void test_algebraic_structure_intern( const CGAL::Euclidean_ring_tag&) {
CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor;
CGAL_static_assertion((!::std::is_same< Div, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Mod, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Div_mod, Null_functor>::value));
static_assert(!::std::is_same< Div, Null_functor>::value);
static_assert(!::std::is_same< Mod, Null_functor>::value);
static_assert(!::std::is_same< Div_mod, Null_functor>::value);
const Div div=Div();
const Mod mod=Mod();
@ -387,7 +386,7 @@ void test_algebraic_structure_intern( const CGAL::Field_with_sqrt_tag& ) {
CGAL_SNAP_AST_FUNCTORS(AST);
CGAL_static_assertion((!::std::is_same< Sqrt, Null_functor>::value));
static_assert(!::std::is_same< Sqrt, Null_functor>::value);
const Sqrt sqrt =Sqrt();
AS a(4);
@ -613,11 +612,9 @@ class Test_is_square {
CGAL_USE_TYPE(First_argument_type);
CGAL_USE_TYPE(Second_argument_type);
CGAL_static_assertion(
( ::std::is_same< AS , First_argument_type>::value));
CGAL_static_assertion(
( ::std::is_same< AS& , Second_argument_type>::value));
//CGAL_static_assertion(( ::std::is_same< bool , Result_type>::value));
static_assert(::std::is_same< AS , First_argument_type>::value);
static_assert(::std::is_same< AS& , Second_argument_type>::value);
//static_assert(::std::is_same< bool , Result_type>::value);
bool b = Result_type(true); CGAL_USE(b);
AS test_number = AS(3)*AS(3);
@ -649,8 +646,8 @@ public:
typedef typename Sqrt::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::std::is_same< AS , Argument_type>::value));
CGAL_static_assertion(( ::std::is_same< AS , Result_type>::value));
static_assert(::std::is_same< AS , Argument_type>::value);
static_assert(::std::is_same< AS , Result_type>::value);
typedef Algebraic_structure_traits<AS> AST;
typedef typename AST::Is_exact Is_exact;
assert( !Is_exact::value || AS (3) == sqrt( AS (9)));
@ -675,12 +672,9 @@ public:
CGAL_USE_TYPE(First_argument_type);
CGAL_USE_TYPE(Second_argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(
( ::std::is_same<int, First_argument_type>::value));
CGAL_static_assertion(
( ::std::is_same< AS , Second_argument_type>::value));
CGAL_static_assertion(
( ::std::is_same< AS , Result_type>::value));
static_assert(::std::is_same<int, First_argument_type>::value);
static_assert(::std::is_same< AS , Second_argument_type>::value);
static_assert(::std::is_same< AS , Result_type>::value);
AS epsilon(1);
assert( test_equality_epsilon( AS (2),
root( 4, AS (16) ), epsilon ) );
@ -803,7 +797,7 @@ void test_algebraic_structure(){
typedef CGAL::Algebraic_structure_traits< AS > AST;
CGAL_SNAP_AST_FUNCTORS(AST);
CGAL_static_assertion((::std::is_same<AS,typename AST::Type>::value));
static_assert(::std::is_same<AS,typename AST::Type>::value);
typedef typename AST::Boolean Boolean;
assert(!Boolean());
@ -816,14 +810,13 @@ void test_algebraic_structure(){
using CGAL::Integral_domain_without_division_tag;
using CGAL::Null_functor;
// Test for desired exactness
CGAL_static_assertion(
( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
static_assert(::std::is_same< typename AST::Is_exact, Is_exact >::value);
static_assert(::std::is_convertible< Tag,
Integral_domain_without_division_tag >::value );
static_assert(::std::is_same< Tag, Algebraic_category>::value);
static_assert(!::std::is_same< Simplify, Null_functor>::value);
static_assert(!::std::is_same< Unit_part, Null_functor>::value);
CGAL_static_assertion(( ::boost::is_convertible< Tag,
Integral_domain_without_division_tag >::value ));
CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
CGAL_static_assertion((!::std::is_same< Simplify, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Unit_part, Null_functor>::value));
const Simplify simplify=Simplify();;
const Unit_part unit_part= Unit_part();
@ -943,8 +936,7 @@ void test_algebraic_structure( const AS & a, const AS & b, const AS & c) {
typedef CGAL::Algebraic_structure_traits<AS> AST;
typedef typename AST::Is_numerical_sensitive Is_numerical_sensitive;
CGAL_static_assertion(
!(::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
static_assert(!::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value);
CGAL_USE_TYPE(Is_numerical_sensitive);
}

8
Algebraic_foundations/include/CGAL/Test/_test_coercion_traits.h
View File

@ -326,7 +326,7 @@ void test_implicit_interoperable_one_way() {
typedef typename CT::Type C;
typedef typename CT::Are_implicit_interoperable Are_implicit_interoperable;
CGAL_static_assertion(
static_assert(
(::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
assert((::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
@ -346,9 +346,9 @@ void test_explicit_interoperable_one_way(){
typedef typename CT::Cast Cast;
typedef typename Cast::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<result_type,Type>::value));
CGAL_static_assertion((::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
CGAL_static_assertion((::std::is_same<Type,RT>::value));
static_assert(::std::is_same<result_type,Type>::value);
static_assert(::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
static_assert(::std::is_same<Type,RT>::value);
typename CT::Cast cast;
A a(3);

10
Algebraic_foundations/include/CGAL/Test/_test_fraction_traits.h
View File

@ -37,11 +37,11 @@ void test_fraction_traits(){
typedef typename FT::Compose Compose;
CGAL_USE_TYPE(Is_fraction);
CGAL_static_assertion( (::std::is_same<Type,T>::value));
CGAL_static_assertion( (::std::is_same<Is_fraction,Tag_true>::value));
CGAL_static_assertion(!(::std::is_same<Common_factor,Null_functor>::value));
CGAL_static_assertion(!(::std::is_same<Decompose,Null_functor>::value));
CGAL_static_assertion(!(::std::is_same<Compose,Null_functor>::value));
static_assert(::std::is_same<Type,T>::value);
static_assert(::std::is_same<Is_fraction,Tag_true>::value);
static_assert(!::std::is_same<Common_factor,Null_functor>::value);
static_assert(!::std::is_same<Decompose,Null_functor>::value);
static_assert(!::std::is_same<Compose,Null_functor>::value);
// Decompose

2
Algebraic_foundations/include/CGAL/Test/_test_rational_traits.h
View File

@ -29,7 +29,7 @@ void test_rational_traits(){
typedef Rational_traits<Rational> Rational_traits;
typedef typename Rational_traits::RT RT;
CGAL_static_assertion((::std::is_same<RT,RT>::value));
static_assert(::std::is_same<RT,RT>::value);
assert( Rational_traits().numerator(x) == RT(7));
assert( Rational_traits().denominator(x) == RT(2));

16
Algebraic_foundations/include/CGAL/Test/_test_real_embeddable.h
View File

@ -48,9 +48,9 @@ namespace CGAL {
void operator() (const ToDouble& to_double) {
typedef typename ToDouble::argument_type Argument_type;
typedef typename ToDouble::result_type Result_type;
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
static_assert( ::std::is_same<Type, Argument_type>::value);
CGAL_USE_TYPE(Argument_type);
CGAL_static_assertion(( ::std::is_same<double, Result_type>::value));
static_assert( ::std::is_same<double, Result_type>::value);
CGAL_USE_TYPE(Result_type);
assert(42.0 == to_double(Type(42)));
}
@ -71,9 +71,9 @@ namespace CGAL {
typedef typename To_interval::argument_type Argument_type;
typedef typename To_interval::result_type Result_type;
typedef std::pair<double,double> Interval_type;
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
static_assert( ::std::is_same<Type, Argument_type>::value);
CGAL_USE_TYPE(Argument_type);
CGAL_static_assertion(( ::std::is_same<Interval_type, Result_type>::value));
static_assert( ::std::is_same<Interval_type, Result_type>::value);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Interval_type);
// assert(NiX::in(42.0,to_Interval(Type(42))));
@ -139,7 +139,7 @@ void test_real_embeddable() {
CGAL_SNAP_RET_FUNCTORS(RET);
typedef typename RET::Is_real_embeddable Is_real_embeddable;
using CGAL::Tag_true;
CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_true>::value));
static_assert(::std::is_same< Is_real_embeddable, Tag_true>::value);
CGAL_USE_TYPE(Is_real_embeddable);
typedef typename RET::Boolean Boolean;
@ -246,7 +246,7 @@ void test_not_real_embeddable() {
typedef CGAL::Real_embeddable_traits<Type> RET;
typedef typename RET::Is_real_embeddable Is_real_embeddable;
using CGAL::Tag_false;
CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_false>::value));
static_assert(::std::is_same< Is_real_embeddable, Tag_false>::value);
CGAL_USE_TYPE(Is_real_embeddable);
}
@ -254,13 +254,13 @@ void test_not_real_embeddable() {
//template <class Type, class CeilLog2Abs>
//void test_rounded_log2_abs(Type zero, CGAL::Null_functor, CeilLog2Abs) {
// typedef CGAL::Null_functor Null_functor;
// CGAL_static_assertion(( ::std::is_same< CeilLog2Abs, Null_functor>::value));
// static_assert(::std::is_same< CeilLog2Abs, Null_functor>::value);
//}
//
//template <class Type, class FloorLog2Abs, class CeilLog2Abs>
//void test_rounded_log2_abs(Type zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
// typedef CGAL::Null_functor Null_functor;
// CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
// static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
//
// assert( fl_log(Type( 7)) == 2 );
// assert( cl_log(Type( 7)) == 3 );

24
Algebraic_foundations/test/Algebraic_foundations/Algebraic_extension_traits.cpp
View File

@ -9,21 +9,21 @@ int main(){
typedef AET::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::std::is_same<int,Type>::value));
static_assert(::std::is_same<int,Type>::value);
typedef AET::Is_extended Is_extended;
CGAL_USE_TYPE(Is_extended);
CGAL_static_assertion(
static_assert(
(::std::is_same<CGAL::Tag_false,Is_extended>::value));
typedef AET::Normalization_factor Normalization_factor;
{
typedef Normalization_factor::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
static_assert(::std::is_same<argument_type,int>::value);
typedef Normalization_factor::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<result_type,int>::value));
static_assert(::std::is_same<result_type,int>::value);
Normalization_factor nfac;
assert(nfac(3)==1);
}
@ -31,10 +31,10 @@ int main(){
{
typedef DFAI::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
static_assert(::std::is_same<argument_type,int>::value);
typedef DFAI::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<result_type,int>::value));
static_assert(::std::is_same<result_type,int>::value);
DFAI dfai;
assert(dfai(3)==1);
}
@ -45,21 +45,21 @@ int main(){
typedef AET::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::std::is_same<EXT,Type>::value));
static_assert(::std::is_same<EXT,Type>::value);
typedef AET::Is_extended Is_extended;
CGAL_USE_TYPE(Is_extended);
CGAL_static_assertion(
static_assert(
(::std::is_same<CGAL::Tag_true,Is_extended>::value));
typedef AET::Normalization_factor Normalization_factor;
{
typedef Normalization_factor::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
static_assert(::std::is_same<argument_type,EXT>::value);
typedef Normalization_factor::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
static_assert(::std::is_same<result_type,EXT>::value);
Normalization_factor nfac;
assert(nfac(EXT(3))==1);
assert(nfac(EXT(3,0,5))==1);
@ -69,10 +69,10 @@ int main(){
{
typedef DFAI::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
static_assert(::std::is_same<argument_type,EXT>::value);
typedef DFAI::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
static_assert(::std::is_same<result_type,EXT>::value);
DFAI dfai;
assert(dfai(EXT(3))==1);
assert(dfai(EXT(3,0,5))==1);

10
Algebraic_foundations/test/Algebraic_foundations/Algebraic_structure_traits.cpp
View File

@ -7,7 +7,7 @@
{ \
typedef AST::NAME NAME; \
CGAL_USE_TYPE(NAME); \
CGAL_static_assertion( \
static_assert( \
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
}
@ -16,19 +16,19 @@ int main(){
typedef AST::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::std::is_same<void,Type>::value));
static_assert(::std::is_same<void,Type>::value);
typedef AST::Algebraic_category Algebraic_category;
CGAL_USE_TYPE(Algebraic_category);
CGAL_static_assertion(
static_assert(
(::std::is_same<CGAL::Null_tag,Algebraic_category>::value));
typedef AST::Is_exact Is_exact;
CGAL_USE_TYPE(Is_exact);
CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_exact>::value));
static_assert(::std::is_same<CGAL::Null_tag,Is_exact>::value);
typedef AST::Is_numerical_sensitive Is_sensitive;
CGAL_USE_TYPE(Is_sensitive);
CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_sensitive>::value));
static_assert(::std::is_same<CGAL::Null_tag,Is_sensitive>::value);
CGAL_IS_AST_NULL_FUNCTOR ( Simplify);
CGAL_IS_AST_NULL_FUNCTOR ( Unit_part);

19
Algebraic_foundations/test/Algebraic_foundations/Coercion_traits.cpp
View File

@ -6,22 +6,17 @@ int main(){
{
typedef CGAL::Coercion_traits<int,int> CT;
CGAL_USE_TYPE(CT);
CGAL_static_assertion(( std::is_same<CT::Type,int>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
static_assert( std::is_same<CT::Type,int>::value);
static_assert( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value);
static_assert( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
assert( 5 == CT::Cast()(5));
}
{
typedef CGAL::Coercion_traits<CGAL::Tag_true,CGAL::Tag_false> CT;
CGAL_USE_TYPE(CT);
// CGAL_static_assertion(( std::is_same<CT::Type,CGAL::Null_type>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( std::is_same<CT::Cast,CGAL::Null_functor>::value));
// static_assert( std::is_same<CT::Type,CGAL::Null_type>::value);
static_assert(std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value);
static_assert(std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value);
static_assert(std::is_same<CT::Cast,CGAL::Null_functor>::value);
}
}

6
Algebraic_foundations/test/Algebraic_foundations/Real_embeddable_traits.cpp
View File

@ -7,7 +7,7 @@
{ \
typedef RET::NAME NAME; \
CGAL_USE_TYPE(NAME); \
CGAL_static_assertion( \
static_assert( \
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
}
@ -16,11 +16,11 @@ int main(){
typedef RET::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::std::is_same<void,Type>::value));
static_assert(::std::is_same<void,Type>::value);
typedef RET::Is_real_embeddable Is_real_embeddable;
CGAL_USE_TYPE(Is_real_embeddable);
CGAL_static_assertion((::std::is_same<CGAL::Tag_false,Is_real_embeddable>::value));
static_assert(::std::is_same<CGAL::Tag_false,Is_real_embeddable>::value);
CGAL_IS_RET_NULL_FUNCTOR(Abs);
CGAL_IS_RET_NULL_FUNCTOR(Sgn);

16
Algebraic_foundations/test/Algebraic_foundations/Scalar_factor_traits.cpp
View File

@ -7,33 +7,31 @@
int main(){
typedef CGAL::Scalar_factor_traits<int> SFT;
CGAL_USE_TYPE(SFT);
CGAL_static_assertion((::std::is_same<int, SFT::Type>::value));
CGAL_static_assertion((::std::is_same<int, SFT::Scalar>::value));
static_assert(::std::is_same<int, SFT::Type>::value);
static_assert(::std::is_same<int, SFT::Scalar>::value);
typedef SFT::Scalar_factor Scalar_factor;
{
typedef Scalar_factor::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<int, result_type>::value));
static_assert(::std::is_same<int, result_type>::value);
typedef Scalar_factor::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::std::is_same<int, argument_type>::value));
static_assert(::std::is_same<int, argument_type>::value);
}
typedef SFT::Scalar_div Scalar_div;
{
typedef Scalar_div::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::std::is_same<void, result_type>::value));
static_assert(::std::is_same<void, result_type>::value);
typedef Scalar_div::first_argument_type first_argument_type;
CGAL_USE_TYPE(first_argument_type);
CGAL_static_assertion(
(::std::is_same<int&, first_argument_type>::value));
static_assert(::std::is_same<int&, first_argument_type>::value);
typedef Scalar_div::second_argument_type second_argument_type;
CGAL_USE_TYPE(second_argument_type);
CGAL_static_assertion(
(::std::is_same<int, second_argument_type>::value));
static_assert(::std::is_same<int, second_argument_type>::value);
}
int i;

24
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Algebraic_curve_kernel_2.h
View File

@ -481,18 +481,18 @@ public:
Curve_analysis_2 _construct_defining_polynomial_from(Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
CGAL_static_assertion((::std::is_same
static_assert(::std::is_same
<Coefficient,
typename Num_coercion::Type>::value));
typename Num_coercion::Type>::value);
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
CGAL_static_assertion((::std::is_same
static_assert(::std::is_same
<Coefficient,
typename Denom_coercion::Type>::value));
typename Denom_coercion::Type>::value);
typename Num_coercion::Cast num_cast;
typename Denom_coercion::Cast denom_cast;
typename FT::Decompose decompose;
@ -2541,18 +2541,18 @@ public:
Polynomial_1 operator() (const Polynomial_2& f, Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
CGAL_static_assertion((::std::is_same
static_assert(::std::is_same
<Coefficient,
typename Num_coercion::Type>::value));
typename Num_coercion::Type>::value);
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
CGAL_static_assertion((::std::is_same
static_assert(::std::is_same
<Coefficient,
typename Denom_coercion::Type>::value));
typename Denom_coercion::Type>::value);
typename Num_coercion::Cast num_cast;
typename Denom_coercion::Cast denom_cast;
typename FT::Decompose decompose;

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

@ -71,7 +71,7 @@ class Algebraic_real_d_1 :
public ::CGAL::Handle_with_policy< AlgebraicRealRep_d_1, HandlePolicy > {
// currently Rational is the only supported Bound type.
CGAL_static_assertion(
static_assert(
( ::std::is_same <Rational_,
typename Get_arithmetic_kernel<Coefficient_>::Arithmetic_kernel::Rational>::value));

7
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Curve_analysis_2.h
View File

@ -23,7 +23,6 @@
#include <type_traits>
#include <boost/mpl/has_xxx.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/logical.hpp>
@ -66,14 +65,14 @@ namespace internal {
template<typename Comparable,bool has_template_typedefs>
struct Is_derived_from_Handle_with_policy {
typedef boost::false_type Tag;
typedef std::false_type Tag;
};
template<typename Comparable>
struct Is_derived_from_Handle_with_policy<Comparable,true> {
typedef typename
boost::is_base_of< CGAL::Handle_with_policy
std::is_base_of< CGAL::Handle_with_policy
< typename Comparable::T,
typename Comparable::Handle_policy,
typename Comparable::Allocator >,
@ -90,7 +89,7 @@ template<typename Comparable,typename Tag> struct Compare_for_vert_line_map_
};
template<typename Comparable>
struct Compare_for_vert_line_map_<Comparable,boost::true_type> {
struct Compare_for_vert_line_map_<Comparable,std::true_type> {
bool operator() (const Comparable& a, const Comparable& b) const {
return CGAL::Handle_id_less_than< Comparable >()(a,b);

10
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/algebraic_curve_kernel_2_tools.h
View File

@ -186,7 +186,7 @@ template<typename AlgebraicKernel_1,
InputIterator start,
InputIterator end,
OutputIterator output) {
CGAL_static_assertion
static_assert
((::std::is_same
<typename AlgebraicKernel_1::Algebraic_real_1,
typename std::iterator_traits<InputIterator>::value_type >::value));
@ -224,14 +224,14 @@ template<typename Poly_coer_1,typename Polynomial_1>
void cast_back_utcf(const Poly_coer_1& p,Polynomial_1& q) {
// We can assume that both template arguments are polynomial types
typedef CGAL::Fraction_traits<Poly_coer_1> FT;
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Polynomial_1> Num_coercion;
CGAL_static_assertion((::std::is_same
static_assert(::std::is_same
<Polynomial_1,
typename Num_coercion::Type>::value));
typename Num_coercion::Type>::value);
Numerator p_num;
Denominator p_denom;
typename FT::Decompose()(p,p_num,p_denom);

16
Algebraic_kernel_d/test/Algebraic_kernel_d/Real_embeddable_traits_extension.cpp
View File

@ -47,8 +47,8 @@ void test_real_embeddable_extension(const NT_&){
typedef typename Floor::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same<Integer, Result_type>::value);
assert(Integer(42) == floor(NT(42)));
assert(Integer(-42) == floor(NT(-42)));
}
@ -59,8 +59,8 @@ void test_real_embeddable_extension(const NT_&){
typedef typename Floor_log2_abs::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same<long, Result_type>::value);
assert(long(0) == floor_log2_abs(NT(1)));
assert(long(0) == floor_log2_abs(NT(-1)));
@ -86,8 +86,8 @@ void test_real_embeddable_extension(const NT_&){
typedef typename Ceil::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same<Integer, Result_type>::value);
assert(Integer(42) == ceil(NT(42)));
assert(Integer(-42) == ceil(NT(-42)));
}
@ -98,8 +98,8 @@ void test_real_embeddable_extension(const NT_&){
typedef typename Ceil_log2_abs::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same<long, Result_type>::value);
assert(long(0) == ceil_log2_abs(NT(1)));
assert(long(0) == ceil_log2_abs(NT(-1)));

16
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_curve_kernel_2.h
View File

@ -62,20 +62,20 @@ void test_algebraic_curve_kernel_2() {
typedef AlgebraicCurveKernel_2 AK_2;
/* CGAL_static_assertion( (::std::is_same<
Algebraic_real_1, typename AK::Algebraic_real_1 >::value) );
/* static_assert(::std::is_same<
Algebraic_real_1, typename AK::Algebraic_real_1 >::value);
CGAL_static_assertion((::std::is_same<
static_assert(::std::is_same<
Isolator,
typename AK::Isolator >::value) );
typename AK::Isolator >::value);
CGAL_static_assertion((::std::is_same<
static_assert(::std::is_same<
Coefficient,
typename AK::Coefficient >::value));
typename AK::Coefficient >::value);
CGAL_static_assertion((::std::is_same<
static_assert(::std::is_same<
Polynomial_1,
typename AK::Polynomial_1 >::value));*/
typename AK::Polynomial_1 >::value);*/
typedef typename AK_2::Polynomial_2 Poly_2;
typedef typename AK_2::Curve_analysis_2 Curve_analysis_2;

10
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_1.h
View File

@ -109,8 +109,8 @@ void test_algebraic_kernel_1(const AlgebraicKernel_d_1& ak_1){
typedef typename Name::result_type RT_; \
CGAL_USE_TYPE(AT_); \
CGAL_USE_TYPE(RT_); \
{CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT,AT_>::value);} \
{static_assert(::std::is_same<RT,RT_>::value);} \
}
#define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT) \
{ \
@ -120,9 +120,9 @@ void test_algebraic_kernel_1(const AlgebraicKernel_d_1& ak_1){
CGAL_USE_TYPE(AT1_); \
CGAL_USE_TYPE(AT2_); \
CGAL_USE_TYPE(RT_); \
{CGAL_static_assertion(( ::std::is_same<AT1,AT1_>::value));} \
{CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(::std::is_same<AT2,AT2_>::value);} \
{static_assert(::std::is_same<RT,RT_>::value);} \
}
// TODO: missing check for Construct_algebraic_real_1

22
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_2.h
View File

@ -93,8 +93,8 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
typedef typename Name::result_type RT_; \
CGAL_USE_TYPE(AT_); \
CGAL_USE_TYPE(RT_); \
{CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT,AT_>::value);} \
{static_assert(::std::is_same<RT,RT_>::value);} \
}
#define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT) \
{ \
@ -104,22 +104,22 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
CGAL_USE_TYPE(AT1_); \
CGAL_USE_TYPE(AT2_); \
CGAL_USE_TYPE(RT_); \
{CGAL_static_assertion(( ::std::is_same<AT1,AT1_>::value));} \
{CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(::std::is_same<AT2,AT2_>::value);} \
{static_assert(::std::is_same<RT,RT_>::value);} \
}
CGAL_static_assertion(( ::std::is_same
static_assert(::std::is_same
<Algebraic_real_2,
typename Construct_algebraic_real_2::result_type>
::value));
::value);
CGAL_CHECK_UFUNCTION(Is_square_free_2,Polynomial_2,bool);
CGAL_CHECK_UFUNCTION(Make_square_free_2,Polynomial_2,Polynomial_2);
// TODO: missing check for Square_free_factorize_2
CGAL_CHECK_BFUNCTION(Is_coprime_2,Polynomial_2,Polynomial_2,bool);
CGAL_static_assertion(( ::std::is_same
<bool,typename Make_coprime_2::result_type>::value));
static_assert(::std::is_same
<bool,typename Make_coprime_2::result_type>::value);
CGAL_CHECK_BFUNCTION(Number_of_solutions_2,Polynomial_2,Polynomial_2,
size_type);
CGAL_CHECK_UFUNCTION(Compute_x_2,Algebraic_real_2,Algebraic_real_1);
@ -128,8 +128,8 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
CGAL_CHECK_UFUNCTION(Compute_polynomial_y_2,Algebraic_real_2,Polynomial_1);
CGAL_CHECK_BFUNCTION(Isolate_x_2,Algebraic_real_2,Polynomial_1,BInterval);
CGAL_CHECK_BFUNCTION(Isolate_y_2,Algebraic_real_2,Polynomial_1,BInterval);
CGAL_static_assertion(( ::std::is_same
< BArray,typename Isolate_2::result_type>::value));
static_assert(::std::is_same
< BArray,typename Isolate_2::result_type>::value);
CGAL_CHECK_BFUNCTION(Sign_at_2,Polynomial_2,Algebraic_real_2,Sign);
CGAL_CHECK_BFUNCTION(Is_zero_at_2,Polynomial_2,Algebraic_real_2,bool);
CGAL_CHECK_BFUNCTION(Compare_x_2,Algebraic_real_2,Algebraic_real_2,Sign);

16
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_real_comparable.h
View File

@ -39,8 +39,8 @@ namespace internal {
void operator() (ToDouble to_double) {
typedef typename ToDouble::argument_type Argument_type;
typedef typename ToDouble::result_type Result_type;
CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::std::is_same<double, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same<double, Result_type>::value);
assert(42.0 == to_double(NT(42)));
}
};
@ -59,8 +59,8 @@ namespace internal {
void operator() (ToInterval to_Interval) {
typedef typename ToInterval::argument_type Argument_type;
typedef typename ToInterval::result_type Result_type;
CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::std::is_same< typename Argument_type::Interval, Result_type>::value));
static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(::std::is_same< typename Argument_type::Interval, Result_type>::value);
// TODO: NiX::in not available!?
//assert(NiX::in(42.0,to_Interval(NT(42))));
@ -99,7 +99,7 @@ void test_real_comparable() {
typedef CGAL::Real_embeddable_traits<NT> Traits;
typedef typename Traits::Is_real_embeddable Is_real_comparable;
using ::CGAL::Tag_true;
CGAL_static_assertion((::std::is_same< Is_real_comparable, Tag_true>::value));
static_assert(::std::is_same< Is_real_comparable, Tag_true>::value);
typename Traits::Compare compare;
typename Traits::Sign sign;
typename Traits::Abs abs;
@ -168,20 +168,20 @@ void test_not_real_comparable() {
typedef CGAL::Real_embeddable_traits<NT> Traits;
typedef typename Traits::Is_real_embeddable Is_real_comparable;
using ::CGAL::Tag_false;
CGAL_static_assertion((::std::is_same< Is_real_comparable, Tag_false>::value));
static_assert(::std::is_same< Is_real_comparable, Tag_false>::value);
}
template <class NT, class CeilLog2Abs>
void test_rounded_log2_abs(NT zero, ::CGAL::Null_functor, CeilLog2Abs) {
typedef ::CGAL::Null_functor Nulltype;
CGAL_static_assertion((::std::is_same< CeilLog2Abs, Nulltype>::value));
static_assert(::std::is_same< CeilLog2Abs, Nulltype>::value);
}
template <class NT, class FloorLog2Abs, class CeilLog2Abs>
void test_rounded_log2_abs(NT zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
typedef ::CGAL::Null_functor Null_functor;
CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
assert( fl_log(NT( 7)) == 2 );
assert( cl_log(NT( 7)) == 3 );

2
Alpha_shapes_2/doc/Alpha_shapes_2/CGAL/Alpha_shape_2.h
View File

@ -80,7 +80,7 @@ use binary search.
`Alpha_shape_2::number_of_solid_components()` performs a graph traversal and takes time
linear in the number of faces of the underlying triangulation.
`Alpha_shape_2::find_optimal_alpha()` uses binary search and takes time
\f$ O(n \log n)\f$, where \f$ n\f$ is the number of points.
\cgalBigO{n \log n}, where \f$ n\f$ is the number of points.
*/
template< typename Dt, typename ExactAlphaComparisonTag >

6
Alpha_shapes_2/include/CGAL/Alpha_shape_2.h
View File

@ -61,7 +61,7 @@ public:
// because the periodic triangulations' point() function returns a temporary
// value while the lazy predicate evaluations that are used when the Exact tag
// is set to true rely on a permanent and safe access to the points.
CGAL_static_assertion(
static_assert(
(std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
@ -76,8 +76,8 @@ public:
typedef Type_of_alpha FT;
// check that simplices are correctly instantiated
CGAL_static_assertion( (std::is_same<NT, typename Dt::Face::NT>::value) );
CGAL_static_assertion( (std::is_same<NT, typename Dt::Vertex::NT>::value) );
static_assert(std::is_same<NT, typename Dt::Face::NT>::value);
static_assert(std::is_same<NT, typename Dt::Vertex::NT>::value);
typedef typename Dt::Point Point;

1
Alpha_shapes_2/include/CGAL/Alpha_shape_vertex_base_2.h
View File

@ -19,6 +19,7 @@
#include <utility>
#include <CGAL/Triangulation_vertex_base_2.h>
#include <CGAL/Alpha_shapes_2/internal/Lazy_alpha_nt_2.h>
#include <CGAL/Default.h>
//-------------------------------------------------------------------
namespace CGAL {

10
Alpha_shapes_2/include/CGAL/Alpha_shapes_2/internal/Lazy_alpha_nt_2.h
View File

@ -148,8 +148,8 @@ class Lazy_alpha_nt_2
Approx_point to_approx(const Input_point& wp) const
{
// The traits class' Point_2 must be convertible using the Cartesian converter
CGAL_static_assertion((Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_approx converter;
return converter(wp);
@ -158,8 +158,8 @@ class Lazy_alpha_nt_2
Exact_point to_exact(const Input_point& wp) const
{
// The traits class' Point_2 must be convertible using the Cartesian converter
CGAL_static_assertion((Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter;
return converter(wp);
@ -448,7 +448,7 @@ struct Alpha_nt_selector_2
GeomTraits,
// If the base traits is already exact then we don't need to do anything,
// and we can simply directly use the traits class
Boolean_tag<boost::is_floating_point<typename GeomTraits::FT>::value &&
Boolean_tag<std::is_floating_point<typename GeomTraits::FT>::value &&
ExactAlphaComparisonTag::value >,
Weighted_tag>
{ };

1
Alpha_shapes_2/package_info/Alpha_shapes_2/dependencies
View File

@ -2,7 +2,6 @@ Algebraic_foundations
Alpha_shapes_2
Arithmetic_kernel
Cartesian_kernel
Filtered_kernel
Hash_map
Homogeneous_kernel
Installation

2
Alpha_shapes_3/doc/Alpha_shapes_3/CGAL/Alpha_shape_3.h
View File

@ -77,7 +77,7 @@ use binary search.
`Alpha_shape_3::number_of_solid_components()` performs a graph traversal and takes time
linear in the number of cells of the underlying triangulation.
`Alpha_shape_3::find_optimal_alpha()` uses binary search and takes time
\f$ O(n \log n)\f$, where \f$ n\f$ is the number of points.
\cgalBigO{n \log n}, where \f$ n\f$ is the number of points.
*/
template< typename Dt, typename ExactAlphaComparisonTag >

6
Alpha_shapes_3/include/CGAL/Alpha_shape_3.h
View File

@ -97,7 +97,7 @@ public:
// because the periodic triangulations' point() function returns a temporary
// value while the lazy predicate evaluations that are used when the Exact tag
// is set to true rely on a permanent and safe access to the points.
CGAL_static_assertion(
static_assert(
(std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
@ -108,8 +108,8 @@ public:
typedef typename Gt::FT Coord_type;
//checks whether tags are correctly set in Vertex and Cell classes
CGAL_static_assertion( (std::is_same<NT,typename Dt::Cell::NT>::value) );
CGAL_static_assertion( (std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value) );
static_assert(std::is_same<NT,typename Dt::Cell::NT>::value);
static_assert(std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value);
typedef typename Dt::Point Point;

10
Alpha_shapes_3/include/CGAL/Alpha_shapes_3/internal/Lazy_alpha_nt_3.h
View File

@ -139,8 +139,8 @@ class Lazy_alpha_nt_3{
Approx_point to_approx(const Input_point& wp) const
{
// The traits class' Point_3 must be convertible using the Cartesian converter
CGAL_static_assertion((Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_approx converter;
return converter(wp);
@ -149,8 +149,8 @@ class Lazy_alpha_nt_3{
Exact_point to_exact(const Input_point& wp) const
{
// The traits class' Point_3 must be convertible using the Cartesian converter
CGAL_static_assertion((Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter;
return converter(wp);
@ -417,7 +417,7 @@ struct Alpha_nt_selector_3
GeomTraits,
// If the base traits is already exact then we don't need to do anything,
// and we can simply directly use the traits class
Boolean_tag<boost::is_floating_point<typename GeomTraits::FT>::value &&
Boolean_tag<std::is_floating_point<typename GeomTraits::FT>::value &&
ExactAlphaComparisonTag::value >,
Weighted_tag>
{ };

3
Alpha_shapes_3/include/CGAL/Fixed_alpha_shape_3.h
View File

@ -27,7 +27,6 @@
#include <utility>
#include <iostream>
#include <queue>
#include <boost/next_prior.hpp>
#include <CGAL/Triangulation_utils_3.h>
#include <CGAL/Unique_hash_map.h>
@ -255,7 +254,7 @@ public:
std::back_inserter(cells),
Emptyset_iterator()));
Facet facet=*boost::prior(facets_on_the_boundary_of_the_hole.end());
Facet facet=*std::prev(facets_on_the_boundary_of_the_hole.end());
// Remember the points that are hidden by the conflicting cells,
// as they will be deleted during the insertion.

5
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h
View File

@ -173,7 +173,7 @@ class Alpha_wrap_3
using Alpha_PQ = Modifiable_priority_queue<Gate, Less_gate, Gate_ID_PM<Dt>, CGAL_BOOST_PAIRING_HEAP>;
protected:
const Oracle& m_oracle;
const Oracle m_oracle;
SC_Iso_cuboid_3 m_bbox;
FT m_alpha, m_sq_alpha;
@ -193,7 +193,7 @@ public:
{
// Due to the Steiner point computation being a dichotomy, the algorithm is inherently inexact
// and passing exact kernels is explicitly disabled to ensure no misunderstanding.
CGAL_static_assertion((std::is_floating_point<FT>::value));
static_assert(std::is_floating_point<FT>::value);
}
public:
@ -1343,6 +1343,7 @@ private:
return true;
}
public:
// Not the best complexity, but it's very cheap compared to the rest of the algorithm.
void make_manifold()
{

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_mesh_oracle.h
View File

@ -146,7 +146,7 @@ public:
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tmesh));
CGAL_static_assertion((std::is_same<typename boost::property_traits<VPM>::value_type, Point_3>::value));
static_assert(std::is_same<typename boost::property_traits<VPM>::value_type, Point_3>::value);
Splitter_base::reserve(num_faces(tmesh));

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_soup_oracle.h
View File

@ -143,7 +143,7 @@ public:
#endif
PPM pm = choose_parameter<PPM>(get_parameter(np, internal_np::point_map));
CGAL_static_assertion((std::is_same<typename boost::property_traits<PPM>::value_type, Point_3>::value));
static_assert(std::is_same<typename boost::property_traits<PPM>::value_type, Point_3>::value);
Splitter_base::reserve(faces.size());

1
Arithmetic_kernel/test/Arithmetic_kernel/CMakeLists.txt
View File

@ -39,6 +39,7 @@ if(GMP_FOUND)
create_single_source_cgal_program("Arithmetic_kernel.cpp")
create_single_source_cgal_program("LEDA_arithmetic_kernel.cpp")
create_single_source_cgal_program("CORE_arithmetic_kernel.cpp")
create_single_source_cgal_program("GMPXX_arithmetic_kernel.cpp")
create_single_source_cgal_program("Get_arithmetic_kernel.cpp")
else()

6
Arithmetic_kernel/test/Arithmetic_kernel/Get_arithmetic_kernel.cpp
View File

@ -18,17 +18,17 @@ int main() {
{
typedef CGAL::Get_arithmetic_kernel<Integer>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_);
CGAL_static_assertion((std::is_same<AK,AK_>::value));
static_assert(std::is_same<AK,AK_>::value);
}
{
typedef CGAL::Get_arithmetic_kernel<Rational>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_);
CGAL_static_assertion((std::is_same<AK,AK_>::value));
static_assert(std::is_same<AK,AK_>::value);
}
{
typedef CGAL::Get_arithmetic_kernel<BFI>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_);
CGAL_static_assertion((std::is_same<AK,AK_>::value));
static_assert(std::is_same<AK,AK_>::value);
}
return 0;
}

2
Arrangement_on_surface_2/demo/Arrangement_on_surface_2/AlgebraicCurveParser.cpp
View File

@ -12,7 +12,7 @@
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// SPDX-License-Identifier: GPL-3.0+
// SPDX-License-Identifier: GPL-3.0-or-later
//
// Author(s): Saurabh Singh <ssingh@cs.iitr.ac.in>
// Ahmed Essam <theartful.ae@gmail.com>

2
Arrangement_on_surface_2/demo/Arrangement_on_surface_2/AlgebraicCurveParser.h
View File

@ -12,7 +12,7 @@
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// SPDX-License-Identifier: GPL-3.0+
// SPDX-License-Identifier: GPL-3.0-or-later
//
// Author(s): Saurabh Singh <ssingh@cs.iitr.ac.in>
// Ahmed Essam <theartful.ae@gmail.com>

18
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/Arrangement_on_surface_2.txt
View File

@ -1223,10 +1223,10 @@ halfedge \f$e_{\mathrm{pred}}\f$ directed toward \f$v\f$, such that
\f$c\f$ is located between the curves associated with
\f$e_{\mathrm{pred}}\f$ and the next halfedge in the clockwise order
in the circular list of halfedges around \f$v\f$; see
\cgalFigureRef{aos_fig-insert}. This search may take \f$O(d)\f$ time,
\cgalFigureRef{aos_fig-insert}. This search may take \cgalBigO{d} time,
where \f$d\f$ is the degree of the vertex \f$v\f$. \cgalFootnote{We
can store the handles to the halfedges incident to \f$v\f$ in an efficient
search structure to obtain \f$O(\log d)\f$ access time. However, as
search structure to obtain \cgalBigO{\log d} access time. However, as
\f$d\f$ is usually very small, this may lead to a waste of storage
space without a meaningful improvement in running time in practice.}
However, if the halfedge \f$e_{\mathrm{pred}}\f$ is known in advance,
@ -1488,9 +1488,9 @@ keep up-to-date as this arrangement changes.
As mentioned above, the triangulation strategy is provided only for
educational purposes, and thus we do not elaborate on this strategy.
The data structure needed by the landmark and the trapezoidal map RIC
strategies can be constructed in \f$O(N \log N)\f$ time, where \f$N\f$
strategies can be constructed in \cgalBigO{N \log N} time, where \f$N\f$
is the overall number of edges in the arrangement, but the constant
hidden in the \f$O()\f$ notation for the trapezoidal map RIC strategy
hidden in the \cgalBigO{&nbsp;} notation for the trapezoidal map RIC strategy
is much larger. Thus, construction needed by the landmark algorithm is
in practice significantly faster than the construction needed by the
trapezoidal map RIC strategy. In addition, although both resulting
@ -1647,7 +1647,7 @@ Section \ref arr_ssecpl. The output pairs are sorted in increasing
\f$xy\f$-lexicographical order of the query point.
The batched point-location operation is carried out by sweeping the
arrangement. Thus, it takes \f$O((m+N)\log{(m+N)})\f$ time, where
arrangement. Thus, it takes \cgalBigO{(m+N)\log{(m+N)}} time, where
\f$N\f$ is the number of edges in the arrangement. Issuing separate
queries exploiting a point-location strategy with logarithmic query
time per query, such as the trapezoidal map RIC strategy (see Section
@ -2037,11 +2037,11 @@ so it must be construct from scratch.
In the first case, we sweep over the input curves, compute their
intersection points, and construct the \dcel that represents their
arrangement. This process is performed in \f$O\left((n + k)\log
n\right)\f$ time, where \f$k\f$ is the total number of intersection
arrangement. This process is performed in \cgalBigO{left((n + k)\log
n\right} time, where \f$k\f$ is the total number of intersection
points. The running time is asymptotically better than the time needed
for incremental insertion if the arrangement is relatively sparse
(when \f$k\f$ is \f$O(\frac{n^2}{\log n}\f$)), but it is recommended
(when \f$k\f$ is \cgalBigO{\frac{n^2}{\log n}}), but it is recommended
that this aggregate construction process be used even for dense
arrangements, since the plane-sweep algorithm performs fewer geometric
operations compared to the incremental insertion algorithms, and hence
@ -4346,7 +4346,7 @@ a point with respect to an \f$x\f$-monotone polyline, we use binary
search to locate the relevant segment that contains the point in its
\f$x\f$-range. Then, we compute the position of the point with respect
to this segment. Thus, operations on \f$x\f$-monotone polylines of
size \f$m\f$ typically take \f$O(\log m)\f$ time.
size \f$m\f$ typically take \cgalBigO{\log m} time.
You are free to choose the underlying segment traits class. Your
decision could be based, for example, on the number of expected

4
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_trapezoid_ric_point_location.h
View File

@ -12,9 +12,9 @@ Seidel \cgalCite{s-sfira-91} (see also [\cgalCite{bkos-cgaa-00} Chapter 6).
It subdivides each arrangement face to pseudo-trapezoidal cells, each
of constant complexity, and constructs and maintains a linear-size search
structure on top of these cells, such that each query can be answered
in \f$ O(\log n)\f$ time, where \f$ n\f$ is the complexity of the arrangement.
in \cgalBigO{\log n} time, where \f$ n\f$ is the complexity of the arrangement.
Constructing the search structures takes \f$ O(n \log n)\f$ expected time
Constructing the search structures takes \cgalBigO{n \log n} expected time
and may require a small number of rebuilds \cgalCite{hkh-iiplgtds-12}. Therefore
attaching a trapezoidal point-location object to an existing arrangement
may incur some overhead in running times. In addition, the point-location

8
Arrangement_on_surface_2/include/CGAL/Arr_bounded_planar_topology_traits_2.h
View File

@ -90,10 +90,10 @@ public:
typedef typename Gt_adaptor_2::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value));
CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value));
CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value));
static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value);
//@}
/*! \struct

8
Arrangement_on_surface_2/include/CGAL/Arr_circular_line_arc_traits_2.h
View File

@ -352,7 +352,7 @@ namespace CGAL {
//typedef const result_type& qualified_result_type;
template < typename T >
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
Circular_arc_point_2
operator()(const T &a) const
{
@ -370,7 +370,7 @@ namespace CGAL {
typedef Point_2 result_type;
//typedef const result_type& qualified_result_type;
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
result_type
operator() (const boost::variant< Arc1, Arc2 > & cv) const
{
@ -397,7 +397,7 @@ namespace CGAL {
//typedef const result_type& qualified_result_type;
template < typename T >
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
Circular_arc_point_2
operator()(const T &a) const
{
@ -420,7 +420,7 @@ namespace CGAL {
typedef Point_2 result_type;
//typedef const result_type& qualified_result_type;
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference<qualified_result_type>
result_type
operator() (const boost::variant< Arc1, Arc2 > & cv) const
{

2
Arrangement_on_surface_2/include/CGAL/Arr_conic_traits_2.h
View File

@ -79,7 +79,7 @@ public:
typedef Tag_true Has_left_category;
typedef Tag_true Has_merge_category;
typedef Tag_false Has_do_intersect_category;
//typedef boost::true_type Has_line_segment_constructor;
//typedef std::true_type Has_line_segment_constructor;
typedef Arr_oblivious_side_tag Left_side_category;
typedef Arr_oblivious_side_tag Bottom_side_category;

2
Arrangement_on_surface_2/include/CGAL/Arr_dcel_base.h
View File

@ -38,7 +38,7 @@ namespace CGAL {
inline void* _clean_pointer(const void* p)
{
CGAL_static_assertion(sizeof(void*) == sizeof(size_t));
static_assert(sizeof(void*) == sizeof(size_t));
const size_t mask = ~1;
const size_t val = (reinterpret_cast<size_t>(p) & mask);

18
Arrangement_on_surface_2/include/CGAL/Arr_geodesic_arc_on_sphere_traits_2.h
View File

@ -66,7 +66,7 @@ public:
typedef Arr_contracted_side_tag Top_side_category;
typedef Arr_identified_side_tag Right_side_category;
typedef boost::integral_constant<bool, atan_y==0> Zero_atan_y;
typedef std::integral_constant<bool, atan_y==0> Zero_atan_y;
// Traits objects
typedef Arr_extended_direction_3<Kernel> Point_2;
@ -358,7 +358,7 @@ public:
*/
void intersection_with_identification(const X_monotone_curve_2& xcv,
Direction_3& dp,
boost::true_type) const
std::true_type) const
{
const Direction_3& normal = xcv.normal();
dp = (CGAL::sign(normal.dz()) == POSITIVE) ?
@ -371,7 +371,7 @@ public:
*/
void intersection_with_identification(const X_monotone_curve_2& xcv,
Direction_3& dp,
boost::false_type) const
std::false_type) const
{
const Direction_3& normal = xcv.normal();
FT z((atan_x * normal.dx() + atan_y * normal.dy()) /
@ -383,7 +383,7 @@ public:
* \param[in] cv the curve
*/
bool overlap_with_identification(const X_monotone_curve_2& xcv,
boost::true_type) const
std::true_type) const
{
const Direction_3& normal = xcv.normal();
return ((x_sign(normal) == ZERO) &&
@ -395,7 +395,7 @@ public:
* \param[in] cv the curve
*/
bool overlap_with_identification(const X_monotone_curve_2& xcv,
boost::false_type) const
std::false_type) const
{
const Direction_3& normal = xcv.normal();
const Direction_3& iden_normal = identification_normal();
@ -441,7 +441,7 @@ public:
Point_2 p;
Direction_3& d(p);
d = Direction_3(x, y, z);
init(p, boost::integral_constant<bool, atan_y==0>());
init(p, std::integral_constant<bool, atan_y==0>());
return p;
}
@ -454,14 +454,14 @@ public:
Point_2 p;
Direction_3& d(p);
d = Direction_3(other);
init(p, boost::integral_constant<bool, atan_y==0>());
init(p, std::integral_constant<bool, atan_y==0>());
return p;
}
/*! Initialize a point on the sphere,
* \param[in] p the point to initialize.
*/
void init(Point_2& p, boost::true_type) const
void init(Point_2& p, std::true_type) const
{
const Direction_3& dir = p;
if (y_sign(dir) != ZERO) {
@ -480,7 +480,7 @@ public:
/*! Initialize a point on the sphere,
* \param[in] p the point to initialize.
*/
void init(Point_2& p, boost::false_type) const
void init(Point_2& p, std::false_type) const
{
const Direction_3& dir = p;
if ((x_sign(dir) == ZERO) && (y_sign(dir) == ZERO)) {

8
Arrangement_on_surface_2/include/CGAL/Arr_overlay_2.h
View File

@ -172,14 +172,14 @@ overlay(const Arrangement_on_surface_2<GeometryTraitsA_2, TopologyTraitsA>& arr1
typedef typename Agt2::Point_2 A_point;
typedef typename Bgt2::Point_2 B_point;
typedef typename Rgt2::Point_2 Res_point;
CGAL_static_assertion((boost::is_convertible<A_point, Res_point>::value));
CGAL_static_assertion((boost::is_convertible<B_point, Res_point>::value));
static_assert(std::is_convertible<A_point, Res_point>::value);
static_assert(std::is_convertible<B_point, Res_point>::value);
typedef typename Agt2::X_monotone_curve_2 A_xcv;
typedef typename Bgt2::X_monotone_curve_2 B_xcv;
typedef typename Rgt2::X_monotone_curve_2 Res_xcv;
CGAL_static_assertion((boost::is_convertible<A_xcv, Res_xcv>::value));
CGAL_static_assertion((boost::is_convertible<B_xcv, Res_xcv>::value));
static_assert(std::is_convertible<A_xcv, Res_xcv>::value);
static_assert(std::is_convertible<B_xcv, Res_xcv>::value);
typedef Arr_traits_basic_adaptor_2<Rgt2> Gt_adaptor_2;
typedef Arr_overlay_traits_2<Gt_adaptor_2, Arr_a, Arr_b>

2
Arrangement_on_surface_2/include/CGAL/Arr_polycurve_basic_traits_2.h
View File

@ -2419,7 +2419,7 @@ protected:
/*! Obtain the index of the subcurve in the polycurve that contains the
* point q in its x-range. The function performs a binary search, so if the
* point q is in the x-range of the polycurve with n subcurves, the subcurve
* containing it can be located in O(log n) operations.
* containing it can be located in \cgalBigO{log n} operations.
* \param cv The polycurve curve.
* \param q The point.
* \return An index i such that q is in the x-range of cv[i].

6
Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Base_rational_arc_ds_1.h
View File

@ -62,9 +62,9 @@ public:
typedef std::vector<std::pair<Algebraic_real_1, Multiplicity> >
Root_multiplicity_vector;
CGAL_static_assertion((std::is_same<Integer,Coefficient>::value));
CGAL_static_assertion((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
static_assert(std::is_same<Integer,Coefficient>::value);
static_assert(std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value);
public:

6
Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Rational_arc_d_1.h
View File

@ -100,9 +100,9 @@ public:
typedef Algebraic_point_2 Point_2;
CGAL_static_assertion((std::is_same<Integer, Coefficient>::value));
CGAL_static_assertion((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
static_assert(std::is_same<Integer, Coefficient>::value);
static_assert(std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value);
public:
const Rational_function& get_rational_function(const Polynomial_1& numerator,

16
Arrangement_on_surface_2/include/CGAL/Arr_spherical_topology_traits_2.h
View File

@ -91,14 +91,14 @@ public:
typedef typename Gt_adaptor_2::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_identified_side_tag >::value));
CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_contracted_side_tag >::value));
CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Top_side_category, Arr_contracted_side_tag >::value));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_identified_side_tag >::value));
static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_identified_side_tag >::value);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_contracted_side_tag >::value);
static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Top_side_category, Arr_contracted_side_tag >::value);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_identified_side_tag >::value);
//@}
/*! \struct

16
Arrangement_on_surface_2/include/CGAL/Arr_unb_planar_topology_traits_2.h
View File

@ -87,14 +87,14 @@ public:
typedef typename Gt_adaptor_2::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag>::value ||
std::is_same< Top_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value));
static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag>::value ||
std::is_same< Top_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value);
//@}
/*! \struct

12
Arrangement_on_surface_2/include/CGAL/Arrangement_2/Arrangement_on_surface_2_global.h
View File

@ -61,7 +61,7 @@ namespace Ss2 = Surface_sweep_2;
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -132,7 +132,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
//
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -406,7 +406,7 @@ void insert_non_empty(Arrangement_on_surface_2<GeometryTraits_2,
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -460,7 +460,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
//
// The last parameter is used to resolve ambiguity between this function and
// insert of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -1522,7 +1522,7 @@ zone(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
// Checks whether the given x-monotone curve intersects the existing arrangement.
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_on_surface_2<>&,
@ -1559,7 +1559,7 @@ do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to

8
Arrangement_on_surface_2/include/CGAL/Arrangement_2/arrangement_type_traits.h
View File

@ -24,7 +24,7 @@
#include <CGAL/license/Arrangement_on_surface_2.h>
#include <boost/type_traits/integral_constant.hpp>
#include <type_traits>
namespace CGAL
{
@ -62,7 +62,7 @@ namespace CGAL
// In the meanwhile we use a default implementation.
template <class T>
class is_arrangement_2 : public boost::false_type
class is_arrangement_2 : public std::false_type
{};
//-------------------------------- Arrangement_2
@ -74,7 +74,7 @@ class Arrangement_2;
template <class GeomTraits_, class DCEL_>
class is_arrangement_2<
Arrangement_2<GeomTraits_, DCEL_>
> : public boost::false_type
> : public std::false_type
{};
@ -87,7 +87,7 @@ class Arrangement_on_surface_2;
template <class GeomTraits_, class TopTraits_>
class is_arrangement_2<
Arrangement_on_surface_2<GeomTraits_, TopTraits_>
> : public boost::true_type
> : public std::true_type
{};
} // namespace CGAL

4
Arrangement_on_surface_2/include/CGAL/Arrangement_on_surface_2.h
View File

@ -77,10 +77,10 @@ public:
typedef typename Traits_adaptor_2::Top_side_category Top_side_category;
typedef typename Traits_adaptor_2::Right_side_category Right_side_category;
CGAL_static_assertion((Arr_sane_identified_tagging<Left_side_category,
static_assert(Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category,
Top_side_category,
Right_side_category>::value));
Right_side_category>::value);
public:
typedef Arrangement_on_surface_2<Geometry_traits_2, Topology_traits>

4
Arrangement_on_surface_2/include/CGAL/Arrangement_zone_2.h
View File

@ -67,10 +67,10 @@ protected:
typedef typename Traits_adaptor_2::Top_side_category Top_side_category;
typedef typename Traits_adaptor_2::Right_side_category Right_side_category;
CGAL_static_assertion((Arr_sane_identified_tagging<Left_side_category,
static_assert(Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category,
Top_side_category,
Right_side_category>::value));
Right_side_category>::value);
public:
typedef ZoneVisitor_ Visitor;

1
Arrangement_on_surface_2/include/CGAL/Curved_kernel_via_analysis_2/Curve_renderer_facade.h
View File

@ -62,7 +62,6 @@
#include <CGAL/Bbox_2.h>
#include <CGAL/Arithmetic_kernel.h>
#include <boost/array.hpp>
#include <CGAL/Curved_kernel_via_analysis_2/gfx/Curve_renderer_2.h>

16
Arrangement_on_surface_2/test/Arrangement_on_surface_2/test_tags.cpp
View File

@ -272,38 +272,38 @@ int main ()
assert(ident12() == false);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_left_side_category< Traits5 >::Category,
CGAL::Arr_oblivious_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_left_side_category< Traits1 >::Category,
CGAL::Arr_open_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same<CGAL::internal::Arr_complete_bottom_side_category< Traits5 >::Category,
CGAL::Arr_oblivious_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same<CGAL::internal::Arr_complete_bottom_side_category< Traits1 >::Category,
CGAL::Arr_open_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_top_side_category< Traits5 >::Category,
CGAL::Arr_oblivious_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_top_side_category< Traits1 >::Category,
CGAL::Arr_open_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_right_side_category< Traits5 >::Category,
CGAL::Arr_oblivious_side_tag >::value)
);
CGAL_static_assertion(
static_assert(
(std::is_same< CGAL::internal::Arr_complete_right_side_category< Traits1 >::Category,
CGAL::Arr_open_side_tag >::value)
);

2
BGL/examples/BGL_LCC/CMakeLists.txt
View File

@ -9,7 +9,7 @@ find_package(CGAL REQUIRED)
# create a target per cppfile
file(
GLOB_RECURSE cppfiles
GLOB cppfiles
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
*.cpp)
foreach(cppfile ${cppfiles})

2
BGL/include/CGAL/boost/graph/Dual.h
View File

@ -458,7 +458,7 @@ out_degree(typename boost::graph_traits<Dual<P> >::vertex_descriptor v,
const Dual<P>& dual)
{
const typename Dual<P>::Primal& primal = dual.primal();
return boost::distance(halfedges_around_face(halfedge(v,primal),primal));
return halfedges_around_face(halfedge(v,primal),primal).size();
}
template <typename P>

6
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -42,7 +42,7 @@ namespace CGAL {
* <a href="https://www.boost.org/doc/libs/release/libs/graph/doc/filtered_graph.html"><code>boost::filtered_graph</code></a>,
* this class only requires a way to access the selected faces and will automatically select the
* edges/halfedges and vertices present in the adapted graph. A vertex is selected if it is incident to at least one
* selected face. A edge is selected if it is incident to at least a selected face. A halfedge is selected if its edge
* selected face. An edge is selected if it is incident to at least a selected face. A halfedge is selected if its edge
* is selected.
*
* Since this class is a model of the `FaceGraph` concept, there is a restriction on the set of selected faces:
@ -486,8 +486,8 @@ struct Face_filtered_graph
selected_halfedges.reset();
typedef typename boost::property_traits<FacePatchIndexMap>::value_type Patch_index;
std::unordered_set<Patch_index> pids(boost::begin(selected_face_patch_indices),
boost::end(selected_face_patch_indices));
std::unordered_set<Patch_index> pids(std::begin(selected_face_patch_indices),
std::end(selected_face_patch_indices));
for(face_descriptor fd : faces(_graph) )
{

8
BGL/include/CGAL/boost/graph/IO/Generic_facegraph_builder.h
View File

@ -49,10 +49,10 @@ public:
typedef typename CGAL::GetVertexPointMap<Graph, NamedParameters>::type VPM;
// usually will be true, but might not be the case if using custom type points
// CGAL_static_assertion((std::is_same<typename Kernel::Point_3,
// typename boost::property_traits<VPM>::value_type>::value));
// CGAL_static_assertion((std::is_same<typename Kernel::Point_3,
// typename boost::range_value<Point_container>::type>::value));
// static_assert(std::is_same<typename Kernel::Point_3,
// typename boost::property_traits<VPM>::value_type>::value);
// static_assert(std::is_same<typename Kernel::Point_3,
// typename boost::range_value<Point_container>::type>::value);
typedef typename internal_np::Lookup_named_param_def<
internal_np::vertex_normal_map_t, NamedParameters,

2
BGL/include/CGAL/boost/graph/IO/STL.h
View File

@ -264,7 +264,7 @@ bool write_STL(std::ostream& os,
if(get_mode(os) == BINARY)
{
os << "FileType: Binary ";
const boost::uint32_t N32 = static_cast<boost::uint32_t>(faces(g).size());
const std::uint32_t N32 = static_cast<std::uint32_t>(faces(g).size());
os.write(reinterpret_cast<const char *>(&N32), sizeof(N32));
for(const face_descriptor f : faces(g))

18
BGL/include/CGAL/boost/graph/helpers.h
View File

@ -848,12 +848,12 @@ inline
std::enable_if_t<!Has_member_clear<FaceGraph>::value, void>
clear_impl(FaceGraph& g)
{
while(boost::begin(edges(g))!=boost::end(edges(g)))
remove_edge(*boost::begin(edges(g)), g);
while(boost::begin(faces(g))!=boost::end(faces(g)))
remove_face(*boost::begin(faces(g)), g);
while(boost::begin(vertices(g))!=boost::end(vertices(g)))
remove_vertex(*boost::begin(vertices(g)), g);
while(std::begin(edges(g))!=std::end(edges(g)))
remove_edge(*std::begin(edges(g)), g);
while(std::begin(faces(g))!=std::end(faces(g)))
remove_face(*std::begin(faces(g)), g);
while(std::begin(vertices(g))!=std::end(vertices(g)))
remove_vertex(*std::begin(vertices(g)), g);
}
template <class FaceGraph>
@ -975,9 +975,9 @@ template<typename FaceGraph>
void clear(FaceGraph& g)
{
internal::clear_impl(g);
CGAL_postcondition(std::distance(boost::begin(edges(g)),boost::end(edges(g))) == 0);
CGAL_postcondition(std::distance(boost::begin(vertices(g)),boost::end(vertices(g))) == 0);
CGAL_postcondition(std::distance(boost::begin(faces(g)),boost::end(faces(g))) == 0);
CGAL_postcondition(std::distance(std::begin(edges(g)),std::end(edges(g))) == 0);
CGAL_postcondition(std::distance(std::begin(vertices(g)),std::end(vertices(g))) == 0);
CGAL_postcondition(std::distance(std::begin(faces(g)),std::end(faces(g))) == 0);
}
/**

2
BGL/include/CGAL/boost/graph/internal/Has_member_clear.h
View File

@ -29,7 +29,7 @@ public:
};
template<class T>
CGAL_CPP17_INLINE constexpr bool Has_member_clear_v = Has_member_clear<T>::value;
inline constexpr bool Has_member_clear_v = Has_member_clear<T>::value;
} // internal
} // cgal

2
BGL/include/CGAL/boost/graph/properties.h
View File

@ -140,7 +140,7 @@ struct Point_accessor<Handle, ValueType, ConstReference, true>
typedef ValueType value_type;
typedef Handle key_type;
typedef typename boost::mpl::if_< boost::is_reference<ConstReference>,
typedef typename boost::mpl::if_< std::is_reference<ConstReference>,
ValueType&,
ValueType >::type Reference;

30
BGL/include/CGAL/boost/graph/property_maps.h
View File

@ -15,9 +15,7 @@
#include <CGAL/property_map.h>
#include <CGAL/boost/graph/properties.h>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace CGAL{
@ -25,7 +23,7 @@ namespace CGAL{
template < class TriangleMesh,
class VertexPointMap = typename boost::property_map<TriangleMesh,vertex_point_t>::type >
struct Triangle_from_face_descriptor_map{
typename boost::remove_const<TriangleMesh>::type* m_tm;
typename std::remove_const_t<TriangleMesh>* m_tm;
VertexPointMap m_vpm;
Triangle_from_face_descriptor_map()
@ -33,13 +31,13 @@ struct Triangle_from_face_descriptor_map{
{}
Triangle_from_face_descriptor_map(TriangleMesh const* tm)
: m_tm( const_cast<typename boost::remove_const<TriangleMesh>::type*>(tm) )
: m_tm( const_cast<std::remove_const_t<TriangleMesh>*>(tm) )
, m_vpm( get(vertex_point, *m_tm) )
{}
Triangle_from_face_descriptor_map(TriangleMesh const* tm,
VertexPointMap vpm )
: m_tm(const_cast<typename boost::remove_const<TriangleMesh>::type*>(tm))
: m_tm(const_cast<std::remove_const_t<TriangleMesh>*>(tm))
, m_vpm(vpm)
{}
@ -57,7 +55,7 @@ struct Triangle_from_face_descriptor_map{
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
key_type f)
{
typename boost::remove_const<TriangleMesh>::type & tm = *(pmap.m_tm);
std::remove_const_t<TriangleMesh>& tm = *(pmap.m_tm);
CGAL_precondition(halfedge(f,tm) == next(next(next(halfedge(f,tm),tm),tm),tm));
return value_type( get(pmap.m_vpm, target(halfedge(f,tm),tm)),
@ -70,7 +68,7 @@ struct Triangle_from_face_descriptor_map{
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
const std::pair<key_type, const TriangleMesh*>& f)
{
typename boost::remove_const<TriangleMesh>::type & tm = *(pmap.m_tm);
std::remove_const_t<TriangleMesh> & tm = *(pmap.m_tm);
CGAL_precondition(halfedge(f.first,tm) == next(next(next(halfedge(f.first,tm),tm),tm),tm));
return value_type( get(pmap.m_vpm, target(halfedge(f.first,tm),tm)),
@ -88,13 +86,13 @@ struct Segment_from_edge_descriptor_map{
{}
Segment_from_edge_descriptor_map(PolygonMesh const * pm)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(pm) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(pm) )
, m_vpm( get(vertex_point, *m_pm) )
{}
Segment_from_edge_descriptor_map(PolygonMesh const * pm,
VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(pm) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(pm) )
, m_vpm(vpm)
{}
@ -106,7 +104,7 @@ struct Segment_from_edge_descriptor_map{
typedef value_type reference;
typedef boost::readable_property_map_tag category;
//data
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//get function for property map
@ -138,16 +136,16 @@ struct One_point_from_face_descriptor_map{
{}
One_point_from_face_descriptor_map(PolygonMesh const * g)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm( get(vertex_point, *m_pm) )
{}
One_point_from_face_descriptor_map(PolygonMesh const * g, VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm(vpm)
{}
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//classical typedefs
@ -182,12 +180,12 @@ struct Source_point_from_edge_descriptor_map{
{}
Source_point_from_edge_descriptor_map(PolygonMesh const * g)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm( get(vertex_point, *m_pm) )
{}
Source_point_from_edge_descriptor_map(PolygonMesh const * g, VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm(vpm)
{}
@ -198,7 +196,7 @@ struct Source_point_from_edge_descriptor_map{
typedef boost::readable_property_map_tag category;
//data
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//get function for property map

339
BGL/include/CGAL/boost/graph/visitor.h
View File

@ -14,13 +14,13 @@
#include <boost/graph/graph_traits.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/ref.hpp>
#include <utility>
namespace boost
{
template<typename V, typename Graph>
struct graph_traits<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > >
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> > >
: boost::graph_traits< Graph >
{
typedef boost::graph_traits<Graph> Base;
@ -29,20 +29,20 @@ namespace boost
template<typename V, typename Graph>
struct graph_traits<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > const >
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> > const >
: boost::graph_traits< Graph >
{};
template<typename V, typename Graph, class PropertyTag>
struct property_map<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> >,
PropertyTag>
: public property_map<Graph, PropertyTag>
{};
template<typename V, typename Graph, class PropertyTag>
struct property_map<
const boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
const boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> >,
PropertyTag>
: public property_map<Graph, PropertyTag>
{};
@ -52,11 +52,11 @@ namespace boost
namespace CGAL
{
template<typename V, typename Graph>
boost::tuple<boost::reference_wrapper<V>,
boost::reference_wrapper<Graph> >
boost::tuple<std::reference_wrapper<V>,
std::reference_wrapper<Graph> >
make_graph_with_visitor(V& v, Graph& g)
{
return boost::make_tuple(boost::ref(v), boost::ref(g));
return boost::make_tuple(std::ref(v), std::ref(g));
}
template<typename Graph>
@ -67,11 +67,8 @@ public:
typedef typename gt::halfedge_descriptor halfedge_descriptor;
typedef typename gt::edge_descriptor edge_descriptor;
typedef typename gt::vertex_descriptor vertex_descriptor;
};
//// OVERLOADS FOR Visitor
template<typename Graph>
@ -260,119 +257,119 @@ void get(PropertyTag ptag, const Visitor_base<Graph>& w)
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertices_size_type
num_vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_vertices(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_vertices(boost::unwrap_ref(w.get<0>()));
return num_vertices(boost::unwrap_ref(w.get<1>()));
num_vertices(get<0>(w).get());
return num_vertices(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::edges_size_type
num_edges(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_edges(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_edges(boost::unwrap_ref(w.get<0>()));
return num_edges(boost::unwrap_ref(w.get<1>()));
num_edges(get<0>(w).get());
return num_edges(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
degree(v, boost::unwrap_ref(w.get<0>()));
return degree(v, boost::unwrap_ref(w.get<1>()));
degree(v, get<0>(w).get());
return degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
out_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
out_degree(v, boost::unwrap_ref(w.get<0>()));
return out_degree(v, boost::unwrap_ref(w.get<1>()));
out_degree(v, get<0>(w).get());
return out_degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
in_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
in_degree(v, boost::unwrap_ref(w.get<0>()));
return in_degree(v, boost::unwrap_ref(w.get<1>()));
in_degree(v, get<0>(w).get());
return in_degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertex_descriptor
source(typename boost::graph_traits<Graph>::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
source(e, boost::unwrap_ref(w.get<0>()));
return source(e, boost::unwrap_ref(w.get<1>()));
source(e, get<0>(w).get());
return source(e, get<1>(w).get);
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertex_descriptor
target(typename boost::graph_traits<Graph>::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
target(e, boost::unwrap_ref(w.get<0>()));
return target(e, boost::unwrap_ref(w.get<1>()));
target(e, get<0>(w).get());
return target(e, get<1>(w).get());
}
template <class Graph, class Visitor>
std::pair<typename boost::graph_traits<Graph>::edge_descriptor, bool>
edge(typename boost::graph_traits<Graph>::vertex_descriptor u
, typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
edge(u, v, boost::unwrap_ref(w.get<0>()));
return edge(u, v, boost::unwrap_ref(w.get<1>()));
edge(u, v, get<0>(w).get());
return edge(u, v, get<1>(w).get);
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::vertex_iterator>
vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
vertices(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
vertices(boost::unwrap_ref(w.get<0>()));
return vertices(boost::unwrap_ref(w.get<1>()));
vertices(get<0>(w).get());
return vertices(get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::edge_iterator>
edges(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
edges(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
edges(boost::unwrap_ref(w.get<0>()));
return edges(boost::unwrap_ref(w.get<1>()));
edges(get<0>(w).get());
return edges(get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::in_edge_iterator>
in_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
in_edges(u, boost::unwrap_ref(w.get<0>()));
return in_edges(u, boost::unwrap_ref(w.get<1>()));
in_edges(u, get<0>(w).get());
return in_edges(u, get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::out_edge_iterator>
out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
out_edges(u, boost::unwrap_ref(w.get<0>()));
return out_edges(u, boost::unwrap_ref(w.get<1>()));
out_edges(u, get<0>(w).get());
return out_edges(u, get<1>(w).get());
}
//
@ -381,72 +378,72 @@ out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
add_vertex(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_vertex(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_vertex(boost::unwrap_ref(w.get<0>()));
return add_vertex(boost::unwrap_ref(w.get<1>()));
add_vertex(get<0>(w).get());
return add_vertex(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
add_vertex(const typename boost::graph_traits<Graph >::vertex_property_type& p
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_vertex(p, boost::unwrap_ref(w.get<0>()));
return add_vertex(p, boost::unwrap_ref(w.get<1>()));
add_vertex(p, get<0>(w).get());
return add_vertex(p, get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_vertex(typename boost::graph_traits< Graph >::vertex_descriptor v
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_vertex(v, boost::unwrap_ref(w.get<0>()));
remove_vertex(v, boost::unwrap_ref(w.get<1>()));
remove_vertex(v, get<0>(w).get());
remove_vertex(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::edge_descriptor
add_edge(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_edge(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_edge(boost::unwrap_ref(w.get<0>()));
return add_edge(boost::unwrap_ref(w.get<1>()));
add_edge(get<0>(w).get());
return add_edge(get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_edge(typename boost::graph_traits< Graph >::edge_descriptor e
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_edge(e, boost::unwrap_ref(w.get<0>()));
remove_edge(e, boost::unwrap_ref(w.get<1>()));
remove_edge(e, get<0>(w).get());
remove_edge(e, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_target(typename boost::graph_traits< Graph >::halfedge_descriptor h1
, typename boost::graph_traits< Graph >::vertex_descriptor v
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_target(h1, v, boost::unwrap_ref(w.get<0>()));
set_target(h1, v, boost::unwrap_ref(w.get<1>()));
set_target(h1, v, get<0>(w).get());
set_target(h1, v, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
, typename boost::graph_traits< Graph >::halfedge_descriptor h2
, boost::tuple<boost::reference_wrapper<Visitor >,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor >,
std::reference_wrapper<Graph> >& w)
{
set_next(h1, h2, boost::unwrap_ref(w.get<0>()));
set_next(h1, h2, boost::unwrap_ref(w.get<1>()));
set_next(h1, h2, get<0>(w).get());
set_next(h1, h2, get<1>(w).get());
}
//
@ -454,65 +451,65 @@ set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
//
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
add_face(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_face(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_face(boost::unwrap_ref(w.get<0>()));
return add_face(boost::unwrap_ref(w.get<1>()));
add_face(get<0>(w).get());
return add_face(get<1>(w).get());
}
template <class InputIterator, class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
add_face(InputIterator begin,
InputIterator end,
boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_face(begin, end, boost::unwrap_ref(w.get<0>()));
return add_face(begin, end, boost::unwrap_ref(w.get<1>()));
add_face(begin, end, get<0>(w).get());
return add_face(begin, end, get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_face(typename boost::graph_traits< Graph >::face_descriptor f
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_face(f, boost::unwrap_ref(w.get<0>()));
return remove_face(f, boost::unwrap_ref(w.get<1>()));
remove_face(f, get<0>(w).get());
return remove_face(f, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_face(typename boost::graph_traits< Graph >::halfedge_descriptor h
, typename boost::graph_traits< Graph >::face_descriptor f
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_face(h, f, boost::unwrap_ref(w.get<0>()));
set_face(h, f, boost::unwrap_ref(w.get<1>()));
set_face(h, f, get<0>(w).get());
set_face(h, f, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_halfedge(typename boost::graph_traits< Graph >::face_descriptor f
, typename boost::graph_traits< Graph >::halfedge_descriptor h
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_halfedge(f, h, boost::unwrap_ref(w.get<0>()));
set_halfedge(f, h, boost::unwrap_ref(w.get<1>()));
set_halfedge(f, h, get<0>(w).get());
set_halfedge(f, h, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
, typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_halfedge(v, h, boost::unwrap_ref(w.get<0>()));
set_halfedge(v, h, boost::unwrap_ref(w.get<1>()));
set_halfedge(v, h, get<0>(w).get());
set_halfedge(v, h, get<1>(w).get());
}
//
@ -521,31 +518,31 @@ boost::reference_wrapper<Graph> >& w)
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::edge_descriptor
edge(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
edge(h, boost::unwrap_ref(w.get<0>()));
return edge(h, boost::unwrap_ref(w.get<1>()));
edge(h, get<0>(w).get());
return edge(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(e, boost::unwrap_ref(w.get<0>()));
return halfedge(e, boost::unwrap_ref(w.get<1>()));
halfedge(e, get<0>(w).get());
return halfedge(e, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(v, boost::unwrap_ref(w.get<0>()));
return halfedge(v, boost::unwrap_ref(w.get<1>()));
halfedge(v, get<0>(w).get());
return halfedge(v, get<1>(w).get());
}
template <class Graph, class Visitor>
@ -553,58 +550,58 @@ std::pair< typename boost::graph_traits< Graph >::halfedge_descriptor
, bool>
halfedge(typename boost::graph_traits< Graph >::vertex_descriptor u
, typename boost::graph_traits< Graph >::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(u, v, boost::unwrap_ref(w.get<0>()));
return halfedge(u, v, boost::unwrap_ref(w.get<1>()));
halfedge(u, v, get<0>(w).get());
return halfedge(u, v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
opposite(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
opposite(h, boost::unwrap_ref(w.get<0>()));
return opposite(h, boost::unwrap_ref(w.get<1>()));
opposite(h, get<0>(w).get());
return opposite(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
source(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
source(h, boost::unwrap_ref(w.get<0>()));
return source(h, boost::unwrap_ref(w.get<1>()));
source(h, get<0>(w).get());
return source(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
target(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
target(h, boost::unwrap_ref(w.get<0>()));
return target(h, boost::unwrap_ref(w.get<1>()));
target(h, get<0>(w).get());
return target(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
next(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
next(outedge, boost::unwrap_ref(w.get<0>()));
return next(outedge, boost::unwrap_ref(w.get<1>()));
next(outedge, get<0>(w).get());
return next(outedge, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
prev(outedge, boost::unwrap_ref(w.get<0>()));
return prev(outedge, boost::unwrap_ref(w.get<1>()));
prev(outedge, get<0>(w).get());
return prev(outedge, get<1>(w).get());
}
//
@ -612,73 +609,73 @@ prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
//
template <class Graph, class Visitor>
CGAL::Iterator_range<typename boost::graph_traits< Graph >::halfedge_iterator>
halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
halfedges(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
halfedges(boost::unwrap_ref(w.get<0>()));
return halfedges(boost::unwrap_ref(w.get<1>()));
halfedges(get<0>(w).get());
return halfedges(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedges_size_type
num_halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
num_halfedges(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
num_halfedges(boost::unwrap_ref(w.get<0>()));
return num_halfedges(boost::unwrap_ref(w.get<1>()));
num_halfedges(get<0>(w).get());
return num_halfedges(get<1>(w).get());
}
// Graph
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
face(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
face(h, boost::unwrap_ref(w.get<0>()));
return face(h, boost::unwrap_ref(w.get<1>()));
face(h, get<0>(w).get());
return face(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::face_descriptor f
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
halfedge(f, boost::unwrap_ref(w.get<0>()));
return halfedge(f, boost::unwrap_ref(w.get<1>()));
halfedge(f, get<0>(w).get());
return halfedge(f, get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::face_iterator >
faces(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
faces(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
faces(boost::unwrap_ref(w.get<0>()));
return faces(boost::unwrap_ref(w.get<1>()));
faces(get<0>(w).get());
return faces(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::faces_size_type
num_faces(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_faces(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_faces(boost::unwrap_ref(w.get<0>()));
return num_faces(boost::unwrap_ref(w.get<1>()));
num_faces(get<0>(w).get());
return num_faces(get<1>(w).get());
}
template <class Graph, class Visitor>
bool is_valid(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w
bool is_valid(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w
, bool verbose = false)
{
is_valid(boost::unwrap_ref(w.get<0>()), verbose);
return is_valid(boost::unwrap_ref(w.get<1>()), verbose);
is_valid(get<0>(w).get(), verbose);
return is_valid(get<1>(w).get(), verbose);
}
template <class Graph, class PropertyTag, class Visitor>
typename boost::property_map< Graph, PropertyTag >::type
get(PropertyTag ptag,
const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
get(ptag, boost::unwrap_ref(w.get<0>()));
return get(ptag, boost::unwrap_ref(w.get<1>()));
get(ptag, get<0>(w).get());
return get(ptag, get<1>(w).get());
}
}//end namespace CGAL

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

@ -270,8 +270,8 @@ join_vertex_interior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 3);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(degree(f.x, f.m) == 4);
assert(CGAL::is_valid_polygon_mesh(f.m));
}
@ -295,8 +295,8 @@ join_vertex_exterior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 4);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 4);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(degree(f.y, f.m) == 3);
assert(CGAL::is_valid_polygon_mesh(f.m));
}
@ -314,8 +314,8 @@ join_vertex_exterior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 4);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 4);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(CGAL::is_valid_polygon_mesh(f.m));
assert(degree(f.w, f.m) == 3);
@ -344,8 +344,8 @@ split_vertex()
assert(CGAL::is_valid_polygon_mesh(f.m));
assert(CGAL::internal::exact_num_vertices(f.m) == 7);
assert(CGAL::internal::exact_num_edges(f.m) == 8);
assert(boost::distance(CGAL::halfedges_around_face(h1, f.m)) == 5);
assert(boost::distance(CGAL::halfedges_around_face(h2, f.m)) == 7);
assert(CGAL::halfedges_around_face(h1, f.m).size() == 5);
assert(CGAL::halfedges_around_face(h2, f.m).size() == 7);
}
template <typename T>
@ -371,8 +371,8 @@ split_join_vertex_inverse()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(CGAL::internal::exact_num_halfedges(f.m) == 12);
assert(boost::distance(CGAL::halfedges_around_face(h1, f.m)) == 3);
assert(boost::distance(CGAL::halfedges_around_face(h2, f.m)) == 3);
assert(CGAL::halfedges_around_face(h1, f.m).size() == 3);
assert(CGAL::halfedges_around_face(h2, f.m).size() == 3);
}
@ -476,8 +476,8 @@ test_swap_edges()
{
Graph g;
CGAL::make_tetrahedron(pt,pt,pt,pt,g);
halfedge_descriptor h1 = *std::next(boost::begin(halfedges(g)), i);
halfedge_descriptor h2 = *std::next(boost::begin(halfedges(g)), j);
halfedge_descriptor h1 = *std::next(std::begin(halfedges(g)), i);
halfedge_descriptor h2 = *std::next(std::begin(halfedges(g)), j);
CGAL::internal::swap_edges(h1, h2, g);
assert(CGAL::is_valid_polygon_mesh(g));
}

2
BGL/test/BGL/test_Face_filtered_graph.cpp
View File

@ -37,7 +37,7 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
assert(target(*havit, fg) == *vit);
// check if we are really moving clockwise
halfedge_around_target_iterator step = boost::next(havit);
halfedge_around_target_iterator step = std::next(havit);
if(step != havend) {
halfedge_descriptor stepd = *step;
assert(stepd == opposite(next(*havit, fg), fg));

8
BGL/test/BGL/test_Has_member_clear.cpp
View File

@ -19,13 +19,13 @@ struct with_clear_const {
int main()
{
using namespace CGAL::internal;
CGAL_static_assertion(Has_member_clear<with_clear>::value);
static_assert(Has_member_clear<with_clear>::value);
CGAL_static_assertion(!Has_member_clear<wo_clear>::value);
static_assert(!Has_member_clear<wo_clear>::value);
CGAL_static_assertion(!Has_member_clear<with_clear_but_args>::value);
static_assert(!Has_member_clear<with_clear_but_args>::value);
CGAL_static_assertion(Has_member_clear<with_clear_const>::value);
static_assert(Has_member_clear<with_clear_const>::value);
return 0;
}

18
BGL/test/BGL/test_Has_member_id.cpp
View File

@ -28,17 +28,17 @@ int main()
{
using namespace CGAL::internal;
CGAL_static_assertion(!Has_member_id<StructNoId>::value);
CGAL_static_assertion(Has_member_id<StructWithId>::value);
CGAL_static_assertion(!Has_member_id<Polyhedron::Face>::value);
CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::Facet>::value);
CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::FBase>::value);
CGAL_static_assertion(
static_assert(!Has_member_id<StructNoId>::value);
static_assert(Has_member_id<StructWithId>::value);
static_assert(!Has_member_id<Polyhedron::Face>::value);
static_assert(Has_member_id<Polyhedron_with_ids::Facet>::value);
static_assert(Has_member_id<Polyhedron_with_ids::FBase>::value);
static_assert(
(Has_member_id<Polyhedron_with_ids::Items::Face_wrapper<Polyhedron_with_ids::HDS, K>::Face>::value));
CGAL_static_assertion(!Has_member_id<CGAL::Triangulation_face_base_2<K> >::value);
CGAL_static_assertion(Has_member_id<CGAL::Triangulation_vertex_base_with_id_2<K> >::value);
CGAL_static_assertion(Has_member_id<CGAL::Triangulation_face_base_with_id_2<K> >::value);
static_assert(!Has_member_id<CGAL::Triangulation_face_base_2<K> >::value);
static_assert(Has_member_id<CGAL::Triangulation_vertex_base_with_id_2<K> >::value);
static_assert(Has_member_id<CGAL::Triangulation_face_base_with_id_2<K> >::value);
return 0;
}

14
BGL/test/BGL/test_Properties.cpp
View File

@ -68,9 +68,9 @@ void test_uniqueness(const Graph&,
#endif
typename boost::range_iterator<ForwardRange>::type
begin = boost::begin(range),
begin2 = boost::begin(range),
end = boost::end(range);
begin = std::begin(range),
begin2 = std::begin(range),
end = std::end(range);
typedef std::unordered_set<typename IndexPropertyMap::value_type> id_map;
typedef std::pair<typename id_map::iterator, bool> resultp;
@ -98,7 +98,7 @@ void test_vertex_index_map_uniqueness(const Graph& g,
typedef typename CGAL::GetInitializedVertexIndexMap<Graph, NamedParameters>::const_type CVIM;
// in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
static_assert((std::is_same<VIM, CVIM>::value), "VIM, CVIM must be the same type");
static_assert(std::is_same<VIM, CVIM>::value, "VIM, CVIM must be the same type");
VIM ivim = CGAL::get_initialized_vertex_index_map(g, np);
@ -114,7 +114,7 @@ void test_halfedge_index_map_uniqueness(const Graph& g,
typedef typename CGAL::GetInitializedHalfedgeIndexMap<Graph, NamedParameters>::const_type CHIM;
// in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
static_assert((std::is_same<HIM, CHIM>::value), "HIM, CHIM must be the same type");
static_assert(std::is_same<HIM, CHIM>::value, "HIM, CHIM must be the same type");
HIM ihim = CGAL::get_initialized_halfedge_index_map(g, np);
@ -130,7 +130,7 @@ void test_edge_index_map_uniqueness(const Graph& g,
typedef typename CGAL::GetInitializedEdgeIndexMap<Graph, NamedParameters>::const_type CEIM;
// in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
static_assert((std::is_same<EIM, CEIM>::value), "EIM, CEIM must be the same type");
static_assert(std::is_same<EIM, CEIM>::value, "EIM, CEIM must be the same type");
EIM ieim = CGAL::get_initialized_edge_index_map(g, np);
@ -146,7 +146,7 @@ void test_face_index_map_uniqueness(const Graph& g,
typedef typename CGAL::GetInitializedFaceIndexMap<Graph, NamedParameters>::const_type CFIM;
// in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
static_assert((std::is_same<FIM, CFIM>::value), "FIM, CFIM must be the same type");
static_assert(std::is_same<FIM, CFIM>::value, "FIM, CFIM must be the same type");
FIM ifim = CGAL::get_initialized_face_index_map(g, np);

125
BGL/test/BGL/test_Surface_mesh.cpp
View File

@ -1,125 +0,0 @@
#define BOOST_TEST_MODULE graph_traits test
#include <boost/test/unit_test.hpp>
#include <boost/test/floating_point_comparison.hpp>
BOOST_AUTO_TEST_CASE( edges_test )
{
edge_iterator eb, ee;
vertex_iterator vb, ve;
Surface_fixture f;
boost::tie(eb, ee) = edges(f.m);
boost::tie(vb, ve) = vertices(f.m);
BOOST_CHECK(std::distance(eb, ee) == 7);
BOOST_CHECK(std::distance(vb, ve) == 5);
Cube_fixture cf;
boost::tie(eb, ee) = edges(cf.m);
boost::tie(vb, ve) = vertices(cf.m);
BOOST_CHECK(std::distance(eb, ee) == 18);
BOOST_CHECK(std::distance(vb, ve) == 8);
}
BOOST_AUTO_TEST_CASE( out_edges_test )
{
Surface_fixture f;
BOOST_CHECK(out_degree(f.u, f.m) == 2);
BOOST_CHECK(out_degree(f.v, f.m) == 4);
std::pair<out_edge_iterator, out_edge_iterator> out = out_edges(f.v, f.m);
BOOST_CHECK(std::distance(out.first, out.second) == 4);
out_edge_iterator it = out.first;
while(it != out.second) {
// the source should always be u
BOOST_CHECK(source(*it, f.m) == f.v);
// the target never
BOOST_CHECK(target(*it, f.m) != f.v);
++it;
}
}
BOOST_AUTO_TEST_CASE( in_edges_test )
{
Surface_fixture f;
BOOST_CHECK(in_degree(f.u, f.m) == 2);
BOOST_CHECK(in_degree(f.x, f.m) == 3);
BOOST_CHECK(in_degree(f.v, f.m) == 4);
std::pair<in_edge_iterator, in_edge_iterator> in = in_edges(f.v, f.m);
BOOST_CHECK(std::distance(in.first, in.second) == 4);
in_edge_iterator it = in.first;
while(it != in.second) {
// the source should never be u
BOOST_CHECK(source(*it, f.m) != f.v);
// the target must always be u
BOOST_CHECK(target(*it, f.m) == f.v);
++it;
}
}
BOOST_AUTO_TEST_CASE( in_out_equality )
{
// in and out degrees must be equal for each vertex
Cube_fixture f;
for(Sm::Vertex_iterator it = f.m.vertices_begin();
it != f.m.vertices_end(); ++it) {
BOOST_CHECK(in_degree(*it, f.m) == out_degree(*it, f.m));
}
}
BOOST_AUTO_TEST_CASE( face_test )
{
Surface_fixture f;
std::pair<enclosure_iterator, enclosure_iterator>
enc = enclosure(f.f1, f.m);
BOOST_CHECK(enc.first != enc.second);
BOOST_CHECK(std::distance(enc.first, enc.second) == 3);
enclosure_iterator begin = enc.first;
while(begin != enc.second)
{
BOOST_CHECK(face(*begin, f.m) == f.f1);
++begin;
}
}
BOOST_AUTO_TEST_CASE( weight_map_test )
{
Surface_fixture f;
Cube_fixture c;
CGAL::SM_edge_weight_pmap<K> wm1 = boost::get(boost::edge_weight, c.m);
edge_iterator eb, ee;
boost::test_tools::check_is_close_t check_close;
for(boost::tie(eb, ee) = edges(c.m); eb != ee; ++eb) {
BOOST_CHECK(
check_close(wm1[*eb], 2.0, boost::test_tools::percent_tolerance_t<double>(0.00001))
|| check_close(wm1[*eb], 2.82843, boost::test_tools::percent_tolerance_t<double>(0.001)));
}
}
BOOST_AUTO_TEST_CASE( vertices_test )
{
Surface_fixture f;
// boost::property_map<Sm,boost::vertex_index_t>::type vi_map = get(f.m, boost::vertex_index);
// vertex_iterator b,e;
// for(boost::tie(b,e) = vertices(f.m);
// b!= e;
// ++b){
// std::cout << boost::get(vi_map, *(b)) << std::endl;
// }
// boost::property_map<Sm,boost::edge_weight_t>::type ew_map = get(f.m, boost::edge_weight);
// edge_iterator be, ee;
// for(boost::tie(be,ee) = edges(f.m);
// be!= ee;
// ++be){
// std::cout << boost::get(ew_map, *(be)) << std::endl;
// }
}

14
BGL/test/BGL/test_deprecated_io.cpp
View File

@ -21,18 +21,18 @@ int main()
SM sm_in, sm_out;
Point_3 p0(0,0,0), p1(1,0,0), p2(0,1,0);
CGAL::make_triangle(p0, p1, p2, sm_out);
bool ok = CGAL::write_off("tmp.off", sm_out);
bool ok = CGAL::write_off("tmp_deprecated.off", sm_out);
assert(ok);
ok = CGAL::read_off("tmp.off", sm_in);
ok = CGAL::read_off("tmp_deprecated.off", sm_in);
assert(ok);
assert(num_vertices(sm_in) == 3 && num_faces(sm_in) == 1);
sm_in.clear();
std::ofstream os("tmp.off");
std::ofstream os("tmp_deprecated.off");
ok = CGAL::write_off(os, sm_out);
assert(ok);
os.close();
std::ifstream is("tmp.off");
std::ifstream is("tmp_deprecated.off");
ok = CGAL::read_off(is, sm_in);
assert(ok);
assert(num_vertices(sm_in) == 3 && num_faces(sm_in) == 1);
@ -40,18 +40,18 @@ int main()
sm_in.clear();
#ifdef CGAL_USE_VTK
//vtk
os.open("tmp.vtp");
os.open("tmp_deprecated.vtp");
ok = CGAL::write_vtp(os, sm_out);
assert(ok);
os.close();
ok = CGAL::IO::read_VTP("tmp.vtp", sm_in);
ok = CGAL::IO::read_VTP("tmp_deprecated.vtp", sm_in);
assert(ok);
assert(num_vertices(sm_in) == 3 && num_faces(sm_in) == 1);
sm_in.clear();
#endif
//wrl
os.open("tmp.wrl");
os.open("tmp_deprecated.wrl");
ok = CGAL::write_wrl(os, sm_out);
assert(ok);
os.close();

2
BGL/test/BGL/test_graph_traits.cpp
View File

@ -34,7 +34,7 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
assert(target(*havit, g) == *vit);
// check if we are really moving clockwise
halfedge_around_target_iterator step = boost::next(havit);
halfedge_around_target_iterator step = std::next(havit);
if(step != havend) {
halfedge_descriptor stepd = *step;
assert(stepd == opposite(next(*havit, g), g));

22
Barycentric_coordinates_2/doc/Barycentric_coordinates_2/Barycentric_coordinates_2.txt
View File

@ -451,10 +451,10 @@ To fix the problem, we modify the weights \f$w_i\f$ as
</center>
After the above normalization, this gives us the precise algorithm to compute Wachspress coordinates
but with \f$O(n^2)\f$ performance only. The max speed \f$O(n)\f$ algorithm uses the standard
but with \cgalBigO{n^2} performance only. The max speed \cgalBigO{n} algorithm uses the standard
weights \f$w_i\f$. Note that mathematically this modification does not change the coordinates. One should
be cautious when using the unnormalized Wachspress weights. In that case, you must choose the
\f$O(n)\f$ type.
\cgalBigO{n} type.
It is known that for strictly convex polygons the denominator's zero set of the
Wachspress coordinates (\f$W^{wp} = 0~\f$) is a curve, which (in many cases) lies quite
@ -507,10 +507,10 @@ To fix the problem, similarly to the previous subsection, we modify the weights
</center>
After the above normalization, this yields the precise algorithm to compute discrete harmonic coordinates
but with \f$O(n^2)\f$ performance only. The max speed \f$O(n)\f$ algorithm uses the standard
but with \cgalBigO{n^2} performance only. The max speed \cgalBigO{n} algorithm uses the standard
weights \f$w_i\f$. Again, mathematically this modification does not change the coordinates,
one should be cautious when using the unnormalized discrete harmonic weights. In that case,
you must choose the \f$O(n)\f$ type.
you must choose the \cgalBigO{n} type.
\b Warning: as for Wachspress coordinates, we do not recommend using discrete harmonic coordinates
for exterior points, because the curve \f$W^{dh} = 0\f$ may have several components,
@ -563,7 +563,7 @@ After the normalization of these weights as before
\f$b_i = \frac{w_i}{W^{mv}}\qquad\f$ with \f$\qquad W^{mv} = \sum_{j=1}^n w_j\f$
</center>
we obtain the max precision \f$O(n^2)\f$ algorithm. The max speed \f$O(n)\f$ algorithm computes the
we obtain the max precision \cgalBigO{n^2} algorithm. The max speed \cgalBigO{n} algorithm computes the
weights \f$w_i\f$ using the pseudocode from <a href="https://www.inf.usi.ch/hormann/nsfworkshop/presentations/Hormann.pdf">here</a>.
These weights
@ -575,7 +575,7 @@ with \f$\qquad t_i = \frac{\text{det}(d_i, d_{i+1})}{r_ir_{i+1} + d_id_{i+1}}\f$
are also normalized. Note that they are unstable if a query point is closer than \f$\approx 1.0e-10\f$
to the polygon boundary, similarly to Wachspress and discrete harmonic coordinates and
one should be cautious when using the unnormalized mean value weights. In that case, you must choose the
\f$O(n)\f$ type.
\cgalBigO{n} type.
\anchor compute_hm_coord
@ -654,17 +654,17 @@ The resulting timings for all closed-form coordinates can be found in the figure
\cgalFigureBegin{analytic_timings, analytic_timings.png}
Time in seconds to compute \f$n\f$ coordinate values for a polygon with \f$n\f$ vertices
at 1 million query points with the max speed \f$O(n)\f$ algorithms (dashed) and
at 1 million query points with the max speed \cgalBigO{n} algorithms (dashed) and
the max precision \f$0(n^2)\f$ algorithms (solid) for Wachspress (blue), discrete
harmonic (red), and mean value (green) coordinates.
\cgalFigureEnd
From the figure above we observe that the \f$O(n^2)\f$ algorithm is as fast
as the \f$O(n)\f$ algorithm if we have a polygon with a small number of vertices.
From the figure above we observe that the \cgalBigO{n^2} algorithm is as fast
as the \cgalBigO{n} algorithm if we have a polygon with a small number of vertices.
But as the number of vertices is increased, the linear algorithm outperforms the squared one,
as expected. One of the reasons for this behavior is that for a small number of vertices
the multiplications of \f$n-2\f$ elements inside the \f$O(n^2)\f$ algorithm take almost the
same time as the corresponding divisions in the \f$O(n)\f$ algorithm. For a polygon with
the multiplications of \f$n-2\f$ elements inside the \cgalBigO{n^2} algorithm take almost the
same time as the corresponding divisions in the \cgalBigO{n} algorithm. For a polygon with
many vertices, these multiplications are substantially slower.
To benchmark harmonic coordinates, we used a MacBook Pro 2018 with 2.2 GHz Intel Core i7 processor (6 cores)

16
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_meta_traits.h
View File

@ -123,14 +123,14 @@ public:
typedef typename Arr::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded)
CGAL_static_assertion((std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Left_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Bottom_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Top_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Top_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Right_side_category, Arr_open_side_tag>::value));
static_assert(std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Left_side_category, Arr_open_side_tag>::value);
static_assert(std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Bottom_side_category, Arr_open_side_tag>::value);
static_assert(std::is_same<Top_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Top_side_category, Arr_open_side_tag>::value);
static_assert(std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Right_side_category, Arr_open_side_tag>::value);
typedef typename Arr::Halfedge_handle Halfedge_handle;
typedef typename Arr::Vertex_handle Vertex_handle;

16
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_traits_decorator.h
View File

@ -53,14 +53,14 @@ public:
typedef typename Base::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded)
CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Top_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value));
static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Top_side_category, Arr_open_side_tag >::value);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value);
class Ex_point_2
{

2
Bounding_volumes/doc/Bounding_volumes/CGAL/Approximate_min_ellipsoid_d.h
View File

@ -119,7 +119,7 @@ We implement Khachyian's algorithm for rounding
polytopes \cgalCite{cgal:k-rprnm-96}. Internally, we use
`double`-arithmetic and (initially a single)
Cholesky-decomposition. The algorithm's running time is
\f$ {\cal O}(nd^2(\epsilon^{-1}+\ln d + \ln\ln(n)))\f$, where \f$ n=|P|\f$ and
\cgalBigO{nd^2(\epsilon^{-1}+\ln d + \ln\ln(n))}, where \f$ n=|P|\f$ and
\f$ 1+\epsilon\f$ is the desired approximation ratio.
\cgalHeading{Example}

2
Bounding_volumes/doc/Bounding_volumes/CGAL/Min_sphere_of_spheres_d.h
View File

@ -76,7 +76,7 @@ We implement two algorithms, the LP-algorithm and a
heuristic \cgalCite{msw-sblp-92}. As described in the documentation of
concept `MinSphereOfSpheresTraits`, each has its advantages and
disadvantages: Our implementation of the LP-algorithm has maximal
expected running time \f$ O(2^d n)\f$, while the heuristic comes without
expected running time \cgalBigO{2^d n}, while the heuristic comes without
any complexity guarantee. In particular, the LP-algorithm runs in
linear time for fixed dimension \f$ d\f$. (These running times hold for the
arithmetic model, so they count the number of operations on

2
Bounding_volumes/doc/Bounding_volumes/CGAL/rectangular_p_center_2.h
View File

@ -245,7 +245,7 @@ must be a model for `RectangularPCenterTraits_2`.
\cgalHeading{Implementation}
The runtime is linear for \f$ p \in \{2,\,3\}\f$ and
\f$ \mathcal{O}(n \cdot \log n)\f$ for \f$ p = 4\f$ where \f$ n\f$ is the number of
\cgalBigO{n \cdot \log n} for \f$ p = 4\f$ where \f$ n\f$ is the number of
input points. These runtimes are worst case optimal. The \f$ 3\f$-center
algorithm uses a prune-and-search technique described in
\cgalCite{cgal:h-slacr-99}. The \f$ 4\f$-center implementation uses sorted matrix

2
Bounding_volumes/doc/Bounding_volumes/Concepts/MinSphereOfSpheresTraits.h
View File

@ -79,7 +79,7 @@ The recommended choice is the first, which is a synonym to the one
of the other two methods which we consider "the best in practice."
In case of `CGAL::LP_algorithm`, the minsphere will be computed
using the LP-algorithm \cgalCite{msw-sblp-92}, which in our
implementation has maximal expected running time \f$ O(2^d n)\f$ (in the
implementation has maximal expected running time \cgalBigO{2^d n} (in the
number of operations on the number type `FT`). In case of
`CGAL::Farthest_first_heuristic`, a simple heuristic will be
used instead which seems to work fine in practice, but comes without

8
Box_intersection_d/doc/Box_intersection_d/Box_intersection_d.txt
View File

@ -350,12 +350,12 @@ parameter the function switches from the streamed segment-tree
algorithm to the two-way-scan algorithm, see \cgalCite{cgal:ze-fsbi-02}
for the details.
The streamed segment-tree algorithm needs \f$ O(n \log^d (n) + k)\f$
worst-case running time and \f$ O(n)\f$ space, where \f$ n\f$ is the number of
The streamed segment-tree algorithm needs \cgalBigO{n \log^d (n) + k}
worst-case running time and \cgalBigO{n} space, where \f$ n\f$ is the number of
boxes in both input sequences, \f$ d\f$ the (constant) dimension of the
boxes, and \f$ k\f$ the output complexity, i.e., the number of pairwise
intersections of the boxes. The two-way-scan algorithm needs \f$ O(n \log
(n) + l)\f$ worst-case running time and \f$ O(n)\f$ space, where \f$ l\f$ is the
intersections of the boxes. The two-way-scan algorithm needs \cgalBigO{n \log
(n) + l} worst-case running time and \cgalBigO{n} space, where \f$ l\f$ is the
number of pairwise overlapping intervals in one dimensions (the
dimension where the algorithm is used instead of the segment tree).
Note that \f$ l\f$ is not necessarily related to \f$ k\f$ and using the

12
Box_intersection_d/doc/Box_intersection_d/CGAL/box_intersection_d.h
View File

@ -77,7 +77,7 @@ namespace CGAL {
\cgalHeading{Implementation}
The algorithm is trivially testing all pairs and runs therefore in time
\f$ O(nm)\f$ where \f$ n\f$ is the size of the first sequence and \f$ m\f$ is the
\cgalBigO{nm} where \f$ n\f$ is the size of the first sequence and \f$ m\f$ is the
size of the second sequence.
*/
@ -219,12 +219,12 @@ void box_intersection_all_pairs_d(
algorithm to the two-way-scan algorithm, see \cgalCite{cgal:ze-fsbi-02}
for the details.
The streamed segment-tree algorithm needs \f$ O(n \log^d (n) + k)\f$
worst-case running time and \f$ O(n)\f$ space, where \f$ n\f$ is the number of
The streamed segment-tree algorithm needs \cgalBigO{n \log^d (n) + k}
worst-case running time and \cgalBigO{n} space, where \f$ n\f$ is the number of
boxes in both input sequences, \f$ d\f$ the (constant) dimension of the
boxes, and \f$ k\f$ the output complexity, i.e., the number of pairwise
intersections of the boxes. The two-way-scan algorithm needs \f$ O(n \log
(n) + l)\f$ worst-case running time and \f$ O(n)\f$ space, where \f$ l\f$ is the
intersections of the boxes. The two-way-scan algorithm needs \cgalBigO{n \log
(n) + l} worst-case running time and \cgalBigO{n} space, where \f$ l\f$ is the
number of pairwise overlapping intervals in one dimensions (the
dimension where the algorithm is used instead of the segment tree).
Note that \f$ l\f$ is not necessarily related to \f$ k\f$ and using the
@ -397,7 +397,7 @@ namespace CGAL {
\cgalHeading{Implementation}
The algorithm is trivially testing all pairs and runs therefore in time
\f$ O(n^2)\f$ where \f$ n\f$ is the size of the input sequence. This algorithm
\cgalBigO{n^2} where \f$ n\f$ is the size of the input sequence. This algorithm
does not use the id-number of the boxes.
*/

2
Box_intersection_d/include/CGAL/Box_intersection_d/segment_tree.h
View File

@ -326,7 +326,7 @@ public:
};
template <class T>
CGAL_CPP17_INLINE constexpr bool Has_member_report_v = Has_member_report<T>::value;
inline constexpr bool Has_member_report_v = Has_member_report<T>::value;
template <typename Callback>
inline

4
Box_intersection_d/include/CGAL/box_intersection_d.h
View File

@ -63,10 +63,10 @@ void box_intersection_segment_tree_d(
const NT sup = Box_intersection_d::box_limits<NT>::sup();
#ifndef CGAL_LINKED_WITH_TBB
CGAL_static_assertion_msg (!(boost::is_convertible<ConcurrencyTag, Parallel_tag>::value),
static_assert (!std::is_convertible<ConcurrencyTag, Parallel_tag>::value,
"Parallel_tag is enabled but TBB is unavailable.");
#else // CGAL_LINKED_WITH_TBB
if(boost::is_convertible<ConcurrencyTag, Parallel_tag>::value)
if(std::is_convertible<ConcurrencyTag, Parallel_tag>::value)
{
// Here is an illustration for n=2.
//

6
Box_intersection_d/test/Box_intersection_d/test_Has_member_report.cpp
View File

@ -18,8 +18,8 @@ struct With_report_as_a_template_member_function {
int main() {
using CGAL::Box_intersection_d::Has_member_report;
CGAL_static_assertion(!Has_member_report<S>::value);
CGAL_static_assertion(Has_member_report<With_report>::value);
CGAL_static_assertion(Has_member_report<With_report_as_a_template_member_function>::value);
static_assert(!Has_member_report<S>::value);
static_assert(Has_member_report<With_report>::value);
static_assert(Has_member_report<With_report_as_a_template_member_function>::value);
return EXIT_SUCCESS;
}

4
CGAL_ImageIO/include/CGAL/ImageIO/bmptypes.h
View File

@ -39,10 +39,10 @@
typedef char CGAL_INT8;
typedef short CGAL_INT16;
typedef boost::int32_t CGAL_INT32;
typedef std::int32_t CGAL_INT32;
typedef unsigned char CGAL_UINT8;
typedef unsigned short CGAL_UINT16;
typedef boost::uint32_t CGAL_UINT32;
typedef std::uint32_t CGAL_UINT32;
/*****************************************************************************
*

10
CGAL_ImageIO/include/CGAL/Image_3_vtk_interface.h
View File

@ -55,31 +55,31 @@ struct VTK_type_generator<char> {
};
template <>
struct VTK_type_generator<boost::uint8_t> {
struct VTK_type_generator<std::uint8_t> {
static const int type = VTK_UNSIGNED_CHAR;
typedef vtkUnsignedCharArray ArrayType;
};
template <>
struct VTK_type_generator<boost::int16_t> {
struct VTK_type_generator<std::int16_t> {
static const int type = VTK_SHORT;
typedef vtkShortArray ArrayType;
};
template <>
struct VTK_type_generator<boost::uint16_t> {
struct VTK_type_generator<std::uint16_t> {
static const int type = VTK_UNSIGNED_SHORT;
typedef vtkUnsignedShortArray ArrayType;
};
template <>
struct VTK_type_generator<boost::int32_t> {
struct VTK_type_generator<std::int32_t> {
static const int type = VTK_INT;
typedef vtkIntArray ArrayType;
};
template <>
struct VTK_type_generator<boost::uint32_t> {
struct VTK_type_generator<std::uint32_t> {
static const int type = VTK_UNSIGNED_INT;
typedef vtkUnsignedIntArray ArrayType;
};

7
CGAL_ImageIO/include/CGAL/SEP_header.h
View File

@ -20,7 +20,6 @@
#include <boost/tuple/tuple.hpp>
#include <boost/fusion/adapted/boost_tuple.hpp>
#include <boost/array.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/phoenix/operator.hpp>
@ -106,9 +105,9 @@ namespace CGAL {
class SEP_header {
boost::array<std::size_t, 3> _n;
boost::array<double, 3> _d;
boost::array<double, 3> _o;
std::array<std::size_t, 3> _n;
std::array<double, 3> _d;
std::array<double, 3> _o;
SEP_header_aux::String_dict _string_dict;

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