[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[creduce-bugs] two crashes
Hello,
I am using the version that Debian calls 2.2~pre1-2 (should be about March
27th checkout from trunk, using llvm-3.4), and got several crashes and
what looked like an infinite loop. Please find attached reproducers for 2
of the crashes, that seem different enough (note that it doesn't crash
every time, you may have to try it a few times).
Side note: it would be nice if creduce didn't give the same name to the
member functions of different classes, if it can avoid it.
--
Marc Glisse
template<class _T1, class _T2> struct pair {
pair(const int& __a, const int& __b) ;
};
struct random_access_iterator_tag ;
template<typename _Iterator> struct iterator_traits ;
template<typename _Tp> struct iterator_traits<_Tp*> {
typedef _Tp value_type;
typedef _Tp& reference;
};
template<typename _Tp> struct allocator {
typedef unsigned long size_type;
};
namespace mpl_ {
}
namespace boost {
namespace mpl {
using namespace mpl_;
}
}
namespace mpl_ {
template< bool C_ > struct bool_;
template< bool C_ > struct bool_ {
static const bool value = C_;
typedef bool_ type;
};
struct na ;
}
namespace boost {
namespace mpl {
template< typename T > struct type_wrapper ;
typedef char (&yes_tag)[2];
template< bool C , typename T1 , typename T2 > struct if_c {
typedef int type;
};
template< typename T1 , typename T2 > struct if_c<false,T1,T2> {
typedef T2 type;
};
template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
typedef typename T1::type type;
};
template< typename C = na , typename F1 = na , typename F2 = na > struct eval_if {
typedef typename C::type type;
};
template< typename T = na > struct identity {
typedef int type;
};
template< typename T > struct nested_type_wknd : T::type {
};
template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : bool_<true> {
};
template< typename T1 = na , typename T2 = na , typename T3 = bool_<false>, typename T4 = bool_<false>, typename T5 = bool_<false> > struct or_ : or_impl< ::boost::mpl::nested_type_wknd<T1>::value , int, int, int, int > {
};
}
}
namespace mpl_ {
template< typename T, int N > struct integral_c {
static const int value = N;
};
}
namespace boost{
template <class T, int val> struct integral_constant : mpl::integral_c<int, val> {
typedef integral_constant type;
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> {
};
template< typename T > struct is_lvalue_reference : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_rvalue_reference : ::boost::integral_constant<bool,false> {
};
struct no_type ;
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_or {
static const bool value = false;
};
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true> struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_and {
static const bool value = true;
};
template <bool b> struct ice_not {
static const bool value = true;
};
template <typename T> struct is_reference_impl {
static const bool value = ::boost::ice_or< ::boost::is_lvalue_reference<int>::value, ::boost::is_rvalue_reference<int>::value >::value;
};
template< typename T > struct is_reference : ::boost::integral_constant<bool,::boost::is_reference_impl<int>::value> {
};
template <typename T> struct is_class_impl {
static const bool value = __is_class(int);
};
template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::is_class_impl<int>::value> {
};
template <typename T> struct is_mem_fun_pointer_impl {
static const bool value = false;
};
template< typename T > struct remove_cv {
typedef int type;
};
template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::is_mem_fun_pointer_impl<typename remove_cv<int>::type>::value> {
};
template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<int>::value> {
};
template< typename T > struct is_pointer_helper {
static const bool value = false;
};
template< typename T > struct is_pointer_impl {
static const bool value = ::boost::ice_and< ::boost::is_pointer_helper<typename remove_cv<int>::type>::value , ::boost::ice_not< ::boost::is_member_pointer<int>::value >::value >::value;
};
template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::is_pointer_impl<int>::value> {
};
template< typename T > struct remove_reference {
typedef int type;
};
template< typename T > struct is_void : ::boost::integral_constant<bool,false> {
};
template <bool B, class T = void> struct disable_if_c {
typedef T type;
};
template <class Cond, class T = void> struct disable_if : disable_if_c<Cond::value, T> {
};
template<typename F> struct result_of;
template<typename F> struct tr1_result_of;
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_result_type {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<int*>(0))) == sizeof(boost::mpl::yes_tag);
};
template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
template<typename F, typename FArgs> struct tr1_result_of_impl<F, FArgs, true> {
typedef typename F::result_type type;
};
template<typename F , typename T0> struct tr1_result_of<F( T0)> : mpl::if_< mpl::or_< is_pointer<F>, is_member_function_pointer<F> > , boost::tr1_result_of_impl< typename remove_cv<F>::type, typename remove_cv<F>::type, boost::has_result_type<F>::value> , boost::tr1_result_of_impl< F, F, boost::has_result_type<F>::value> >::type {
};
template<typename F , typename T0> struct result_of<F( T0)> : tr1_result_of<F( T0)> {
};
}
enum Sign {
POSITIVE , ON_POSITIVE_SIDE };
template <bool b> struct Boolean_tag {
static const bool value = b;
};
struct Null_tag ;
struct Null_functor ;
namespace mpl_ {
template< int N > struct arg;
}
namespace boost {
namespace mpl {
template< long C_ > struct not_impl : bool_<!C_> {
};
template< typename T = na > struct not_ : not_impl< ::boost::mpl::nested_type_wknd<T>::value > {
};
}
}
namespace mpl_ {
typedef arg<1> _1;
}
namespace boost {
template< typename T > struct is_array : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_integral : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_float : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_arithmetic_impl {
static const bool value = ::boost::ice_or< ::boost::is_integral<int>::value, ::boost::is_float<int>::value >::value;
};
template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::is_arithmetic_impl<int>::value> {
};
template <class T> struct is_abstract_imp {
static const bool value = __is_abstract(int);
};
template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::is_abstract_imp<int>::value> {
};
template< typename T > struct add_reference ;
struct false_result {
template <typename T> struct result_ {
static const bool value = false;
};
};
template<bool is_ref = true> struct is_function_chooser : ::boost::false_result {
};
template <typename T> struct is_function_impl : is_function_chooser< ::boost::is_reference<int>::value > ::template result_<int> {
};
template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::is_function_impl<int>::value> {
};
struct any_conversion ;
template <typename T> struct checker ;
template <typename From, typename To> struct is_convertible_basic_impl {
static int _m_from;
static bool const value = sizeof 0 == sizeof(char);
};
template <typename From, typename To> struct is_convertible_impl {
static const bool value = ::boost::ice_and< ::boost::ice_or< ::boost::is_convertible_basic_impl<int,int>::value, ::boost::is_void<int>::value >::value, ::boost::ice_not< ::boost::is_array<int>::value >::value, ::boost::ice_not< ::boost::is_function<int>::value >::value >::value;
};
template <bool trivial1, bool trivial2, bool abstract_target> struct is_convertible_impl_select {
template <class From, class To> struct rebind {
typedef is_convertible_impl<int, int> type;
};
};
template <typename From, typename To> struct is_convertible_impl_dispatch_base {
typedef typename is_convertible_impl_select< ::boost::is_arithmetic<int>::value, ::boost::is_arithmetic<int>::value, ::boost::is_abstract<int>::value>::template rebind<int, int> isc_binder;
typedef typename isc_binder::type type;
};
template <typename From, typename To> struct is_convertible_impl_dispatch : is_convertible_impl_dispatch_base<int, int>::type {
};
template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,::boost::is_convertible_impl_dispatch<int,int>::value> {
};
struct no_traversal_tag {
};
struct incrementable_traversal_tag : no_traversal_tag {
};
struct single_pass_traversal_tag : incrementable_traversal_tag {
};
struct forward_traversal_tag : single_pass_traversal_tag {
};
struct bidirectional_traversal_tag : forward_traversal_tag {
};
struct random_access_traversal_tag : bidirectional_traversal_tag {
};
template <class Cat> struct old_category_to_traversal : mpl::identity<random_access_traversal_tag> {
};
template <class Cat> struct iterator_category_to_traversal : mpl::eval_if< is_convertible<int,incrementable_traversal_tag> , mpl::identity<int> , boost::old_category_to_traversal<int> > {
};
template <class Iterator = mpl::_1> struct iterator_traversal : iterator_category_to_traversal< random_access_iterator_tag> {
};
template <class Iterator> struct iterator_value ;
template <class Iterator> struct iterator_reference ;
template <class Iterator> struct iterator_difference {
typedef int type;
};
namespace mpl {
template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : bool_<false> {
};
template< typename T1 = na , typename T2 = na , typename T3 = bool_<true>, typename T4 = bool_<true>, typename T5 = bool_<true> > struct and_ : and_impl< ::boost::mpl::nested_type_wknd<T1>::value , int, int, int, int > {
};
}
template < class Derived , class Value , class CategoryOrTraversal , class Reference = Value& , class Difference = long > struct iterator_facade {
int operator*() const ;
void operator++() ;
};
struct use_default;
template <class T, class DefaultNullaryFn> struct ia_dflt_help : mpl::eval_if< is_same<int, use_default> , int , mpl::identity<int> > {
};
template < class Derived , class Base , class Value , class Traversal , class Reference , class Difference > struct iterator_adaptor_base {
typedef iterator_facade< Derived , typename boost::ia_dflt_help< int , mpl::eval_if< is_same<int,use_default> , iterator_value<int> , remove_reference<int> > >::type , typename boost::ia_dflt_help< int , iterator_traversal<int> >::type , typename boost::ia_dflt_help< int , mpl::eval_if< is_same<int,use_default> , iterator_reference<int> , add_reference<int> > >::type , typename boost::ia_dflt_help< int, iterator_difference<int> >::type > type;
};
template < class Derived , class Base , class Value = use_default , class Traversal = use_default , class Reference = use_default , class Difference = use_default > struct iterator_adaptor : boost::iterator_adaptor_base< Derived, Base, int, int, int, int >::type {
Base m_iterator;
};
template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> struct transform_iterator;
template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator_base {
typedef iterator_adaptor< transform_iterator<int, Iterator, int, int> , Iterator , int , use_default , int > type;
};
template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator : boost::transform_iterator_base<int, Iterator, int, int>::type {
};
template <class UnaryFunc, class Iterator> transform_iterator<UnaryFunc, Iterator> make_transform_iterator(Iterator it, UnaryFunc fun) ;
}
template <bool Protected = true> struct Interval_nt ;
namespace boost {
template <typename T> struct empty_base {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct less_than_comparable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct less_than_comparable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct equality_comparable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct equality_comparable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct multipliable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct multipliable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct addable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct addable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct subtractable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct subtractable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct subtractable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct dividable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct dividable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct dividable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct modable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct modable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct modable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct xorable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct andable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct orable2 : boost::empty_base<int> {
};
template <class T, class B = ::boost::empty_base<T> > struct incrementable : B {
};
template <class T, class B = ::boost::empty_base<T> > struct decrementable : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct left_shiftable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct right_shiftable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct totally_ordered2 : less_than_comparable2<int, int , equality_comparable2<int, int, B > > {
};
template <class T, class B = ::boost::empty_base<int> > struct totally_ordered1 : less_than_comparable1<int , equality_comparable1<int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct additive2 : addable2<int, int , subtractable2<int, int, B > > {
};
template <class T, class B = ::boost::empty_base<int> > struct additive1 : addable1<int , subtractable1<int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct bitwise2 : xorable2<int, int , andable2<int, int , orable2<int, int, boost::empty_base<int> > > > {
};
template <class T, class B = ::boost::empty_base<int> > struct unit_steppable : incrementable<int , decrementable<int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct shiftable2 : left_shiftable2<int, int , right_shiftable2<int, int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct ring_operators2 : additive2<int, int , subtractable2_left<int, int , multipliable2<int, int, B > > > {
};
template <class T, class B = ::boost::empty_base<int> > struct ring_operators1 : additive1<int , multipliable1<int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct field_operators2 : ring_operators2<int, int , dividable2<int, int , dividable2_left<int, int, B > > > {
};
template <class T, class B = ::boost::empty_base<int> > struct field_operators1 : ring_operators1<int , dividable1<int, B > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct ordered_field_operators2 : field_operators2<int, int , totally_ordered2<int, int, B > > {
};
class Gmpq;
class Gmpz;
class Gmpfr;
template <class T, class B = ::boost::empty_base<int> > struct ordered_field_operators1 : field_operators1<int , totally_ordered1<int, boost::ordered_field_operators2<Gmpq, int, boost::ordered_field_operators2<Gmpq, long, boost::ordered_field_operators2<Gmpq, double, boost::ordered_field_operators2<Gmpq, Gmpz, boost::ordered_field_operators2<Gmpq, Gmpfr, boost::empty_base<int> > > > > > > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct euclidian_ring_operators2 : ring_operators2<int, int , dividable2<int, int , dividable2_left<int, int , modable2<int, int , modable2_left<int, int, B > > > > > {
};
template <class T, class B = ::boost::empty_base<int> > struct euclidian_ring_operators1 : ring_operators1<int , dividable1<int , modable1<int, B > > > {
};
template <class T, class U, class B = ::boost::empty_base<int> > struct ordered_euclidian_ring_operators2 : totally_ordered2<int, int , euclidian_ring_operators2<int, int, B > > {
};
template <class T, class B = ::boost::empty_base<int> > struct ordered_euclidian_ring_operators1 : totally_ordered1<int , euclidian_ring_operators1<int, B > > {
};
struct false_t ;
template<class T> struct is_chained_base {
typedef boost::false_t value;
};
template <class T ,class U = int ,class B = ::boost::empty_base<int> ,class O = typename is_chained_base<int>::value > struct bitwise : bitwise2<int, int, B> {
};
template <class T ,class U = int ,class B = ::boost::empty_base<int> ,class O = typename is_chained_base<int>::value > struct shiftable : shiftable2<int, int, B> {
}
;
}
template<typename _Tp > struct vector {
typedef _Tp * iterator;
typedef const _Tp * const_iterator;
iterator begin() ;
iterator end() ;
};
namespace boost {
namespace mpl {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template< typename Tag > struct begin_impl ;
template< typename Tag > struct end_impl ;
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<boost::mpl::type_wrapper<int>*>(0))) == sizeof(boost::mpl::yes_tag);
};
template< bool has_tag_, bool has_begin_ > struct sequence_tag_impl ;
template<> struct sequence_tag_impl<true,false> {
template< typename Sequence > struct result2_ {
typedef typename Sequence::tag type;
};
};
template< typename Sequence = na > struct sequence_tag : sequence_tag_impl< ::boost::mpl::has_tag<Sequence>::value , ::boost::mpl::has_begin<Sequence>::value >::template result2_<Sequence> {
};
template< typename Sequence = na > struct begin {
typedef typename sequence_tag<Sequence>::type tag_;
typedef typename begin_impl< tag_ > ::template apply< Sequence >::type type;
};
template< typename Sequence = na > struct end {
typedef typename sequence_tag<Sequence>::type tag_;
typedef typename end_impl< tag_ > ::template apply< Sequence >::type type;
};
}
template< long N > struct long_ {
static const long value = N;
};
namespace mpl {
template< typename Tag > struct pop_front_impl;
};
template <typename T, bool is_a_class = false> struct empty_helper {
static const bool value = false;
};
template <typename T> struct is_empty_impl {
static const bool value = ::boost::ice_or< ::boost::empty_helper<int,::boost::is_class<int>::value>::value , false >::value ;
};
template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::is_empty_impl<int>::value> {
};
namespace mpl {
template< typename Tag > struct empty_impl {
template< typename Sequence > struct apply : is_same< typename begin<Sequence>::type , typename end<Sequence>::type > {
};
};
template< typename Sequence = na > struct empty : empty_impl< typename sequence_tag<Sequence>::type > ::template apply< Sequence > {
};
template< typename Sequence = na , typename Predicate = na > struct find_if {
typedef int type;
};
template< typename Tag > struct front_impl ;
template< typename Sequence = na > struct front : front_impl< typename sequence_tag<Sequence>::type > ::template apply {
};
template< typename T1 > struct same_as ;
}
}
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_type {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
typedef boost::mpl::type_wrapper<int> t_;
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::yes_tag);
};
}
template <class T, class No, bool=internal::has_type<T>::value > struct Has_type_different_from : boost::false_type {
};
template <class T, class No> struct Has_type_different_from <T, No, true> : boost::mpl::not_<boost::is_same<typename T::type, No> > {
};
template < int dim > struct Dimension_tag {
static const int value = dim;
};
struct Dynamic_dimension_tag ;
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Do_not_store_kernel {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template<class T,bool=has_Do_not_store_kernel<T>::value> struct Do_not_store_kernel {
enum {
value };
};
}
template<class R_,bool=boost::is_empty<R_>::value||internal::Do_not_store_kernel<R_>::value> struct Store_kernel {
Store_kernel(R_ const&);
R_ kernel()const;
};
template<class R_,bool=boost::is_empty<R_>::value||internal::Do_not_store_kernel<R_>::value> struct Store_kernel2 {
};
struct Default {
template <typename Argument, typename Value> struct Get {
typedef int type;
};
template <typename Value> struct Get <Default, Value> {
typedef Value type;
};
};
namespace internal {
template<class T,bool=boost::is_empty<T>::value> struct Functor_as_base {
T f;
};
template <typename Derived, typename F, typename Iter, typename Ref, typename Val> struct transforming_iterator_helper {
typedef int reference;
typedef boost::iterator_adaptor< int, Iter, int, random_access_iterator_tag, reference > type;
};
}
template <typename F, typename Iter, typename Ref=Default, typename Val=Default> struct transforming_iterator : internal::transforming_iterator_helper<transforming_iterator<F,Iter,int,int>,F,Iter,int,int>::type, internal::Functor_as_base<F> {
};
namespace boost {
namespace mpl {
struct vector_tag;
template< typename T , typename Base , int at_front = 0 > struct v_item : Base {
};
template< typename Vector , long n_ > struct v_iter ;
template< typename Dummy = na > struct vector0;
template<> struct vector0<na> {
typedef vector_tag tag;
typedef long_<0> size;
};
template<> struct begin_impl< vector_tag > {
template< typename Vector > struct apply {
typedef v_iter<Vector,0> type;
};
};
template<> struct end_impl< vector_tag > {
template< typename Vector > struct apply {
typedef v_iter<Vector,Vector::size::value> type;
};
};
template< typename T0 > struct vector1 : v_item< int , vector0< > > {
};
template< typename T0, typename T1 > struct vector2 : v_item< int , vector1<int> > {
};
template< typename T0, typename T1, typename T2 > struct vector3 : v_item< int , vector2< int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3 > struct vector4 : v_item< int , vector3< int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 : v_item< int , vector4< int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 : v_item< int , vector5< int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 : v_item< int , vector6< int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 : v_item< int , vector7< int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 : v_item< int , vector8< int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector10 : v_item< int , vector9< int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector11 : v_item< int , vector10< int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector12 : v_item< int , vector11< int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector13 : v_item< int , vector12< int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector14 : v_item< int , vector13< int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector15 : v_item< int , vector14< int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector16 : v_item< int , vector15< int,int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector17 : v_item< int , vector16< int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector18 : v_item< int , vector17< int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector19 : v_item< int , vector18< int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector20 : v_item< int , vector19< int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int > > {
};
template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector;
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< int, int, int, int, int, int, int, int, int, int, int, int, int, int, int , int, int, int, int, int > {
};
template< typename Sequence = na > struct pop_front : pop_front_impl< typename sequence_tag<Sequence>::type > ::template apply {
};
}
}
template <class K, class T, class=void> struct Get_type : K::template Type<int> {
};
template <class K, class F, class O=void, class=void> struct Get_functor : K::template Functor<F, int> {
};
class Null_type ;
struct Misc_tag ;
template <class K, class F, class=void, class=void> struct Get_functor_category {
typedef Misc_tag type;
};
template<class Kernel, class Tg> struct Provides_type : Has_type_different_from<Get_type<int, Tg>, Null_type> {
};
template<class Kernel, class Tg, class O=void> struct Provides_functor : Has_type_different_from<Get_functor<Kernel, int, int>, Null_functor> {
};
template<class K, class List, bool=boost::mpl::empty<List>::type::value> struct Provides_functors : boost::mpl::and_ < Provides_functor<int, typename boost::mpl::front<List>::type>, Provides_functors<int, typename boost::mpl::pop_front<List>::type> > {
};
template<class K, class List> struct Provides_functors<K, List, true> : boost::true_type {
};
template<class K, class List, bool=boost::mpl::empty<List>::type::value> struct Provides_types : boost::mpl::and_ < Provides_type<int, typename boost::mpl::front<List>::type>, Provides_types<int, typename boost::mpl::pop_front<List>::type> > {
};
template<class K, class List> struct Provides_types<K, List, true> : boost::true_type {
};
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Type {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
}
template<class Kernel, class Tg, bool = internal::has_Type<Kernel>::value > struct Provides_type_i : boost::false_type {
};
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Functor {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<boost::mpl::type_wrapper<int>*>(0))) == sizeof(boost::mpl::yes_tag);
};
}
template<class Kernel, class Tg, class O=void, bool = internal::has_Functor<Kernel>::value > struct Provides_functor_i : boost::false_type {
};
template<class Kernel, class Tg, class O> struct Provides_functor_i <Kernel, Tg, O, true> : Has_type_different_from<typename Kernel::template Functor<Tg, O>, Null_functor> {
};
template <class K, class T, class D=void, bool = internal::has_Functor<K>::value > struct Inherit_functor : K::template Functor<int> {
};
struct RT_tag ;
struct Orientation_tag ;
struct Flat_orientation_tag ;
struct Vector_tag ;
struct Point_tag ;
struct Segment_tag ;
struct Sphere_tag ;
template <class K> struct Get_type<K, Orientation_tag, typename boost::mpl::if_c< Provides_type_i<K, Orientation_tag>::value || !Provides_types<K, boost::mpl::vector<RT_tag> >::value || !Provides_functors<K, boost::mpl::vector<> >::value , int, void>::type> {
typedef Sign type;
};
struct Compute_point_cartesian_coordinate_tag ;
template<class>struct map_result_tag{
typedef Null_type type;
};
struct In_flat_orientation_tag ;
struct Construct_flat_orientation_tag ;
struct Point_dimension_tag ;
struct Flat_orientation {
};
template<class R_> struct Construct_flat_orientation : Store_kernel<R_> {
typedef R_ R;
typedef typename Get_functor<R, Compute_point_cartesian_coordinate_tag>::type CCC;
typedef Flat_orientation result_type;
template<class Iter> result_type operator()(Iter f, Iter e)const{
Iter f_save = f;
typename Get_functor<R, Point_dimension_tag>::type pd (this->kernel());
CCC ccc (this->kernel());
int dim = pd(*f);
int col = 0;
Flat_orientation o;
bool o_2;
for( ;
0 ;
++col, ++f ) ;
typename Get_functor<R, In_flat_orientation_tag>::type ifo(this->kernel());
o_2 = ifo(o, f_save, e) != POSITIVE;
}
};
template<class R_> struct In_flat_orientation : Store_kernel<R_> {
In_flat_orientation(R_ const&r):Store_kernel<R_>(r){
}
template<class Iter> typename Get_type<R_, Orientation_tag>::type operator()(Flat_orientation const&o, Iter f, Iter e) const ;
};
template <class K, class O> struct Get_functor<K, In_flat_orientation_tag, O, typename boost::mpl::if_c< Provides_functor_i<K, In_flat_orientation_tag, O>::value || !Provides_types<K, boost::mpl::vector<Point_tag> >::value || !Provides_functors<K, boost::mpl::vector<Compute_point_cartesian_coordinate_tag,Point_dimension_tag> >::value , int, void>::type> {
typedef In_flat_orientation<K> type;
};
template <class K, class O> struct Get_functor<K, Construct_flat_orientation_tag, O, typename boost::mpl::if_c< Provides_functor_i<K, Construct_flat_orientation_tag, O>::value || !Provides_types<K, boost::mpl::vector<Point_tag> >::value || !Provides_functors<K, boost::mpl::vector<Compute_point_cartesian_coordinate_tag,Point_dimension_tag,In_flat_orientation_tag> >::value , int, void>::type> {
typedef Construct_flat_orientation<K> type;
};
template<class,class> struct typeset;
template<class H=void, class T=typename boost::mpl::if_<boost::is_same<H,void>, void, typeset<void, void> >::type > struct typeset {
typedef typeset type;
typedef T tail;
};
template<class T1, class T2> struct typeset_intersection_ {
typedef typeset<Point_tag, typeset<void, boost::integral_constant<bool, 1> > > type;
};
template<class T1, class T2> struct typeset_intersection : typeset_intersection_<typeset<Point_tag, typeset<void, boost::integral_constant<bool, 1> > >,int>::type {
};
template<class=Dynamic_dimension_tag> struct Dimension_base {
};
template<class R_> struct Compute_cartesian_coordinate {
Compute_cartesian_coordinate(R_ const&);
};
template<class R_> struct PV_dimension {
PV_dimension(R_ const&);
template<class T> int operator()(T const& v) const ;
};
namespace boost {
template<class T, unsigned long> struct array {
typedef const T* const_iterator;
};
}
using boost::array;
template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
template< class D2, class D3=D2 > struct Rebind_dimension {
typedef Array_vector Other;
};
static const unsigned d_=Dimension_tag<2>::value;
typedef boost::array<int,d_> Vector;
};
template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector ;
template <class Static_, class Dynamic_, class NT_ ,class Dim_, class Max_dim_ = Dim_> struct Mix_vector : Dynamic_::template Rebind_dimensionDim_, Max_dim_::Other {
};
template <class Static_, class Dynamic_, class NT_, int d, class Max_dim_> struct Mix_vector<Static_, Dynamic_, NT_, Dimension_tag<d>, Max_dim_> : Static_::template Rebind_dimension<Dimension_tag<d>, Max_dim_>::Other {
};
template<class NT_,class Dim_,class Max_dim_=Dim_> struct LA_eigen ;
template < typename FT_, typename Dim_, typename Vec_=Mix_vector<Array_vector<FT_, Dim_>, Vector_vector<FT_, Dim_>, FT_, Dim_>, typename LA_=LA_eigen<FT_,Dim_> > struct Cartesian_LA_base_d : Dimension_base<Dim_> {
typedef Cartesian_LA_base_d Self;
typedef Dim_ Dimension;
typedef typename Vec_::Vector Vector_;
template<class, class=void> struct Type {
typedef Vector_ type;
};
typedef typeset<Point_tag, typeset<> > Object_list;
template<class, class=void, class=boost::integral_constant<int,0> > struct Functor {
typedef Null_functor type;
};
template<class D> struct Functor<Compute_point_cartesian_coordinate_tag,D> {
typedef Compute_cartesian_coordinate<Self> type;
};
template<class D> struct Functor<Point_dimension_tag,D> {
typedef PV_dimension<Self> type;
};
};
template < typename FT_, typename Dim_, typename Derived_=Default> struct Cartesian_base_d : Cartesian_LA_base_d< int, Dim_ > {
};
template <class Dim_ , class R_, class Derived_=Default> struct Cartesian_static_filters : R_ {
};
template<class Final_, class K1, class K2, class List> struct KernelD_converter_ : KernelD_converter_<int,int,int,typename List::tail> {
};
template<class Final_, class K1, class K2> struct KernelD_converter_<Final_,K1,K2,typeset<> > {
};
template<class K1, class K2, class List_= typename typeset_intersection<typename K1::Object_list, typename K2::Object_list>::type > struct KernelD_converter : Store_kernel<K1>, Store_kernel2<K2>, KernelD_converter_<KernelD_converter<K1,K2,List_>,K1,K2,List_> {
template<class It> transforming_iterator<KernelD_converter<K1, K2, List_>,It> operator()(It const& it) const ;
};
template <class EP, class AP, class C2E, class C2A, bool Protection = true> struct Filtered_predicate2 {
EP ep;
AP ap;
C2E c2e;
C2A c2a;
typedef typename EP::result_type result_type;
template < class A0 , class A1> result_type operator()( A0 const& a0 , A1 const& a1) const {
ap( c2a(a0) , c2a(a1));
return ep( c2e(a0) , c2e(a1));
}
};
template < typename Base_, typename AK_, typename EK_ > struct Cartesian_filter_K : Cartesian_base_d<double, Dimension_tag<2>, Default>, Store_kernel<AK_>, Store_kernel2<EK_> {
typedef Cartesian_base_d<double, Dimension_tag<2>, Default> Kernel_base;
typedef AK_ AK;
typedef EK_ EK;
typedef KernelD_converter<Kernel_base,AK> C2A;
template<class T,class D=void,class=typename Get_functor_category<Cartesian_filter_K,T>::type> struct Functor : Inherit_functor<Kernel_base,T,int> {
typedef Filtered_predicate2<typename Get_functor<EK, T>::type,typename Get_functor<AK, T>::type,KernelD_converter<Kernel_base, EK>,C2A> type;
};
};
template <class T, class Alloc = void > struct Handle_for {
};
namespace boost {
namespace mpl {
template< typename Sequence = na , typename T = na > struct find : find_if< int,same_as<int> > {
};
template< typename Tag > struct contains_impl {
template< typename Sequence, typename T > struct apply : not_< is_same< typename find<Sequence,int>::type , typename end<Sequence>::type > > {
};
};
template< typename Sequence = na , typename T = na > struct contains : contains_impl< typename sequence_tag<Sequence>::type > ::template apply< Sequence,int > {
};
}
}
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Is_wrapper {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template<class T,bool=has_Is_wrapper<T>::value> struct Is_wrapper {
typedef Boolean_tag<false> type;
};
template<class T,bool=0> struct Is_wrapper_iterator ;
struct Forward_rep {
template <class T> typename boost::disable_if<boost::mpl::or_<Is_wrapper<T>,Is_wrapper_iterator<T> >,T>::type const& operator()(T const& t) const ;
};
}
template < typename Base_ , typename Derived_ = Default > struct Cartesian_wrap : Base_ {
typedef Base_ Kernel_base;
template <class T, class D = void, class=typename Get_functor_category<Base_,T>::type, bool=Provides_functor<Kernel_base, T>::value, bool=boost::mpl::contains<boost::mpl::vector<Point_tag, Segment_tag, Sphere_tag, Vector_tag>,typename map_result_tag<T>::type>::type::value> struct Functor {
typedef typename Get_functor<Kernel_base, T>::type B;
struct type {
B b;
typedef typename B::result_type result_type;
template< class U0,class V> void operator()( U0 const&u0,V const&v)const{
b( internal::Forward_rep()(u0),internal::Forward_rep()(v));
}
};
};
};
template <class Base_> struct Kernel_d_interface : Base_ {
typedef Base_ Base;
typedef typename Get_type<Base, Flat_orientation_tag>::type Flat_orientation_d;
typedef typename Get_type<Base, Point_tag>::type Point_d;
typedef typename Get_functor<Base, Construct_flat_orientation_tag>::type Construct_flat_orientation_d;
};
struct Gmpz_rep ;
class Gmpz : Handle_for<Gmpz_rep>, boost::ordered_euclidian_ring_operators1< Gmpz , boost::ordered_euclidian_ring_operators2< Gmpz, int , boost::ordered_euclidian_ring_operators2< Gmpz, long , boost::ordered_euclidian_ring_operators2< Gmpz, unsigned long , boost::shiftable< Gmpz , long , boost::unit_steppable<Gmpz , boost::bitwise<Gmpz > > > > > > > {
};
class Gmpfr;
struct Gmpq_rep ;
class Gmpq : Handle_for<Gmpq_rep>, boost::ordered_field_operators1< Gmpq , boost::ordered_field_operators2< Gmpq, int , boost::ordered_field_operators2< Gmpq, long , boost::ordered_field_operators2< Gmpq, double , boost::ordered_field_operators2< Gmpq, Gmpz , boost::ordered_field_operators2< Gmpq, Gmpfr > > > > > > {
};
namespace internal {
template < typename > struct Exact_field_selector {
typedef Gmpq Type;
};
}
template<class Dim> struct Epick_d_help1 : Cartesian_filter_K< Cartesian_base_d<double, Dim>, Cartesian_base_d<Interval_nt<false>, Dim>, Cartesian_base_d<internal::Exact_field_selector<double>::Type, Dim> > {
};
template<class Dim> struct Epick_d_help2 : Cartesian_static_filters<Dim,Epick_d_help1<Dim>,Epick_d_help2<Dim> > {
};
template<class Dim> struct Epick_d : Kernel_d_interface< Cartesian_wrap< Epick_d_help2<Dim>, Epick_d<Dim> > > {
Epick_d();
};
namespace internal {
template < class DSC, bool Const > struct CC_iterator;
}
template < class T, class Allocator_ = Default > struct Compact_container {
typedef Allocator_ Al;
typedef typename Default::Get< Al, allocator< T > >::type Allocator;
typedef Compact_container Self;
typedef T value_type;
typedef typename Allocator::size_type size_type;
typedef internal::CC_iterator<Self, false> iterator;
typedef internal::CC_iterator<Self, true> const_iterator;
};
namespace internal {
template < class DSC, bool Const > struct CC_iterator {
typedef typename DSC::value_type value_type;
CC_iterator() ;
CC_iterator (const typename DSC::iterator &it) ;
const value_type * operator->() const ;
};
template<typename D> struct Dimen_plus_one;
template<int D> struct Dimen_plus_one<Dimension_tag<D> > {
typedef Dimension_tag<D+1> type;
};
template< typename Containee, typename D, bool WithCompactContainerHelper = false> struct S_or_D_array;
template< typename Containee, int D, bool WithCompactContainerHelper > struct S_or_D_array< Containee, Dimension_tag< D >, WithCompactContainerHelper > : array<Containee, D> {
};
}
template< class TDS = void > struct Triangulation_ds_vertex {
template <typename TDS2> struct Rebind_TDS {
typedef Triangulation_ds_vertex Other;
};
};
struct TDS_full_cell_default_storage_policy ;
template< typename V, typename S, typename D, typename StoragePolicy > struct TFC_data;
template< typename Vertex_handle, typename Full_cell_handle, typename Dimen > struct TFC_data< Vertex_handle, Full_cell_handle, Dimen, TDS_full_cell_default_storage_policy > {
typedef typename internal::S_or_D_array< Vertex_handle, typename internal::Dimen_plus_one<Dimen>::type, true > Vertex_handle_array;
};
template< class TDS = void, typename FullCellStoragePolicy = Default > struct Triangulation_ds_full_cell {
typedef typename TDS::Full_cell_handle Full_cell_handle;
typedef typename TFC_data<typename TDS::Vertex_handle, Full_cell_handle, typename TDS::Maximal_dimension, typename Default::Get<FullCellStoragePolicy, TDS_full_cell_default_storage_policy>::type>::Vertex_handle_array Vertex_handle_array;
typedef typename Vertex_handle_array::const_iterator Vertex_handle_const_iterator;
Vertex_handle_const_iterator vertices_begin() const ;
Full_cell_handle neighbor(const int i) const ;
};
template< typename StoragePolicy > struct Triangulation_ds_full_cell<void, StoragePolicy> {
template <typename TDS2> struct Rebind_TDS {
typedef Triangulation_ds_full_cell<TDS2, StoragePolicy> Other;
};
};
template<typename _Tp, typename _Alloc> struct _Deque_base ;
template<typename _Tp, typename _Alloc = allocator<int> > struct deque : _Deque_base<int, _Alloc> {
};
template<typename _Tp, typename _Sequence = deque<_Tp> > struct queue {
typedef _Tp reference;
reference front() ;
};
template< class Dimen, class Vb = Default, class Fcb = Default > struct Triangulation_data_structure {
typedef Triangulation_data_structure Self;
typedef Vb V_base;
typedef Fcb FC_base;
typedef typename V_base::template Rebind_TDS<Self>::Other Vertex;
typedef typename FC_base::template Rebind_TDS<Self>::Other Full_cell;
typedef Compact_container<Vertex> Vertex_container;
typedef Compact_container<Full_cell> Full_cell_container;
typedef Dimension_tag<2> Maximal_dimension;
typedef typename Vertex_container::size_type size_type;
typedef typename Vertex_container::iterator Vertex_handle;
typedef typename Full_cell_container::iterator Full_cell_handle;
typedef typename Full_cell_container::const_iterator Full_cell_const_handle;
struct Facet {
Facet(Full_cell_handle f, int i) ;
};
template< typename TraversalPredicate> Facet gather_full_cells(Full_cell_handle, TraversalPredicate &) const;
};
template< class Dim, class Vb, class Fcb > template< typename TraversalPredicate > typename Triangulation_data_structure<Dim, Vb, Fcb>::Facet Triangulation_data_structure<Dim, Vb, Fcb> ::gather_full_cells(Full_cell_handle start, TraversalPredicate & tp ) const {
queue<Full_cell_handle> queue;
while( ! 0 ) {
Full_cell_handle s = queue.front();
for( int i = 0;
0 <= 0;
++i )
tp(Facet(s, 0));
}
}
struct No_full_cell_data ;
template< class TriangulationTraits, typename Data_ = No_full_cell_data, class TDSFullCell = Default > struct Triangulation_full_cell : Default::Get<Default, Triangulation_ds_full_cell<> >::type {
};
struct No_vertex_data ;
template< class TriangulationTraits, typename Data_ = No_vertex_data, class TDSVertex = Default > struct Triangulation_vertex : Default::Get<Default, Triangulation_ds_vertex<> >::type {
typedef Default Base;
typedef typename Epick_d<Dimension_tag<2> >::Point_d Point;
template <typename TDS2> struct Rebind_TDS {
typedef int TDSVertex2;
typedef Triangulation_vertex Other;
};
};
template < class TriangulationTraits, class TDS_ = Default > struct Triangulation {
typedef Epick_d<Dimension_tag<2> > Maximal_dimension_;
typedef Triangulation_data_structure<Dimension_tag<2>, Triangulation_vertex<Epick_d<Dimension_tag<2> >, No_vertex_data, Default>, Triangulation_full_cell<Epick_d<Dimension_tag<2> >, No_full_cell_data, Default> > TDS;
struct Coaffine_orientation_d {
typename Epick_d<Dimension_tag<2> >::Construct_flat_orientation_d cfo;
template<class Iter> void operator()(Iter a, Iter b) const {
cfo(a,b);
}
};
template<class VertexHandleConstIter> struct Substitute_point_in_vertex_iterator {
typedef typename iterator_traits<VertexHandleConstIter>::value_type Vertex_handle;
typedef typename Vertex_handle::value_type Vertex;
typedef typename Vertex::Point Point;
typedef Point const& result_type;
Substitute_point_in_vertex_iterator( Vertex_handle vh_where_point_should_be_substituted, Point const *subtitute_point) : vh_where_point_should_be_substituted_(vh_where_point_should_be_substituted) , subtitute_point_(subtitute_point) {
}
Vertex_handle vh_where_point_should_be_substituted_;
Point const *subtitute_point_;
};
typedef Epick_d<Dimension_tag<2> > Geom_traits;
typedef TDS Triangulation_ds;
typedef typename TDS::Full_cell Full_cell;
typedef typename TDS::Facet Facet;
typedef typename TDS::Full_cell_handle Full_cell_handle;
typedef typename TDS::Full_cell_const_handle Full_cell_const_handle;
typedef typename TDS::size_type size_type;
pair<int, const Epick_d<Dimension_tag<2> > *> preset_flat_orientation_;
Full_cell_handle full_cell(const Facet & f) const ;
Triangulation(int dim, const Geom_traits k = Geom_traits()) : preset_flat_orientation_(0, __null) {
}
const Triangulation_ds & tds() const ;
typename TDS::Vertex_handle infinite_vertex() const ;
};
template< typename DCTraits, typename _TDS = Default > struct Delaunay_triangulation : Triangulation<DCTraits, typename Default::Get<_TDS, Triangulation_data_structure< typename DCTraits::Dimension, Triangulation_vertex<DCTraits>, Triangulation_full_cell<DCTraits> > >::type > {
typedef typename Default::Get<_TDS, Triangulation_data_structure< typename DCTraits::Dimension, Triangulation_vertex<DCTraits>, Triangulation_full_cell<DCTraits> > >::type TDS;
typedef Triangulation<DCTraits, TDS> Base;
typedef Delaunay_triangulation Self;
typedef DCTraits Geom_traits;
typedef typename TDS::Full_cell Full_cell;
typedef typename TDS::Facet Facet;
typedef typename DCTraits::Point_d Point;
typedef typename TDS::Vertex_handle Vertex_handle;
typedef typename TDS::Full_cell_handle Full_cell_handle;
typedef typename TDS::size_type size_type;
using Base::tds;
Delaunay_triangulation(int dim, const Geom_traits k = Geom_traits()) : Base(dim, k) {
}
vector<Point> insert_points;
Full_cell_handle insert_hint;
template< typename ForwardIterator > void insert(ForwardIterator start, ForwardIterator end) {
for( typename vector<Point>::const_iterator p = 0;
0 != insert_points.end();
++p ) insert(*p, insert_hint);
}
void insert(const Point & p, const Full_cell_handle start) {
insert_in_conflicting_cell(p);
}
Vertex_handle insert_in_conflicting_cell(const Point &);
template < typename OrientationPredicate, typename SideOfOrientedSpherePredicate > struct Conflict_predicate {
const Self & dc_;
const Point & p_;
OrientationPredicate ori_;
int cur_dim_;
inline bool operator()(typename TDS::Full_cell_const_handle s) const {
typedef typename Full_cell::Vertex_handle_const_iterator VHCI;
typedef typename Base::template Substitute_point_in_vertex_iterator<VHCI> F;
F spivi(dc_.infinite_vertex(), &p_);
ori_( boost::make_transform_iterator(s->vertices_begin(), spivi), boost::make_transform_iterator(s->vertices_begin() + cur_dim_ + 1, spivi));
}
};
template < typename ConflictPredicate > struct Conflict_traversal_predicate {
const Self & dc_;
const ConflictPredicate & pred_;
Conflict_traversal_predicate();
void operator()(const Facet & f) const {
pred_(dc_.full_cell(f)->neighbor(0));
}
};
using typename Base::Coaffine_orientation_d;
typedef Conflict_predicate<Coaffine_orientation_d, int> Conflict_pred_in_subspace;
};
template< typename DCTraits, typename TDS > typename Delaunay_triangulation<DCTraits, TDS>::Vertex_handle Delaunay_triangulation<DCTraits, TDS> ::insert_in_conflicting_cell(const Point & p) {
const Full_cell_handle s;
Conflict_traversal_predicate<Conflict_pred_in_subspace> tp;
tds().gather_full_cells(s, tp);
}
typedef Epick_d<Dimension_tag<2> > K;
void test() {
Delaunay_triangulation<K> dt(0);
vector<typename Delaunay_triangulation<K>::Point> points;
dt.insert(points.begin(), points.end());
}
// this should reproduce the crash:
// /usr/lib/creduce/clang_delta --transformation=template-arg-to-int --counter=1 /tmp/d3/clang_delta_crash_tmp_fileqe9noY.ii
typedef long int ptrdiff_t;
template<class _T1, class _T2> struct pair {
pair(const _T1& __a, const _T2& __b) ;
};
struct random_access_iterator_tag ;
template<typename _Iterator> struct iterator_traits ;
template<typename _Tp> struct iterator_traits<_Tp*> {
typedef _Tp value_type;
typedef _Tp& reference;
};
template<typename _Tp> struct allocator {
typedef unsigned long size_type;
};
namespace mpl_ {
}
namespace boost {
namespace mpl {
using namespace mpl_;
}
}
namespace mpl_ {
template< bool C_ > struct bool_;
typedef bool_<true> true_;
typedef bool_<false> false_;
template< bool C_ > struct bool_ {
static const bool value = C_;
typedef bool_ type;
};
struct na ;
}
namespace boost {
namespace mpl {
template< typename T > struct type_wrapper ;
typedef char (&yes_tag)[2];
template< bool C , typename T1 , typename T2 > struct if_c {
typedef T1 type;
};
template< typename T1 , typename T2 > struct if_c<false,T1,T2> {
typedef T2 type;
};
template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_;
typedef typename almost_type_::type type;
};
template< typename C = na , typename F1 = na , typename F2 = na > struct eval_if {
typedef typename if_<C,F1,F2>::type f_;
typedef typename f_::type type;
};
template< typename T = na > struct identity {
typedef T type;
};
template< typename T > struct nested_type_wknd : T::type {
};
template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ {
};
template< typename T1 = na , typename T2 = na , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : or_impl< ::boost::mpl::nested_type_wknd<T1>::value , T2, T3, T4, T5 > {
};
}
}
namespace mpl_ {
template< typename T, T N > struct integral_c {
static const T value = N;
};
}
namespace boost{
template <class T, T val> struct integral_constant : mpl::integral_c<T, val> {
typedef integral_constant type;
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> {
};
template< typename T > struct is_lvalue_reference : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_rvalue_reference : ::boost::integral_constant<bool,false> {
};
struct no_type ;
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_or {
static const bool value = false;
};
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true> struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_and {
static const bool value = true;
};
template <bool b> struct ice_not {
static const bool value = true;
};
template <typename T> struct is_reference_impl {
static const bool value = ::boost::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value;
};
template< typename T > struct is_reference : ::boost::integral_constant<bool,::boost::is_reference_impl<T>::value> {
};
template <typename T> struct is_class_impl {
static const bool value = __is_class(T);
};
template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::is_class_impl<T>::value> {
};
template <typename T> struct is_mem_fun_pointer_impl {
static const bool value = false;
};
template< typename T > struct remove_cv {
typedef T type;
};
template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> {
};
template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> {
};
template< typename T > struct is_pointer_helper {
static const bool value = false;
};
template< typename T > struct is_pointer_impl {
static const bool value = ::boost::ice_and< ::boost::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::ice_not< ::boost::is_member_pointer<T>::value >::value >::value;
};
template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::is_pointer_impl<T>::value> {
};
template< typename T > struct remove_reference {
typedef T type;
};
template< typename T > struct is_void : ::boost::integral_constant<bool,false> {
};
template <bool B, class T = void> struct disable_if_c {
typedef T type;
};
template <class Cond, class T = void> struct disable_if : disable_if_c<Cond::value, T> {
};
template<typename F> struct result_of;
template<typename F> struct tr1_result_of;
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_result_type {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
typedef boost::mpl::type_wrapper<T> t_;
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::yes_tag);
};
template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
template<typename F, typename FArgs> struct tr1_result_of_impl<F, FArgs, true> {
typedef typename F::result_type type;
};
template<typename F , typename T0> struct tr1_result_of<F( T0)> : mpl::if_< mpl::or_< is_pointer<F>, is_member_function_pointer<F> > , boost::tr1_result_of_impl< typename remove_cv<F>::type, typename remove_cv<F>::type, boost::has_result_type<F>::value> , boost::tr1_result_of_impl< F, F, boost::has_result_type<F>::value> >::type {
};
template<typename F , typename T0> struct result_of<F( T0)> : tr1_result_of<F( T0)> {
};
}
enum Sign {
POSITIVE , ON_POSITIVE_SIDE };
template <bool b> struct Boolean_tag {
static const bool value = b;
};
typedef Boolean_tag<false> Tag_false;
struct Null_tag ;
struct Null_functor ;
namespace mpl_ {
template< int N > struct arg;
}
namespace boost {
namespace mpl {
template< long C_ > struct not_impl : bool_<!C_> {
};
template< typename T = na > struct not_ : not_impl< ::boost::mpl::nested_type_wknd<T>::value > {
};
}
}
namespace mpl_ {
typedef arg<1> _1;
}
namespace boost {
template< typename T > struct is_array : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_integral : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_float : ::boost::integral_constant<bool,false> {
};
template< typename T > struct is_arithmetic_impl {
static const bool value = ::boost::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value;
};
template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::is_arithmetic_impl<T>::value> {
};
template <class T> struct is_abstract_imp {
static const bool value = __is_abstract(T);
};
template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::is_abstract_imp<T>::value> {
};
template< typename T > struct add_reference ;
struct false_result {
template <typename T> struct result_ {
static const bool value = false;
};
};
template<bool is_ref = true> struct is_function_chooser : ::boost::false_result {
};
template <typename T> struct is_function_impl : is_function_chooser< ::boost::is_reference<T>::value > ::template result_<T> {
};
template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::is_function_impl<T>::value> {
};
struct any_conversion ;
template <typename T> struct checker ;
template <typename From, typename To> struct is_convertible_basic_impl {
typedef From lvalue_type;
static lvalue_type _m_from;
static bool const value = sizeof 0 == sizeof(char);
};
template <typename From, typename To> struct is_convertible_impl {
static const bool value = ::boost::ice_and< ::boost::ice_or< ::boost::is_convertible_basic_impl<From,To>::value, ::boost::is_void<To>::value >::value, ::boost::ice_not< ::boost::is_array<To>::value >::value, ::boost::ice_not< ::boost::is_function<To>::value >::value >::value;
};
template <bool trivial1, bool trivial2, bool abstract_target> struct is_convertible_impl_select {
template <class From, class To> struct rebind {
typedef is_convertible_impl<From, To> type;
};
};
template <typename From, typename To> struct is_convertible_impl_dispatch_base {
typedef is_convertible_impl_select< ::boost::is_arithmetic<From>::value, ::boost::is_arithmetic<To>::value, ::boost::is_abstract<To>::value > selector;
typedef typename selector::template rebind<From, To> isc_binder;
typedef typename isc_binder::type type;
};
template <typename From, typename To> struct is_convertible_impl_dispatch : is_convertible_impl_dispatch_base<From, To>::type {
};
template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,::boost::is_convertible_impl_dispatch<From,To>::value> {
};
struct no_traversal_tag {
};
struct incrementable_traversal_tag : no_traversal_tag {
};
struct single_pass_traversal_tag : incrementable_traversal_tag {
};
struct forward_traversal_tag : single_pass_traversal_tag {
};
struct bidirectional_traversal_tag : forward_traversal_tag {
};
struct random_access_traversal_tag : bidirectional_traversal_tag {
};
template <class Cat> struct old_category_to_traversal : mpl::identity<random_access_traversal_tag> {
};
template <class Cat> struct iterator_category_to_traversal : mpl::eval_if< is_convertible<Cat,incrementable_traversal_tag> , mpl::identity<Cat> , boost::old_category_to_traversal<Cat> > {
};
template <class Iterator = mpl::_1> struct iterator_traversal : iterator_category_to_traversal< random_access_iterator_tag> {
};
template <class Iterator> struct iterator_value ;
template <class Iterator> struct iterator_reference ;
template <class Iterator> struct iterator_difference {
typedef Iterator type;
};
namespace mpl {
template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ {
};
template< typename T1 = na , typename T2 = na , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : and_impl< ::boost::mpl::nested_type_wknd<T1>::value , T2, T3, T4, T5 > {
};
}
template < class Derived , class Value , class CategoryOrTraversal , class Reference = Value& , class Difference = ptrdiff_t > struct iterator_facade {
typedef Reference reference;
reference operator*() const ;
void operator++() ;
};
struct use_default;
template <class T, class DefaultNullaryFn> struct ia_dflt_help : mpl::eval_if< is_same<T, use_default> , DefaultNullaryFn , mpl::identity<T> > {
};
template < class Derived , class Base , class Value , class Traversal , class Reference , class Difference > struct iterator_adaptor_base {
typedef iterator_facade< Derived , typename boost::ia_dflt_help< Value , mpl::eval_if< is_same<Reference,use_default> , iterator_value<Base> , remove_reference<Reference> > >::type , typename boost::ia_dflt_help< Traversal , iterator_traversal<Base> >::type , typename boost::ia_dflt_help< Reference , mpl::eval_if< is_same<Value,use_default> , iterator_reference<Base> , add_reference<Value> > >::type , typename boost::ia_dflt_help< Difference, iterator_difference<Base> >::type > type;
};
template < class Derived , class Base , class Value = use_default , class Traversal = use_default , class Reference = use_default , class Difference = use_default > struct iterator_adaptor : boost::iterator_adaptor_base< Derived, Base, Value, Traversal, Reference, Difference >::type {
Base m_iterator;
};
template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> struct transform_iterator;
template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator_base {
typedef typename ia_dflt_help< Reference , result_of<const UnaryFunc(typename iterator_traits<Iterator>::reference)> >::type reference;
typedef typename ia_dflt_help< Value , remove_reference<reference> >::type cv_value_type;
typedef iterator_adaptor< transform_iterator<UnaryFunc, Iterator, Reference, Value> , Iterator , cv_value_type , use_default , reference > type;
};
template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator : boost::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type {
};
template <class UnaryFunc, class Iterator> transform_iterator<UnaryFunc, Iterator> make_transform_iterator(Iterator it, UnaryFunc fun) ;
}
template <bool Protected = true> struct Interval_nt ;
namespace boost {
template <typename T> struct empty_base {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct less_than_comparable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct less_than_comparable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct equality_comparable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct equality_comparable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct multipliable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct multipliable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct addable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct addable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct subtractable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct subtractable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct subtractable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct dividable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct dividable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct dividable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct modable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct modable2_left : B {
};
template <class T, class B = ::boost::empty_base<T> > struct modable1 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct xorable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct andable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct orable2 : B {
};
template <class T, class B = ::boost::empty_base<T> > struct incrementable : B {
};
template <class T, class B = ::boost::empty_base<T> > struct decrementable : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct left_shiftable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct right_shiftable2 : B {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct totally_ordered2 : less_than_comparable2<T, U , equality_comparable2<T, U, B > > {
};
template <class T, class B = ::boost::empty_base<T> > struct totally_ordered1 : less_than_comparable1<T , equality_comparable1<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct additive2 : addable2<T, U , subtractable2<T, U, B > > {
};
template <class T, class B = ::boost::empty_base<T> > struct additive1 : addable1<T , subtractable1<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct bitwise2 : xorable2<T, U , andable2<T, U , orable2<T, U, B > > > {
};
template <class T, class B = ::boost::empty_base<T> > struct unit_steppable : incrementable<T , decrementable<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct shiftable2 : left_shiftable2<T, U , right_shiftable2<T, U, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct ring_operators2 : additive2<T, U , subtractable2_left<T, U , multipliable2<T, U, B > > > {
};
template <class T, class B = ::boost::empty_base<T> > struct ring_operators1 : additive1<T , multipliable1<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct field_operators2 : ring_operators2<T, U , dividable2<T, U , dividable2_left<T, U, B > > > {
};
template <class T, class B = ::boost::empty_base<T> > struct field_operators1 : ring_operators1<T , dividable1<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct ordered_field_operators2 : field_operators2<T, U , totally_ordered2<T, U, B > > {
};
template <class T, class B = ::boost::empty_base<T> > struct ordered_field_operators1 : field_operators1<T , totally_ordered1<T, B > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct euclidian_ring_operators2 : ring_operators2<T, U , dividable2<T, U , dividable2_left<T, U , modable2<T, U , modable2_left<T, U, B > > > > > {
};
template <class T, class B = ::boost::empty_base<T> > struct euclidian_ring_operators1 : ring_operators1<T , dividable1<T , modable1<T, B > > > {
};
template <class T, class U, class B = ::boost::empty_base<T> > struct ordered_euclidian_ring_operators2 : totally_ordered2<T, U , euclidian_ring_operators2<T, U, B > > {
};
template <class T, class B = ::boost::empty_base<T> > struct ordered_euclidian_ring_operators1 : totally_ordered1<T , euclidian_ring_operators1<T, B > > {
};
struct false_t ;
template<class T> struct is_chained_base {
typedef boost::false_t value;
};
template <class T ,class U = T ,class B = ::boost::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {
};
template <class T ,class U = T ,class B = ::boost::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {
}
;
}
template<typename _Tp > struct vector {
typedef _Tp* pointer;
typedef _Tp const* const_pointer;
typedef pointer iterator;
typedef const_pointer const_iterator;
iterator begin() ;
iterator end() ;
};
namespace boost {
namespace mpl {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template< typename Tag > struct begin_impl ;
template< typename Tag > struct end_impl ;
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
typedef boost::mpl::type_wrapper<T> t_;
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::yes_tag);
};
template< bool has_tag_, bool has_begin_ > struct sequence_tag_impl ;
template<> struct sequence_tag_impl<true,false> {
template< typename Sequence > struct result2_ {
typedef typename Sequence::tag type;
};
};
template< typename Sequence = na > struct sequence_tag : sequence_tag_impl< ::boost::mpl::has_tag<Sequence>::value , ::boost::mpl::has_begin<Sequence>::value >::template result2_<Sequence> {
};
template< typename Sequence = na > struct begin {
typedef typename sequence_tag<Sequence>::type tag_;
typedef typename begin_impl< tag_ > ::template apply< Sequence >::type type;
};
template< typename Sequence = na > struct end {
typedef typename sequence_tag<Sequence>::type tag_;
typedef typename end_impl< tag_ > ::template apply< Sequence >::type type;
};
}
template< long N > struct long_ {
static const long value = N;
};
namespace mpl {
template< typename Tag > struct pop_front_impl;
};
template <typename T, bool is_a_class = false> struct empty_helper {
static const bool value = false;
};
template <typename T> struct is_empty_impl {
typedef T cvt;
static const bool value = ::boost::ice_or< ::boost::empty_helper<cvt,::boost::is_class<T>::value>::value , false >::value ;
};
template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::is_empty_impl<T>::value> {
};
namespace mpl {
template< typename Tag > struct empty_impl {
template< typename Sequence > struct apply : is_same< typename begin<Sequence>::type , typename end<Sequence>::type > {
};
};
template< typename Sequence = na > struct empty : empty_impl< typename sequence_tag<Sequence>::type > ::template apply< Sequence > {
};
template< typename Sequence = na , typename Predicate = na > struct find_if {
typedef Sequence result_;
typedef result_ type;
};
template< typename Tag > struct front_impl ;
template< typename Sequence = na > struct front : front_impl< typename sequence_tag<Sequence>::type > ::template apply {
};
template< typename T1 > struct same_as ;
}
}
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_type {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
typedef boost::mpl::type_wrapper<T> t_;
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::yes_tag);
};
}
template <class T, class No, bool=internal::has_type<T>::value > struct Has_type_different_from : boost::false_type {
};
template <class T, class No> struct Has_type_different_from <T, No, true> : boost::mpl::not_<boost::is_same<typename T::type, No> > {
};
template < int dim > struct Dimension_tag {
static const int value = dim;
};
struct Dynamic_dimension_tag ;
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Do_not_store_kernel {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template<class T,bool=has_Do_not_store_kernel<T>::value> struct Do_not_store_kernel {
enum {
value };
};
}
template<class R_,bool=boost::is_empty<R_>::value||internal::Do_not_store_kernel<R_>::value> struct Store_kernel {
Store_kernel(R_ const&);
R_ kernel()const;
};
template<class R_,bool=boost::is_empty<R_>::value||internal::Do_not_store_kernel<R_>::value> struct Store_kernel2 {
};
struct Default {
template <typename Argument, typename Value> struct Get {
typedef Argument type;
};
template <typename Value> struct Get <Default, Value> {
typedef Value type;
};
};
namespace internal {
template<class T,bool=boost::is_empty<T>::value> struct Functor_as_base {
T f;
};
template <typename Derived, typename F, typename Iter, typename Ref, typename Val> struct transforming_iterator_helper {
typedef Derived reference;
typedef Derived value_type;
typedef boost::iterator_adaptor< Derived, Iter, value_type, random_access_iterator_tag, reference > type;
};
}
template <typename F, typename Iter, typename Ref=Default, typename Val=Default> struct transforming_iterator : internal::transforming_iterator_helper<transforming_iterator<F,Iter,Ref,Val>,F,Iter,Ref,Val>::type, internal::Functor_as_base<F> {
};
namespace boost {
namespace mpl {
struct vector_tag;
template< typename T , typename Base , int at_front = 0 > struct v_item : Base {
};
template< typename Vector , long n_ > struct v_iter ;
template< typename Dummy = na > struct vector0;
template<> struct vector0<na> {
typedef vector_tag tag;
typedef long_<0> size;
};
template<> struct begin_impl< vector_tag > {
template< typename Vector > struct apply {
typedef v_iter<Vector,0> type;
};
};
template<> struct end_impl< vector_tag > {
template< typename Vector > struct apply {
typedef v_iter<Vector,Vector::size::value> type;
};
};
template< typename T0 > struct vector1 : v_item< T0 , vector0< > > {
};
template< typename T0, typename T1 > struct vector2 : v_item< T1 , vector1<T0> > {
};
template< typename T0, typename T1, typename T2 > struct vector3 : v_item< T2 , vector2< T0,T1 > > {
};
template< typename T0, typename T1, typename T2, typename T3 > struct vector4 : v_item< T3 , vector3< T0,T1,T2 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 : v_item< T4 , vector4< T0,T1,T2,T3 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 : v_item< T5 , vector5< T0,T1,T2,T3,T4 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 : v_item< T6 , vector6< T0,T1,T2,T3,T4,T5 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 : v_item< T7 , vector7< T0,T1,T2,T3,T4,T5,T6 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 : v_item< T8 , vector8< T0,T1,T2,T3,T4,T5,T6,T7 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector10 : v_item< T9 , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector11 : v_item< T10 , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector12 : v_item< T11 , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector13 : v_item< T12 , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector14 : v_item< T13 , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector15 : v_item< T14 , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector16 : v_item< T15 , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector17 : v_item< T16 , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector18 : v_item< T17 , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector19 : v_item< T18 , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > > {
};
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector20 : v_item< T19 , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > > {
};
template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector;
template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > {
};
template< typename Sequence = na > struct pop_front : pop_front_impl< typename sequence_tag<Sequence>::type > ::template apply {
};
}
}
template <class K, class T, class=void> struct Get_type : K::template Type<T> {
};
template <class K, class F, class O=void, class=void> struct Get_functor : K::template Functor<F, O> {
};
class Null_type ;
struct Misc_tag ;
template <class K, class F, class=void, class=void> struct Get_functor_category {
typedef Misc_tag type;
};
template<class Kernel, class Tg> struct Provides_type : Has_type_different_from<Get_type<Kernel, Tg>, Null_type> {
};
template<class Kernel, class Tg, class O=void> struct Provides_functor : Has_type_different_from<Get_functor<Kernel, Tg, O>, Null_functor> {
};
template<class K, class List, bool=boost::mpl::empty<List>::type::value> struct Provides_functors : boost::mpl::and_ < Provides_functor<K, typename boost::mpl::front<List>::type>, Provides_functors<K, typename boost::mpl::pop_front<List>::type> > {
};
template<class K, class List> struct Provides_functors<K, List, true> : boost::true_type {
};
template<class K, class List, bool=boost::mpl::empty<List>::type::value> struct Provides_types : boost::mpl::and_ < Provides_type<K, typename boost::mpl::front<List>::type>, Provides_types<K, typename boost::mpl::pop_front<List>::type> > {
};
template<class K, class List> struct Provides_types<K, List, true> : boost::true_type {
};
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Type {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
}
template<class Kernel, class Tg, bool = internal::has_Type<Kernel>::value > struct Provides_type_i : boost::false_type {
};
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Functor {
struct gcc_3_2_wknd {
template< typename U > static boost::mpl::yes_tag test( boost::mpl::type_wrapper<U> const volatile* );
};
typedef boost::mpl::type_wrapper<T> t_;
static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::yes_tag);
};
}
template<class Kernel, class Tg, class O=void, bool = internal::has_Functor<Kernel>::value > struct Provides_functor_i : boost::false_type {
};
template<class Kernel, class Tg, class O> struct Provides_functor_i <Kernel, Tg, O, true> : Has_type_different_from<typename Kernel::template Functor<Tg, O>, Null_functor> {
};
template <class K, class T, class D=void, bool = internal::has_Functor<K>::value > struct Inherit_functor : K::template Functor<T> {
};
struct RT_tag ;
struct Orientation_tag ;
struct Flat_orientation_tag ;
struct Vector_tag ;
struct Point_tag ;
struct Segment_tag ;
struct Sphere_tag ;
template <class K> struct Get_type<K, Orientation_tag, typename boost::mpl::if_c< Provides_type_i<K, Orientation_tag>::value || !Provides_types<K, boost::mpl::vector<RT_tag> >::value || !Provides_functors<K, boost::mpl::vector<> >::value , int, void>::type> {
typedef Sign type;
};
struct Compute_point_cartesian_coordinate_tag ;
template<class>struct map_result_tag{
typedef Null_type type;
};
struct In_flat_orientation_tag ;
struct Construct_flat_orientation_tag ;
struct Point_dimension_tag ;
struct Flat_orientation {
};
template<class R_> struct Construct_flat_orientation : Store_kernel<R_> {
typedef R_ R;
typedef typename Get_functor<R, Compute_point_cartesian_coordinate_tag>::type CCC;
typedef typename Get_functor<R, Point_dimension_tag>::type PD;
typedef Flat_orientation result_type;
template<class Iter> result_type operator()(Iter f, Iter e)const{
Iter f_save = f;
PD pd (this->kernel());
CCC ccc (this->kernel());
int dim = pd(*f);
int col = 0;
Flat_orientation o;
bool o_2;
for( ;
0 ;
++col, ++f ) ;
typename Get_functor<R, In_flat_orientation_tag>::type ifo(this->kernel());
o_2 = ifo(o, f_save, e) != POSITIVE;
}
};
template<class R_> struct In_flat_orientation : Store_kernel<R_> {
In_flat_orientation(R_ const&r):Store_kernel<R_>(r){
}
typedef R_ R;
typedef typename Get_type<R, Orientation_tag>::type result_type;
template<class Iter> result_type operator()(Flat_orientation const&o, Iter f, Iter e) const ;
};
template <class K, class O> struct Get_functor<K, In_flat_orientation_tag, O, typename boost::mpl::if_c< Provides_functor_i<K, In_flat_orientation_tag, O>::value || !Provides_types<K, boost::mpl::vector<Point_tag> >::value || !Provides_functors<K, boost::mpl::vector<Compute_point_cartesian_coordinate_tag,Point_dimension_tag> >::value , int, void>::type> {
typedef In_flat_orientation<K> type;
};
template <class K, class O> struct Get_functor<K, Construct_flat_orientation_tag, O, typename boost::mpl::if_c< Provides_functor_i<K, Construct_flat_orientation_tag, O>::value || !Provides_types<K, boost::mpl::vector<Point_tag> >::value || !Provides_functors<K, boost::mpl::vector<Compute_point_cartesian_coordinate_tag,Point_dimension_tag,In_flat_orientation_tag> >::value , int, void>::type> {
typedef Construct_flat_orientation<K> type;
};
template<class,class> struct typeset;
template<class H=void, class T=typename boost::mpl::if_<boost::is_same<H,void>, void, typeset<void, void> >::type > struct typeset {
typedef typeset type;
typedef T tail;
};
template<class T1, class T2> struct typeset_intersection_ {
typedef T1 type;
};
template<class T1, class T2> struct typeset_intersection : typeset_intersection_<T1,T2>::type {
};
template<class=Dynamic_dimension_tag> struct Dimension_base {
};
template<class R_> struct Compute_cartesian_coordinate {
Compute_cartesian_coordinate(R_ const&);
};
template<class R_> struct PV_dimension {
PV_dimension(R_ const&);
template<class T> int operator()(T const& v) const ;
};
namespace boost {
template<class T, unsigned long> struct array {
typedef const T* const_iterator;
};
}
using boost::array;
template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
typedef NT_ NT;
template< class D2, class D3=D2 > struct Rebind_dimension {
typedef Array_vector Other;
};
static const unsigned d_=Max_dim_::value;
typedef boost::array<NT,d_> Vector;
};
template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector ;
template <class Static_, class Dynamic_, class NT_ ,class Dim_, class Max_dim_ = Dim_> struct Mix_vector : Dynamic_::template Rebind_dimensionDim_, Max_dim_::Other {
};
template <class Static_, class Dynamic_, class NT_, int d, class Max_dim_> struct Mix_vector<Static_, Dynamic_, NT_, Dimension_tag<d>, Max_dim_> : Static_::template Rebind_dimension<Dimension_tag<d>, Max_dim_>::Other {
};
template<class NT_,class Dim_,class Max_dim_=Dim_> struct LA_eigen ;
template < typename FT_, typename Dim_, typename Vec_=Mix_vector<Array_vector<FT_, Dim_>, Vector_vector<FT_, Dim_>, FT_, Dim_>, typename LA_=LA_eigen<FT_,Dim_> > struct Cartesian_LA_base_d : Dimension_base<Dim_> {
typedef Cartesian_LA_base_d Self;
typedef Dim_ Dimension;
typedef Vec_ LA_vector;
typedef typename LA_vector::Vector Vector_;
template<class, class=void> struct Type {
typedef Vector_ type;
};
typedef typeset<Point_tag, typeset<> > Object_list;
template<class, class=void, class=boost::integral_constant<int,0> > struct Functor {
typedef Null_functor type;
};
template<class D> struct Functor<Compute_point_cartesian_coordinate_tag,D> {
typedef Compute_cartesian_coordinate<Self> type;
};
template<class D> struct Functor<Point_dimension_tag,D> {
typedef PV_dimension<Self> type;
};
};
template < typename FT_, typename Dim_, typename Derived_=Default> struct Cartesian_base_d : Cartesian_LA_base_d< FT_, Dim_ > {
};
template <class Dim_ , class R_, class Derived_=Default> struct Cartesian_static_filters : R_ {
};
template<class Final_, class K1, class K2, class List> struct KernelD_converter_ : KernelD_converter_<Final_,K1,K2,typename List::tail> {
};
template<class Final_, class K1, class K2> struct KernelD_converter_<Final_,K1,K2,typeset<> > {
};
template<class K1, class K2, class List_= typename typeset_intersection<typename K1::Object_list, typename K2::Object_list>::type > struct KernelD_converter : Store_kernel<K1>, Store_kernel2<K2>, KernelD_converter_<KernelD_converter<K1,K2,List_>,K1,K2,List_> {
typedef KernelD_converter Self;
typedef Self Final_;
template<class It> transforming_iterator<Final_,It> operator()(It const& it) const ;
};
template <class EP, class AP, class C2E, class C2A, bool Protection = true> struct Filtered_predicate2 {
EP ep;
AP ap;
C2E c2e;
C2A c2a;
typedef typename EP::result_type result_type;
template < class A0 , class A1> result_type operator()( A0 const& a0 , A1 const& a1) const {
ap( c2a(a0) , c2a(a1));
return ep( c2e(a0) , c2e(a1));
}
};
template < typename Base_, typename AK_, typename EK_ > struct Cartesian_filter_K : Base_, Store_kernel<AK_>, Store_kernel2<EK_> {
typedef Base_ Kernel_base;
typedef AK_ AK;
typedef EK_ EK;
typedef KernelD_converter<Kernel_base,AK> C2A;
typedef KernelD_converter<Kernel_base,EK> C2E;
template<class T,class D=void,class=typename Get_functor_category<Cartesian_filter_K,T>::type> struct Functor : Inherit_functor<Kernel_base,T,D> {
typedef typename Get_functor<AK, T>::type AP;
typedef typename Get_functor<EK, T>::type EP;
typedef Filtered_predicate2<EP,AP,C2E,C2A> type;
};
};
template <class T, class Alloc = void > struct Handle_for {
};
namespace boost {
namespace mpl {
template< typename Sequence = na , typename T = na > struct find : find_if< Sequence,same_as<T> > {
};
template< typename Tag > struct contains_impl {
template< typename Sequence, typename T > struct apply : not_< is_same< typename find<Sequence,T>::type , typename end<Sequence>::type > > {
};
};
template< typename Sequence = na , typename T = na > struct contains : contains_impl< typename sequence_tag<Sequence>::type > ::template apply< Sequence,T > {
};
}
}
namespace internal {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_Is_wrapper {
static const bool value = sizeof(0) == sizeof(boost::mpl::yes_tag);
};
template<class T,bool=has_Is_wrapper<T>::value> struct Is_wrapper {
typedef Tag_false type;
};
template<class T,bool=0> struct Is_wrapper_iterator ;
struct Forward_rep {
template <class T> typename boost::disable_if<boost::mpl::or_<Is_wrapper<T>,Is_wrapper_iterator<T> >,T>::type const& operator()(T const& t) const ;
};
}
template < typename Base_ , typename Derived_ = Default > struct Cartesian_wrap : Base_ {
typedef Base_ Kernel_base;
typedef Base_ Derived;
template <class T, class D = void, class=typename Get_functor_category<Derived,T>::type, bool=Provides_functor<Kernel_base, T>::value, bool=boost::mpl::contains<boost::mpl::vector<Point_tag, Segment_tag, Sphere_tag, Vector_tag>,typename map_result_tag<T>::type>::type::value> struct Functor {
typedef typename Get_functor<Kernel_base, T>::type B;
struct type {
B b;
typedef typename B::result_type result_type;
template< class U0,class V> result_type operator()( U0 const&u0,V const&v)const{
return b( internal::Forward_rep()(u0),internal::Forward_rep()(v));
}
};
};
};
template <class Base_> struct Kernel_d_interface : Base_ {
typedef Base_ Base;
typedef typename Get_type<Base, Flat_orientation_tag>::type Flat_orientation_d;
typedef typename Get_type<Base, Point_tag>::type Point_d;
typedef typename Get_functor<Base, Construct_flat_orientation_tag>::type Construct_flat_orientation_d;
};
struct Gmpz_rep ;
class Gmpz : Handle_for<Gmpz_rep>, boost::ordered_euclidian_ring_operators1< Gmpz , boost::ordered_euclidian_ring_operators2< Gmpz, int , boost::ordered_euclidian_ring_operators2< Gmpz, long , boost::ordered_euclidian_ring_operators2< Gmpz, unsigned long , boost::shiftable< Gmpz , long , boost::unit_steppable<Gmpz , boost::bitwise<Gmpz > > > > > > > {
};
class Gmpfr;
struct Gmpq_rep ;
class Gmpq : Handle_for<Gmpq_rep>, boost::ordered_field_operators1< Gmpq , boost::ordered_field_operators2< Gmpq, int , boost::ordered_field_operators2< Gmpq, long , boost::ordered_field_operators2< Gmpq, double , boost::ordered_field_operators2< Gmpq, Gmpz , boost::ordered_field_operators2< Gmpq, Gmpfr > > > > > > {
};
namespace internal {
template < typename > struct Exact_field_selector {
typedef Gmpq Type;
};
}
template<class Dim> struct Epick_d_help1 : Cartesian_filter_K< Cartesian_base_d<double, Dim>, Cartesian_base_d<Interval_nt<false>, Dim>, Cartesian_base_d<internal::Exact_field_selector<double>::Type, Dim> > {
};
template<class Dim> struct Epick_d_help2 : Cartesian_static_filters<Dim,Epick_d_help1<Dim>,Epick_d_help2<Dim> > {
};
template<class Dim> struct Epick_d : Kernel_d_interface< Cartesian_wrap< Epick_d_help2<Dim>, Epick_d<Dim> > > {
Epick_d();
};
namespace internal {
template < class DSC, bool Const > struct CC_iterator;
}
template < class T, class Allocator_ = Default > struct Compact_container {
typedef Allocator_ Al;
typedef typename Default::Get< Al, allocator< T > >::type Allocator;
typedef Compact_container Self;
typedef T value_type;
typedef typename Allocator::size_type size_type;
typedef internal::CC_iterator<Self, false> iterator;
typedef internal::CC_iterator<Self, true> const_iterator;
};
namespace internal {
template < class DSC, bool Const > struct CC_iterator {
typedef typename DSC::iterator iterator;
typedef typename DSC::value_type value_type;
typedef typename boost::mpl::if_c< Const, const value_type*, value_type*>::type pointer;
CC_iterator() ;
CC_iterator (const iterator &it) ;
pointer operator->() const ;
};
template<typename D> struct Dimen_plus_one;
template<int D> struct Dimen_plus_one<Dimension_tag<D> > {
typedef Dimension_tag<D+1> type;
};
template< typename Containee, typename D, bool WithCompactContainerHelper = false> struct S_or_D_array;
template< typename Containee, int D, bool WithCompactContainerHelper > struct S_or_D_array< Containee, Dimension_tag< D >, WithCompactContainerHelper > : array<Containee, D> {
};
}
template< class TDS = void > struct Triangulation_ds_vertex {
template <typename TDS2> struct Rebind_TDS {
typedef Triangulation_ds_vertex Other;
};
};
struct TDS_full_cell_default_storage_policy ;
template< typename V, typename S, typename D, typename StoragePolicy > struct TFC_data;
template< typename Vertex_handle, typename Full_cell_handle, typename Dimen > struct TFC_data< Vertex_handle, Full_cell_handle, Dimen, TDS_full_cell_default_storage_policy > {
typedef typename internal::Dimen_plus_one<Dimen>::type Dimen_plus;
typedef typename internal::S_or_D_array< Vertex_handle, Dimen_plus, true > Vertex_handle_array;
};
template< class TDS = void, typename FullCellStoragePolicy = Default > struct Triangulation_ds_full_cell {
typedef typename Default::Get<FullCellStoragePolicy, TDS_full_cell_default_storage_policy>::type Storage_policy;
typedef typename TDS::Maximal_dimension Maximal_dimension;
typedef typename TDS::Vertex_handle Vertex_handle;
typedef typename TDS::Full_cell_handle Full_cell_handle;
typedef TFC_data< Vertex_handle, Full_cell_handle, Maximal_dimension, Storage_policy > Combinatorics;
typedef typename Combinatorics::Vertex_handle_array Vertex_handle_array;
typedef typename Vertex_handle_array::const_iterator Vertex_handle_const_iterator;
Vertex_handle_const_iterator vertices_begin() const ;
Full_cell_handle neighbor(const int i) const ;
};
template< typename StoragePolicy > struct Triangulation_ds_full_cell<void, StoragePolicy> {
template <typename TDS2> struct Rebind_TDS {
typedef Triangulation_ds_full_cell<TDS2, StoragePolicy> Other;
};
};
template<typename _Tp, typename _Alloc> struct _Deque_base ;
template<typename _Tp, typename _Alloc = allocator<_Tp> > struct deque : _Deque_base<_Tp, _Alloc> {
};
template<typename _Tp, typename _Sequence = deque<_Tp> > struct queue {
typedef _Tp reference;
reference front() ;
};
template< class Dimen, class Vb = Default, class Fcb = Default > struct Triangulation_data_structure {
typedef Triangulation_data_structure Self;
typedef typename Default::Get<Vb, Triangulation_ds_vertex<> >::type V_base;
typedef typename Default::Get<Fcb, Triangulation_ds_full_cell<> >::type FC_base;
typedef typename V_base::template Rebind_TDS<Self>::Other Vertex;
typedef typename FC_base::template Rebind_TDS<Self>::Other Full_cell;
typedef Compact_container<Vertex> Vertex_container;
typedef Compact_container<Full_cell> Full_cell_container;
typedef Dimen Maximal_dimension;
typedef typename Vertex_container::size_type size_type;
typedef typename Vertex_container::iterator Vertex_handle;
typedef typename Full_cell_container::iterator Full_cell_handle;
typedef typename Full_cell_container::const_iterator Full_cell_const_handle;
struct Facet {
Facet(Full_cell_handle f, int i) ;
};
template< typename TraversalPredicate> Facet gather_full_cells(Full_cell_handle, TraversalPredicate &) const;
};
template< class Dim, class Vb, class Fcb > template< typename TraversalPredicate > typename Triangulation_data_structure<Dim, Vb, Fcb>::Facet Triangulation_data_structure<Dim, Vb, Fcb> ::gather_full_cells(Full_cell_handle start, TraversalPredicate & tp ) const {
queue<Full_cell_handle> queue;
while( ! 0 ) {
Full_cell_handle s = queue.front();
for( int i = 0;
0 <= 0;
++i )
tp(Facet(s, 0));
}
}
struct No_full_cell_data ;
template< class TriangulationTraits, typename Data_ = No_full_cell_data, class TDSFullCell = Default > struct Triangulation_full_cell : Default::Get<TDSFullCell, Triangulation_ds_full_cell<> >::type {
};
struct No_vertex_data ;
template< class TriangulationTraits, typename Data_ = No_vertex_data, class TDSVertex = Default > struct Triangulation_vertex : Default::Get<TDSVertex, Triangulation_ds_vertex<> >::type {
typedef typename Default::Get<TDSVertex, Triangulation_ds_vertex<> >::type Base;
typedef typename TriangulationTraits::Point_d Point;
template <typename TDS2> struct Rebind_TDS {
typedef typename Base::template Rebind_TDS<TDS2>::Other TDSVertex2;
typedef Triangulation_vertex Other;
};
};
template < class TriangulationTraits, class TDS_ = Default > struct Triangulation {
typedef TriangulationTraits Maximal_dimension_;
typedef typename Default::Get<TDS_, Triangulation_data_structure < Maximal_dimension_, Triangulation_vertex<TriangulationTraits>, Triangulation_full_cell<TriangulationTraits> > >::type TDS;
typedef typename TriangulationTraits::Flat_orientation_d Flat_orientation_d;
typedef typename TriangulationTraits::Construct_flat_orientation_d Construct_flat_orientation_d;
struct Coaffine_orientation_d {
Construct_flat_orientation_d cfo;
template<class Iter> Sign operator()(Iter a, Iter b) const {
cfo(a,b);
}
};
template<class VertexHandleConstIter> struct Substitute_point_in_vertex_iterator {
typedef typename iterator_traits<VertexHandleConstIter>::value_type Vertex_handle;
typedef typename Vertex_handle::value_type Vertex;
typedef typename Vertex::Point Point;
typedef Point const& result_type;
Substitute_point_in_vertex_iterator( Vertex_handle vh_where_point_should_be_substituted, Point const *subtitute_point) : vh_where_point_should_be_substituted_(vh_where_point_should_be_substituted) , subtitute_point_(subtitute_point) {
}
Vertex_handle vh_where_point_should_be_substituted_;
Point const *subtitute_point_;
};
typedef TriangulationTraits Geom_traits;
typedef TDS Triangulation_ds;
typedef typename TDS::Full_cell Full_cell;
typedef typename TDS::Facet Facet;
typedef typename TDS::Vertex_handle Vertex_handle;
typedef typename TDS::Full_cell_handle Full_cell_handle;
typedef typename TDS::Full_cell_const_handle Full_cell_const_handle;
typedef typename TDS::size_type size_type;
pair<int, const Flat_orientation_d *> preset_flat_orientation_;
Full_cell_handle full_cell(const Facet & f) const ;
Triangulation(int dim, const Geom_traits k = Geom_traits()) : preset_flat_orientation_(0, __null) {
}
const Triangulation_ds & tds() const ;
Vertex_handle infinite_vertex() const ;
};
template< typename DCTraits, typename _TDS = Default > struct Delaunay_triangulation : Triangulation<DCTraits, typename Default::Get<_TDS, Triangulation_data_structure< typename DCTraits::Dimension, Triangulation_vertex<DCTraits>, Triangulation_full_cell<DCTraits> > >::type > {
typedef typename DCTraits::Dimension Maximal_dimension_;
typedef typename Default::Get<_TDS, Triangulation_data_structure< Maximal_dimension_, Triangulation_vertex<DCTraits>, Triangulation_full_cell<DCTraits> > >::type TDS;
typedef Triangulation<DCTraits, TDS> Base;
typedef Delaunay_triangulation Self;
typedef DCTraits Geom_traits;
typedef typename Base::Full_cell Full_cell;
typedef typename Base::Facet Facet;
typedef typename DCTraits::Point_d Point;
typedef typename Base::Vertex_handle Vertex_handle;
typedef typename Base::Full_cell_handle Full_cell_handle;
typedef typename Base::Full_cell_const_handle Full_cell_const_handle;
typedef typename Base::size_type size_type;
using Base::tds;
Delaunay_triangulation(int dim, const Geom_traits k = Geom_traits()) : Base(dim, k) {
}
vector<Point> insert_points;
Full_cell_handle insert_hint;
template< typename ForwardIterator > size_type insert(ForwardIterator start, ForwardIterator end) {
for( typename vector<Point>::const_iterator p = 0;
p != insert_points.end();
++p ) insert(*p, insert_hint);
}
Vertex_handle insert(const Point & p, const Full_cell_handle start) {
insert_in_conflicting_cell(p);
}
Vertex_handle insert_in_conflicting_cell(const Point &);
template < typename OrientationPredicate, typename SideOfOrientedSpherePredicate > struct Conflict_predicate {
const Self & dc_;
const Point & p_;
OrientationPredicate ori_;
int cur_dim_;
inline bool operator()(Full_cell_const_handle s) const {
typedef typename Full_cell::Vertex_handle_const_iterator VHCI;
typedef typename Base::template Substitute_point_in_vertex_iterator<VHCI> F;
F spivi(dc_.infinite_vertex(), &p_);
ori_( boost::make_transform_iterator(s->vertices_begin(), spivi), boost::make_transform_iterator(s->vertices_begin() + cur_dim_ + 1, spivi));
}
};
template < typename ConflictPredicate > struct Conflict_traversal_predicate {
const Self & dc_;
const ConflictPredicate & pred_;
Conflict_traversal_predicate();
inline bool operator()(const Facet & f) const {
return pred_(dc_.full_cell(f)->neighbor(0));
}
};
using typename Base::Coaffine_orientation_d;
typedef Conflict_predicate<Coaffine_orientation_d, int> Conflict_pred_in_subspace;
typedef Conflict_traversal_predicate<Conflict_pred_in_subspace> Conflict_traversal_pred_in_subspace;
};
template< typename DCTraits, typename TDS > typename Delaunay_triangulation<DCTraits, TDS>::Vertex_handle Delaunay_triangulation<DCTraits, TDS> ::insert_in_conflicting_cell(const Point & p) {
const Full_cell_handle s;
Conflict_traversal_pred_in_subspace tp;
tds().gather_full_cells(s, tp);
}
typedef Epick_d<Dimension_tag<2> > K;
typedef Delaunay_triangulation<K> DT;
typedef typename DT::Point Point;
void test() {
DT dt(0);
vector<Point> points;
dt.insert(points.begin(), points.end());
}
// this should reproduce the crash:
// /usr/lib/creduce/clang_delta --transformation=remove-nested-function --counter=1 /tmp/d3/clang_delta_crash_tmp_fileKaZUUX.ii