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

Merge remote-tracking branch 'sloriot/CGAL-restore_rounding_mode'

This commit is contained in:
Sébastien Loriot 2021-09-09 11:09:16 +02:00
parent 75ca34c2a5 c8624ee0b3
commit 6bae0e3939
12 changed files with 514 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Convex_hull_3/include/CGAL/convex_hull_3.h
View File

@ -359,6 +359,8 @@ public:
}
}
catch (Uncertain_conversion_exception&){}
Protector protector(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (ek_plane_ptr==nullptr) {
const typename Exact_K::Point_3 ep = to_EK(p);
ek_plane_ptr = new Vector_plus_point<Exact_K>;

20
Filtered_kernel/include/CGAL/Filtered_construction.h
View File

@ -43,6 +43,7 @@ public:
template <class A1>
result_type
operator()(const A1 &a1) const
{
{
// Protection is outside the try block as VC8 has the CGAL_CFG_FPU_ROUNDING_MODE_UNWINDING_VC_BUG
Protect_FPU_rounding<Protection> P1;
@ -51,14 +52,16 @@ public:
return From_Filtered( Filter_construction(To_Filtered(a1)) );
}
catch (Uncertain_conversion_exception&)
{
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1)) );
{}
}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1)) );
}
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const
{
{
Protect_FPU_rounding<Protection> P1;
try
@ -67,16 +70,18 @@ public:
To_Filtered(a2)) );
}
catch (Uncertain_conversion_exception&)
{
{}
}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1),
To_Exact(a2)) );
}
}
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{
{
Protect_FPU_rounding<Protection> P1;
try
@ -86,13 +91,14 @@ public:
To_Filtered(a3)) );
}
catch (Uncertain_conversion_exception&)
{
{}
}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return From_Exact( Exact_construction(To_Exact(a1),
To_Exact(a2),
To_Exact(a3)) );
}
}
};

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

@ -107,6 +107,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return ep(c2e(args)...);
}

1
Filtered_kernel/include/CGAL/Filtered_predicate_with_state.h
View File

