Two equal lazy numbers but their double approximations are not equal

[stla]

Hello,

I have a lazy number (entry 1,1 of the matrix below) which is equal to the lazy number 1 (I compare these two lazy numbers with ==) but however the double approximation of this number (with relative precision 1e-15) is not equal to 1. How is it possible?

library(lazyNumbers)
# a random 3x3 matrix
set.seed(666L)
M <- matrix(rnorm(9L), nrow = 3L, ncol = 3L)
# the corresponding matrix of lazy numbers
M_lazy <- lazymat(M)
# its inverse
invM_lazy <- lazyInv(M_lazy)
# the product P of the lazy matrix and its inverse
P <- M_lazy %*% invM_lazy
# the identity 3x3 matrix I3
I3 <- diag(3L)
# the double approximation of P is not equal to I3
asDouble(P, prec = 1e-15) == I3 # FALSE for entry 1,1
# however the lazy matrix P is equal to the lazy identity matrix
P == lazymat(I3) # TRUE for all entries

[stla]

Oops sorry, wanted to post in Q&A.

[lrineau]

Can you please show use the code of asDouble?

[stla]

This is a call from R to this C++ function:

Rcpp::NumericVector lvx2nv(lazyVectorXPtr lvx, double prec) {
  lazyVector lv = *(lvx.get());
  const size_t n = lv.size();
  Rcpp::NumericVector nv(n);
  lazyScalar::set_relative_precision_of_to_double(prec);
  for(size_t i = 0; i < n; i++) {
    nv(i) = CGAL::to_double<lazyScalar>(lv[i]);
  }
  return nv;
}

[stla]

Ah no sorry this is the matricial version:

Rcpp::NumericMatrix lmx2nm(lazyMatrixXPtr lmx, double prec) {
  lazyMatrix lm = *(lmx.get());
  const size_t nrow = lm.rows();
  const size_t ncol = lm.cols();
  Rcpp::NumericMatrix nm(nrow, ncol);
  lazyScalar::set_relative_precision_of_to_double(prec);
  for(size_t i = 0; i < nrow; i++) {
    for(size_t j = 0; j < ncol; j++) {
      nm(i, j) = CGAL::to_double<lazyScalar>(lm.coeff(i, j));
    }
  }
  return nm;
}

[stla]

Aahhh I see (more or less): if I call asDouble a second time, then the equality is true!

[stla]

No. The equality becomes true if I call asDouble after the equality test between the lazy matrices:

asDouble(P, prec = 1e-15) == I3 # FALSE for entry 1,1
asDouble(P, prec = 1e-15) == I3 # FALSE for entry 1,1
asDouble(P, prec = 1e-15) == I3 # FALSE for entry 1,1
asDouble(P, prec = 1e-15) == I3 # FALSE for entry 1,1
# however the lazy matrix P is equal to the lazy identity matrix
P == lazymat(I3) # TRUE for all entries
asDouble(P, prec = 1e-15) == I3 # TRUE for all entries

I guess this is because == calls .exact(), right?

[stla]

I really don't understand that:

library(lazyNumbers)

x <- 1 - lazynb(7)/10
asDouble(x, prec = 1e-15) == 0.3 # TRUE
asDouble(x, prec = 1e-15) == 0.3 # TRUE
asDouble(x, prec = 1e-15) == 0.3 # TRUE
asDouble(x, prec = 1e-15) == 0.3 # TRUE
asDouble(x, prec = 1e-16) == 0.3 # FALSE
asDouble(x, prec = 1e-15) == 0.3 # FALSE ???

[stla]

I really don't understand that:
...

Ah, that's because the call with 1e-16 performs a refinement?

Anyway, now I apply .exact before doing the double approximation, and nothing strange happens in this way.

[lrineau]

Sorry, the CGAL team has not been very responsive last week.

Calling .exact() is indeed the only way to get a reproducible double approximation of an exact number. Otherwise, you can have all the surprises you painfully discovered during your attempts.

I hope your attempt to use CGAL lazy numbers is now a success. Let us know otherwise.

[stla]

Yep, my package is on CRAN now :-) No problem so far but they haven't check with all the platforms yet.