Number_types: add regression test for to_interval(cpp_int) with large values

Add a dedicated test that exercises CGAL::to_interval() on
boost::multiprecision::cpp_int values whose double conversion
overflows to infinity (2^10000, 2^1024, -2^10000), as well as
well-behaved values (2^52, 2^100, 0).

The old implementation in RET_boost_mp_base::To_interval called
x.compare(double), which Boost.MP implements via convert_to<number>,
throwing 'Cannot convert a non-finite number to an integer' when
the double is ±infinity.  The fix (integer specialization dispatching
to Boost_MP_internal::to_interval, using bit-level extraction) is
already in place; this test ensures it does not regress.

Closes #5990

Author: RajdeepKushwaha5

Number_types/test/Number_types/CMakeLists.txt

@@ -57,6 +57,7 @@ create_single_source_cgal_program("Sqrt_extension_true.cpp")
 create_single_source_cgal_program("_test_valid_finite_double.cpp")
 create_single_source_cgal_program("_test_valid_finite_float.cpp")
 create_single_source_cgal_program("to_interval_test.cpp")
+create_single_source_cgal_program("to_interval_cpp_int_large.cpp")
 create_single_source_cgal_program("unsigned.cpp")
 create_single_source_cgal_program("utilities.cpp")
 create_single_source_cgal_program("Exact_rational.cpp")

Number_types/test/Number_types/to_interval_cpp_int_large.cpp

@@ -0,0 +1,116 @@
+// Regression test for https://github.com/CGAL/cgal/issues/5990
+//
+// to_interval(cpp_int) threw "Cannot convert a non-finite number to an
+// integer" for values whose double conversion overflows to infinity.
+// The old implementation called x.compare(double), which Boost.MP
+// implements via convert_to<number>, failing on ±infinity.
+//
+// The fix (Boost_MP_internal::to_interval) uses bit-level extraction
+// instead.  This test ensures the fix does not regress.
+
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <limits>
+
+#ifndef CGAL_DO_NOT_USE_BOOST_MP
+#include <CGAL/boost_mp.h>
+#endif
+
+int main()
+{
+#ifndef CGAL_DO_NOT_USE_BOOST_MP
+  typedef boost::multiprecision::cpp_int I;
+  const double inf = std::numeric_limits<double>::infinity();
+
+  std::cout << "Testing to_interval(cpp_int) for large numbers (issue #5990)..."
+            << std::endl;
+
+  // --- Exact reproducer from the issue ---
+  // i = 2^10000, which overflows double to +inf.
+  // The old code threw std::runtime_error here.
+  {
+    I i = 1;
+    i <<= 10000;
+    auto interval = CGAL::to_interval(i);
+    double lo = interval.first;
+    double hi = interval.second;
+    std::cout << "  2^10000: [" << lo << ", " << hi << "]" << std::endl;
+    assert(lo > 0);
+    assert(hi == inf || hi == (std::numeric_limits<double>::max)());
+    assert(lo <= hi);
+    // The lower bound must be at least double_max.
+    assert(lo >= (std::numeric_limits<double>::max)());
+  }
+
+  // --- Negative large value ---
+  {
+    I i = -1;
+    i <<= 10000;
+    auto interval = CGAL::to_interval(i);
+    double lo = interval.first;
+    double hi = interval.second;
+    std::cout << "  -2^10000: [" << lo << ", " << hi << "]" << std::endl;
+    assert(hi < 0);
+    assert(lo == -inf || lo == std::numeric_limits<double>::lowest());
+    assert(lo <= hi);
+    assert(hi <= std::numeric_limits<double>::lowest());
+  }
+
+  // --- Moderately large value: 2^1024 (just above double_max ≈ 2^1023.999) ---
+  {
+    I i = 1;
+    i <<= 1024;
+    auto interval = CGAL::to_interval(i);
+    double lo = interval.first;
+    double hi = interval.second;
+    std::cout << "  2^1024: [" << lo << ", " << hi << "]" << std::endl;
+    assert(lo > 0);
+    assert(lo <= hi);
+    assert(lo >= (std::numeric_limits<double>::max)());
+  }
+
+  // --- Value that fits in double: 2^52 ---
+  {
+    I i = 1;
+    i <<= 52;
+    auto interval = CGAL::to_interval(i);
+    double lo = interval.first;
+    double hi = interval.second;
+    double expected = std::ldexp(1.0, 52);
+    std::cout << "  2^52: [" << lo << ", " << hi << "]" << std::endl;
+    assert(lo == expected);
+    assert(hi == expected);
+  }
+
+  // --- Zero ---
+  {
+    I i = 0;
+    auto interval = CGAL::to_interval(i);
+    std::cout << "  0: [" << interval.first << ", " << interval.second << "]"
+              << std::endl;
+    assert(interval.first == 0.0);
+    assert(interval.second == 0.0);
+  }
+
+  // --- Large value that is exactly representable: 2^100 ---
+  {
+    I i = 1;
+    i <<= 100;
+    auto interval = CGAL::to_interval(i);
+    double lo = interval.first;
+    double hi = interval.second;
+    double expected = std::ldexp(1.0, 100);
+    std::cout << "  2^100: [" << lo << ", " << hi << "]" << std::endl;
+    assert(lo == expected);
+    assert(hi == expected);
+  }
+
+  std::cout << "All tests passed." << std::endl;
+
+#else
+  std::cout << "Test skipped (Boost.Multiprecision not available)." << std::endl;
+#endif
+
+  return 0;
+}