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

remove extra parenthesis

This commit is contained in:
Sébastien Loriot 2023-06-19 19:17:49 +02:00
parent bbc4d08ee0
commit 0ee31a5d4f
156 changed files with 510 additions and 521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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 > boost::optional< typename AABB_tree<AABBTraits>::template Intersection_and_primitive_id<Ray>::Type >
AABB_tree<AABBTraits>::first_intersection(const Ray& query, AABB_tree<AABBTraits>::first_intersection(const Ray& query,
const SkipFunctor& skip) const { const SkipFunctor& skip) const {
static_assert((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"); "Ray and Ray_3 must be the same type");
switch(size()) // copy-paste from AABB_tree::traversal switch(size()) // copy-paste from AABB_tree::traversal

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::Numerator_type Numerator_type;
typedef FT::Denominator_type Denominator_type; typedef FT::Denominator_type Denominator_type;
static_assert((std::is_same<Numerator_type,CGAL::Gmpz>::value)); static_assert(std::is_same<Numerator_type,CGAL::Gmpz>::value);
static_assert((std::is_same<Denominator_type,CGAL::Gmpz>::value)); static_assert(std::is_same<Denominator_type,CGAL::Gmpz>::value);
Numerator_type numerator; Numerator_type numerator;
Denominator_type denominator; 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; typedef CGAL::Coercion_traits<A,B> CT;
// check for explicit interoperability // check for explicit interoperability
static_assert((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 // CT::Cast is used to to convert both types into the coercion type
typename CT::Cast cast; 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 Coercion_traits< NT1, NT2 > CT;
typedef typename CT::Type Coercion_type_NT1_NT2; typedef typename CT::Type Coercion_type_NT1_NT2;
CGAL_USE_TYPE(Coercion_type_NT1_NT2); CGAL_USE_TYPE(Coercion_type_NT1_NT2);
static_assert(( static_assert(::std::is_same<Coercion_type_NT1_NT2 , Type >::value);
::std::is_same<Coercion_type_NT1_NT2 , Type >::value));
typename Coercion_traits< NT1, NT2 >::Cast cast; typename Coercion_traits< NT1, NT2 >::Cast cast;
operator()( cast(x), cast(y), q, r ); 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 ) \ #define CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR_WITH_RT( NT, Result_type ) \
template < class CT_Type_1, class CT_Type_2 > \ template < class CT_Type_1, class CT_Type_2 > \
Result_type operator()( const CT_Type_1& x, const CT_Type_2& y ) const { \ Result_type operator()( const CT_Type_1& x, const CT_Type_2& y ) const { \
static_assert((::std::is_same< \ static_assert(::std::is_same< \
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT \ typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT \
>::value)); \ >::value) ; \
\ \
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Cast cast; \ typename Coercion_traits< CT_Type_1, CT_Type_2 >::Cast cast; \
return operator()( cast(x), cast(y) ); \ 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 // determine extractable scalar factor
Scalar operator () (const NT& a) { Scalar operator () (const NT& a) {
static_assert(( ::std::is_same< NT,Scalar >::value)); static_assert(::std::is_same< NT,Scalar >::value);
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT; typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
return scalar_factor(a, SAT()); return scalar_factor(a, SAT());
} }
// determine extractable scalar factor // determine extractable scalar factor
Scalar operator () (const NT& a, const Scalar& d) { Scalar operator () (const NT& a, const Scalar& d) {
static_assert(( ::std::is_same< NT,Scalar >::value)); static_assert(::std::is_same< NT,Scalar >::value);
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT; typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
return scalar_factor(a,d,SAT()); return scalar_factor(a,d,SAT());
} }

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

@ -44,7 +44,7 @@
template <typename AdaptableFunctor, typename ResultType> template <typename AdaptableFunctor, typename ResultType>
void check_result_type(AdaptableFunctor, ResultType){ void check_result_type(AdaptableFunctor, ResultType){
typedef typename AdaptableFunctor::result_type result_type; typedef typename AdaptableFunctor::result_type result_type;
static_assert((::std::is_same<result_type,ResultType>::value)); static_assert(::std::is_same<result_type,ResultType>::value);
CGAL_USE_TYPE(result_type); CGAL_USE_TYPE(result_type);
} }
// check nothing for CGAL::Null_functor // 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); CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor; using CGAL::Null_functor;
static_assert( static_assert(!::std::is_same< Integral_division, Null_functor >::value);
(!::std::is_same< Integral_division, Null_functor >::value)); static_assert(!::std::is_same< Divides, 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_zero, Null_functor >::value)); static_assert(!::std::is_same< Is_one, Null_functor >::value);
static_assert((!::std::is_same< Is_one, Null_functor >::value)); static_assert(!::std::is_same< Square, Null_functor >::value);
static_assert((!::std::is_same< Square, Null_functor >::value));
// functor // functor
const Is_zero is_zero = Is_zero(); const Is_zero is_zero = Is_zero();
@ -206,7 +205,7 @@ void test_algebraic_structure_intern(
CGAL_SNAP_AST_FUNCTORS(AST); CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor; using CGAL::Null_functor;
static_assert((!::std::is_same< Gcd, Null_functor>::value)); static_assert(!::std::is_same< Gcd, Null_functor>::value);
const Gcd gcd = Gcd(); const Gcd gcd = Gcd();
assert( gcd( AS ( 0), AS ( 0)) == unit_normal( AS (0) ) ); 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); CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor; using CGAL::Null_functor;
static_assert((!::std::is_same< Div, 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< Mod, Null_functor>::value);
static_assert((!::std::is_same< Div_mod, Null_functor>::value)); static_assert(!::std::is_same< Div_mod, Null_functor>::value);
const Div div=Div(); const Div div=Div();
const Mod mod=Mod(); 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_SNAP_AST_FUNCTORS(AST);
static_assert((!::std::is_same< Sqrt, Null_functor>::value)); static_assert(!::std::is_same< Sqrt, Null_functor>::value);
const Sqrt sqrt =Sqrt(); const Sqrt sqrt =Sqrt();
AS a(4); AS a(4);
@ -617,7 +616,7 @@ class Test_is_square {
( ::std::is_same< AS , First_argument_type>::value)); ( ::std::is_same< AS , First_argument_type>::value));
static_assert( static_assert(
( ::std::is_same< AS& , Second_argument_type>::value)); ( ::std::is_same< AS& , Second_argument_type>::value));
//static_assert(( ::std::is_same< bool , Result_type>::value)); //static_assert(::std::is_same< bool , Result_type>::value);
bool b = Result_type(true); CGAL_USE(b); bool b = Result_type(true); CGAL_USE(b);
AS test_number = AS(3)*AS(3); AS test_number = AS(3)*AS(3);
@ -649,8 +648,8 @@ public:
typedef typename Sqrt::result_type Result_type; typedef typename Sqrt::result_type Result_type;
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
static_assert(( ::std::is_same< AS , Argument_type>::value)); static_assert(::std::is_same< AS , Argument_type>::value);
static_assert(( ::std::is_same< AS , Result_type>::value)); static_assert(::std::is_same< AS , Result_type>::value);
typedef Algebraic_structure_traits<AS> AST; typedef Algebraic_structure_traits<AS> AST;
typedef typename AST::Is_exact Is_exact; typedef typename AST::Is_exact Is_exact;
assert( !Is_exact::value || AS (3) == sqrt( AS (9))); assert( !Is_exact::value || AS (3) == sqrt( AS (9)));
@ -803,7 +802,7 @@ void test_algebraic_structure(){
typedef CGAL::Algebraic_structure_traits< AS > AST; typedef CGAL::Algebraic_structure_traits< AS > AST;
CGAL_SNAP_AST_FUNCTORS(AST); CGAL_SNAP_AST_FUNCTORS(AST);
static_assert((::std::is_same<AS,typename AST::Type>::value)); static_assert(::std::is_same<AS,typename AST::Type>::value);
typedef typename AST::Boolean Boolean; typedef typename AST::Boolean Boolean;
assert(!Boolean()); assert(!Boolean());
@ -816,14 +815,12 @@ void test_algebraic_structure(){
using CGAL::Integral_domain_without_division_tag; using CGAL::Integral_domain_without_division_tag;
using CGAL::Null_functor; using CGAL::Null_functor;
// Test for desired exactness // Test for desired exactness
static_assert( static_assert(::std::is_same< typename AST::Is_exact, Is_exact >::value);
( ::std::is_same< typename AST::Is_exact, Is_exact >::value)); static_assert(::std::is_convertible< Tag,
Integral_domain_without_division_tag >::value );
static_assert(( ::boost::is_convertible< Tag, static_assert(::std::is_same< Tag, Algebraic_category>::value);
Integral_domain_without_division_tag >::value )); static_assert(!::std::is_same< Simplify, Null_functor>::value);
static_assert(( ::std::is_same< Tag, Algebraic_category>::value)); static_assert(!::std::is_same< Unit_part, Null_functor>::value);
static_assert((!::std::is_same< Simplify, Null_functor>::value));
static_assert((!::std::is_same< Unit_part, Null_functor>::value));
const Simplify simplify=Simplify();; const Simplify simplify=Simplify();;
const Unit_part unit_part= Unit_part(); const Unit_part unit_part= Unit_part();

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

@ -346,9 +346,9 @@ void test_explicit_interoperable_one_way(){
typedef typename CT::Cast Cast; typedef typename CT::Cast Cast;
typedef typename Cast::result_type result_type; typedef typename Cast::result_type result_type;
CGAL_USE_TYPE(result_type); CGAL_USE_TYPE(result_type);
static_assert((::std::is_same<result_type,Type>::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< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
static_assert((::std::is_same<Type,RT>::value)); static_assert(::std::is_same<Type,RT>::value);
typename CT::Cast cast; typename CT::Cast cast;
A a(3); 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; typedef typename FT::Compose Compose;
CGAL_USE_TYPE(Is_fraction); CGAL_USE_TYPE(Is_fraction);
static_assert( (::std::is_same<Type,T>::value)); static_assert(::std::is_same<Type,T>::value);
static_assert( (::std::is_same<Is_fraction,Tag_true>::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<Common_factor,Null_functor>::value);
static_assert(!(::std::is_same<Decompose,Null_functor>::value)); static_assert(!::std::is_same<Decompose,Null_functor>::value);
static_assert(!(::std::is_same<Compose,Null_functor>::value)); static_assert(!::std::is_same<Compose,Null_functor>::value);
// Decompose // 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 Rational_traits<Rational> Rational_traits;
typedef typename Rational_traits::RT RT; typedef typename Rational_traits::RT RT;
static_assert((::std::is_same<RT,RT>::value)); static_assert(::std::is_same<RT,RT>::value);
assert( Rational_traits().numerator(x) == RT(7)); assert( Rational_traits().numerator(x) == RT(7));
assert( Rational_traits().denominator(x) == RT(2)); 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) { void operator() (const ToDouble& to_double) {
typedef typename ToDouble::argument_type Argument_type; typedef typename ToDouble::argument_type Argument_type;
typedef typename ToDouble::result_type Result_type; typedef typename ToDouble::result_type Result_type;
static_assert(( ::std::is_same<Type, Argument_type>::value)); static_assert( ::std::is_same<Type, Argument_type>::value);
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
static_assert(( ::std::is_same<double, Result_type>::value)); static_assert( ::std::is_same<double, Result_type>::value);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
assert(42.0 == to_double(Type(42))); 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::argument_type Argument_type;
typedef typename To_interval::result_type Result_type; typedef typename To_interval::result_type Result_type;
typedef std::pair<double,double> Interval_type; typedef std::pair<double,double> Interval_type;
static_assert(( ::std::is_same<Type, Argument_type>::value)); static_assert( ::std::is_same<Type, Argument_type>::value);
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
static_assert(( ::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); CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Interval_type);
// assert(NiX::in(42.0,to_Interval(Type(42)))); // assert(NiX::in(42.0,to_Interval(Type(42))));
@ -139,7 +139,7 @@ void test_real_embeddable() {
CGAL_SNAP_RET_FUNCTORS(RET); CGAL_SNAP_RET_FUNCTORS(RET);
typedef typename RET::Is_real_embeddable Is_real_embeddable; typedef typename RET::Is_real_embeddable Is_real_embeddable;
using CGAL::Tag_true; using CGAL::Tag_true;
static_assert(( ::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); CGAL_USE_TYPE(Is_real_embeddable);
typedef typename RET::Boolean Boolean; typedef typename RET::Boolean Boolean;
@ -246,7 +246,7 @@ void test_not_real_embeddable() {
typedef CGAL::Real_embeddable_traits<Type> RET; typedef CGAL::Real_embeddable_traits<Type> RET;
typedef typename RET::Is_real_embeddable Is_real_embeddable; typedef typename RET::Is_real_embeddable Is_real_embeddable;
using CGAL::Tag_false; using CGAL::Tag_false;
static_assert(( ::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); CGAL_USE_TYPE(Is_real_embeddable);
} }
@ -254,13 +254,13 @@ void test_not_real_embeddable() {
//template <class Type, class CeilLog2Abs> //template <class Type, class CeilLog2Abs>
//void test_rounded_log2_abs(Type zero, CGAL::Null_functor, CeilLog2Abs) { //void test_rounded_log2_abs(Type zero, CGAL::Null_functor, CeilLog2Abs) {
// typedef CGAL::Null_functor Null_functor; // typedef CGAL::Null_functor Null_functor;
// static_assert(( ::std::is_same< CeilLog2Abs, Null_functor>::value)); // static_assert(::std::is_same< CeilLog2Abs, Null_functor>::value);
//} //}
// //
//template <class Type, class FloorLog2Abs, class CeilLog2Abs> //template <class Type, class FloorLog2Abs, class CeilLog2Abs>
//void test_rounded_log2_abs(Type zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) { //void test_rounded_log2_abs(Type zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
// typedef CGAL::Null_functor Null_functor; // typedef CGAL::Null_functor Null_functor;
// static_assert((!::std::is_same< CeilLog2Abs, Null_functor>::value)); // static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
// //
// assert( fl_log(Type( 7)) == 2 ); // assert( fl_log(Type( 7)) == 2 );
// assert( cl_log(Type( 7)) == 3 ); // assert( cl_log(Type( 7)) == 3 );

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

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

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

@ -16,7 +16,7 @@ int main(){
typedef AST::Type Type; typedef AST::Type Type;
CGAL_USE_TYPE(Type); CGAL_USE_TYPE(Type);
static_assert((::std::is_same<void,Type>::value)); static_assert(::std::is_same<void,Type>::value);
typedef AST::Algebraic_category Algebraic_category; typedef AST::Algebraic_category Algebraic_category;
CGAL_USE_TYPE(Algebraic_category); CGAL_USE_TYPE(Algebraic_category);
@ -25,10 +25,10 @@ int main(){
typedef AST::Is_exact Is_exact; typedef AST::Is_exact Is_exact;
CGAL_USE_TYPE(Is_exact); CGAL_USE_TYPE(Is_exact);
static_assert((::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; typedef AST::Is_numerical_sensitive Is_sensitive;
CGAL_USE_TYPE(Is_sensitive); CGAL_USE_TYPE(Is_sensitive);
static_assert((::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 ( Simplify);
CGAL_IS_AST_NULL_FUNCTOR ( Unit_part); 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; typedef CGAL::Coercion_traits<int,int> CT;
CGAL_USE_TYPE(CT); CGAL_USE_TYPE(CT);
static_assert(( std::is_same<CT::Type,int>::value)); static_assert( std::is_same<CT::Type,int>::value);
static_assert( static_assert( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value);
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value)); static_assert( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
static_assert(
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
assert( 5 == CT::Cast()(5)); assert( 5 == CT::Cast()(5));
} }
{ {
typedef CGAL::Coercion_traits<CGAL::Tag_true,CGAL::Tag_false> CT; typedef CGAL::Coercion_traits<CGAL::Tag_true,CGAL::Tag_false> CT;
CGAL_USE_TYPE(CT); CGAL_USE_TYPE(CT);
// static_assert(( std::is_same<CT::Type,CGAL::Null_type>::value)); // static_assert( std::is_same<CT::Type,CGAL::Null_type>::value);
static_assert( static_assert(std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value);
( 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( static_assert(std::is_same<CT::Cast,CGAL::Null_functor>::value);
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
static_assert(
( std::is_same<CT::Cast,CGAL::Null_functor>::value));
} }
} }

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

@ -16,11 +16,11 @@ int main(){
typedef RET::Type Type; typedef RET::Type Type;
CGAL_USE_TYPE(Type); CGAL_USE_TYPE(Type);
static_assert((::std::is_same<void,Type>::value)); static_assert(::std::is_same<void,Type>::value);
typedef RET::Is_real_embeddable Is_real_embeddable; typedef RET::Is_real_embeddable Is_real_embeddable;
CGAL_USE_TYPE(Is_real_embeddable); CGAL_USE_TYPE(Is_real_embeddable);
static_assert((::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(Abs);
CGAL_IS_RET_NULL_FUNCTOR(Sgn); CGAL_IS_RET_NULL_FUNCTOR(Sgn);

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

@ -7,33 +7,31 @@
int main(){ int main(){
typedef CGAL::Scalar_factor_traits<int> SFT; typedef CGAL::Scalar_factor_traits<int> SFT;
CGAL_USE_TYPE(SFT); CGAL_USE_TYPE(SFT);
static_assert((::std::is_same<int, SFT::Type>::value)); static_assert(::std::is_same<int, SFT::Type>::value);
static_assert((::std::is_same<int, SFT::Scalar>::value)); static_assert(::std::is_same<int, SFT::Scalar>::value);
typedef SFT::Scalar_factor Scalar_factor; typedef SFT::Scalar_factor Scalar_factor;
{ {
typedef Scalar_factor::result_type result_type; typedef Scalar_factor::result_type result_type;
CGAL_USE_TYPE(result_type); CGAL_USE_TYPE(result_type);
static_assert((::std::is_same<int, result_type>::value)); static_assert(::std::is_same<int, result_type>::value);
typedef Scalar_factor::argument_type argument_type; typedef Scalar_factor::argument_type argument_type;
CGAL_USE_TYPE(argument_type); CGAL_USE_TYPE(argument_type);
static_assert((::std::is_same<int, argument_type>::value)); static_assert(::std::is_same<int, argument_type>::value);
} }
typedef SFT::Scalar_div Scalar_div; typedef SFT::Scalar_div Scalar_div;
{ {
typedef Scalar_div::result_type result_type; typedef Scalar_div::result_type result_type;
CGAL_USE_TYPE(result_type); CGAL_USE_TYPE(result_type);
static_assert((::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; typedef Scalar_div::first_argument_type first_argument_type;
CGAL_USE_TYPE(first_argument_type); CGAL_USE_TYPE(first_argument_type);
static_assert( static_assert(::std::is_same<int&, first_argument_type>::value);
(::std::is_same<int&, first_argument_type>::value));
typedef Scalar_div::second_argument_type second_argument_type; typedef Scalar_div::second_argument_type second_argument_type;
CGAL_USE_TYPE(second_argument_type); CGAL_USE_TYPE(second_argument_type);
static_assert( static_assert(::std::is_same<int, second_argument_type>::value);
(::std::is_same<int, second_argument_type>::value));
} }
int i; 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 { Curve_analysis_2 _construct_defining_polynomial_from(Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT; typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction // We rely on the fact that the Bound is a fraction
static_assert((::std::is_same<typename FT::Is_fraction, static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value)); CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator; typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator; typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion; typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
static_assert((::std::is_same static_assert(::std::is_same
<Coefficient, <Coefficient,
typename Num_coercion::Type>::value)); typename Num_coercion::Type>::value);
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion; typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
static_assert((::std::is_same static_assert(::std::is_same
<Coefficient, <Coefficient,
typename Denom_coercion::Type>::value)); typename Denom_coercion::Type>::value);
typename Num_coercion::Cast num_cast; typename Num_coercion::Cast num_cast;
typename Denom_coercion::Cast denom_cast; typename Denom_coercion::Cast denom_cast;
typename FT::Decompose decompose; typename FT::Decompose decompose;
@ -2541,18 +2541,18 @@ public:
Polynomial_1 operator() (const Polynomial_2& f, Bound b) const { Polynomial_1 operator() (const Polynomial_2& f, Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT; typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction // We rely on the fact that the Bound is a fraction
static_assert((::std::is_same<typename FT::Is_fraction, static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value)); CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator; typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator; typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion; typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
static_assert((::std::is_same static_assert(::std::is_same
<Coefficient, <Coefficient,
typename Num_coercion::Type>::value)); typename Num_coercion::Type>::value);
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion; typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
static_assert((::std::is_same static_assert(::std::is_same
<Coefficient, <Coefficient,
typename Denom_coercion::Type>::value)); typename Denom_coercion::Type>::value);
typename Num_coercion::Cast num_cast; typename Num_coercion::Cast num_cast;
typename Denom_coercion::Cast denom_cast; typename Denom_coercion::Cast denom_cast;
typename FT::Decompose decompose; typename FT::Decompose decompose;

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

@ -224,14 +224,14 @@ template<typename Poly_coer_1,typename Polynomial_1>
void cast_back_utcf(const Poly_coer_1& p,Polynomial_1& q) { void cast_back_utcf(const Poly_coer_1& p,Polynomial_1& q) {
// We can assume that both template arguments are polynomial types // We can assume that both template arguments are polynomial types
typedef CGAL::Fraction_traits<Poly_coer_1> FT; typedef CGAL::Fraction_traits<Poly_coer_1> FT;
static_assert((::std::is_same<typename FT::Is_fraction, static_assert(::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value)); CGAL::Tag_true>::value);
typedef typename FT::Numerator_type Numerator; typedef typename FT::Numerator_type Numerator;
typedef typename FT::Denominator_type Denominator; typedef typename FT::Denominator_type Denominator;
typedef CGAL::Coercion_traits<Numerator,Polynomial_1> Num_coercion; typedef CGAL::Coercion_traits<Numerator,Polynomial_1> Num_coercion;
static_assert((::std::is_same static_assert(::std::is_same
<Polynomial_1, <Polynomial_1,
typename Num_coercion::Type>::value)); typename Num_coercion::Type>::value);
Numerator p_num; Numerator p_num;
Denominator p_denom; Denominator p_denom;
typename FT::Decompose()(p,p_num,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; typedef typename Floor::result_type Result_type;
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
static_assert(( ::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(( ::std::is_same<Integer, Result_type>::value)); static_assert(::std::is_same<Integer, Result_type>::value);
assert(Integer(42) == floor(NT(42))); assert(Integer(42) == floor(NT(42)));
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; typedef typename Floor_log2_abs::result_type Result_type;
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
static_assert(( ::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(( ::std::is_same<long, Result_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)));
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; typedef typename Ceil::result_type Result_type;
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
static_assert(( ::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(( ::std::is_same<Integer, Result_type>::value)); static_assert(::std::is_same<Integer, Result_type>::value);
assert(Integer(42) == ceil(NT(42))); assert(Integer(42) == ceil(NT(42)));
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; typedef typename Ceil_log2_abs::result_type Result_type;
CGAL_USE_TYPE(Argument_type); CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Result_type);
static_assert(( ::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert(( ::std::is_same<long, Result_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)));
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; typedef AlgebraicCurveKernel_2 AK_2;
/* static_assert( (::std::is_same< /* static_assert(::std::is_same<
Algebraic_real_1, typename AK::Algebraic_real_1 >::value) ); Algebraic_real_1, typename AK::Algebraic_real_1 >::value);
static_assert((::std::is_same< static_assert(::std::is_same<
Isolator, Isolator,
typename AK::Isolator >::value) ); typename AK::Isolator >::value);
static_assert((::std::is_same< static_assert(::std::is_same<
Coefficient, Coefficient,
typename AK::Coefficient >::value)); typename AK::Coefficient >::value);
static_assert((::std::is_same< static_assert(::std::is_same<
Polynomial_1, Polynomial_1,
typename AK::Polynomial_1 >::value));*/ typename AK::Polynomial_1 >::value);*/
typedef typename AK_2::Polynomial_2 Poly_2; typedef typename AK_2::Polynomial_2 Poly_2;
typedef typename AK_2::Curve_analysis_2 Curve_analysis_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_; \ typedef typename Name::result_type RT_; \
CGAL_USE_TYPE(AT_); \ CGAL_USE_TYPE(AT_); \
CGAL_USE_TYPE(RT_); \ CGAL_USE_TYPE(RT_); \
{static_assert(( ::std::is_same<AT,AT_>::value));} \ {static_assert(::std::is_same<AT,AT_>::value);} \
{static_assert(( ::std::is_same<RT,RT_>::value));} \ {static_assert(::std::is_same<RT,RT_>::value);} \
} }
#define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT) \ #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(AT1_); \
CGAL_USE_TYPE(AT2_); \ CGAL_USE_TYPE(AT2_); \
CGAL_USE_TYPE(RT_); \ CGAL_USE_TYPE(RT_); \
{static_assert(( ::std::is_same<AT1,AT1_>::value));} \ {static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(( ::std::is_same<AT2,AT2_>::value));} \ {static_assert(::std::is_same<AT2,AT2_>::value);} \
{static_assert(( ::std::is_same<RT,RT_>::value));} \ {static_assert(::std::is_same<RT,RT_>::value);} \
} }
// TODO: missing check for Construct_algebraic_real_1 // 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_; \ typedef typename Name::result_type RT_; \
CGAL_USE_TYPE(AT_); \ CGAL_USE_TYPE(AT_); \
CGAL_USE_TYPE(RT_); \ CGAL_USE_TYPE(RT_); \
{static_assert(( ::std::is_same<AT,AT_>::value));} \ {static_assert(::std::is_same<AT,AT_>::value);} \
{static_assert(( ::std::is_same<RT,RT_>::value));} \ {static_assert(::std::is_same<RT,RT_>::value);} \
} }
#define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT) \ #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(AT1_); \
CGAL_USE_TYPE(AT2_); \ CGAL_USE_TYPE(AT2_); \
CGAL_USE_TYPE(RT_); \ CGAL_USE_TYPE(RT_); \
{static_assert(( ::std::is_same<AT1,AT1_>::value));} \ {static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(( ::std::is_same<AT2,AT2_>::value));} \ {static_assert(::std::is_same<AT2,AT2_>::value);} \
{static_assert(( ::std::is_same<RT,RT_>::value));} \ {static_assert(::std::is_same<RT,RT_>::value);} \
} }
static_assert(( ::std::is_same static_assert(::std::is_same
<Algebraic_real_2, <Algebraic_real_2,
typename Construct_algebraic_real_2::result_type> typename Construct_algebraic_real_2::result_type>
::value)); ::value);
CGAL_CHECK_UFUNCTION(Is_square_free_2,Polynomial_2,bool); CGAL_CHECK_UFUNCTION(Is_square_free_2,Polynomial_2,bool);
CGAL_CHECK_UFUNCTION(Make_square_free_2,Polynomial_2,Polynomial_2); CGAL_CHECK_UFUNCTION(Make_square_free_2,Polynomial_2,Polynomial_2);
// TODO: missing check for Square_free_factorize_2 // TODO: missing check for Square_free_factorize_2
CGAL_CHECK_BFUNCTION(Is_coprime_2,Polynomial_2,Polynomial_2,bool); CGAL_CHECK_BFUNCTION(Is_coprime_2,Polynomial_2,Polynomial_2,bool);
static_assert(( ::std::is_same static_assert(::std::is_same
<bool,typename Make_coprime_2::result_type>::value)); <bool,typename Make_coprime_2::result_type>::value);
CGAL_CHECK_BFUNCTION(Number_of_solutions_2,Polynomial_2,Polynomial_2, CGAL_CHECK_BFUNCTION(Number_of_solutions_2,Polynomial_2,Polynomial_2,
size_type); size_type);
CGAL_CHECK_UFUNCTION(Compute_x_2,Algebraic_real_2,Algebraic_real_1); 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_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_x_2,Algebraic_real_2,Polynomial_1,BInterval);
CGAL_CHECK_BFUNCTION(Isolate_y_2,Algebraic_real_2,Polynomial_1,BInterval); CGAL_CHECK_BFUNCTION(Isolate_y_2,Algebraic_real_2,Polynomial_1,BInterval);
static_assert(( ::std::is_same static_assert(::std::is_same
< BArray,typename Isolate_2::result_type>::value)); < BArray,typename Isolate_2::result_type>::value);
CGAL_CHECK_BFUNCTION(Sign_at_2,Polynomial_2,Algebraic_real_2,Sign); 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(Is_zero_at_2,Polynomial_2,Algebraic_real_2,bool);
CGAL_CHECK_BFUNCTION(Compare_x_2,Algebraic_real_2,Algebraic_real_2,Sign); 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) { void operator() (ToDouble to_double) {
typedef typename ToDouble::argument_type Argument_type; typedef typename ToDouble::argument_type Argument_type;
typedef typename ToDouble::result_type Result_type; typedef typename ToDouble::result_type Result_type;
static_assert((::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert((::std::is_same<double, Result_type>::value)); static_assert(::std::is_same<double, Result_type>::value);
assert(42.0 == to_double(NT(42))); assert(42.0 == to_double(NT(42)));
} }
}; };
@ -59,8 +59,8 @@ namespace internal {
void operator() (ToInterval to_Interval) { void operator() (ToInterval to_Interval) {
typedef typename ToInterval::argument_type Argument_type; typedef typename ToInterval::argument_type Argument_type;
typedef typename ToInterval::result_type Result_type; typedef typename ToInterval::result_type Result_type;
static_assert((::std::is_same<NT, Argument_type>::value)); static_assert(::std::is_same<NT, Argument_type>::value);
static_assert((::std::is_same< typename Argument_type::Interval, Result_type>::value)); static_assert(::std::is_same< typename Argument_type::Interval, Result_type>::value);
// TODO: NiX::in not available!? // TODO: NiX::in not available!?
//assert(NiX::in(42.0,to_Interval(NT(42)))); //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 CGAL::Real_embeddable_traits<NT> Traits;
typedef typename Traits::Is_real_embeddable Is_real_comparable; typedef typename Traits::Is_real_embeddable Is_real_comparable;
using ::CGAL::Tag_true; using ::CGAL::Tag_true;
static_assert((::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::Compare compare;
typename Traits::Sign sign; typename Traits::Sign sign;
typename Traits::Abs abs; typename Traits::Abs abs;
@ -168,20 +168,20 @@ void test_not_real_comparable() {
typedef CGAL::Real_embeddable_traits<NT> Traits; typedef CGAL::Real_embeddable_traits<NT> Traits;
typedef typename Traits::Is_real_embeddable Is_real_comparable; typedef typename Traits::Is_real_embeddable Is_real_comparable;
using ::CGAL::Tag_false; using ::CGAL::Tag_false;
static_assert((::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> template <class NT, class CeilLog2Abs>
void test_rounded_log2_abs(NT zero, ::CGAL::Null_functor, CeilLog2Abs) { void test_rounded_log2_abs(NT zero, ::CGAL::Null_functor, CeilLog2Abs) {
typedef ::CGAL::Null_functor Nulltype; typedef ::CGAL::Null_functor Nulltype;
static_assert((::std::is_same< CeilLog2Abs, Nulltype>::value)); static_assert(::std::is_same< CeilLog2Abs, Nulltype>::value);
} }
template <class NT, class FloorLog2Abs, class CeilLog2Abs> template <class NT, class FloorLog2Abs, class CeilLog2Abs>
void test_rounded_log2_abs(NT zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) { void test_rounded_log2_abs(NT zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
typedef ::CGAL::Null_functor Null_functor; typedef ::CGAL::Null_functor Null_functor;
static_assert((!::std::is_same< CeilLog2Abs, Null_functor>::value)); static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
assert( fl_log(NT( 7)) == 2 ); assert( fl_log(NT( 7)) == 2 );
assert( cl_log(NT( 7)) == 3 ); assert( cl_log(NT( 7)) == 3 );

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

@ -76,8 +76,8 @@ public:
typedef Type_of_alpha FT; typedef Type_of_alpha FT;
// check that simplices are correctly instantiated // check that simplices are correctly instantiated
static_assert( (std::is_same<NT, typename Dt::Face::NT>::value) ); static_assert(std::is_same<NT, typename Dt::Face::NT>::value);
static_assert( (std::is_same<NT, typename Dt::Vertex::NT>::value) ); static_assert(std::is_same<NT, typename Dt::Vertex::NT>::value);
typedef typename Dt::Point Point; typedef typename Dt::Point Point;

8
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 Approx_point to_approx(const Input_point& wp) const
{ {
// The traits class' Point_2 must be convertible using the Cartesian converter // The traits class' Point_2 must be convertible using the Cartesian converter
static_assert((Is_traits_point_convertible_2< static_assert(Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value)); Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_approx converter; To_approx converter;
return converter(wp); return converter(wp);
@ -158,8 +158,8 @@ class Lazy_alpha_nt_2
Exact_point to_exact(const Input_point& wp) const Exact_point to_exact(const Input_point& wp) const
{ {
// The traits class' Point_2 must be convertible using the Cartesian converter // The traits class' Point_2 must be convertible using the Cartesian converter
static_assert((Is_traits_point_convertible_2< static_assert(Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value)); Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter; To_exact converter;
return converter(wp); return converter(wp);

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

@ -108,8 +108,8 @@ public:
typedef typename Gt::FT Coord_type; typedef typename Gt::FT Coord_type;
//checks whether tags are correctly set in Vertex and Cell classes //checks whether tags are correctly set in Vertex and Cell classes
static_assert( (std::is_same<NT,typename Dt::Cell::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) ); static_assert(std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value);
typedef typename Dt::Point Point; typedef typename Dt::Point Point;

8
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 Approx_point to_approx(const Input_point& wp) const
{ {
// The traits class' Point_3 must be convertible using the Cartesian converter // The traits class' Point_3 must be convertible using the Cartesian converter
static_assert((Is_traits_point_convertible_3< static_assert(Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value)); Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_approx converter; To_approx converter;
return converter(wp); return converter(wp);
@ -149,8 +149,8 @@ class Lazy_alpha_nt_3{
Exact_point to_exact(const Input_point& wp) const Exact_point to_exact(const Input_point& wp) const
{ {
// The traits class' Point_3 must be convertible using the Cartesian converter // The traits class' Point_3 must be convertible using the Cartesian converter
static_assert((Is_traits_point_convertible_3< static_assert(Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value)); Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter; To_exact converter;
return converter(wp); return converter(wp);

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

@ -193,7 +193,7 @@ public:
{ {
// Due to the Steiner point computation being a dichotomy, the algorithm is inherently inexact // 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. // and passing exact kernels is explicitly disabled to ensure no misunderstanding.
static_assert((std::is_floating_point<FT>::value)); static_assert(std::is_floating_point<FT>::value);
} }
public: public:

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), VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tmesh)); get_const_property_map(vertex_point, tmesh));
static_assert((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)); 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 #endif
PPM pm = choose_parameter<PPM>(get_parameter(np, internal_np::point_map)); PPM pm = choose_parameter<PPM>(get_parameter(np, internal_np::point_map));
static_assert((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()); Splitter_base::reserve(faces.size());

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_; typedef CGAL::Get_arithmetic_kernel<Integer>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_); CGAL_USE_TYPE(AK_);
static_assert((std::is_same<AK,AK_>::value)); static_assert(std::is_same<AK,AK_>::value);
} }
{ {
typedef CGAL::Get_arithmetic_kernel<Rational>::Arithmetic_kernel AK_; typedef CGAL::Get_arithmetic_kernel<Rational>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_); CGAL_USE_TYPE(AK_);
static_assert((std::is_same<AK,AK_>::value)); static_assert(std::is_same<AK,AK_>::value);
} }
{ {
typedef CGAL::Get_arithmetic_kernel<BFI>::Arithmetic_kernel AK_; typedef CGAL::Get_arithmetic_kernel<BFI>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_); CGAL_USE_TYPE(AK_);
static_assert((std::is_same<AK,AK_>::value)); static_assert(std::is_same<AK,AK_>::value);
} }
return 0; return 0;
} }

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::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category; typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
static_assert((std::is_same< Left_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< 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< Top_side_category, Arr_oblivious_side_tag >::value);
static_assert((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value)); static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value);
//@} //@}
/*! \struct /*! \struct

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 Agt2::Point_2 A_point;
typedef typename Bgt2::Point_2 B_point; typedef typename Bgt2::Point_2 B_point;
typedef typename Rgt2::Point_2 Res_point; typedef typename Rgt2::Point_2 Res_point;
static_assert((boost::is_convertible<A_point, Res_point>::value)); static_assert(std::is_convertible<A_point, Res_point>::value);
static_assert((boost::is_convertible<B_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 Agt2::X_monotone_curve_2 A_xcv;
typedef typename Bgt2::X_monotone_curve_2 B_xcv; typedef typename Bgt2::X_monotone_curve_2 B_xcv;
typedef typename Rgt2::X_monotone_curve_2 Res_xcv; typedef typename Rgt2::X_monotone_curve_2 Res_xcv;
static_assert((boost::is_convertible<A_xcv, Res_xcv>::value)); static_assert(std::is_convertible<A_xcv, Res_xcv>::value);
static_assert((boost::is_convertible<B_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_traits_basic_adaptor_2<Rgt2> Gt_adaptor_2;
typedef Arr_overlay_traits_2<Gt_adaptor_2, Arr_a, Arr_b> typedef Arr_overlay_traits_2<Gt_adaptor_2, Arr_a, Arr_b>

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> > typedef std::vector<std::pair<Algebraic_real_1, Multiplicity> >
Root_multiplicity_vector; Root_multiplicity_vector;
static_assert((std::is_same<Integer,Coefficient>::value)); static_assert(std::is_same<Integer,Coefficient>::value);
static_assert((std::is_same<Polynomial_1, static_assert(std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value)); typename FT_poly_rat_1::Numerator_type>::value);
public: 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; typedef Algebraic_point_2 Point_2;
static_assert((std::is_same<Integer, Coefficient>::value)); static_assert(std::is_same<Integer, Coefficient>::value);
static_assert((std::is_same<Polynomial_1, static_assert(std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value)); typename FT_poly_rat_1::Numerator_type>::value);
public: public:
const Rational_function& get_rational_function(const Polynomial_1& numerator, 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::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category; typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
static_assert((std::is_same< Left_side_category, Arr_oblivious_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)); std::is_same< Left_side_category, Arr_identified_side_tag >::value);
static_assert((std::is_same< Bottom_side_category, Arr_oblivious_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)); std::is_same< Bottom_side_category, Arr_contracted_side_tag >::value);
static_assert((std::is_same< Top_side_category, Arr_oblivious_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)); std::is_same< Top_side_category, Arr_contracted_side_tag >::value);
static_assert((std::is_same< Right_side_category, Arr_oblivious_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)); std::is_same< Right_side_category, Arr_identified_side_tag >::value);
//@} //@}
/*! \struct /*! \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::Top_side_category Top_side_category;
typedef typename Gt_adaptor_2::Right_side_category Right_side_category; typedef typename Gt_adaptor_2::Right_side_category Right_side_category;
static_assert((std::is_same< Left_side_category, Arr_oblivious_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)); std::is_same< Left_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Bottom_side_category, Arr_oblivious_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)); std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Top_side_category, Arr_oblivious_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)); std::is_same< Top_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Right_side_category, Arr_oblivious_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)); std::is_same< Right_side_category, Arr_open_side_tag >::value);
//@} //@}
/*! \struct /*! \struct

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::Top_side_category Top_side_category;
typedef typename Traits_adaptor_2::Right_side_category Right_side_category; typedef typename Traits_adaptor_2::Right_side_category Right_side_category;
static_assert((Arr_sane_identified_tagging<Left_side_category, static_assert(Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category, Bottom_side_category,
Top_side_category, Top_side_category,
Right_side_category>::value)); Right_side_category>::value);
public: public:
typedef Arrangement_on_surface_2<Geometry_traits_2, Topology_traits> 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::Top_side_category Top_side_category;
typedef typename Traits_adaptor_2::Right_side_category Right_side_category; typedef typename Traits_adaptor_2::Right_side_category Right_side_category;
static_assert((Arr_sane_identified_tagging<Left_side_category, static_assert(Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category, Bottom_side_category,
Top_side_category, Top_side_category,
Right_side_category>::value)); Right_side_category>::value);
public: public:
typedef ZoneVisitor_ Visitor; typedef ZoneVisitor_ Visitor;

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

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

@ -98,7 +98,7 @@ void test_vertex_index_map_uniqueness(const Graph& g,
typedef typename CGAL::GetInitializedVertexIndexMap<Graph, NamedParameters>::const_type CVIM; 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 // 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); 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; 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 // 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); 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; 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 // 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); 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; 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 // 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); FIM ifim = CGAL::get_initialized_face_index_map(g, np);

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; typedef typename Arr::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded) // a side is either oblivious or open (unbounded)
static_assert((std::is_same<Left_side_category, Arr_oblivious_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)); std::is_same<Left_side_category, Arr_open_side_tag>::value);
static_assert((std::is_same<Bottom_side_category, Arr_oblivious_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)); std::is_same<Bottom_side_category, Arr_open_side_tag>::value);
static_assert((std::is_same<Top_side_category, Arr_oblivious_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)); std::is_same<Top_side_category, Arr_open_side_tag>::value);
static_assert((std::is_same<Right_side_category, Arr_oblivious_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)); std::is_same<Right_side_category, Arr_open_side_tag>::value);
typedef typename Arr::Halfedge_handle Halfedge_handle; typedef typename Arr::Halfedge_handle Halfedge_handle;
typedef typename Arr::Vertex_handle Vertex_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; typedef typename Base::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded) // a side is either oblivious or open (unbounded)
static_assert((std::is_same< Left_side_category, Arr_oblivious_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)); std::is_same< Left_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Bottom_side_category, Arr_oblivious_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)); std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Top_side_category, Arr_oblivious_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)); std::is_same< Top_side_category, Arr_open_side_tag >::value);
static_assert((std::is_same< Right_side_category, Arr_oblivious_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)); std::is_same< Right_side_category, Arr_open_side_tag >::value);
class Ex_point_2 class Ex_point_2
{ {

14
Circulator/include/CGAL/circulator.h
View File

@ -193,45 +193,45 @@ template <class C> inline
void Assert_circulator( const C &) { void Assert_circulator( const C &) {
typedef typename Circulator_traits<C>::category category; typedef typename Circulator_traits<C>::category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, Circulator_tag>::value)); static_assert(boost::is_convertible<category, Circulator_tag>::value);
} }
template <class I> inline template <class I> inline
void Assert_iterator( const I &) { void Assert_iterator( const I &) {
typedef typename Circulator_traits<I>::category category; typedef typename Circulator_traits<I>::category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, Iterator_tag>::value)); static_assert(boost::is_convertible<category, Iterator_tag>::value);
} }
template <class I> inline template <class I> inline
void Assert_input_category( const I &/*i*/) { void Assert_input_category( const I &/*i*/) {
typedef typename std::iterator_traits<I>::iterator_category category; typedef typename std::iterator_traits<I>::iterator_category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, std::input_iterator_tag>::value)); static_assert(boost::is_convertible<category, std::input_iterator_tag>::value);
} }
template <class I> inline template <class I> inline
void Assert_output_category( const I &/*i*/) { void Assert_output_category( const I &/*i*/) {
typedef typename std::iterator_traits<I>::iterator_category category; typedef typename std::iterator_traits<I>::iterator_category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, std::output_iterator_tag>::value)); static_assert(boost::is_convertible<category, std::output_iterator_tag>::value);
} }
template <class IC> inline template <class IC> inline
void Assert_forward_category( const IC &/*ic*/) { void Assert_forward_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category; typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, std::forward_iterator_tag>::value)); static_assert(boost::is_convertible<category, std::forward_iterator_tag>::value);
} }
template <class IC> inline template <class IC> inline
void Assert_bidirectional_category( const IC &/*ic*/) { void Assert_bidirectional_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category; typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, std::bidirectional_iterator_tag>::value)); static_assert(boost::is_convertible<category, std::bidirectional_iterator_tag>::value);
} }
template <class IC> inline template <class IC> inline
void Assert_random_access_category( const IC &/*ic*/) { void Assert_random_access_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category; typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category); CGAL_USE_TYPE(category);
static_assert((boost::is_convertible<category, std::random_access_iterator_tag>::value)); static_assert(boost::is_convertible<category, std::random_access_iterator_tag>::value);
} }
// The assert at-least-category functions use the following // The assert at-least-category functions use the following
// functions to resolve properly. Note the proper order of the // functions to resolve properly. Note the proper order of the

12
Combinatorial_map/include/CGAL/Cell_iterators.h
View File

@ -82,8 +82,8 @@ namespace CGAL {
Ite(amap, adart, amap.get_new_mark()), Ite(amap, adart, amap.get_new_mark()),
mcell_mark_number(amap.get_new_mark()) mcell_mark_number(amap.get_new_mark())
{ {
static_assert( (std::is_same<typename Ite::Basic_iterator, static_assert(std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mcell_mark_number)); CGAL_assertion(amap.is_whole_map_unmarked(mcell_mark_number));
mark_cell<Map,i,dim>(amap, adart, mcell_mark_number); mark_cell<Map,i,dim>(amap, adart, mcell_mark_number);
@ -196,8 +196,8 @@ namespace CGAL {
Ite(amap, adart), Ite(amap, adart),
mmark_number(amap.get_new_mark()) mmark_number(amap.get_new_mark())
{ {
static_assert( (std::is_same<typename Ite::Basic_iterator, static_assert(std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mmark_number)); CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
mark_cell<Map,i,dim>(amap, adart, mmark_number); mark_cell<Map,i,dim>(amap, adart, mmark_number);
} }
@ -303,8 +303,8 @@ namespace CGAL {
Base(amap), Base(amap),
mmark_number(amap.get_new_mark()) mmark_number(amap.get_new_mark())
{ {
static_assert( (std::is_same<typename Base::Basic_iterator, static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mmark_number)); CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
mark_cell<Map,i,dim>(amap, (*this), mmark_number); mark_cell<Map,i,dim>(amap, (*this), mmark_number);
} }

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

@ -1524,8 +1524,8 @@ namespace CGAL {
template < class Ite > template < class Ite >
std::ostream& display_orbits(std::ostream & aos) const std::ostream& display_orbits(std::ostream & aos) const
{ {
static_assert( (std::is_same<typename Ite::Basic_iterator, static_assert(std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
unsigned int nb = 0; unsigned int nb = 0;
size_type amark = get_new_mark(); size_type amark = get_new_mark();
for ( typename Dart_range::const_iterator it1(darts().begin()), for ( typename Dart_range::const_iterator it1(darts().begin()),

16
Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h
View File

@ -34,8 +34,8 @@ namespace CGAL
typename Map::Dart_const_descriptor adart1, typename Map::Dart_const_descriptor adart1,
typename Map::Dart_const_descriptor adart2) typename Map::Dart_const_descriptor adart2)
{ {
static_assert( (std::is_same<typename Iterator::Basic_iterator, static_assert(std::is_same<typename Iterator::Basic_iterator,
Tag_false>::value) ); Tag_false>::value);
bool found=false; bool found=false;
for (Iterator it(amap, adart1); !found && it.cont(); ++it) for (Iterator it(amap, adart1); !found && it.cont(); ++it)
@ -57,8 +57,8 @@ namespace CGAL
typename Map::Dart_const_descriptor adart, typename Map::Dart_const_descriptor adart,
typename Map::size_type amark) typename Map::size_type amark)
{ {
static_assert( (std::is_same<typename Iterator::Basic_iterator, static_assert(std::is_same<typename Iterator::Basic_iterator,
Tag_false>::value) ); Tag_false>::value);
bool res=true; bool res=true;
for ( Iterator it(amap, adart); res && it.cont(); ++it ) for ( Iterator it(amap, adart); res && it.cont(); ++it )
@ -98,8 +98,8 @@ namespace CGAL
typename Map::Dart_const_descriptor adart, typename Map::Dart_const_descriptor adart,
typename Map::size_type amark) typename Map::size_type amark)
{ {
static_assert( (std::is_same<typename Iterator::Basic_iterator, static_assert(std::is_same<typename Iterator::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion( (is_whole_orbit_unmarked<Map, CGAL_assertion( (is_whole_orbit_unmarked<Map,
CMap_non_basic_iterator<Map,Iterator> > CMap_non_basic_iterator<Map,Iterator> >
(amap, adart, amark)) ); (amap, adart, amark)) );
@ -305,8 +305,8 @@ namespace CGAL
typename Map::size_type amark, typename Map::size_type amark,
typename Map::size_type amark2=Map::INVALID_MARK) typename Map::size_type amark2=Map::INVALID_MARK)
{ {
static_assert( (std::is_same<typename Iterator::Basic_iterator, static_assert(std::is_same<typename Iterator::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion( (is_whole_orbit_unmarked<Map, CGAL_assertion( (is_whole_orbit_unmarked<Map,
CMap_non_basic_iterator<Map,Iterator> > CMap_non_basic_iterator<Map,Iterator> >
(amap, adart, amark)) ); (amap, adart, amark)) );

12
Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h
View File

@ -305,8 +305,8 @@ namespace CGAL {
typedef typename Map::size_type size_type; typedef typename Map::size_type size_type;
static_assert( (Bi<=Map::dimension && static_assert(Bi<=Map::dimension &&
std::is_same<Ite_has_stack,Tag_false>::value) ); std::is_same<Ite_has_stack,Tag_false>::value);
public: public:
/// Main constructor. /// Main constructor.
@ -493,8 +493,8 @@ namespace CGAL {
typedef typename Map::size_type size_type; typedef typename Map::size_type size_type;
static_assert( (std::is_same<typename Base::Basic_iterator, static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
/// Main constructor. /// Main constructor.
CMap_non_basic_iterator(Map& amap, Dart_descriptor adart1): CMap_non_basic_iterator(Map& amap, Dart_descriptor adart1):
@ -579,8 +579,8 @@ namespace CGAL {
/// True iff this iterator is basic /// True iff this iterator is basic
typedef Tag_false Basic_iterator; typedef Tag_false Basic_iterator;
static_assert( (std::is_same<typename Base::Basic_iterator, static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
/// Main constructor. /// Main constructor.
CMap_non_basic_iterator(Map& amap, Dart_descriptor adart): CMap_non_basic_iterator(Map& amap, Dart_descriptor adart):

14
Convex_hull_3/test/Convex_hull_3/quick_hull_default_traits.cpp
View File

@ -23,12 +23,12 @@ using namespace CGAL::Convex_hull_3::internal;
int main() int main()
{ {
static_assert( (std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value) ); static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value);
static_assert( (std::is_same<SCD,Default_traits_for_Chull_3<SCD::Point_3>::type>::value) ); static_assert(std::is_same<SCD,Default_traits_for_Chull_3<SCD::Point_3>::type>::value);
static_assert( (std::is_same<SHD,Default_traits_for_Chull_3<SHD::Point_3>::type>::value) ); static_assert(std::is_same<SHD,Default_traits_for_Chull_3<SHD::Point_3>::type>::value);
static_assert( (std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value) ); static_assert(std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value);
static_assert( (std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value) ); static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value);
static_assert( (std::is_same<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>,Default_traits_for_Chull_3<EPIC::Point_3>::type>::value) ); static_assert(std::is_same<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>,Default_traits_for_Chull_3<EPIC::Point_3>::type>::value);
static_assert( (std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value) ); static_assert(std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value);
return 0; return 0;
} }

8
Generalized_map/include/CGAL/GMap_cell_iterators.h
View File

@ -70,8 +70,8 @@ namespace CGAL {
Base(amap), Base(amap),
mmark_number(amap.get_new_mark()) mmark_number(amap.get_new_mark())
{ {
static_assert( (std::is_same<typename Base::Basic_iterator, static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mmark_number)); CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
mark_cell<Map,i,dim>(amap, (*this), mmark_number); mark_cell<Map,i,dim>(amap, (*this), mmark_number);
} }
@ -183,8 +183,8 @@ namespace CGAL {
Base(amap), Base(amap),
mmark_number(amap.get_new_mark()) mmark_number(amap.get_new_mark())
{ {
static_assert( (std::is_same<typename Base::Basic_iterator, static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mmark_number)); CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
mark_cell<Map,i,dim>(amap, (*this), mmark_number); mark_cell<Map,i,dim>(amap, (*this), mmark_number);
} }

6
Generalized_map/include/CGAL/GMap_dart_iterators.h
View File

@ -154,7 +154,7 @@ namespace CGAL {
typedef Tag_false Use_mark; ///< True iff this iterator uses mark typedef Tag_false Use_mark; ///< True iff this iterator uses mark
typedef Tag_true Basic_iterator; ///< True iff this iterator is basic typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
static_assert( (0<=Ai && Ai+delta<=Map::dimension && delta>1) ); static_assert(0<=Ai && Ai+delta<=Map::dimension && delta>1);
public: public:
/// Main constructor. /// Main constructor.
@ -468,9 +468,9 @@ namespace CGAL {
typedef Tag_false Use_mark; ///< True iff this iterator uses mark typedef Tag_false Use_mark; ///< True iff this iterator uses mark
typedef Tag_true Basic_iterator; ///< True iff this iterator is basic typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
static_assert( (0<=Ai && delta1<delta2 && static_assert(0<=Ai && delta1<delta2 &&
Ai+delta2<=Map::dimension && Ai+delta2<=Map::dimension &&
delta1>1) ); delta1>1);
public: public:
/// Main constructor. /// Main constructor.

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

@ -1347,8 +1347,8 @@ namespace CGAL {
template < class Ite > template < class Ite >
std::ostream& display_orbits(std::ostream & aos) const std::ostream& display_orbits(std::ostream & aos) const
{ {
static_assert( (std::is_same<typename Ite::Basic_iterator, static_assert(std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) ); Tag_true>::value);
unsigned int nb = 0; unsigned int nb = 0;
size_type amark = get_new_mark(); size_type amark = get_new_mark();
for ( typename Dart_range::const_iterator it1(darts().begin()), for ( typename Dart_range::const_iterator it1(darts().begin()),

4
Generalized_map/include/CGAL/Generalized_map_iterators_base.h
View File

@ -59,8 +59,8 @@ namespace CGAL {
typedef Tag_true Use_mark; typedef Tag_true Use_mark;
static_assert( (Ai<=Map::dimension && static_assert(Ai<=Map::dimension &&
std::is_same<Ite_has_stack,Tag_false>::value) ); std::is_same<Ite_has_stack,Tag_false>::value);
public: public:
/// Main constructor. /// Main constructor.

4
Heat_method_3/include/CGAL/Heat_method_3/Surface_mesh_geodesic_distances_3.h
View File

@ -752,8 +752,8 @@ class Surface_mesh_geodesic_distances_3
> >
#endif #endif
{ {
static_assert((std::is_same<Mode, Direct>::value) || static_assert(std::is_same<Mode, Direct>::value) ||
(std::is_same<Mode, Intrinsic_Delaunay>::value)); (std::is_same<Mode, Intrinsic_Delaunay>::value);
// extract real types from Default // extract real types from Default
#ifdef CGAL_EIGEN3_ENABLED #ifdef CGAL_EIGEN3_ENABLED

2
Installation/test/Installation/test_configuration_qt5.cpp
View File

@ -13,7 +13,7 @@ template <typename A, typename B>
typename CGAL::Coercion_traits<A,B>::Type typename CGAL::Coercion_traits<A,B>::Type
binary_func(const A& a , const B& b){ binary_func(const A& a , const B& b){
typedef CGAL::Coercion_traits<A,B> CT; typedef CGAL::Coercion_traits<A,B> CT;
static_assert((CT::Are_explicit_interoperable::value)); static_assert(CT::Are_explicit_interoperable::value);
typename CT::Cast cast; typename CT::Cast cast;
return cast(a)*cast(b); return cast(a)*cast(b);
} }

6
Intersections_2/include/CGAL/Intersection_traits.h
View File

@ -181,8 +181,8 @@ do_intersect_impl(const A& a, const B& b, Dynamic_dimension_tag) {
// inline // inline
// typename Intersection_traits< typename Kernel_traits<A>::Kernel, A, B>::result_type >::type // typename Intersection_traits< typename Kernel_traits<A>::Kernel, A, B>::result_type >::type
// intersection(const A& a, const B& b) { // intersection(const A& a, const B& b) {
// static_assert( (std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value), // static_assert(std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value),
// "intersection with objects of different dimensions not supported"); // "intersection with objects of different dimensions not supported";
// return internal::intersection_impl(a, b, typename A::Ambient_dimension()); // return internal::intersection_impl(a, b, typename A::Ambient_dimension());
// } // }
@ -190,7 +190,7 @@ do_intersect_impl(const A& a, const B& b, Dynamic_dimension_tag) {
// inline // inline
// auto // K::Boolean // auto // K::Boolean
// do_intersect(const A& a, const B& b) { // do_intersect(const A& a, const B& b) {
// static_assert((std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value), // static_assert(std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value,
// "do_intersect with objects of different dimensions not supported"); // "do_intersect with objects of different dimensions not supported");
// return internal::do_intersect_impl(a, b, typename A::Ambient_dimension()); // return internal::do_intersect_impl(a, b, typename A::Ambient_dimension());
// } // }

2
Intersections_3/include/CGAL/Intersections_3/internal/Bbox_3_Segment_3_do_intersect.h
View File

@ -66,7 +66,7 @@ class Do_intersect_bbox_segment_aux_is_greater<FT, bounded_0, true>
double dmax; double dmax;
public: public:
static_assert((std::is_same<FT, double>::value)); static_assert(std::is_same<FT, double>::value);
Do_intersect_bbox_segment_aux_is_greater() : error(0.), tmax(0.), dmax(0.) {} Do_intersect_bbox_segment_aux_is_greater() : error(0.), tmax(0.), dmax(0.) {}

2
Interval_support/include/CGAL/Test/_test_bigfloat_interval_traits.h
View File

@ -41,7 +41,7 @@ void test_bigfloat_interval_traits() {
typedef typename BFIT::Is_bigfloat_interval Is_bigfloat_interval; typedef typename BFIT::Is_bigfloat_interval Is_bigfloat_interval;
CGAL_USE_TYPE(Is_bigfloat_interval); CGAL_USE_TYPE(Is_bigfloat_interval);
// using CGAL::Tag_true; // using CGAL::Tag_true;
static_assert(( ::std::is_same< Is_bigfloat_interval, CGAL::Tag_true>::value)); static_assert(::std::is_same< Is_bigfloat_interval, CGAL::Tag_true>::value);
const typename BFIT::Construct construct = typename BFIT::Construct(); const typename BFIT::Construct construct = typename BFIT::Construct();
const typename BFIT::Set_precision set_precision = typename BFIT::Set_precision(); const typename BFIT::Set_precision set_precision = typename BFIT::Set_precision();

2
Interval_support/include/CGAL/Test/_test_convert_to_bfi.h
View File

@ -41,7 +41,7 @@ template <typename BFI, typename From>
void test_convert_to_bfi_from(BFI,From){ void test_convert_to_bfi_from(BFI,From){
typedef typename CGAL::Coercion_traits<BFI,From>::Type CT_type; typedef typename CGAL::Coercion_traits<BFI,From>::Type CT_type;
CGAL_USE_TYPE(CT_type); CGAL_USE_TYPE(CT_type);
static_assert(( ::std::is_same<CT_type, BFI>::value)); static_assert(::std::is_same<CT_type, BFI>::value);
assert(CGAL::convert_to_bfi(From(0)) == BFI(0)); assert(CGAL::convert_to_bfi(From(0)) == BFI(0));
assert(CGAL::convert_to_bfi(From(1)) == BFI(1)); assert(CGAL::convert_to_bfi(From(1)) == BFI(1));
assert(CGAL::convert_to_bfi(From(2)) == BFI(2)); assert(CGAL::convert_to_bfi(From(2)) == BFI(2));

4
Interval_support/include/CGAL/Test/_test_interval_traits.h
View File

@ -74,8 +74,8 @@ void test_interval_traits() {
typedef typename IT::With_empty_interval With_empty_interval; typedef typename IT::With_empty_interval With_empty_interval;
CGAL_USE_TYPE(Is_interval); CGAL_USE_TYPE(Is_interval);
using CGAL::Tag_true; using CGAL::Tag_true;
static_assert(( ::std::is_same< Is_interval, Tag_true>::value)); static_assert(::std::is_same< Is_interval, Tag_true>::value);
static_assert(( ::std::is_same< Interval_, Interval>::value)); static_assert(::std::is_same< Interval_, Interval>::value);
test_with_empty_interval<Interval>(With_empty_interval()); test_with_empty_interval<Interval>(With_empty_interval());

2
Kernel_23/include/CGAL/Circle_2.h
View File

@ -35,7 +35,7 @@ class Circle_2 : public R_::Kernel_base::Circle_2
typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2;
typedef Circle_2 Self; typedef Circle_2 Self;
static_assert((std::is_same<Self, typename R_::Circle_2>::value)); static_assert(std::is_same<Self, typename R_::Circle_2>::value);
public: public:

2
Kernel_23/include/CGAL/Circle_3.h
View File

@ -43,7 +43,7 @@ template <class R_>
typedef typename R_::Direction_3 Direction_3; typedef typename R_::Direction_3 Direction_3;
typedef Circle_3 Self; typedef Circle_3 Self;
static_assert((std::is_same<Self, typename R_::Circle_3>::value)); static_assert(std::is_same<Self, typename R_::Circle_3>::value);
public: public:

2
Kernel_23/include/CGAL/Direction_2.h
View File

@ -38,7 +38,7 @@ class Direction_2 : public R_::Kernel_base::Direction_2
typedef typename R_::Kernel_base::Direction_2 RDirection_2; typedef typename R_::Kernel_base::Direction_2 RDirection_2;
typedef Direction_2 Self; typedef Direction_2 Self;
static_assert((std::is_same<Self, typename R_::Direction_2>::value)); static_assert(std::is_same<Self, typename R_::Direction_2>::value);
public: public:

2
Kernel_23/include/CGAL/Direction_3.h
View File

@ -37,7 +37,7 @@ class Direction_3 : public R_::Kernel_base::Direction_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Direction_3 Self; typedef Direction_3 Self;
static_assert((std::is_same<Self, typename R_::Direction_3>::value)); static_assert(std::is_same<Self, typename R_::Direction_3>::value);
public: public:

12
Kernel_23/include/CGAL/Has_conversion.h
View File

@ -23,9 +23,9 @@ namespace internal {
template<typename K1, typename K2, typename Rep = typename K1::Rep_tag /* Cartesian_tag */> template<typename K1, typename K2, typename Rep = typename K1::Rep_tag /* Cartesian_tag */>
struct Converter_selector struct Converter_selector
{ {
static_assert((std::is_same<typename K1::Rep_tag, static_assert(std::is_same<typename K1::Rep_tag,
typename K2::Rep_tag>::value), typename K2::Rep_tag>::value,
"Kernels must have the same representation"); "Kernels must have the same representation");
typedef CGAL::Cartesian_converter<K1, K2> type; typedef CGAL::Cartesian_converter<K1, K2> type;
}; };
@ -33,9 +33,9 @@ struct Converter_selector
template<typename K1, typename K2> template<typename K1, typename K2>
struct Converter_selector<K1, K2, Homogeneous_tag> struct Converter_selector<K1, K2, Homogeneous_tag>
{ {
static_assert((std::is_same<typename K1::Rep_tag, static_assert(std::is_same<typename K1::Rep_tag,
typename K2::Rep_tag>::value), typename K2::Rep_tag>::value,
"Kernels must have the same representation"); "Kernels must have the same representation");
typedef CGAL::Homogeneous_converter<K1, K2> type; typedef CGAL::Homogeneous_converter<K1, K2> type;
}; };

2
Kernel_23/include/CGAL/Iso_cuboid_3.h
View File

@ -35,7 +35,7 @@ class Iso_cuboid_3 : public R_::Kernel_base::Iso_cuboid_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Iso_cuboid_3 Self; typedef Iso_cuboid_3 Self;
static_assert((std::is_same<Self, typename R_::Iso_cuboid_3>::value)); static_assert(std::is_same<Self, typename R_::Iso_cuboid_3>::value);
public: public:

2
Kernel_23/include/CGAL/Iso_rectangle_2.h
View File

@ -33,7 +33,7 @@ class Iso_rectangle_2 : public R_::Kernel_base::Iso_rectangle_2
typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2;
typedef Iso_rectangle_2 Self; typedef Iso_rectangle_2 Self;
static_assert((std::is_same<Self, typename R_::Iso_rectangle_2>::value)); static_assert(std::is_same<Self, typename R_::Iso_rectangle_2>::value);
public: public:

2
Kernel_23/include/CGAL/Line_2.h
View File

@ -41,7 +41,7 @@ class Line_2 : public R_::Kernel_base::Line_2
typedef typename R_::Kernel_base::Line_2 RLine_2; typedef typename R_::Kernel_base::Line_2 RLine_2;
typedef Line_2 Self; typedef Line_2 Self;
static_assert((std::is_same<Self, typename R_::Line_2>::value)); static_assert(std::is_same<Self, typename R_::Line_2>::value);
public: public:

2
Kernel_23/include/CGAL/Line_3.h
View File

@ -38,7 +38,7 @@ class Line_3 : public R_::Kernel_base::Line_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Line_3 Self; typedef Line_3 Self;
static_assert((std::is_same<Self, typename R_::Line_3>::value)); static_assert(std::is_same<Self, typename R_::Line_3>::value);
public: public:

2
Kernel_23/include/CGAL/Plane_3.h
View File

@ -41,7 +41,7 @@ class Plane_3 : public R_::Kernel_base::Plane_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Plane_3 Self; typedef Plane_3 Self;
static_assert((std::is_same<Self, typename R_::Plane_3>::value)); static_assert(std::is_same<Self, typename R_::Plane_3>::value);
public: public:

2
Kernel_23/include/CGAL/Point_2.h
View File

@ -37,7 +37,7 @@ class Point_2 : public R_::Kernel_base::Point_2
typedef typename R_::Kernel_base::Point_2 RPoint_2; typedef typename R_::Kernel_base::Point_2 RPoint_2;
typedef Point_2 Self; typedef Point_2 Self;
static_assert((std::is_same<Self, typename R_::Point_2>::value)); static_assert(std::is_same<Self, typename R_::Point_2>::value);
public: public:

2
Kernel_23/include/CGAL/Point_3.h
View File

@ -34,7 +34,7 @@ class Point_3 : public R_::Kernel_base::Point_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Point_3 Self; typedef Point_3 Self;
static_assert((std::is_same<Self, typename R_::Point_3>::value)); static_assert(std::is_same<Self, typename R_::Point_3>::value);
public: public:

2
Kernel_23/include/CGAL/Ray_2.h
View File

@ -42,7 +42,7 @@ class Ray_2 : public R_::Kernel_base::Ray_2
typedef typename R_::Kernel_base::Ray_2 RRay_2; typedef typename R_::Kernel_base::Ray_2 RRay_2;
typedef Ray_2 Self; typedef Ray_2 Self;
static_assert((std::is_same<Self, typename R_::Ray_2>::value)); static_assert(std::is_same<Self, typename R_::Ray_2>::value);
public: public:

2
Kernel_23/include/CGAL/Ray_3.h
View File

@ -36,7 +36,7 @@ class Ray_3 : public R_::Kernel_base::Ray_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Ray_3 Self; typedef Ray_3 Self;
static_assert((std::is_same<Self, typename R_::Ray_3>::value)); static_assert(std::is_same<Self, typename R_::Ray_3>::value);
public: public:

2
Kernel_23/include/CGAL/Segment_2.h
View File

@ -40,7 +40,7 @@ class Segment_2 : public R_::Kernel_base::Segment_2
typedef typename R_::Kernel_base::Segment_2 RSegment_2; typedef typename R_::Kernel_base::Segment_2 RSegment_2;
typedef Segment_2 Self; typedef Segment_2 Self;
static_assert((std::is_same<Self, typename R_::Segment_2>::value)); static_assert(std::is_same<Self, typename R_::Segment_2>::value);
public: public:

2
Kernel_23/include/CGAL/Segment_3.h
View File

@ -38,7 +38,7 @@ class Segment_3 : public R_::Kernel_base::Segment_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Segment_3 Self; typedef Segment_3 Self;
static_assert((std::is_same<Self, typename R_::Segment_3>::value)); static_assert(std::is_same<Self, typename R_::Segment_3>::value);
public: public:

2
Kernel_23/include/CGAL/Sphere_3.h
View File

@ -37,7 +37,7 @@ class Sphere_3 : public R_::Kernel_base::Sphere_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Sphere_3 Self; typedef Sphere_3 Self;
static_assert((std::is_same<Self, typename R_::Sphere_3>::value)); static_assert(std::is_same<Self, typename R_::Sphere_3>::value);
public: public:

2
Kernel_23/include/CGAL/Tetrahedron_3.h
View File

@ -33,7 +33,7 @@ class Tetrahedron_3 : public R_::Kernel_base::Tetrahedron_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Tetrahedron_3 Self; typedef Tetrahedron_3 Self;
static_assert((std::is_same<Self, typename R_::Tetrahedron_3>::value)); static_assert(std::is_same<Self, typename R_::Tetrahedron_3>::value);
public: public:

2
Kernel_23/include/CGAL/Triangle_2.h
View File

@ -35,7 +35,7 @@ class Triangle_2 : public R_::Kernel_base::Triangle_2
typedef typename R_::Kernel_base::Triangle_2 RTriangle_2; typedef typename R_::Kernel_base::Triangle_2 RTriangle_2;
typedef Triangle_2 Self; typedef Triangle_2 Self;
static_assert((std::is_same<Self, typename R_::Triangle_2>::value)); static_assert(std::is_same<Self, typename R_::Triangle_2>::value);
public: public:

2
Kernel_23/include/CGAL/Triangle_3.h
View File

@ -36,7 +36,7 @@ class Triangle_3 : public R_::Kernel_base::Triangle_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Triangle_3 Self; typedef Triangle_3 Self;
static_assert((std::is_same<Self, typename R_::Triangle_3>::value)); static_assert(std::is_same<Self, typename R_::Triangle_3>::value);
public: public:

2
Kernel_23/include/CGAL/Vector_2.h
View File

@ -42,7 +42,7 @@ class Vector_2 : public R_::Kernel_base::Vector_2
typedef typename R_::Kernel_base::Vector_2 RVector_2; typedef typename R_::Kernel_base::Vector_2 RVector_2;
typedef Vector_2 Self; typedef Vector_2 Self;
static_assert((std::is_same<Self, typename R_::Vector_2>::value)); static_assert(std::is_same<Self, typename R_::Vector_2>::value);
public: public:

2
Kernel_23/include/CGAL/Vector_3.h
View File

@ -42,7 +42,7 @@ class Vector_3 : public R_::Kernel_base::Vector_3
typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3;
typedef Vector_3 Self; typedef Vector_3 Self;
static_assert((std::is_same<Self, typename R_::Vector_3>::value)); static_assert(std::is_same<Self, typename R_::Vector_3>::value);
public: public:

2
Kernel_23/include/CGAL/Weighted_point_2.h
View File

@ -34,7 +34,7 @@ class Weighted_point_2 : public R_::Kernel_base::Weighted_point_2
typedef typename R_::FT RT; typedef typename R_::FT RT;
typedef Weighted_point_2<R_> Self; typedef Weighted_point_2<R_> Self;
static_assert((std::is_same<Self, typename R_::Weighted_point_2>::value)); static_assert(std::is_same<Self, typename R_::Weighted_point_2>::value);
public: public:
typedef Dimension_tag<2> Ambient_dimension; typedef Dimension_tag<2> Ambient_dimension;

2
Kernel_23/include/CGAL/Weighted_point_3.h
View File

@ -34,7 +34,7 @@ class Weighted_point_3 : public R_::Kernel_base::Weighted_point_3
typedef typename R_::FT FT; typedef typename R_::FT FT;
typedef Weighted_point_3 Self; typedef Weighted_point_3 Self;
static_assert((std::is_same<Self, typename R_::Weighted_point_3>::value)); static_assert(std::is_same<Self, typename R_::Weighted_point_3>::value);
public: public:

4
Kernel_23/test/Kernel_23/test_RT_or_FT_predicates.cpp
View File

@ -229,12 +229,12 @@ void generate_atomic_compilation_test(const std::string& FT_name,
if(check != NO_CHECK) if(check != NO_CHECK)
{ {
out << " static_assert((std::is_same<decltype("; out << " static_assert(std::is_same<decltype(";
out << "p("; out << "p(";
for(std::size_t j=0, i=parameters.size(); j<i; ++j) for(std::size_t j=0, i=parameters.size(); j<i; ++j)
out << ((j != 0) ? ", o" : "o") << j; out << ((j != 0) ? ", o" : "o") << j;
out << "))"; out << ")";
if(check == CHECK_NO_NEEDS_FT) if(check == CHECK_NO_NEEDS_FT)
out << ", B>::value));\n"; out << ", B>::value));\n";

4
Mesh_3/include/CGAL/Compact_mesh_cell_base_3.h
View File

@ -485,8 +485,8 @@ public:
template<typename GT_> template<typename GT_>
const Point_3& weighted_circumcenter(const GT_& gt) const const Point_3& weighted_circumcenter(const GT_& gt) const
{ {
static_assert((std::is_same<Point_3, static_assert(std::is_same<Point_3,
typename GT_::Construct_weighted_circumcenter_3::result_type>::value)); typename GT_::Construct_weighted_circumcenter_3::result_type>::value);
if (internal_tbb::is_null(weighted_circumcenter_)) { if (internal_tbb::is_null(weighted_circumcenter_)) {
this->try_to_set_circumcenter( this->try_to_set_circumcenter(
new Point_3(gt.construct_weighted_circumcenter_3_object() new Point_3(gt.construct_weighted_circumcenter_3_object()

8
Mesh_3/include/CGAL/Mesh_criteria_3.h
View File

@ -101,19 +101,19 @@ public:
template <typename Facet_criterion> template <typename Facet_criterion>
void add_facet_criterion(Facet_criterion* criterion) { void add_facet_criterion(Facet_criterion* criterion) {
static_assert((boost::is_base_of< static_assert(boost::is_base_of<
typename Facet_criteria::Abstract_criterion, typename Facet_criteria::Abstract_criterion,
Facet_criterion Facet_criterion
>::value)); >::value);
facet_criteria_.add(criterion); facet_criteria_.add(criterion);
} }
template <typename Cell_criterion> template <typename Cell_criterion>
void add_cell_criterion(Cell_criterion* criterion) { void add_cell_criterion(Cell_criterion* criterion) {
static_assert((boost::is_base_of< static_assert(boost::is_base_of<
typename Cell_criteria::Abstract_criterion, typename Cell_criteria::Abstract_criterion,
Cell_criterion Cell_criterion
>::value)); >::value);
cell_criteria_.add(criterion); cell_criteria_.add(criterion);
} }

4
Mesh_3/test/Mesh_3/test_meshing_polyhedron.cpp
View File

@ -35,10 +35,10 @@ struct Polyhedron_tester : public Tester<K>
typedef CGAL::Polyhedron_3<Gt> Polyhedron; typedef CGAL::Polyhedron_3<Gt> Polyhedron;
typedef CGAL::Polyhedral_mesh_domain_3<Polyhedron, Gt> Mesh_domain; typedef CGAL::Polyhedral_mesh_domain_3<Polyhedron, Gt> Mesh_domain;
static_assert((std::is_same< static_assert(std::is_same<
typename Mesh_domain::Surface_patch_index, typename Mesh_domain::Surface_patch_index,
std::pair<int, int> std::pair<int, int>
>::value)); >::value);
typedef typename CGAL::Mesh_triangulation_3< typedef typename CGAL::Mesh_triangulation_3<
Mesh_domain, Mesh_domain,

2
Nef_2/include/CGAL/Nef_2/PM_overlayer.h
View File

@ -959,7 +959,7 @@ bool is_forward_edge(const Const_decorator& N,
void assert_type_precondition() const void assert_type_precondition() const
{ typename PM_decorator_::Point p1; Point p2; { typename PM_decorator_::Point p1; Point p2;
static_assert((std::is_same<typename PM_decorator_::Point, Point>::value)); } static_assert(std::is_same<typename PM_decorator_::Point, Point>::value); }

4
NewKernel_d/include/CGAL/NewKernel_d/Kernel_d_interface.h
View File

@ -135,8 +135,8 @@ template <class Base_> struct Kernel_d_interface : public Base_ {
typedef typename Base::Point_cartesian_const_iterator result_type; typedef typename Base::Point_cartesian_const_iterator result_type;
// Kernel_d requires a common iterator type for points and vectors // Kernel_d requires a common iterator type for points and vectors
// TODO: provide this mixed functor in preKernel? // TODO: provide this mixed functor in preKernel?
// static_assert((std::is_same<typename CGAL::decay<typename boost::result_of<CVI(Vector_d,CGAL::Begin_tag)>::type>::type, result_type>::value)); // static_assert(std::is_same<typename CGAL::decay<typename boost::result_of<CVI(Vector_d,CGAL::Begin_tag)>::type>::type, result_type>::value);
// static_assert((std::is_same<typename CGAL::decay<typename CVI::result_type>::type, result_type>::value)); // static_assert(std::is_same<typename CGAL::decay<typename CVI::result_type>::type, result_type>::value);
template <class Tag_> template <class Tag_>
auto operator()(Point_d const&p, Tag_ t)const{ auto operator()(Point_d const&p, Tag_ t)const{
return CPI(this->kernel())(p,t); return CPI(this->kernel())(p,t);

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Hyperplane_d.h
View File

@ -32,7 +32,7 @@ class Hyperplane_d : public Get_type<typename R_::Kernel_base, Hyperplane_tag>::
typedef typename Get_functor<Kbase, Hyperplane_translation_tag>::type HTBase; typedef typename Get_functor<Kbase, Hyperplane_translation_tag>::type HTBase;
typedef Hyperplane_d Self; typedef Hyperplane_d Self;
static_assert((std::is_same<Self, typename Get_type<R_, Hyperplane_tag>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Hyperplane_tag>::type>::value);
public: public:

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Point_d.h
View File

@ -40,7 +40,7 @@ class Point_d : public Get_type<typename R_::Kernel_base, Point_tag>::type
typedef Point_d Self; typedef Point_d Self;
static_assert((std::is_same<Self, typename Get_type<R_, Point_tag>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Point_tag>::type>::value);
public: public:

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Ref_count_obj.h
View File

@ -33,7 +33,7 @@ class Ref_count_obj
typedef typename Get_functor<Kbase, Construct_ttag<Tag_> >::type CBase; typedef typename Get_functor<Kbase, Construct_ttag<Tag_> >::type CBase;
typedef Ref_count_obj Self; typedef Ref_count_obj Self;
static_assert((std::is_same<Self, typename Get_type<R_, Tag_>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Tag_>::type>::value);
public: public:
typedef R_ R; typedef R_ R;

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Segment_d.h
View File

@ -35,7 +35,7 @@ class Segment_d : public Get_type<typename R_::Kernel_base, Segment_tag>::type
typedef typename Get_functor<Kbase, Segment_extremity_tag>::type CSEBase; typedef typename Get_functor<Kbase, Segment_extremity_tag>::type CSEBase;
typedef Segment_d Self; typedef Segment_d Self;
static_assert((std::is_same<Self, typename Get_type<R_, Segment_tag>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Segment_tag>::type>::value);
public: public:

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Sphere_d.h
View File

@ -32,7 +32,7 @@ class Sphere_d : public Get_type<typename R_::Kernel_base, Sphere_tag>::type
typedef typename Get_functor<Kbase, Squared_radius_tag>::type SRBase; typedef typename Get_functor<Kbase, Squared_radius_tag>::type SRBase;
typedef Sphere_d Self; typedef Sphere_d Self;
static_assert((std::is_same<Self, typename Get_type<R_, Sphere_tag>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Sphere_tag>::type>::value);
public: public:

2
NewKernel_d/include/CGAL/NewKernel_d/Wrapper/Vector_d.h
View File

@ -39,7 +39,7 @@ class Vector_d : public Get_type<typename R_::Kernel_base, Vector_tag>::type
typedef typename Get_functor<Kbase, Squared_length_tag>::type SLBase; typedef typename Get_functor<Kbase, Squared_length_tag>::type SLBase;
typedef Vector_d Self; typedef Vector_d Self;
static_assert((std::is_same<Self, typename Get_type<R_, Vector_tag>::type>::value)); static_assert(std::is_same<Self, typename Get_type<R_, Vector_tag>::type>::value);
public: public:

10
NewKernel_d/test/NewKernel_d/Epick_d.cpp
View File

@ -740,11 +740,11 @@ template struct CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
typedef CGAL::Epick_d<CGAL::Dimension_tag<2> > Ker2; typedef CGAL::Epick_d<CGAL::Dimension_tag<2> > Ker2;
typedef CGAL::Epick_d<CGAL::Dimension_tag<3> > Ker3; typedef CGAL::Epick_d<CGAL::Dimension_tag<3> > Ker3;
typedef CGAL::Epick_d<CGAL::Dynamic_dimension_tag> Kerd; typedef CGAL::Epick_d<CGAL::Dynamic_dimension_tag> Kerd;
static_assert((std::is_same<CGAL::Dimension_tag<2>,Ker2::Dimension>::value)); static_assert(std::is_same<CGAL::Dimension_tag<2>,Ker2::Dimension>::value);
static_assert((std::is_same<CGAL::Dimension_tag<3>,Ker3::Dimension>::value)); static_assert(std::is_same<CGAL::Dimension_tag<3>,Ker3::Dimension>::value);
static_assert((std::is_same<CGAL::Dynamic_dimension_tag,Kerd::Dimension>::value)); static_assert(std::is_same<CGAL::Dynamic_dimension_tag,Kerd::Dimension>::value);
static_assert((std::is_same<CGAL::Dimension_tag<2>,CGAL::Ambient_dimension<Ker2::Point_d>::type>::value)); static_assert(std::is_same<CGAL::Dimension_tag<2>,CGAL::Ambient_dimension<Ker2::Point_d>::type>::value);
static_assert((std::is_same<CGAL::Dimension_tag<3>,CGAL::Ambient_dimension<Ker3::Point_d,Ker3>::type>::value)); static_assert(std::is_same<CGAL::Dimension_tag<3>,CGAL::Ambient_dimension<Ker3::Point_d,Ker3>::type>::value);
int main(){ int main(){
//Broken with Linear_base_d (output iterator) //Broken with Linear_base_d (output iterator)
//test2<CGAL::Kernel_d_interface<KK> >(); //test2<CGAL::Kernel_d_interface<KK> >();

8
Number_types/include/CGAL/Lazy_exact_nt.h
View File

@ -944,9 +944,9 @@ struct Div_mod_selector {
void operator()( const NT1& x, const NT2& y, void operator()( const NT1& x, const NT2& y,
NT& q, NT& q,
NT& r ) const { NT& r ) const {
static_assert((::std::is_same< static_assert(::std::is_same<
typename Coercion_traits< NT1, NT2 >::Type, NT typename Coercion_traits< NT1, NT2 >::Type, NT
>::value)); >::value);
typename Coercion_traits< NT1, NT2 >::Cast cast; typename Coercion_traits< NT1, NT2 >::Cast cast;
operator()( cast(x), cast(y), q, r ); operator()( cast(x), cast(y), q, r );
@ -1029,8 +1029,8 @@ template < typename ET > class Real_embeddable_traits< Lazy_exact_nt<ET> >
: public INTERN_RET::Real_embeddable_traits_base< Lazy_exact_nt<ET> , CGAL::Tag_true > { : public INTERN_RET::Real_embeddable_traits_base< Lazy_exact_nt<ET> , CGAL::Tag_true > {
// Every type ET of Lazy_exact_nt<ET> has to be real embeddable. // Every type ET of Lazy_exact_nt<ET> has to be real embeddable.
static_assert((::std::is_same< typename Real_embeddable_traits< ET > static_assert(::std::is_same< typename Real_embeddable_traits< ET >
::Is_real_embeddable, Tag_true >::value)); ::Is_real_embeddable, Tag_true >::value);
public: public:
typedef Lazy_exact_nt<ET> Type; typedef Lazy_exact_nt<ET> Type;

2
Number_types/include/CGAL/Root_of_traits.h
View File

@ -150,7 +150,7 @@ private:
// We have the typedef as VC10 fails with // We have the typedef as VC10 fails with
// static_assert(FrT::Is_fraction::value) // static_assert(FrT::Is_fraction::value)
typedef typename FrT::Is_fraction ISF; typedef typename FrT::Is_fraction ISF;
static_assert((ISF::value)); static_assert(ISF::value);
typedef typename FrT::Numerator_type RT; typedef typename FrT::Numerator_type RT;

12
Number_types/include/CGAL/Test/test_root_of_traits.h
View File

@ -28,8 +28,8 @@ void test_root_of_traits(){
typedef typename RoT::Root_of_1 Root_of_1; typedef typename RoT::Root_of_1 Root_of_1;
typedef typename RoT::Root_of_2 Root_of_2; typedef typename RoT::Root_of_2 Root_of_2;
static_assert((::std::is_same<RootOf1,Root_of_1>::value)); static_assert(::std::is_same<RootOf1,Root_of_1>::value);
static_assert((::std::is_same<RootOf2,Root_of_2>::value)); static_assert(::std::is_same<RootOf2,Root_of_2>::value);
typedef typename RoT::Make_root_of_2 Make_root_of_2; typedef typename RoT::Make_root_of_2 Make_root_of_2;
typedef typename RoT::Make_sqrt Make_sqrt; typedef typename RoT::Make_sqrt Make_sqrt;
@ -41,10 +41,10 @@ void test_root_of_traits(){
const Inverse& inverse = Inverse(); const Inverse& inverse = Inverse();
const Square& square = Square(); const Square& square = Square();
static_assert((::std::is_same<Root_of_2,typename Make_root_of_2::result_type>::value)); static_assert(::std::is_same<Root_of_2,typename Make_root_of_2::result_type>::value);
static_assert((::std::is_same<Root_of_2,typename Make_sqrt::result_type>::value)); static_assert(::std::is_same<Root_of_2,typename Make_sqrt::result_type>::value);
static_assert((::std::is_same<Root_of_2,typename Inverse::result_type>::value)); static_assert(::std::is_same<Root_of_2,typename Inverse::result_type>::value);
static_assert((::std::is_same<Root_of_2,typename Square::result_type>::value)); static_assert(::std::is_same<Root_of_2,typename Square::result_type>::value);
{ {

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