@ -74,6 +74,7 @@ Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if(! oep){
#if BOOST_VERSION < 105600
oep = EP(c2e(o1));

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

@ -885,16 +885,18 @@ struct Lazy_construction_bbox
operator()(const L1& l1) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
// Protection is outside the try block as VC8 has the CGAL_CFG_FPU_ROUNDING_MODE_UNWINDING_VC_BUG
Protect_FPU_rounding<Protection> P;
try {
return ac(CGAL::approx(l1));
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return ec(CGAL::exact(l1));
}
}
};
@ -1009,15 +1011,17 @@ struct Lazy_construction_nt {
typedef std::remove_cv_t<std::remove_reference_t<decltype(ec(CGAL::exact(l)...))>> ET;
typedef std::remove_cv_t<std::remove_reference_t<decltype(ac(CGAL::approx(l)...))>> AT;
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
return new Lazy_rep_n<AT, ET, AC, EC, To_interval<ET>, L... >(ac, ec, l...);
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec( CGAL::exact(l)... ));
}
}
};
@ -1229,18 +1233,21 @@ public:
operator()(const L1& l1, const L2& l2, R1& r1) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
// 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));
} catch (Uncertain_conversion_exception&) {
return;
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
typename R1::ET et;
ec(CGAL::exact(l1), CGAL::exact(l2), et);
r1 = R1(new Lazy_rep_0<typename R1::AT,typename R1::ET,E2A>(et));
}
}
};
@ -1295,6 +1302,7 @@ public:
typedef Lazy<typename R1::AT, typename R1::ET, E2A> Handle_1;
typedef Lazy<typename R2::AT, typename R2::ET, E2A> Handle_2;
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
typedef Lazy<std::pair<typename R1::AT, typename R2::AT>, std::pair<typename R1::ET, typename R2::ET>, E2A> Lazy_pair;
@ -1302,15 +1310,17 @@ public:
// lv->approx() is a std::pair<R1::AT, R2::AT>;
r1 = R1(Handle_1(new Lazy_rep_n<void, void, 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(Handle_2(new Lazy_rep_n<void, void, 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 (Uncertain_conversion_exception&) {
return;
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
typename R1::ET et1, et2;
ec(CGAL::exact(l1), CGAL::exact(l2), et1, et2);
r1 = R1(Handle_1(new Lazy_rep_0<typename R1::AT,typename R1::ET,E2A>(et1)));
r2 = R2(Handle_2(new Lazy_rep_0<typename R2::AT,typename R2::ET,E2A>(et2)));
}
}
};
@ -1339,6 +1349,7 @@ public:
operator()(const L1& l1, const L2& l2, OutputIterator it) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy_vector lv(new Lazy_rep_with_vector_2<AC, EC, E2A, L1, L2>(ac, ec, l1, l2));
@ -1357,11 +1368,13 @@ public:
std::cerr << "we need more casts" << std::endl;
}
} catch (Uncertain_conversion_exception&) {
return it;
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
// TODO: Instead of using a vector, write an iterator adapter
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
std::vector<Object> exact_objects;
ec(CGAL::exact(l1), CGAL::exact(l2), std::back_inserter(exact_objects));
for (std::vector<Object>::const_iterator oit = exact_objects.begin();
@ -1369,7 +1382,6 @@ public:
++oit){
*it++ = make_lazy<LK>(*oit);
}
}
return it;
}
};
@ -1417,6 +1429,7 @@ public:
operator()(const L1& l1) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy_object lo(new Lazy_rep_n<result_type, result_type, AC, EC, E2A, L1>(ac, ec, l1));
@ -1435,21 +1448,22 @@ public:
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;
} catch (Uncertain_conversion_exception&) {
return Object();
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1));
return make_lazy<LK>(eto);
}
return Object();
}
template <typename L1, typename L2>
decltype(auto)
operator()(const L1& l1, const L2& l2) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy_object lo(new Lazy_rep_n<result_type, result_type, AC, EC, E2A, L1, L2>(ac, ec, l1, l2));
@ -1490,20 +1504,22 @@ CGAL_Kernel_obj(Point_3)
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;
} catch (Uncertain_conversion_exception&) {
return Object();
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1), CGAL::exact(l2));
return make_lazy<LK>(eto);
}
return Object();
}
template <typename L1, typename L2, typename L3>
decltype(auto)
operator()(const L1& l1, const L2& l2, const L3& l3) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy_object lo(new Lazy_rep_n<result_type, result_type, AC, EC, E2A, L1, L2, L3>(ac, ec, l1, l2, l3));
@ -1522,15 +1538,15 @@ CGAL_Kernel_obj(Point_3)
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;
} catch (Uncertain_conversion_exception&) {
return Object();
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
ET eto = ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3));
return make_lazy<LK>(eto);
}
return Object();
}
};
@ -1680,8 +1696,8 @@ struct Lazy_construction_variant {
typedef decltype(std::declval<EC const&>()( CGAL::exact(l1), CGAL::exact(l2))) ET;
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy<AT, ET, E2A> lazy(new Lazy_rep_n<AT, ET, AC, EC, E2A, L1, L2>(AC(), EC(), l1, l2));
@ -1700,10 +1716,11 @@ struct Lazy_construction_variant {
boost::apply_visitor(visitor, *approx_v);
return res;
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
ET exact_v = EC()(CGAL::exact(l1), CGAL::exact(l2));
result_type res;
@ -1715,7 +1732,6 @@ struct Lazy_construction_variant {
boost::apply_visitor(visitor, *exact_v);
return res;
}
}
template <typename L1, typename L2, typename L3>
decltype(auto)
@ -1733,8 +1749,8 @@ struct Lazy_construction_variant {
typedef decltype(std::declval<EC const&>()( CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3))) ET;
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
Lazy<AT, ET, E2A> lazy(new Lazy_rep_n<AT, ET, AC, EC, E2A, L1, L2, L3>(AC(), EC(), l1, l2, l3));
@ -1753,10 +1769,12 @@ struct Lazy_construction_variant {
boost::apply_visitor(visitor, *approx_v);
return res;
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
ET exact_v = EC()(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3));
result_type res;
@ -1768,7 +1786,6 @@ struct Lazy_construction_variant {
boost::apply_visitor(visitor, *exact_v);
return res;
}
}
};
template<typename LK, typename AC, typename EC, typename E2A = Default,
@ -1801,14 +1818,16 @@ struct Lazy_construction<LK, AC, EC, E2A_, true> {
operator()( BOOST_PP_ENUM(n, CGAL_LARGS, _) ) const { \
typedef Lazy< AT, ET, E2A> Handle; \
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp); \
{ \
Protect_FPU_rounding<Protection> P; \
try { \
return result_type( Handle(new Lazy_rep_n<AT, ET, AC, EC, E2A, BOOST_PP_ENUM_PARAMS(n, L)>(ac, ec, BOOST_PP_ENUM_PARAMS(n, l)))); \
} catch (Uncertain_conversion_exception&) { \
} catch (Uncertain_conversion_exception&) {} \
} \
CGAL_BRANCH_PROFILER_BRANCH(tmp); \
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST); \
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST); \
return result_type( Handle(new Lazy_rep_0<AT,ET,E2A>(ec( BOOST_PP_ENUM(n, CGAL_LEXACT, _) ))) ); \
} \
}
// arity 1-8
@ -1859,14 +1878,16 @@ struct Lazy_construction<LK, AC, EC, E2A_, false>
typedef Lazy< AT, ET, E2A> Handle; \
typedef typename result<Lazy_construction(BOOST_PP_ENUM_PARAMS(n, L))>::type result_type; \
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp); \
{ \
Protect_FPU_rounding<Protection> P; \
try { \
return result_type( Handle(new Lazy_rep_n<AT, ET, AC, EC, E2A, BOOST_PP_ENUM_PARAMS(n, L)>(ac, ec, BOOST_PP_ENUM_PARAMS(n, l)))); \
} catch (Uncertain_conversion_exception&) { \
} catch (Uncertain_conversion_exception&) {} \
} \
CGAL_BRANCH_PROFILER_BRANCH(tmp); \
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST); \
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST); \
return result_type( Handle(new Lazy_rep_0<AT,ET,E2A>(ec( BOOST_PP_ENUM(n, CGAL_LEXACT, _) ))) ); \
} \
}
// arity 1-8

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

