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

Number_types/doc/Number_types/CGAL/Lazy_exact_nt.h

@@ -111,7 +111,15 @@ static double get_relative_precision_of_to_double();
 }; /* end Lazy_exact_nt */
 
 /*!
-writes `m` to ostream `out` in an interval format.
+writes `m` to ostream `out`. By default a `double` approximation
+(`to_double(m)`) is written, as historically. After calling
+`CGAL::IO::set_exact_mode(out)`, the exact value `m.exact()` is written instead,
+using `NT`'s own output operator. When `NT` has an exact stream representation,
+such as a rational type (`Exact_rational`, `Gmpq`), `operator>>` then reconstructs
+the same exact number, so exact values can be saved and reloaded without loss. For
+`NT` whose output operator writes an approximation (for example `CORE::Expr`, which
+writes a decimal), exact mode writes that approximation and the round-trip is not
+exact.
 \relates Lazy_exact_nt
 */
 std::ostream& operator<<(std::ostream& out, const Lazy_exact_nt<NT>& m);
@@ -122,5 +130,31 @@ reads a `NT` from `in`, then converts it to a `Lazy_exact_nt<NT>`.
 */
 std::istream& operator>>(std::istream& in, Lazy_exact_nt<NT>& m);
 
+namespace IO {
+
+/*!
+makes `operator<<` write `Lazy_exact_nt` values on the stream `s` through their
+exact value (`NT`'s output operator). The round-trip through `operator>>` is exact
+when `NT` has an exact stream representation, such as a rational type; it is not
+exact for `NT` whose output writes an approximation, such as `CORE::Expr`. Returns
+the previous state. Mirrors `CGAL::IO::set_pretty_mode()`.
+\relates Lazy_exact_nt
+*/
+bool set_exact_mode(std::ios& s);
+
+/*!
+makes `operator<<` write `Lazy_exact_nt` values on the stream `s` through
+`to_double()`, which is the default. Returns the previous state.
+\relates Lazy_exact_nt
+*/
+bool set_lossy_mode(std::ios& s);
+
+/*!
+returns `true` if the stream `s` is in exact-output mode for `Lazy_exact_nt`.
+\relates Lazy_exact_nt
+*/
+bool is_exact_mode(std::ios& s);
+
+} /* end namespace IO */
 
 } /* end namespace CGAL */

Number_types/include/CGAL/Lazy_exact_nt.h

@@ -1300,10 +1300,66 @@ const Lazy_exact_nt<ET> & y){
   return CGAL::Max<Lazy_exact_nt<ET> > ()(x,y);
 }
 
+namespace IO {
+
+// Per-stream flag controlling how Lazy_exact_nt is written by operator<<. By
+// default (flag unset) the value is written via to_double(), the historical
+// behaviour. After set_exact_mode(s), operator<< writes the exact() value; the
+// round-trip through operator>> is then exact for ET with an exact stream
+// representation such as a rational type, but not for ET whose operator<< writes
+// an approximation such as CORE::Expr (issue #135). This mirrors set_pretty_mode()
+// / is_pretty().
+namespace internal {
+inline int lazy_exact_nt_exact_output_index()
+{
+  static const int index = std::ios_base::xalloc();
+  return index;
+}
+} // namespace internal
+
+// Sets the stream s so that operator<< writes Lazy_exact_nt values through their
+// exact value. operator>> then reconstructs the same number when ET has an exact
+// stream representation (e.g. a rational type); this is not exact for ET whose
+// operator<< writes an approximation (e.g. CORE::Expr). Returns the previous state.
+inline bool set_exact_mode(std::ios& s)
+{
+  const bool old = s.iword(internal::lazy_exact_nt_exact_output_index()) != 0;
+  s.iword(internal::lazy_exact_nt_exact_output_index()) = 1;
+  return old;
+}
+
+// Sets the stream s so that operator<< writes Lazy_exact_nt values through
+// to_double() (the default). Returns the previous state.
+inline bool set_lossy_mode(std::ios& s)
+{
+  const bool old = s.iword(internal::lazy_exact_nt_exact_output_index()) != 0;
+  s.iword(internal::lazy_exact_nt_exact_output_index()) = 0;
+  return old;
+}
+
+// Returns true if s is in exact-output mode for Lazy_exact_nt.
+inline bool is_exact_mode(std::ios& s)
+{
+  return s.iword(internal::lazy_exact_nt_exact_output_index()) != 0;
+}
+
+} // namespace IO
+
 template <typename ET>
 std::ostream &
 operator<< (std::ostream & os, const Lazy_exact_nt<ET> & a)
-{ return os << CGAL_NTS to_double(a); }
+{
+  // By default output a double, the historical behaviour. After
+  // CGAL::IO::set_exact_mode(os), output the exact value via ET's own operator<<.
+  // The round-trip through operator>> is exact only when ET has an exact stream
+  // representation (e.g. a rational type such as Exact_rational or Gmpq); it is
+  // not exact for ET whose operator<< writes an approximation (e.g. CORE::Expr,
+  // which writes a decimal). Keeping the default keeps this non-breaking. See
+  // issue #135.
+  if (IO::is_exact_mode(os))
+    return os << a.exact();
+  return os << CGAL_NTS to_double(a);
+}
 
 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,179 @@
