simplify headers

Author: pachadotdev

extended-tests/cpp4rtest/R/cpp4r.R

@@ -247,6 +247,14 @@ matrix_add <- function(x, y) {
 	.Call(`_cpp4rtest_matrix_add`, x, y)
 }
 
+matrix_add_coerce_test <- function(x, y) {
+	.Call(`_cpp4rtest_matrix_add_coerce_test`, x, y)
+}
+
+matrix_mixed_add <- function(int_mat, dbl_mat) {
+	.Call(`_cpp4rtest_matrix_mixed_add`, int_mat, dbl_mat)
+}
+
 #' @title Protect functions
 #' @rdname testing-protect
 #' @keywords internal

extended-tests/cpp4rtest/src/cpp4r.cpp

@@ -403,6 +403,20 @@ extern "C" SEXP _cpp4rtest_matrix_add(SEXP x, SEXP y) {
     return cpp4r::as_sexp(matrix_add(cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(x), cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(y)));
   END_CPP4R
 }
+// matrix.h
+cpp4r::doubles_matrix<> matrix_add_coerce_test(const cpp4r::doubles_matrix<>& x, const cpp4r::doubles_matrix<>& y);
+extern "C" SEXP _cpp4rtest_matrix_add_coerce_test(SEXP x, SEXP y) {
+  BEGIN_CPP4R
+    return cpp4r::as_sexp(matrix_add_coerce_test(cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(x), cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(y)));
+  END_CPP4R
+}
+// matrix.h
+cpp4r::doubles_matrix<> matrix_mixed_add(const cpp4r::doubles_matrix<>& int_mat, const cpp4r::doubles_matrix<>& dbl_mat);
+extern "C" SEXP _cpp4rtest_matrix_mixed_add(SEXP int_mat, SEXP dbl_mat) {
+  BEGIN_CPP4R
+    return cpp4r::as_sexp(matrix_mixed_add(cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(int_mat), cpp4r::as_cpp<cpp4r::decay_t<const cpp4r::doubles_matrix<>&>>(dbl_mat)));
+  END_CPP4R
+}
 // protect.h
 void protect_one_(SEXP x, int n);
 extern "C" SEXP _cpp4rtest_protect_one_(SEXP x, SEXP n) {
@@ -915,6 +929,8 @@ static const R_CallMethodDef CallEntries[] = {
     {"_cpp4rtest_mat_mat_create_dimnames",       (DL_FUNC) &_cpp4rtest_mat_mat_create_dimnames,       0},
     {"_cpp4rtest_mat_sexp_copy_dimnames",        (DL_FUNC) &_cpp4rtest_mat_sexp_copy_dimnames,        1},
     {"_cpp4rtest_matrix_add",                    (DL_FUNC) &_cpp4rtest_matrix_add,                    2},
+    {"_cpp4rtest_matrix_add_coerce_test",        (DL_FUNC) &_cpp4rtest_matrix_add_coerce_test,        2},
+    {"_cpp4rtest_matrix_mixed_add",              (DL_FUNC) &_cpp4rtest_matrix_mixed_add,              2},
     {"_cpp4rtest_my_message",                    (DL_FUNC) &_cpp4rtest_my_message,                    2},
     {"_cpp4rtest_my_message_n1",                 (DL_FUNC) &_cpp4rtest_my_message_n1,                 1},
     {"_cpp4rtest_my_message_n1fmt",              (DL_FUNC) &_cpp4rtest_my_message_n1fmt,              1},

extended-tests/cpp4rtest/src/matrix.h

@@ -119,3 +119,40 @@
 
   return result;
 }
+
+// Test function specifically for integer matrix coercion
+// This takes doubles_matrix<> but should accept integer matrices via implicit coercion
+[[cpp4r::register]] cpp4r::doubles_matrix<>
+matrix_add_coerce_test(const cpp4r::doubles_matrix<>& x,
+                       const cpp4r::doubles_matrix<>& y) {
+  int nrow = x.nrow();
+  int ncol = x.ncol();
+
+  cpp4r::writable::doubles_matrix<> result(nrow, ncol);
+
+  for (int i = 0; i < nrow; i++) {
+    for (int j = 0; j < ncol; j++) {
+      result(i, j) = x(i, j) + y(i, j);
+    }
+  }
+
+  return result;
+}
+
+// Test function for integer + double mixed coercion
+[[cpp4r::register]] cpp4r::doubles_matrix<>
+matrix_mixed_add(const cpp4r::doubles_matrix<>& int_mat,
+                 const cpp4r::doubles_matrix<>& dbl_mat) {
+  int nrow = int_mat.nrow();
+  int ncol = int_mat.ncol();
+
+  cpp4r::writable::doubles_matrix<> result(nrow, ncol);
+
+  for (int i = 0; i < nrow; i++) {
+    for (int j = 0; j < ncol; j++) {
+      result(i, j) = int_mat(i, j) + dbl_mat(i, j);
+    }
+  }
+
+  return result;
+}

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

@@ -152,7 +152,7 @@ context("matrix-C++") {
     expect_error(cpp4r::writable::integers_matrix<cpp4r::by_column>(x));
   }
 
-  test_that("as_doubles_matrix coerces integer matrix to double") {
+  test_that("doubles_matrix implicitly coerces integer matrix to double") {
     // Create an integer matrix
     SEXP int_mat = PROTECT(Rf_allocMatrix(INTSXP, 2, 3));
     INTEGER(int_mat)[0] = 1;
@@ -162,8 +162,8 @@ context("matrix-C++") {
     INTEGER(int_mat)[4] = 5;
     INTEGER(int_mat)[5] = 6;
 
-    // Coerce to doubles
-    cpp4r::doubles_matrix<> result = cpp4r::as_doubles_matrix<>(int_mat);
+    // Implicit coercion via constructor
+    cpp4r::doubles_matrix<> result(int_mat);
 
     expect_true(result.nrow() == 2);
     expect_true(result.ncol() == 3);
@@ -180,14 +180,14 @@ context("matrix-C++") {
     UNPROTECT(1);
   }
 
-  test_that("as_doubles_matrix handles NA values correctly") {
+  test_that("doubles_matrix implicit coercion handles NA values correctly") {
     SEXP int_mat = PROTECT(Rf_allocMatrix(INTSXP, 2, 2));
     INTEGER(int_mat)[0] = 1;
     INTEGER(int_mat)[1] = NA_INTEGER;
     INTEGER(int_mat)[2] = 3;
     INTEGER(int_mat)[3] = 4;
 
-    cpp4r::doubles_matrix<> result = cpp4r::as_doubles_matrix<>(int_mat);
+    cpp4r::doubles_matrix<> result(int_mat);
 
     expect_true(result(0, 0) == 1.0);
     expect_true(cpp4r::is_na(result(1, 0)));
@@ -197,7 +197,7 @@ context("matrix-C++") {
     UNPROTECT(1);
   }
 
-  test_that("as_doubles_matrix preserves dimnames") {
+  test_that("doubles_matrix implicit coercion preserves dimnames") {
     // Create integer matrix with dimnames
     SEXP int_mat = PROTECT(Rf_allocMatrix(INTSXP, 2, 2));
     INTEGER(int_mat)[0] = 1;
@@ -218,7 +218,7 @@ context("matrix-C++") {
     SET_VECTOR_ELT(dimnames, 1, colnames);
     Rf_setAttrib(int_mat, R_DimNamesSymbol, dimnames);
 
-    cpp4r::doubles_matrix<> result = cpp4r::as_doubles_matrix<>(int_mat);
+    cpp4r::doubles_matrix<> result(int_mat);
 
     // Check dimnames are preserved
     SEXP result_dimnames = Rf_getAttrib(result.data(), R_DimNamesSymbol);
@@ -235,14 +235,14 @@ context("matrix-C++") {
     UNPROTECT(4);
   }
 
-  test_that("as_doubles_matrix handles logical matrix") {
+  test_that("doubles_matrix implicitly coerces logical matrix") {
     SEXP lgl_mat = PROTECT(Rf_allocMatrix(LGLSXP, 2, 2));
     LOGICAL(lgl_mat)[0] = TRUE;
     LOGICAL(lgl_mat)[1] = FALSE;
     LOGICAL(lgl_mat)[2] = TRUE;
     LOGICAL(lgl_mat)[3] = NA_LOGICAL;
 
-    cpp4r::doubles_matrix<> result = cpp4r::as_doubles_matrix<>(lgl_mat);
+    cpp4r::doubles_matrix<> result(lgl_mat);
 
     expect_true(result(0, 0) == 1.0);
     expect_true(result(1, 0) == 0.0);
@@ -252,109 +252,79 @@ context("matrix-C++") {
     UNPROTECT(1);
   }
 
-  test_that("as_doubles_matrix rejects non-matrix types") {
+  test_that("doubles_matrix rejects incompatible types") {
     SEXP str_mat = PROTECT(Rf_allocMatrix(STRSXP, 2, 2));
-    expect_error(cpp4r::as_doubles_matrix<>(str_mat));
+    expect_error(cpp4r::doubles_matrix<>(str_mat));
     UNPROTECT(1);
   }
 
-  test_that("as_integers_matrix coerces integer-like doubles") {
-    SEXP dbl_mat = PROTECT(Rf_allocMatrix(REALSXP, 2, 2));
-    REAL(dbl_mat)[0] = 1.0;
-    REAL(dbl_mat)[1] = 2.0;
-    REAL(dbl_mat)[2] = 3.0;
-    REAL(dbl_mat)[3] = 4.0;
+  test_that("integers_matrix implicitly coerces logical matrix") {
+    SEXP lgl_mat = PROTECT(Rf_allocMatrix(LGLSXP, 2, 2));
+    LOGICAL(lgl_mat)[0] = TRUE;
+    LOGICAL(lgl_mat)[1] = FALSE;
+    LOGICAL(lgl_mat)[2] = TRUE;
+    LOGICAL(lgl_mat)[3] = NA_LOGICAL;
 
-    cpp4r::integers_matrix<> result = cpp4r::as_integers_matrix<>(dbl_mat);
+    cpp4r::integers_matrix<> result(lgl_mat);
 
     expect_true(result(0, 0) == 1);
-    expect_true(result(1, 0) == 2);
-    expect_true(result(0, 1) == 3);
-    expect_true(result(1, 1) == 4);
-
-    expect_true(cpp4r::detail::r_typeof(result.data()) == INTSXP);
+    expect_true(result(1, 0) == 0);
+    expect_true(result(0, 1) == 1);
+    expect_true(result(1, 1) == NA_INTEGER);
 
     UNPROTECT(1);
   }
 
-  test_that("as_integers_matrix rejects non-integer-like doubles") {
+  test_that("integers_matrix rejects double matrix (narrowing)") {
     SEXP dbl_mat = PROTECT(Rf_allocMatrix(REALSXP, 2, 2));
     REAL(dbl_mat)[0] = 1.0;
-    REAL(dbl_mat)[1] = 2.5;  // Has fractional part!
+    REAL(dbl_mat)[1] = 2.0;
     REAL(dbl_mat)[2] = 3.0;
     REAL(dbl_mat)[3] = 4.0;
 
-    expect_error(cpp4r::as_integers_matrix<>(dbl_mat));
+    // integers_matrix should NOT accept doubles (would be narrowing conversion)
+    expect_error(cpp4r::integers_matrix<>(dbl_mat));
 
     UNPROTECT(1);
   }
 
-  test_that("as_integers_matrix handles NA values") {
+  test_that("complexes_matrix implicitly coerces double matrix") {
     SEXP dbl_mat = PROTECT(Rf_allocMatrix(REALSXP, 2, 2));
     REAL(dbl_mat)[0] = 1.0;
-    REAL(dbl_mat)[1] = NA_REAL;
+    REAL(dbl_mat)[1] = 2.0;
     REAL(dbl_mat)[2] = 3.0;
     REAL(dbl_mat)[3] = 4.0;
 
-    cpp4r::integers_matrix<> result = cpp4r::as_integers_matrix<>(dbl_mat);
+    cpp4r::complexes_matrix<> result(dbl_mat);
 
-    expect_true(result(0, 0) == 1);
-    expect_true(result(1, 0) == NA_INTEGER);
-    expect_true(result(0, 1) == 3);
-    expect_true(result(1, 1) == 4);
+    expect_true(result(0, 0).real() == 1.0);
+    expect_true(result(1, 0).real() == 2.0);
+    expect_true(result(0, 1).real() == 3.0);
+    expect_true(result(1, 1).real() == 4.0);
 
-    UNPROTECT(1);
-  }
+    // Imaginary parts should be 0
+    expect_true(result(0, 0).imag() == 0.0);
+    expect_true(result(1, 1).imag() == 0.0);
 
-  test_that("as_integers_matrix from logical matrix") {
-    SEXP lgl_mat = PROTECT(Rf_allocMatrix(LGLSXP, 2, 2));
-    LOGICAL(lgl_mat)[0] = TRUE;
-    LOGICAL(lgl_mat)[1] = FALSE;
-    LOGICAL(lgl_mat)[2] = TRUE;
-    LOGICAL(lgl_mat)[3] = NA_LOGICAL;
-
-    cpp4r::integers_matrix<> result = cpp4r::as_integers_matrix<>(lgl_mat);
-
-    expect_true(result(0, 0) == 1);
-    expect_true(result(1, 0) == 0);
-    expect_true(result(0, 1) == 1);
-    expect_true(result(1, 1) == NA_INTEGER);
+    expect_true(cpp4r::detail::r_typeof(result.data()) == CPLXSXP);
 
     UNPROTECT(1);
   }
 
-  test_that("as_integers_matrix preserves dimnames") {
-    SEXP dbl_mat = PROTECT(Rf_allocMatrix(REALSXP, 2, 2));
-    REAL(dbl_mat)[0] = 10.0;
-    REAL(dbl_mat)[1] = 20.0;
-    REAL(dbl_mat)[2] = 30.0;
-    REAL(dbl_mat)[3] = 40.0;
-
-    SEXP dimnames = PROTECT(Rf_allocVector(VECSXP, 2));
-    SEXP rownames = PROTECT(Rf_allocVector(STRSXP, 2));
-    SEXP colnames = PROTECT(Rf_allocVector(STRSXP, 2));
-
-    SET_STRING_ELT(rownames, 0, Rf_mkChar("row1"));
-    SET_STRING_ELT(rownames, 1, Rf_mkChar("row2"));
-    SET_STRING_ELT(colnames, 0, Rf_mkChar("col1"));
-    SET_STRING_ELT(colnames, 1, Rf_mkChar("col2"));
-
-    SET_VECTOR_ELT(dimnames, 0, rownames);
-    SET_VECTOR_ELT(dimnames, 1, colnames);
-    Rf_setAttrib(dbl_mat, R_DimNamesSymbol, dimnames);
-
-    cpp4r::integers_matrix<> result = cpp4r::as_integers_matrix<>(dbl_mat);
-
-    // Check dimnames are preserved
-    SEXP result_dimnames = Rf_getAttrib(result.data(), R_DimNamesSymbol);
-    expect_true(result_dimnames != R_NilValue);
+  test_that("complexes_matrix implicitly coerces integer matrix") {
+    SEXP int_mat = PROTECT(Rf_allocMatrix(INTSXP, 2, 2));
+    INTEGER(int_mat)[0] = 1;
+    INTEGER(int_mat)[1] = 2;
+    INTEGER(int_mat)[2] = 3;
+    INTEGER(int_mat)[3] = 4;
 
-    SEXP result_rownames = VECTOR_ELT(result_dimnames, 0);
-    SEXP result_colnames = VECTOR_ELT(result_dimnames, 1);
+    cpp4r::complexes_matrix<> result(int_mat);
 
-    expect_true(strcmp(CHAR(STRING_ELT(result_rownames, 0)), "row1") == 0);
-    expect_true(strcmp(CHAR(STRING_ELT(result_colnames, 1)), "col2") == 0);
+    expect_true(result(0, 0).real() == 1.0);
+    expect_true(result(1, 0).real() == 2.0);
+    expect_true(result(0, 1).real() == 3.0);
+    expect_true(result(1, 1).real() == 4.0);
 
-    UNPROTECT(4);
+    UNPROTECT(1);
   }
 }

extended-tests/cpp4rtest/src/vendor/00-cpp4r-vendoring-info.txt

@@ -1,2 +1,2 @@
 cpp4r version: 0.4.0
-vendored on: 2025-11-30
+vendored on: 2025-12-02