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

Replace Interval_nt_advanced::unsafe_comparison by Uncertain_conversion_exception. 

(it was alrady the same type, but now the filtering code can be independent on Interval_nt_advanced
(think other interval types, or other types of filters).
This commit is contained in:
Sylvain Pion 2008-07-31 13:31:26 +00:00
parent ff620d3430
commit a8e8ecfdcf
12 changed files with 81 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Circular_kernel_2/include/CGAL/Filtered_hexagon_circular_kernel_2/hexagon_primitives.h
View File

@ -510,7 +510,7 @@ template < class CK, class Hexagon>
Conv cnv; Conv cnv;
static const bool Protection = true; static const bool Protection = true;
try{return CGALi::construct_bounding_hexagons_2<CK2>(cnv(a),res);} try{return CGALi::construct_bounding_hexagons_2<CK2>(cnv(a),res);}
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return CGALi::construct_bounding_hexagons_2<CK>(a,res); return CGALi::construct_bounding_hexagons_2<CK>(a,res);
@ -523,7 +523,7 @@ template < class CK, class Hexagon>
Conv cnv; Conv cnv;
static const bool Protection = true; static const bool Protection = true;
try{return CGALi::construct_bounding_hexagon_for_line_arc_2<CK2>(cnv(a));} try{return CGALi::construct_bounding_hexagon_for_line_arc_2<CK2>(cnv(a));}
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return CGALi::construct_bounding_hexagon_for_line_arc_2<CK>(a); return CGALi::construct_bounding_hexagon_for_line_arc_2<CK>(a);
@ -548,7 +548,7 @@ template < class CK, class Hexagon>
{ {
static const bool Protection = true; static const bool Protection = true;
try{return CGALi::construct_bounding_hexagons_2<typename CK::AK>(a.approx(),res);} try{return CGALi::construct_bounding_hexagons_2<typename CK::AK>(a.approx(),res);}
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return CGALi::construct_bounding_hexagons_2<typename CK::EK>(a.exact(),res); return CGALi::construct_bounding_hexagons_2<typename CK::EK>(a.exact(),res);
@ -560,7 +560,7 @@ template < class CK, class Hexagon>
{ {
static const bool Protection = true; static const bool Protection = true;
try{return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::AK>(a.approx());} try{return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::AK>(a.approx());}
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::EK>(a.exact()); return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::EK>(a.exact());

10
Circular_kernel_2/include/CGAL/Lazy_circular_kernel_constructions.h
View File

@ -130,7 +130,7 @@ public:
} }
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
// TODO: Instead of using a vector, write an iterator adapter // TODO: Instead of using a vector, write an iterator adapter
@ -198,7 +198,7 @@ public:
} }
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
// TODO: Instead of using a vector, write an iterator adapter // TODO: Instead of using a vector, write an iterator adapter
@ -267,7 +267,7 @@ public:
} }
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
// TODO: Instead of using a vector, write an iterator adapter // TODO: Instead of using a vector, write an iterator adapter
@ -350,7 +350,7 @@ template <typename L1>
else { else {
std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl; std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl;
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1)); ET eto = ec(CGAL::exact(l1));
@ -401,7 +401,7 @@ template <typename L1>
else { else {
std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl; std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl;
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1), CGAL::exact(l2)); ET eto = ec(CGAL::exact(l1), CGAL::exact(l2));

22
Filtered_kernel/include/CGAL/Filtered_predicate.h
View File

@ -161,7 +161,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(args)...); return ep(c2e(args)...);
@ -183,7 +183,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1)); return ep(c2e(a1));
@ -203,7 +203,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ")+ std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ")+ std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2)); return ep(c2e(a1), c2e(a2));
@ -223,7 +223,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3)); return ep(c2e(a1), c2e(a2), c2e(a3));
@ -243,7 +243,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4)); return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4));
@ -264,7 +264,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5)); return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5));
@ -285,7 +285,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6)); return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6));
@ -308,7 +308,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7)); return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7));
@ -331,7 +331,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7), return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
@ -356,7 +356,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7), return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
@ -381,7 +381,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
if (is_certain(res)) if (is_certain(res))
return get_certain(res); return get_certain(res);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7), return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),

38
Filtered_kernel/include/CGAL/Lazy.h
View File

