CORE: Use boost::multiprecision::number API

Algebraic_foundations/include/CGAL/Rational_traits.h

@@ -53,21 +53,21 @@ struct Rational_traits_base<Rational, true>
 {
 private:
     typedef Fraction_traits<Rational> FT;
-    typedef typename FT::Decompose Decomose;
+    typedef typename FT::Decompose Decompose;
     typedef typename FT::Compose Compose;
 
 public:
     typedef typename FT::Numerator_type RT;
 
     RT numerator (const Rational& r) const {
         RT num,den;
-        Decomose()(r,num,den);
+        Decompose()(r,num,den);
         return num;
     }
 
     RT denominator (const Rational& r) const {
         RT num,den;
-        Decomose()(r,num,den);
+        Decompose()(r,num,den);
         return den;
     }
 

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Bitstream_descartes_rndl_tree_traits.h

@@ -28,7 +28,7 @@
 #include <vector>
 
 #if CGAL_USE_CORE
-namespace CORE { class BigInt; }
+#include <CGAL/CORE/BigInt.h>
 #endif
 
 namespace CGAL {

Arithmetic_kernel/include/CGAL/BOOST_MP_arithmetic_kernel.h

@@ -19,27 +19,39 @@
 
 #ifdef CGAL_USE_BOOST_MP
 
+// already protected by CGAL_USE_CORE macro
+#include <CGAL/CORE_arithmetic_kernel.h>
+
 //Currently already included in boost_mp.h
 //#include <boost/multiprecision/cpp_int.hpp>
 //#ifdef CGAL_USE_GMP
 //#include <boost/multiprecision/gmp.hpp>
 //#endif
 
 // FIXME: the could be several kernels based on Boost.Multiprecision.
-
 namespace CGAL {
 /** \ingroup CGAL_Arithmetic_kernel
  *  \brief The Boost.Multiprecision set of exact number types
  */
+
+#if !defined(CGAL_USE_CORE) || defined(CGAL_CORE_USE_GMP_BACKEND)
 struct BOOST_cpp_arithmetic_kernel : internal::Arithmetic_kernel_base {
   typedef boost::multiprecision::cpp_int Integer;
   typedef boost::multiprecision::cpp_rational Rational;
 };
+#else
+typedef CORE_arithmetic_kernel BOOST_cpp_arithmetic_kernel;
+#endif
+
 #ifdef CGAL_USE_GMP
+#if !defined(CGAL_USE_CORE) || !defined(CGAL_CORE_USE_GMP_BACKEND)
 struct BOOST_gmp_arithmetic_kernel : internal::Arithmetic_kernel_base {
   typedef boost::multiprecision::mpz_int Integer;
   typedef boost::multiprecision::mpq_rational Rational;
 };
+#else
+typedef CORE_arithmetic_kernel BOOST_gmp_arithmetic_kernel;
+#endif
 #endif
 
 template <class T1, class T2, class T3, class T4, class T5>

Arithmetic_kernel/include/CGAL/CORE_arithmetic_kernel.h

@@ -55,14 +55,6 @@ class CORE_arithmetic_kernel : public internal::Arithmetic_kernel_base {
 };
 
 
-template <>
-struct Get_arithmetic_kernel<CORE::BigInt>{
-  typedef CORE_arithmetic_kernel Arithmetic_kernel;
-};
-template <>
-struct Get_arithmetic_kernel<CORE::BigRat>{
-  typedef CORE_arithmetic_kernel Arithmetic_kernel;
-};
 template <>
 struct Get_arithmetic_kernel<CORE::Expr>{
   typedef CORE_arithmetic_kernel Arithmetic_kernel;
@@ -74,6 +66,8 @@ struct Get_arithmetic_kernel<CORE::BigFloat>{
 
 } //namespace CGAL
 
+#include <CGAL/BOOST_MP_arithmetic_kernel.h>
+
 #endif // CGAL_USE_CORE
 
 #endif //  CGAL_CORE_ARITHMETIC_KERNEL_H

Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Conic_arc_2.h

@@ -1389,9 +1389,9 @@ class _Conic_arc_2
     //
     Nt_traits        nt_traits;
     const int        or_fact = (_orient == CLOCKWISE) ? -1 : 1;
-    const Algebraic  r = nt_traits.convert (or_fact * _r);
-    const Algebraic  s = nt_traits.convert (or_fact * _s);
-    const Algebraic  t = nt_traits.convert (or_fact * _t);
+    const Algebraic  r = nt_traits.convert (Integer(or_fact * _r));
+    const Algebraic  s = nt_traits.convert (Integer(or_fact * _s));
+    const Algebraic  t = nt_traits.convert (Integer(or_fact * _t));
     const Algebraic  cos_2phi = (r - s) / nt_traits.sqrt((r-s)*(r-s) + t*t);
     const Algebraic  _zero = 0;
     const Algebraic  _one = 1;
@@ -1441,8 +1441,8 @@ class _Conic_arc_2
     //        4*r*s - t^2                4*r*s - t^2
     //
     // The denominator (4*r*s - t^2) must be negative for hyperbolas.
-    const Algebraic  u = nt_traits.convert (or_fact * _u);
-    const Algebraic  v = nt_traits.convert (or_fact * _v);
+    const Algebraic  u = nt_traits.convert (Integer(or_fact * _u));
+    const Algebraic  v = nt_traits.convert (Integer(or_fact * _v));
     const Algebraic  det = 4*r*s - t*t;
     Algebraic        x0, y0;
 
@@ -1650,9 +1650,9 @@ class _Conic_arc_2
     int           n_xs;
     Nt_traits     nt_traits;
 
-    xs_end = nt_traits.solve_quadratic_equation (_t*_t - _four*_r*_s,
-                                                 _two*_t*_v - _four*_s*_u,
-                                                 _v*_v - _four*_s*_w,
+    xs_end = nt_traits.solve_quadratic_equation (Integer(_t*_t - _four*_r*_s),
+                                                 Integer(_two*_t*_v - _four*_s*_u),
+                                                 Integer(_v*_v - _four*_s*_w),
                                                  xs);
     n_xs = static_cast<int>(xs_end - xs);
 
@@ -1664,15 +1664,15 @@ class _Conic_arc_2
     if (CGAL::sign (_t) == ZERO)
     {
       // The two vertical tangency points have the same y coordinate:
-      ys[0] = nt_traits.convert (-_v) /nt_traits.convert (_two*_s);
+      ys[0] = nt_traits.convert (Integer(-_v)) /nt_traits.convert (Integer(_two*_s));
       n_ys = 1;
     }
     else
     {
       ys_end =
-        nt_traits.solve_quadratic_equation (_four*_r*_s*_s - _s*_t*_t,
-                                            _four*_r*_s*_v - _two*_s*_t*_u,
-                                            _r*_v*_v - _t*_u*_v + _t*_t*_w,
+        nt_traits.solve_quadratic_equation (Integer(_four*_r*_s*_s - _s*_t*_t),
+                                            Integer(_four*_r*_s*_v - _two*_s*_t*_u),
+                                            Integer(_r*_v*_v - _t*_u*_v + _t*_t*_w),
                                             ys);
       n_ys = static_cast<int>(ys_end - ys);
     }
@@ -1692,7 +1692,7 @@ class _Conic_arc_2
       {
         for (j = 0; j < n_ys; j++)
         {
-          if (CGAL::compare (nt_traits.convert(_two*_s) * ys[j],
+          if (CGAL::compare (nt_traits.convert(Integer(_two*_s)) * ys[j],
                              -(nt_traits.convert(_t) * xs[i] +
                                nt_traits.convert(_v))) == EQUAL)
           {
@@ -1735,9 +1735,9 @@ class _Conic_arc_2
     Algebraic    *ys_end;
     Nt_traits     nt_traits;
 
-    ys_end = nt_traits.solve_quadratic_equation (_t*_t - _four*_r*_s,
-                                                 _two*_t*_u - _four*_r*_v,
-                                                 _u*_u - _four*_r*_w,
+    ys_end = nt_traits.solve_quadratic_equation (Integer(_t*_t - _four*_r*_s),
+                                                 Integer(_two*_t*_u - _four*_r*_v),
+                                                 Integer(_u*_u - _four*_r*_w),
                                                  ys);
     n = static_cast<int>(ys_end - ys);
 

Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Conic_intersections_2.h

@@ -72,13 +72,14 @@ int
   unsigned int                       degree = 4;
   typename Nt_traits::Algebraic     *xs_end;
 
+  typedef typename Nt_traits::Integer Integer;
   if (deg1 == 1)
   {
     // The first curve has no quadratic coefficients, and represents a line.
     if (CGAL::sign (v1) == ZERO)
     {
       // The first line is u1*x + w1 = 0, therefore:
-      xs[0] = nt_traits.convert(-w1) / nt_traits.convert(u1);
+      xs[0] = nt_traits.convert(Integer(-w1)) / nt_traits.convert(u1);
       return (1);
     }
 
@@ -94,7 +95,7 @@ int
         // The two lines are parallel:
         return (0);
 
-      xs[0] =  nt_traits.convert(-c[0]) /  nt_traits.convert(c[1]);
+      xs[0] =  nt_traits.convert(Integer(-c[0])) /  nt_traits.convert(c[1]);
       return (1);
     }
 

Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Algebraic_point_2.h

@@ -225,10 +225,11 @@ class Algebraic_point_2_rep : public Base_rational_arc_ds_1<AlgebraicKernelD_1>
         if (CGAL::compare(
                 CGAL::width(y_bfi),
                 CGAL::lower(CGAL::abs(y_bfi)) * eps)
-            == SMALLER)
+            == SMALLER){
           return std::make_pair(
               Bound(CGAL::lower(y_bfi)),
               Bound(CGAL::upper(y_bfi)));
+        }
       }
       else precision*=2;
     }
@@ -287,10 +288,12 @@ class Algebraic_point_2_rep : public Base_rational_arc_ds_1<AlgebraicKernelD_1>
       if (CGAL::zero_in(y_denom_bfi) == false)
       {
         BFI y_bfi(y_numer_bfi/y_denom_bfi);
-        if (CGAL::width(y_bfi) < eps )
+        if (CGAL::width(y_bfi) < eps ){
+          assert(false) ; // AF fix
           return std::make_pair(
               Bound(CGAL::lower(y_bfi)),
               Bound(CGAL::upper(y_bfi)));
+        }
 
       }
       else precision*=2;

Arrangement_on_surface_2/include/CGAL/CORE_algebraic_number_traits.h

@@ -106,7 +106,7 @@ class CORE_algebraic_number_traits
       ix1 = scaled_x1.BigIntValue();
       ix2 = scaled_x2.BigIntValue();
 
-      if (CORE::abs (ix2 - ix1) > one)
+      if (CGAL::abs (ix2 - ix1) > one)
         break;
 
       // Scale the values by a factor of 2.
@@ -179,9 +179,9 @@ class CORE_algebraic_number_traits
         temp_gcd = numer_gcd;
 
         denom_lcm *= denom;
-        denom_lcm /= CORE::gcd (temp_lcm, denom);
+        denom_lcm /= CGAL::gcd (temp_lcm, denom);
 
-        numer_gcd = CORE::gcd (temp_gcd, numer);
+        numer_gcd = CGAL::gcd (temp_gcd, numer);
       }
 
       ++q_iter;
@@ -246,16 +246,16 @@ class CORE_algebraic_number_traits
 
     if (sign_disc == ZERO)
     {
-      // We have one real root with mutliplicity 2.
-      *oi = -Algebraic (b) / Algebraic (2*a);
+      // We have one real root with multiplicity 2.
+      *oi = -Algebraic (b) / Algebraic (NT(2*a));
       ++oi;
     }
     else if (sign_disc == POSITIVE)
     {
       // We have two distinct real roots. We return them in ascending order.
       const Algebraic      sqrt_disc = CGAL::sqrt (Algebraic (disc));
       const Algebraic      alg_b = b;
-      const Algebraic      alg_2a = 2*a;
+      const Algebraic      alg_2a = NT(2*a);
 
       if (sign_a == POSITIVE)
       {
@@ -334,7 +334,7 @@ class CORE_algebraic_number_traits
         temp_lcm = denom_lcm;
 
         denom_lcm *= denom;
-        denom_lcm /= CORE::gcd (temp_lcm, denom);
+        denom_lcm /= CGAL::gcd (temp_lcm, denom);
       }
 
       index--;

CGAL_Core/include/CGAL/CORE/BigFloat.h

@@ -59,7 +59,7 @@ class CGAL_CORE_EXPORT BigFloat : public RCBigFloat {
   /// constructor for <tt>const char* </tt>(default base = 10)
   BigFloat(const char* s) : RCBigFloat(new BigFloatRep(s)) {}
   /// constructor for <tt>std::string</tt>(default base = 10)
-  BigFloat(const std::string& s) : RCBigFloat(new BigFloatRep(s)) {}
+  BigFloat(const std::string& s) : RCBigFloat(new BigFloatRep(s.c_str())) {}
 
   /// constructor for <tt>int</tt> and <tt>long</tt>
   //     This is a hack because in Sturm, we need to approximate any
@@ -106,6 +106,9 @@ class CGAL_CORE_EXPORT BigFloat : public RCBigFloat {
   explicit BigFloat(BigFloatRep* r, bool) : RCBigFloat(r) {
   }
 
+  operator BigRat() const {
+    return this->BigRatValue();
+  }
 
   //@}
 
@@ -615,10 +618,16 @@ inline BigFloat gcd(const BigFloat& a, const BigFloat& b) {
 //}//
 
 
-// constructor BigRat from BigFloat
-inline BigRat::BigRat(const BigFloat& f) : RCBigRat(new BigRatRep()){
-  *this = f.BigRatValue();
+inline double doubleValue(const BigFloat& bf)
+{
+  return bf.doubleValue();
+}
+
+inline long longValue(const BigFloat& bf)
+{
+  return bf.longValue();
 }
+
 } //namespace CORE
 
 #ifdef CGAL_HEADER_ONLY

CGAL_Core/include/CGAL/CORE/BigFloat_impl.h

@@ -455,6 +455,7 @@ void BigFloatRep::centerize(const BigFloatRep& a, const BigFloatRep& b) {
   // Zilin & Vikram, 08/24/04
   // err = 1 + longValue(chunkShift(r.m, r.exp - exp));
   BigInt E = chunkShift(r.m, r.exp - exp);
+  E = abs(E);
   bigNormal(E);
 }
 
@@ -869,7 +870,7 @@ BigFloatRep::toDecimal(unsigned int width, bool Scientific) const {
     M <<= e2;         // M = x * 2^(e2)
   }
 
-  std::string decRep = M.get_str();
+  std::string decRep = M.convert_to<std::string>();
   // Determine the "significant part" of this string, i.e. the part which
   // is guaranteed to be correct in the presence of error,
   // except that the last digit which might be subject to +/- 1.