Number_types: fix Lazy_exact_nt operator<< to write exact() value

Change operator<< for Lazy_exact_nt to output a.exact() instead of
to_double(a). The old to_double() conversion loses precision and breaks
round-trip save/load of exact kernel coordinates (issue #135).

The corresponding operator>> already uses read_float_or_quotient() which
handles both floating-point and rational (n/d) formats, so no changes
are needed on the input side.

Add Lazy_exact_nt_io.cpp regression test verifying round-trip I/O for
rationals, integers, negative values, computed sums, large values, and zero.

Author: RajdeepKushwaha5

Number_types/doc/Number_types/CGAL/Lazy_exact_nt.h

@@ -111,7 +111,9 @@ static double get_relative_precision_of_to_double();
 }; /* end Lazy_exact_nt */
 
 /*!
-writes `m` to ostream `out` in an interval format.
+writes the exact value `m.exact()` to ostream `out`.
+This enables round-trip save/load of `Lazy_exact_nt` values without
+loss of precision: `operator>>` reconstructs the same exact number.
 \relates Lazy_exact_nt
 */
 std::ostream& operator<<(std::ostream& out, const Lazy_exact_nt<NT>& m);

Number_types/include/CGAL/Lazy_exact_nt.h

@@ -1303,7 +1303,12 @@ const Lazy_exact_nt<ET> & y){
 template <typename ET>
 std::ostream &
 operator<< (std::ostream & os, const Lazy_exact_nt<ET> & a)
-{ return os << CGAL_NTS to_double(a); }
+{
+  // Output the exact value so that operator>> can reconstruct the same number.
+  // Using to_double() (as was done before issue #135 was fixed) loses precision
+  // and breaks round-trip save/load of exact kernel coordinates.
+  return os << a.exact();
+}
 
 template <typename ET>
 std::istream &

Number_types/test/Number_types/CMakeLists.txt

@@ -30,6 +30,7 @@ create_single_source_cgal_program("Interval_nt_new.cpp")
 create_single_source_cgal_program("ioformat.cpp")
 create_single_source_cgal_program("known_bit_size_integers.cpp")
 create_single_source_cgal_program("Lazy_exact_nt.cpp")
+create_single_source_cgal_program("Lazy_exact_nt_io.cpp")
 create_single_source_cgal_program("Lazy_exact_nt_new.cpp")
 create_single_source_cgal_program("leda_bigfloat.cpp")
 create_single_source_cgal_program("leda_bigfloat_interval.cpp")

Number_types/test/Number_types/Lazy_exact_nt_io.cpp

@@ -0,0 +1,100 @@
+// Regression test for issue #135:
+// Lazy_exact_nt operator<< used to_double(), losing precision and breaking
+// round-trip save/load of exact kernel coordinates.
+
+#include <CGAL/Lazy_exact_nt.h>
+#include <CGAL/Gmpq.h>
+
+#include <cassert>
+#include <iostream>
+#include <sstream>
+
+typedef CGAL::Lazy_exact_nt<CGAL::Gmpq> Lazy_nt;
+
+int main()
+{
+  // Test 1: exact rational round-trip
+  {
+    std::cout << "Test 1: round-trip of 1/3" << std::endl;
+    Lazy_nt a(CGAL::Gmpq(1, 3));
+    std::ostringstream oss;
+    oss << a;
+    // Should output "1/3", not "0.333333..."
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\", read back equal" << std::endl;
+  }
+
+  // Test 2: integer value
+  {
+    std::cout << "Test 2: round-trip of 42" << std::endl;
+    Lazy_nt a(42);
+    std::ostringstream oss;
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 3: negative rational
+  {
+    std::cout << "Test 3: round-trip of -5/7" << std::endl;
+    Lazy_nt a(CGAL::Gmpq(-5, 7));
+    std::ostringstream oss;
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 4: value that cannot be represented exactly as double
+  // 1/3 + 1/7 = 10/21, to_double() would give 0.476190476190...
+  {
+    std::cout << "Test 4: round-trip of computed 1/3 + 1/7 = 10/21" << std::endl;
+    Lazy_nt a(CGAL::Gmpq(1, 3));
+    Lazy_nt b(CGAL::Gmpq(1, 7));
+    Lazy_nt c = a + b;
+    std::ostringstream oss;
+    oss << c;
+    std::istringstream iss(oss.str());
+    Lazy_nt d;
+    iss >> d;
+    assert(c == d);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 5: very large rational that would lose precision as double
+  {
+    std::cout << "Test 5: round-trip of large rational" << std::endl;
+    Lazy_nt a(CGAL::Gmpq(CGAL::Gmpz("99999999999999999999"), CGAL::Gmpz("100000000000000000007")));
+    std::ostringstream oss;
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 6: zero
+  {
+    std::cout << "Test 6: round-trip of 0" << std::endl;
+    Lazy_nt a(0);
+    std::ostringstream oss;
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  std::cout << "All tests passed." << std::endl;
+  return 0;
+}