@ -1184,7 +1184,7 @@ struct Lazy_construction_bbox
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return ac(CGAL::approx(l1)); return ac(CGAL::approx(l1));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return ec(CGAL::exact(l1)); return ec(CGAL::exact(l1));
@ -1214,7 +1214,7 @@ struct Lazy_construction_nt {
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return new Lazy_rep_1<AC, EC, To_interval<ET>, L1>(ac, ec, l1); return new Lazy_rep_1<AC, EC, To_interval<ET>, L1>(ac, ec, l1);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1))); return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1)));
@ -1228,7 +1228,7 @@ struct Lazy_construction_nt {
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return new Lazy_rep_2<AC, EC, To_interval<ET>, L1,L2>(ac, ec, l1,l2); return new Lazy_rep_2<AC, EC, To_interval<ET>, L1,L2>(ac, ec, l1,l2);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2))); return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2)));
@ -1242,7 +1242,7 @@ struct Lazy_construction_nt {
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return new Lazy_rep_3<AC, EC, To_interval<ET>, L1,L2,L3>(ac, ec, l1,l2,l3); return new Lazy_rep_3<AC, EC, To_interval<ET>, L1,L2,L3>(ac, ec, l1,l2,l3);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3))); return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3)));
@ -1256,7 +1256,7 @@ struct Lazy_construction_nt {
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return new Lazy_rep_4<AC, EC, To_interval<ET>, L1,L2,L3,L4>(ac, ec, l1,l2,l3,l4); return new Lazy_rep_4<AC, EC, To_interval<ET>, L1,L2,L3,L4>(ac, ec, l1,l2,l3,l4);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4))); return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4)));
@ -1270,7 +1270,7 @@ struct Lazy_construction_nt {
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return new Lazy_rep_5<AC, EC, To_interval<ET>, L1,L2,L3,L4,L5>(ac, ec, l1,l2,l3,l4,l5); return new Lazy_rep_5<AC, EC, To_interval<ET>, L1,L2,L3,L4,L5>(ac, ec, l1,l2,l3,l4,l5);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5))); return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5)));
@ -1429,7 +1429,7 @@ public:
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
// we suppose that R1 is a Lazy<Something> // we suppose that R1 is a Lazy<Something>
r1 = R1(new Lazy_rep_2_1<AC, EC, E2A, L1, L2, R1>(ac, ec, l1, l2)); r1 = R1(new Lazy_rep_2_1<AC, EC, E2A, L1, L2, R1>(ac, ec, l1, l2));
} catch(Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
typename R1::ET et; typename R1::ET et;
@ -1497,7 +1497,7 @@ public:
// lv->approx() is a std::pair<R1::AT, R2::AT>; // lv->approx() is a std::pair<R1::AT, R2::AT>;
r1 = R1(new Lazy_rep_1<First<std::pair<typename R1::AT, typename R2::AT> >, First<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(First<std::pair<typename R1::AT, typename R2::AT> >(), First<std::pair<typename R1::ET, typename R2::ET> >(), lv)); r1 = R1(new Lazy_rep_1<First<std::pair<typename R1::AT, typename R2::AT> >, First<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(First<std::pair<typename R1::AT, typename R2::AT> >(), First<std::pair<typename R1::ET, typename R2::ET> >(), lv));
r2 = R2(new Lazy_rep_1<Second<std::pair<typename R1::AT, typename R2::AT> >, Second<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(Second<std::pair<typename R1::AT, typename R2::AT> >(), Second<std::pair<typename R1::ET, typename R2::ET> >(), lv)); r2 = R2(new Lazy_rep_1<Second<std::pair<typename R1::AT, typename R2::AT> >, Second<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(Second<std::pair<typename R1::AT, typename R2::AT> >(), Second<std::pair<typename R1::ET, typename R2::ET> >(), lv));
} catch(Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
typename R1::ET et1, et2; typename R1::ET et1, et2;
@ -1554,7 +1554,7 @@ public:
std::cerr << "we need more casts" << std::endl; std::cerr << "we need more casts" << std::endl;
} }
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
// TODO: Instead of using a vector, write an iterator adapter // TODO: Instead of using a vector, write an iterator adapter
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
@ -1633,7 +1633,7 @@ public:
std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl; std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl;
std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl; std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl;
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1)); ET eto = ec(CGAL::exact(l1));
@ -1666,7 +1666,7 @@ public:
std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl; std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl;
std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl; std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl;
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1), CGAL::exact(l2)); ET eto = ec(CGAL::exact(l1), CGAL::exact(l2));
@ -1715,7 +1715,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_1<AC, EC, E2A, L1>(ac, ec, l1)); return Handle(new Lazy_rep_1<AC, EC, E2A, L1>(ac, ec, l1));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1))));
@ -1730,7 +1730,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_2<AC, EC, E2A, L1, L2>(ac, ec, l1, l2)); return Handle(new Lazy_rep_2<AC, EC, E2A, L1, L2>(ac, ec, l1, l2));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2))));
@ -1745,7 +1745,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_3<AC, EC, E2A, L1, L2, L3>(ac, ec, l1, l2, l3)); return Handle(new Lazy_rep_3<AC, EC, E2A, L1, L2, L3>(ac, ec, l1, l2, l3));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3))));
@ -1760,7 +1760,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_4<AC, EC, E2A, L1, L2, L3, L4>(ac, ec, l1, l2, l3, l4)); return Handle(new Lazy_rep_4<AC, EC, E2A, L1, L2, L3, L4>(ac, ec, l1, l2, l3, l4));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4))));
@ -1775,7 +1775,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_5<AC, EC, E2A, L1, L2, L3, L4, L5>(ac, ec, l1, l2, l3, l4, l5)); return Handle(new Lazy_rep_5<AC, EC, E2A, L1, L2, L3, L4, L5>(ac, ec, l1, l2, l3, l4, l5));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5))));
@ -1790,7 +1790,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_6<AC, EC, E2A, L1, L2, L3, L4, L5, L6>(ac, ec, l1, l2, l3, l4, l5, l6)); return Handle(new Lazy_rep_6<AC, EC, E2A, L1, L2, L3, L4, L5, L6>(ac, ec, l1, l2, l3, l4, l5, l6));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6))));
@ -1805,7 +1805,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_7<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7>(ac, ec, l1, l2, l3, l4, l5, l6, l7)); return Handle(new Lazy_rep_7<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7>(ac, ec, l1, l2, l3, l4, l5, l6, l7));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7))));
@ -1820,7 +1820,7 @@ public:
CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("calls to : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return Handle(new Lazy_rep_8<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7, L8>(ac, ec, l1, l2, l3, l4, l5, l6, l7, l8)); return Handle(new Lazy_rep_8<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7, L8>(ac, ec, l1, l2, l3, l4, l5, l6, l7, l8));
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION)); CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7), CGAL::exact(l8)))); return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7), CGAL::exact(l8))));