+// Regression test for issue #135:
+// Lazy_exact_nt operator<< used to_double(), losing precision and breaking
+// round-trip save/load of exact kernel coordinates.
+//
+// The default operator<< still writes to_double(). CGAL::IO::set_exact_mode(os)
+// switches it to write the exact value. For a rational backend (Exact_rational)
+// that round-trips losslessly through operator>>; for CORE::Expr, whose operator<<
+// writes a decimal approximation, exact mode is not lossless (see Test 9).
+
+#include <CGAL/Lazy_exact_nt.h>
+#include <CGAL/Exact_rational.h>
+
+#include <CGAL/CORE_Expr.h>
+
+#include <cassert>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+typedef CGAL::Lazy_exact_nt<CGAL::Exact_rational> 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::Exact_rational(1, 3));
+    std::ostringstream oss;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a;
+    // Should output "1/3", not "0.333333..."
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(iss);
+    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;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(iss);
+    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::Exact_rational(-5, 7));
+    std::ostringstream oss;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(iss);
+    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::Exact_rational(1, 3));
+    Lazy_nt b(CGAL::Exact_rational(1, 7));
+    Lazy_nt c = a + b;
+    std::ostringstream oss;
+    CGAL::IO::set_exact_mode(oss);
+    oss << c;
+    std::istringstream iss(oss.str());
+    Lazy_nt d;
+    iss >> d;
+    assert(iss);
+    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;
+    CGAL::Exact_rational big;
+    std::istringstream bigin("99999999999999999999/100000000000000000007");
+    bigin >> big;
+    assert(bigin);
+    Lazy_nt a(big);
+    std::ostringstream oss;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(iss);
+    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;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a;
+    std::istringstream iss(oss.str());
+    Lazy_nt b;
+    iss >> b;
+    assert(iss);
+    assert(a == b);
+    std::cout << "  OK: wrote \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 7: the default (no set_exact_mode) still writes a double, so existing
+  // behaviour and user code are unchanged. Issue #135 must remain opt-in.
+  {
+    std::cout << "Test 7: default output is still to_double" << std::endl;
+    Lazy_nt a(CGAL::Exact_rational(1, 3));
+    std::ostringstream oss;
+    oss << a; // no set_exact_mode: lossy, historical behaviour
+    const std::string s = oss.str();
+    assert(s.find('/') == std::string::npos); // a double, not "1/3"
+    std::cout << "  OK: default wrote \"" << s << "\" (double, unchanged)" << std::endl;
+  }
+
+  // Test 8: set_lossy_mode reverts to the default double output, and the mode
+  // setters report the previous state (like set_pretty_mode).
+  {
+    std::cout << "Test 8: set_lossy_mode reverts, setters report previous state" << std::endl;
+    Lazy_nt a(CGAL::Exact_rational(1, 3));
+    std::ostringstream oss;
+    const bool was_exact_before = CGAL::IO::set_exact_mode(oss); // default is lossy
+    assert(!was_exact_before);
+    assert(CGAL::IO::is_exact_mode(oss));
+    const bool was_exact_after = CGAL::IO::set_lossy_mode(oss);   // back to lossy
+    assert(was_exact_after);
+    assert(!CGAL::IO::is_exact_mode(oss));
+    oss << a; // lossy again: a double, not "1/3"
+    assert(oss.str().find('/') == std::string::npos);
+    std::cout << "  OK: reverted to \"" << oss.str() << "\"" << std::endl;
+  }
+
+  // Test 9: CORE::Expr regression. Exact mode is lossless only for backends whose
+  // operator<< writes an exact representation. CORE::Expr::operator<< writes a
+  // decimal approximation, so exact mode is NOT lossless for it. We check the
+  // documented behaviour: the default still writes a double, and exact mode writes
+  // exact()'s (approximate) representation, which parses.
+  {
+    typedef CGAL::Lazy_exact_nt<CORE::Expr> Lazy_core;
+    std::cout << "Test 9: CORE::Expr exact mode is approximate, not lossless" << std::endl;
+    Lazy_core a = Lazy_core(1) / Lazy_core(3); // 1/3
+
+    std::ostringstream def;
+    def << a; // default: a double, unchanged
+    assert(def.str().find('/') == std::string::npos);
+
+    std::ostringstream oss;
+    CGAL::IO::set_exact_mode(oss);
+    oss << a; // exact mode: CORE::Expr's decimal, parses but is not exact
+    std::istringstream iss(oss.str());
+    Lazy_core b;
+    iss >> b;
+    assert(iss);
+    std::cout << "  OK: default \"" << def.str() << "\", exact-mode \""
+              << oss.str() << "\" (approximate for CORE::Expr)" << std::endl;
+  }
+
+  std::cout << "All tests passed." << std::endl;
+  return 0;
+}
+