@ -390,40 +390,64 @@ int orientation(const Extended_point<RT>& p1,
const Extended_point<RT>& p3)
{ CGAL_NEF_TRACEN("orientation "<<p1<<p2<<p3);
int res;
try { INCTOTAL(or2); Protect_FPU_rounding<true> Protection;
bool run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(or2);
res = orientation_coeff2(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(or2);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(or2);
run_exact=true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
}
if ( res != 0 ) return res;
try { INCTOTAL(or1); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(or1);
res = orientation_coeff1(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(or1);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(or1);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
}
if ( res != 0 ) return res;
try { INCTOTAL(or0); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(or0);
res = orientation_coeff0(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(or0);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(or0);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
}
return res;
}
@ -441,20 +465,38 @@ int compare_x(const Extended_point<RT>& p1,
const Extended_point<RT>& p2)
{
int res;
try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection;
bool run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmpx1);
res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmpx1);
res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmpx1);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
if ( res != 0 ) return res;
try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try {
INCTOTAL(cmpx0);
res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmpx0);
res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmpx0);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
return res;
}
@ -466,20 +508,36 @@ int compare_y(const Extended_point<RT>& p1,
const Extended_point<RT>& p2)
{
int res;
try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection;
bool run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmpy1);
res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmpy1);
res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmpy1);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
if ( res != 0 ) return res;
try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmpy0);
res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmpy0);
res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmpy0);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
return res;
}
@ -608,46 +666,71 @@ int compare_pair_dist(
const Extended_point<RT>& p3, const Extended_point<RT>& p4)
{
int res;
try { INCTOTAL(cmppd2); Protect_FPU_rounding<true> Protection;
bool run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmppd2);
res = cmppd_coeff2(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmppd2);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmppd2);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
if ( res != 0 ) return res;
try { INCTOTAL(cmppd1); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmppd1);
res = cmppd_coeff1(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmppd1);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmppd1);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
if ( res != 0 ) return res;
try { INCTOTAL(cmppd0); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(cmppd0);
res = cmppd_coeff0(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
}
catch (Uncertain_conversion_exception&) { INCEXCEPTION(cmppd0);
catch (Uncertain_conversion_exception&) {
INCEXCEPTION(cmppd0);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
return res;
}
@ -873,42 +956,68 @@ int orientation(const Extended_direction<RT>& d1,
Extended_point<RT> p1(d1.p1()), p2(d1.p2()),
p3(d2.p1()), p4(d2.p2());
int res;
try { INCTOTAL(ord2); Protect_FPU_rounding<true> Protection;
bool run_exact = true;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(ord2);
res = coeff2_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Uncertain_conversion_exception&) { INCEXCEPTION(ord2);
} catch (Uncertain_conversion_exception&) {
INCEXCEPTION(ord2);
run_exact=true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
if ( res != 0 ) return res;
try { INCTOTAL(ord1); Protect_FPU_rounding<true> Protection;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(ord1);
res = coeff1_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Uncertain_conversion_exception&) { INCEXCEPTION(ord1);
} catch (Uncertain_conversion_exception&) {
INCEXCEPTION(ord1);
run_exact=true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
if ( res != 0 ) return res;
run_exact = false;
{
Protect_FPU_rounding<true> Protection;
try { INCTOTAL(ord0); Protect_FPU_rounding<true> Protection;
res = coeff0_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(),
p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
} catch (Uncertain_conversion_exception&) { INCEXCEPTION(ord0);
} catch (Uncertain_conversion_exception&) {
INCEXCEPTION(ord0);
run_exact = true;
}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if(run_exact)
res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw());
}
return res;
}

1
NewKernel_d/include/CGAL/NewKernel_d/Cartesian_filter_NT.h
View File

@ -48,6 +48,7 @@ struct Cartesian_filter_NT : public Base_
if(is_certain(res)) return get_certain(res);
} catch (Uncertain_conversion_exception&) {}
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return p2(std::forward<U>(u)...);
}
};