26
Nef_2/include/CGAL/Filtered_extended_homogeneous.h
View File

@ -393,7 +393,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or2); catch (Uncertain_conversion_exception) { INCEXCEPTION(or2);
res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -405,7 +405,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or1); catch (Uncertain_conversion_exception) { INCEXCEPTION(or1);
res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -417,7 +417,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or0); catch (Uncertain_conversion_exception) { INCEXCEPTION(or0);
res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -442,7 +442,7 @@ int compare_x(const Extended_point<RT>& p1,
try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD()); res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx1);
res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw()); res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
} }
if ( res != 0 ) return res; if ( res != 0 ) return res;
@ -450,7 +450,7 @@ int compare_x(const Extended_point<RT>& p1,
try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD()); res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx0);
res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw()); res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
} }
return res; return res;
@ -467,7 +467,7 @@ int compare_y(const Extended_point<RT>& p1,
try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD()); res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy1);
res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw()); res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
} }
if ( res != 0 ) return res; if ( res != 0 ) return res;
@ -475,7 +475,7 @@ int compare_y(const Extended_point<RT>& p1,
try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD()); res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy0);
res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw()); res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
} }
return res; return res;
@ -612,7 +612,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd2); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd2);
res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -626,7 +626,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd1);
res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -640,7 +640,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd0);
res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -876,7 +876,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord2); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord2);
res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -889,7 +889,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord1); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord1);
res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -901,7 +901,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord0); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord0);
res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),

28
Nef_2/noweb/Filtered_extended_kernel.lw
View File

