re-add implicit conversion from int matrix to dbl matrix

Author: pachadotdev

extended-tests/Rcppbenchmark/DESCRIPTION

@@ -1,9 +1,9 @@
 Package: Rcppbenchmark
 Type: Package
 Title: Checking speed improvement/worsening with different C++ standards for Rcpp
-Description: A benchmark package to test the speed of various C++ implementations using the Rcpp package.
-    The benchmarks include operations such as cumulative sums, outer products, pairwise distances, grouped
-    means, and bootstrap resampling.
+Description: Benchmark adapted from the official Armadillo documentation to test the speed of different C++ standards
+    when using the cpp4r package. The idea is to check how compiling with GCC or Clang using C++11, C++14, C++17, C++20
+    or C++23 affects the speed of various linear algebra operations.
 Version: 0.1
 Authors@R:
     person("Mauricio", "Vargas Sepulveda", role = c("aut","cre","cph"), 
@@ -16,8 +16,6 @@ Suggests:
 Depends: R(>= 4.0.0)
 Imports: Rcpp
 License: Apache License (>= 2)
-BugReports: https://github.com/USERNAME/PKGNAME/issues
-URL: https://WEBSITE.COM
 RoxygenNote: 7.3.3
 Encoding: UTF-8
 NeedsCompilation: yes

extended-tests/cpp11benchmark/DESCRIPTION

@@ -1,9 +1,9 @@
 Package: cpp11benchmark
 Type: Package
 Title: Checking speed improvement/worsening with different C++ standards for cpp11
-Description: A benchmark package to test the speed of various C++ implementations using the cpp11 package.
-    The benchmarks include operations such as cumulative sums, outer products, pairwise distances, grouped
-    means, and bootstrap resampling.
+Description: Benchmark adapted from the official Armadillo documentation to test the speed of different C++ standards
+    when using the cpp4r package. The idea is to check how compiling with GCC or Clang using C++11, C++14, C++17, C++20
+    or C++23 affects the speed of various linear algebra operations.
 Version: 0.1
 Authors@R:
     person("Mauricio", "Vargas Sepulveda", role = c("aut","cre","cph"), 
@@ -15,8 +15,6 @@ Suggests:
     testthat (>= 3.0.0)
 Depends: R(>= 4.0.0)
 License: Apache License (>= 2)
-BugReports: https://github.com/USERNAME/PKGNAME/issues
-URL: https://WEBSITE.COM
 RoxygenNote: 7.3.3
 Encoding: UTF-8
 LinkingTo: cpp11

extended-tests/cpp4rbenchmark/DESCRIPTION

@@ -1,9 +1,9 @@
 Package: cpp4rbenchmark
 Type: Package
 Title: Checking speed improvement/worsening with different C++ standards for cpp4r
-Description: A benchmark package to test the speed of various C++ implementations using the cpp4r package.
-    The benchmarks include operations such as cumulative sums, outer products, pairwise distances, grouped
-    means, and bootstrap resampling.
+Description: Benchmark adapted from the official Armadillo documentation to test the speed of different C++ standards
+    when using the cpp4r package. The idea is to check how compiling with GCC or Clang using C++11, C++14, C++17, C++20
+    or C++23 affects the speed of various linear algebra operations.
 Version: 0.1
 Authors@R:
     person("Mauricio", "Vargas Sepulveda", role = c("aut","cre","cph"), 
@@ -15,8 +15,6 @@ Suggests:
     testthat (>= 3.0.0)
 Depends: R(>= 4.0.0)
 License: Apache License (>= 2)
-BugReports: https://github.com/USERNAME/PKGNAME/issues
-URL: https://WEBSITE.COM
 RoxygenNote: 7.3.3
 Encoding: UTF-8
 LinkingTo: cpp4r

extended-tests/cpp4rtest/DESCRIPTION

@@ -1,5 +1,7 @@
 Package: cpp4rtest
 Title: A Test Suite and Benchmark Code for 'cpp4r'
+Description: To check cpp4r correctness. The headers are vendored to check which lines of
+    the C++ code are covered by the unit tests.
 Version: 0.1.0
 Authors@R: 
     person(
@@ -9,7 +11,6 @@ Authors@R:
         email = "[email protected]",
         comment = c(ORCID = "0000-0003-1017-7574")
     )
-Description: Provides a test suite and benchmarking code for the 'cpp4r' package.
 License: Apache License (>= 2)
 Encoding: UTF-8
 LinkingTo: testthat

extended-tests/cpp4rtest/src/test-logicals-extended.h

@@ -213,7 +213,7 @@ context("logicals-extended-C++") {
   }
 
   test_that("r_bool NA handling") {
-    cpp4r::writable::logicals x({NA_LOGICAL});
+    cpp4r::writable::logicals x{NA_LOGICAL};
 
     cpp4r::r_bool rb = x[0];
     expect_true(rb == NA_LOGICAL);
@@ -567,7 +567,7 @@ context("logicals-extended-C++") {
 
   test_that("logicals get_sexptype returns LGLSXP") {
     // Verify the SEXPTYPE by creating and checking
-    cpp4r::writable::logicals x({TRUE});
+    cpp4r::writable::logicals x{TRUE};
     SEXP s = x.data();
     expect_true(TYPEOF(s) == LGLSXP);
   }

extended-tests/cpp4rtest/src/test-r_vector_fwd-extended.h

@@ -905,7 +905,7 @@ context("r_vector_fwd-extended-C++") {
   }
 
   test_that("logicals multiple assignments to same element") {
-    cpp4r::writable::logicals x({TRUE});
+    cpp4r::writable::logicals x{TRUE};
 
     // Repeated assignments to exercise set_elt
     x[0] = TRUE;

inst/include/cpp4r/matrix.hpp

@@ -318,6 +318,101 @@ using strings_matrix = matrix<r_vector<r_string>, r_string, S>;
 template <typename S = by_column>
 using complexes_matrix = matrix<r_vector<r_complex>, r_complex, S>;
 
+// Implicit coercion from integer/logical to double
+template <typename S = by_column>
+class numeric_matrix {
+ private:
+  r_vector<double> vector_;
+  int nrow_;
+  int ncol_;
+
+  // Convert integer SEXP to double r_vector
+  static r_vector<double> convert_integer(SEXP x, int nrow, int ncol) {
+    R_xlen_t size = static_cast<R_xlen_t>(nrow) * ncol;
+    SEXP result = PROTECT(Rf_allocMatrix(REALSXP, nrow, ncol));
+    const int* CPP4R_RESTRICT x_ptr = INTEGER(x);
+    double* CPP4R_RESTRICT ret_ptr = REAL(result);
+
+    for (R_xlen_t i = 0; i < size; ++i) {
+      int val = x_ptr[i];
+      ret_ptr[i] = CPP4R_LIKELY(val != NA_INTEGER) ? static_cast<double>(val) : NA_REAL;
+    }
+
+    // Preserve dimnames
+    SEXP dimnames = Rf_getAttrib(x, R_DimNamesSymbol);
+    if (CPP4R_UNLIKELY(dimnames != R_NilValue)) {
+      Rf_setAttrib(result, R_DimNamesSymbol, dimnames);
+    }
+
+    UNPROTECT(1);
+    return r_vector<double>(result);
+  }
+
+  // Convert logical SEXP to double r_vector
+  static r_vector<double> convert_logical(SEXP x, int nrow, int ncol) {
+    R_xlen_t size = static_cast<R_xlen_t>(nrow) * ncol;
+    SEXP result = PROTECT(Rf_allocMatrix(REALSXP, nrow, ncol));
+    const int* CPP4R_RESTRICT x_ptr = LOGICAL(x);
+    double* CPP4R_RESTRICT ret_ptr = REAL(result);
+
+    for (R_xlen_t i = 0; i < size; ++i) {
+      int val = x_ptr[i];
+      ret_ptr[i] = CPP4R_LIKELY(val != NA_LOGICAL) ? static_cast<double>(val) : NA_REAL;
+    }
+
+    // Preserve dimnames
+    SEXP dimnames = Rf_getAttrib(x, R_DimNamesSymbol);
+    if (CPP4R_UNLIKELY(dimnames != R_NilValue)) {
+      Rf_setAttrib(result, R_DimNamesSymbol, dimnames);
+    }
+
+    UNPROTECT(1);
+    return r_vector<double>(result);
+  }
+
+  // Coerce SEXP to double r_vector (zero-copy if already double)
+  static r_vector<double> coerce_to_double(SEXP x, int nrow, int ncol) {
+    SEXPTYPE type = detail::r_typeof(x);
+    if (type == REALSXP) {
+      return r_vector<double>(x);  // Zero-copy
+    } else if (type == INTSXP) {
+      return convert_integer(x, nrow, ncol);
+    } else if (type == LGLSXP) {
+      return convert_logical(x, nrow, ncol);
+    }
+    throw type_error(REALSXP, type);
+  }
+
+ public:
+  using underlying_type = double;
+
+  numeric_matrix(SEXP x)
+      : nrow_(Rf_nrows(x)),
+        ncol_(Rf_ncols(x)),
+        vector_(coerce_to_double(x, nrow_, ncol_)) {}
+
+  // Allow construction from doubles_matrix (zero-copy)
+  numeric_matrix(const doubles_matrix<S>& m)
+      : vector_(m.vector()), nrow_(m.nrow()), ncol_(m.ncol()) {}
+
+  CPP4R_ALWAYS_INLINE int nrow() const noexcept { return nrow_; }
+  CPP4R_ALWAYS_INLINE int ncol() const noexcept { return ncol_; }
+  R_xlen_t size() const { return vector_.size(); }
+  SEXP data() const { return vector_.data(); }
+  operator SEXP() const { return SEXP(vector_); }
+
+  // Convert to doubles_matrix for full matrix functionality
+  operator doubles_matrix<S>() const { return doubles_matrix<S>(vector_.data()); }
+
+  CPP4R_ALWAYS_INLINE double operator()(int row, int col) const {
+    return vector_[row + (col * nrow_)];
+  }
+
+  CPP4R_ALWAYS_INLINE const double* CPP4R_RESTRICT data_ptr() const noexcept {
+    return vector_.data_ptr();
+  }
+};
+
 namespace writable {
 template <typename S = by_column>
 using doubles_matrix = matrix<r_vector<double>, typename r_vector<double>::reference, S>;