2
NewKernel_d/include/CGAL/NewKernel_d/Filtered_predicate2.h
View File

@ -92,6 +92,8 @@ public:
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return ep(c2e(std::forward<Args>(args))...);
}
};

6
NewKernel_d/include/CGAL/NewKernel_d/Lazy_cartesian.h
View File

@ -176,15 +176,17 @@ struct Lazy_construction2 {
template<class...L>
std::enable_if_t<(sizeof...(L)>0), result_type> operator()(L const&...l) const {
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> P;
try {
return new Lazy_rep_XXX<AT, ET, AC, EC, E2A, L...>(ac, ec, l...);
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l)...));
}
}
// FIXME: this forces us to have default constructors for all types, try to make its instantiation lazier
// Actually, that may be the clearing in update_exact().
result_type operator()() const

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

@ -313,7 +313,7 @@ sign(TMC_Vertex_handle vit) const
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
typedef Exact_predicates_exact_constructions_kernel EK;
typedef Skin_surface_traits_3<EK> Exact_skin_surface_traits;
typedef Skin_surface_base_3<Exact_skin_surface_traits> Exact_skin_surface_base;
@ -355,6 +355,7 @@ sign(const Bare_point &p, const Cell_info &info) const
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return construct_surface(info.first,
Exact_predicates_exact_constructions_kernel()).sign(p);
}
@ -630,7 +631,7 @@ compare(Cell_info &info1, const Bare_point &p1,
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
return CGAL_NTS sign(
construct_surface(info1.first,
Exact_predicates_exact_constructions_kernel()).value(p1) -
@ -689,12 +690,17 @@ locate_in_tmc(const Bare_point &p0, TMC_Cell_handle start) const
// We temporarily put p at i's place in pts.
const TMC_Point* backup = pts[i];
pts[i] = &p_inexact;
bool run_exact=false;
{
Protect_FPU_rounding<true> P;
try {
o = TMC_Geom_traits().orientation_3_object()(*pts[0], *pts[1],
*pts[2], *pts[3]);
} catch (Uncertain_conversion_exception&) {
} catch (Uncertain_conversion_exception&) { run_exact=true; }
}
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
if (run_exact)
{
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
typedef Exact_predicates_exact_constructions_kernel EK;
Cartesian_converter<typename Bare_point::R, EK> converter_ek;
@ -716,7 +722,6 @@ locate_in_tmc(const Bare_point &p0, TMC_Cell_handle start) const
}
o = orientation(e_pts[0], e_pts[1], e_pts[2], e_pts[3]);
}
}
if ( o != NEGATIVE ) {
pts[i] = backup;

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

@ -1197,7 +1197,7 @@ Mixed_complex_triangulator_3<RegularTriangulation_3,
TriangulatedMixedComplexObserver_3>::
orientation(Tmc_Cell_handle ch)
{
Orientation o;
{
// Protection is outside the try block as VC8 has the CGAL_CFG_FPU_ROUNDING_MODE_UNWINDING_VC_BUG
Protect_FPU_rounding<true> P;
try {
@ -1206,9 +1206,11 @@ orientation(Tmc_Cell_handle ch)
pts[i] = ch->vertex(i)->point();
// filtered kernel
o = _tmc.geom_traits().orientation_3_object()(pts[0], pts[1], pts[2], pts[3]);
} catch (Uncertain_conversion_exception&) {
return _tmc.geom_traits().orientation_3_object()(pts[0], pts[1], pts[2], pts[3]);
} catch (Uncertain_conversion_exception&) {}
}
Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
typedef Exact_predicates_exact_constructions_kernel EK;
typedef Cartesian_converter<EK, Tmc_traits> Exact_converter;
typedef Skin_surface_traits_3<EK> Exact_traits;
@ -1226,11 +1228,9 @@ orientation(Tmc_Cell_handle ch)
// Store the more precise point
ch->vertex(k)->point() = converter(e_pts[k]);
}
o = exact_traits.orientation_3_object()(e_pts[0], e_pts[1],
return exact_traits.orientation_3_object()(e_pts[0], e_pts[1],
e_pts[2], e_pts[3]);
}
return o;
}
template <class RegularTriangulation_3,
class TriangulatedMixedComplex_3,

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

@ -136,9 +136,10 @@ public:
result_type
operator()(A&& ... a) const
{
try
{
Protect_FPU_rounding<Protection> P;
try
{
FC_result_type fr = Filter_construction(To_Filtered(std::forward<A>(a))...);
const double precision =
@ -148,8 +149,10 @@ public:
return From_Filtered(fr);
}
catch (Uncertain_conversion_exception&) {}
}
Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
EC_result_type er = Exact_construction(To_Exact(std::forward<A>(a))...) ;
return From_Exact(er);
}