@ -508,7 +508,7 @@ DEFCOUNTER(or2)
Now the final orientation predicate consists of three |try|-|catch| Now the final orientation predicate consists of three |try|-|catch|
blocks. Each |try| block contains the filtered coefficient evaluation. blocks. Each |try| block contains the filtered coefficient evaluation.
If the sign evaluation is not defined (the resulting interval contains If the sign evaluation is not defined (the resulting interval contains
zero) then the |unsafe_comparison| exception is thrown. The |catch| zero) then the |Uncertain_conversion_exception| exception is thrown. The |catch|
block evaluates the expression with |RT| arithmetic. Note again the block evaluates the expression with |RT| arithmetic. Note again the
protection of the rounding mode with the |Protect_FPU_rounding<true>| protection of the rounding mode with the |Protect_FPU_rounding<true>|
class declaration. The macros |INCTOTAL()| and |INCEXCEPTION()| are class declaration. The macros |INCTOTAL()| and |INCEXCEPTION()| are
@ -525,7 +525,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or2); catch (Uncertain_conversion_exception) { INCEXCEPTION(or2);
res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -537,7 +537,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or1); catch (Uncertain_conversion_exception) { INCEXCEPTION(or1);
res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -549,7 +549,7 @@ int orientation(const Extended_point<RT>& p1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or0); catch (Uncertain_conversion_exception) { INCEXCEPTION(or0);
res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@ -582,7 +582,7 @@ int compare_x(const Extended_point<RT>& p1,
try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD()); res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx1);
res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw()); res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
} }
if ( res != 0 ) return res; if ( res != 0 ) return res;
@ -590,7 +590,7 @@ int compare_x(const Extended_point<RT>& p1,
try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD()); res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx0);
res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw()); res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
} }
return res; return res;
@ -607,7 +607,7 @@ int compare_y(const Extended_point<RT>& p1,
try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD()); res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy1);
res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw()); res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
} }
if ( res != 0 ) return res; if ( res != 0 ) return res;
@ -615,7 +615,7 @@ int compare_y(const Extended_point<RT>& p1,
try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection; try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection;
res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD()); res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy0);
res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw()); res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
} }
return res; return res;
@ -752,7 +752,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd2); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd2);
res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -766,7 +766,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd1); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd1);
res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -780,7 +780,7 @@ int compare_pair_dist(
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} }
catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd0); catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd0);
res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -1124,7 +1124,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord2); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord2);
res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -1137,7 +1137,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord1); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord1);
res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@ -1149,7 +1149,7 @@ int orientation(const Extended_direction<RT>& d1,
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord0); } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord0);
res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),

4
Number_types/doc_tex/NumberTypeSupport_ref/Interval_nt.tex
View File

