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

Convex_hull_3/include/CGAL/convex_hull_3.h

@@ -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>;

Filtered_kernel/include/CGAL/Filtered_construction.h

@@ -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)) );
   }
-  }
 
 };
 

Filtered_kernel/include/CGAL/Filtered_predicate.h

@@ -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)...);
 }
 

Filtered_kernel/include/CGAL/Filtered_predicate_with_state.h

@@ -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){
       oep.emplace(c2e(o1));
     }

Filtered_kernel/include/CGAL/Lazy.h

@@ -1169,16 +1169,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));
   }
-  }
 };
 
 
@@ -1198,9 +1200,9 @@ struct Lazy_construction_optional_for_polygonal_envelope
   // for Intersect_point_3 with 3 Plane_3
   template <typename L1>
   result_type operator()(const L1& l1, const L1& l2, const L1& l3) const
+  {
     {
       Protect_FPU_rounding<Protection> P;
-
       try {
         boost::optional<typename AK::Point_3> oap = ac(CGAL::approx(l1),CGAL::approx(l2),CGAL::approx(l3));
         if(oap == boost::none){
@@ -1216,9 +1218,10 @@ struct Lazy_construction_optional_for_polygonal_envelope
         typename LK::Point_3 lp(&rep);
         return boost::make_optional(lp);
 
-
+      } catch (Uncertain_conversion_exception&) {}
-    } catch (Uncertain_conversion_exception&) {
+    }
     Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
+    CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
     boost::optional<typename EK::Point_3> oep = ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3));
     if(oep == boost::none){
       return boost::none;
@@ -1229,17 +1232,14 @@ struct Lazy_construction_optional_for_polygonal_envelope
     typename LK::Point_3 lp(rep);
     return boost::make_optional(lp);
   }
-    // AF can we get here??
-    return boost::none;
-  }
 
   // for Intersect_point_3 with  Plane_3  Line_3
   template <typename L1, typename L2>
   result_type operator()(const L1& l1, const L2& l2) const
   {
 
+    {
       Protect_FPU_rounding<Protection> P;
-
       try {
         boost::optional<typename AK::Point_3> oap = ac(CGAL::approx(l1),CGAL::approx(l2));
         if(oap == boost::none){
@@ -1255,9 +1255,10 @@ struct Lazy_construction_optional_for_polygonal_envelope
         typename LK::Point_3 lp(&rep);
         return boost::make_optional(lp);
 
-
+      } catch (Uncertain_conversion_exception&) {}
-    } catch (Uncertain_conversion_exception&) {
+    }
     Protect_FPU_rounding<!Protection> P2(CGAL_FE_TONEAREST);
+    CGAL_expensive_assertion(FPU_get_cw() == CGAL_FE_TONEAREST);
     boost::optional<typename EK::Point_3> oep = ec(CGAL::exact(l1), CGAL::exact(l2));
     if(oep == boost::none){
       return boost::none;
@@ -1268,9 +1269,6 @@ struct Lazy_construction_optional_for_polygonal_envelope
     typename LK::Point_3 lp(rep);
     return boost::make_optional(lp);
   }
-    // AF can we get here??
-    return boost::none;
-  }
 };
 
 
@@ -1295,15 +1293,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>, false, 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)... ));
   }
-  }
 };
 
 
@@ -1515,18 +1515,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));
   }
-  }
 };
 
 
@@ -1581,6 +1584,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;
@@ -1588,15 +1592,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, false, 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, false, 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)));
   }
-  }
 };
 
 
@@ -1625,6 +1631,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));
@@ -1643,11 +1650,13 @@ public:
 
           std::cerr << "we need  more casts" << std::endl;
         }
-
+        return it;
-    } catch (Uncertain_conversion_exception&) {
+      } 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();
@@ -1655,7 +1664,6 @@ public:
          ++oit){
       *it++ = make_lazy<LK>(*oit);
     }
-    }
     return it;
   }
 };
@@ -1703,6 +1711,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, false, L1>(ac, ec, l1));
@@ -1722,20 +1731,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, false, L1, L2>(ac, ec, l1, l2));
@@ -1776,20 +1787,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&) {
+      } catch (Uncertain_conversion_exception&) {}
+      return Object();
+    }
     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, false, L1, L2, L3>(ac, ec, l1, l2, l3));
@@ -1808,16 +1821,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;
-
+        return Object();
-    } 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 eto = ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3));
     return make_lazy<LK>(eto);
   }
-    return Object();
-  }
-
 };
 
 
@@ -1955,6 +1967,7 @@ struct Lazy_construction_variant {
   template <typename L1, typename L2>
   decltype(auto)
   operator()(const L1& l1, const L2& l2) const {
+
     typedef typename result<Lazy_construction_variant(L1, L2)>::type result_type;
 
     // typedef decltype(std::declval<AC>()(std::declval<typename Type_mapper<L1, LK, AK>::type>(),
@@ -1966,6 +1979,7 @@ 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 {
@@ -1986,10 +2000,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;
 
@@ -2001,7 +2016,6 @@ struct Lazy_construction_variant {
     boost::apply_visitor(visitor, *exact_v);
     return res;
   }
-  }
 
   template <typename L1, typename L2, typename L3>
   decltype(auto)
@@ -2019,6 +2033,7 @@ 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 {
@@ -2039,10 +2054,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), CGAL::exact(l3));
     result_type res;
 
@@ -2054,7 +2070,6 @@ struct Lazy_construction_variant {
     boost::apply_visitor(visitor, *exact_v);
     return res;
   }
-  }
 };
 
 template<typename LK, typename AC, typename EC, typename E2A = Default,
@@ -2092,14 +2107,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, noprune, 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
@@ -2152,14 +2169,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, noprune, 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

Nef_2/include/CGAL/Filtered_extended_homogeneous.h

@@ -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);
+    catch (Uncertain_conversion_exception&) {
-    res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
+      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);
+    catch (Uncertain_conversion_exception&) {
-    res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
+      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);
+    catch (Uncertain_conversion_exception&) {
-    res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
+      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);
+    catch (Uncertain_conversion_exception&) {
-    res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
+      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;
 }
 

NewKernel_d/include/CGAL/NewKernel_d/Cartesian_filter_NT.h

@@ -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)...);
                     }
             };

NewKernel_d/include/CGAL/NewKernel_d/Filtered_predicate2.h

@@ -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))...);
   }
 };

NewKernel_d/include/CGAL/NewKernel_d/Lazy_cartesian.h

@@ -178,15 +178,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

Skin_surface_3/include/CGAL/Skin_surface_base_3.h

@@ -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;

Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h

@@ -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]);
+    return _tmc.geom_traits().orientation_3_object()(pts[0], pts[1], pts[2], pts[3]);
-  } catch (Uncertain_conversion_exception&) {
+    } 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,

Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h

@@ -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);
   }