@ -58,11 +58,9 @@ doing any computations with the interval class.
\ccTypes \ccTypes
The class \ccc{Interval_nt} defines the following types: The class \ccc{Interval_nt} defines the following types:
%Three{typedef std::exception unsafe_comparison;}{Tetrahedronxxxxx}{}
%ThreeToTwo
\ccTypedef{typedef double value_type;}{The type of the bounds of the interval.} \ccTypedef{typedef double value_type;}{The type of the bounds of the interval.}
\ccGlue \ccGlue
\ccTypedef{typedef std::exception unsafe_comparison;}{The type of the \ccTypedef{typedef Uncertain_conversion_exception unsafe_comparison;}{The type of the
exceptions raised when uncertain comparisons are performed.} exceptions raised when uncertain comparisons are performed.}
\ccGlue \ccGlue
\ccNestedType{Protector}{A type whose default constructor and destructor allow \ccNestedType{Protector}{A type whose default constructor and destructor allow

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

@ -51,7 +51,7 @@ public:
typedef double value_type; typedef double value_type;
typedef Uncertain<bool>::Uncertain_conversion_exception unsafe_comparison; typedef Uncertain_conversion_exception unsafe_comparison;
typedef Checked_protect_FPU_rounding<Protected> Internal_protector; typedef Checked_protect_FPU_rounding<Protected> Internal_protector;
typedef Protect_FPU_rounding<!Protected> Protector; typedef Protect_FPU_rounding<!Protected> Protector;

6
Segment_Delaunay_graph_2/include/CGAL/Filtered_construction.h
View File

@ -59,7 +59,7 @@ public:
Protect_FPU_rounding<Protection> P; Protect_FPU_rounding<Protection> P;
return From_Filtered( Filter_construction(To_Filtered(a1)) ); return From_Filtered( Filter_construction(To_Filtered(a1)) );
} }
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1)) ); return From_Exact( Exact_construction(To_Exact(a1)) );
@ -75,7 +75,7 @@ public:
return From_Filtered( Filter_construction(To_Filtered(a1), return From_Filtered( Filter_construction(To_Filtered(a1),
To_Filtered(a2)) ); To_Filtered(a2)) );
} }
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1), return From_Exact( Exact_construction(To_Exact(a1),
@ -94,7 +94,7 @@ public:
To_Filtered(a2), To_Filtered(a2),
To_Filtered(a3)) ); To_Filtered(a3)) );
} }
catch (Interval_nt_advanced::unsafe_comparison) catch (Uncertain_conversion_exception)
{ {
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1), return From_Exact( Exact_construction(To_Exact(a1),

8
Skin_surface_3/include/CGAL/Skin_surface_base_3.h
View File

@ -303,7 +303,7 @@ sign(TMC_Vertex_handle vit) const {
if (is_certain(result)) if (is_certain(result))
return result; return result;
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("NGHK: failures of : ") + CGAL_PROFILER(std::string("NGHK: failures of : ") +
std::string(CGAL_PRETTY_FUNCTION)); std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@ -341,7 +341,7 @@ sign(const Bare_point &p, const Cell_info &info) const {
if (is_certain(result)) if (is_certain(result))
return result; return result;
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("NGHK: failures of : ") + CGAL_PROFILER(std::string("NGHK: failures of : ") +
std::string(CGAL_PRETTY_FUNCTION)); std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@ -634,7 +634,7 @@ compare(Cell_info &info1,
if (is_certain(result)) if (is_certain(result))
return result; return result;
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
CGAL_PROFILER(std::string("NGHK: failures of : ") + CGAL_PROFILER(std::string("NGHK: failures of : ") +
std::string(CGAL_PRETTY_FUNCTION)); std::string(CGAL_PRETTY_FUNCTION));
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@ -698,7 +698,7 @@ locate_in_tmc(const Bare_point &p0,
Protect_FPU_rounding<true> P; Protect_FPU_rounding<true> P;
o = TMC_Geom_traits().orientation_3_object()(*pts[0], *pts[1], *pts[2], *pts[3]); o = TMC_Geom_traits().orientation_3_object()(*pts[0], *pts[1], *pts[2], *pts[3]);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
typedef Exact_predicates_exact_constructions_kernel EK; typedef Exact_predicates_exact_constructions_kernel EK;
Cartesian_converter<typename Geometric_traits::Bare_point::R, EK> converter_ek; Cartesian_converter<typename Geometric_traits::Bare_point::R, EK> converter_ek;

2
Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h
View File

@ -1265,7 +1265,7 @@ orientation(Tmc_Cell_handle ch) {
// filtered kernel // filtered kernel
o = _tmc.geom_traits().orientation_3_object()(pts[0], pts[1], o = _tmc.geom_traits().orientation_3_object()(pts[0], pts[1],
pts[2], pts[3]); pts[2], pts[3]);
} catch (Interval_nt_advanced::unsafe_comparison) { } catch (Uncertain_conversion_exception) {
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
typedef Exact_predicates_exact_constructions_kernel EK; typedef Exact_predicates_exact_constructions_kernel EK;
typedef Cartesian_converter<EK, Tmc_traits> Exact_converter; typedef Cartesian_converter<EK, Tmc_traits> Exact_converter;

10
Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h
View File

@ -121,7 +121,7 @@ public:
if ( fr ) if ( fr )
return From_Filtered(fr); return From_Filtered(fr);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(a1)) ; EC_result_type er = Exact_construction(To_Exact(a1)) ;
@ -139,7 +139,7 @@ public:
if ( fr ) if ( fr )
return From_Filtered(fr); return From_Filtered(fr);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2)) ; EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2)) ;
@ -157,7 +157,7 @@ public:
if ( fr ) if ( fr )
return From_Filtered(fr); return From_Filtered(fr);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3)) ; EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3)) ;
@ -176,7 +176,7 @@ public:
if ( fr ) if ( fr )
return From_Filtered(fr); return From_Filtered(fr);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)) ; EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)) ;
@ -195,7 +195,7 @@ public:
if ( fr ) if ( fr )
return From_Filtered(fr); return From_Filtered(fr);
} }
catch (Interval_nt_advanced::unsafe_comparison) {} catch (Uncertain_conversion_exception) {}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST); Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)) ; EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)) ;