complex tests work, BUT THERE IS A CATCH ERROR I DO NOT GET

Author: pachadotdev

cpp11test/src/grow.cpp

@@ -1,5 +1,5 @@
-#include "cpp11/doubles.hpp"
 #include "cpp11/complexes.hpp"
+#include "cpp11/doubles.hpp"
 
 [[cpp11::register]] cpp11::writable::doubles grow_(R_xlen_t n) {
   cpp11::writable::doubles x;

inst/include/cpp11/complexes.hpp

@@ -1,18 +1,15 @@
 #pragma once
 
-#include <algorithm>         // for min
-#include <array>             // for array
+#include <algorithm>         // for std::transform
 #include <complex>           // for std::complex
-#include <initializer_list>  // for initializer_list
+#include <initializer_list>  // for std::initializer_list
 
-#include "cpp11/R.hpp"                // for SEXP, SEXPREC, Rf_allocVector
-#include "cpp11/as.hpp"               // for as_sexp
-#include "cpp11/attribute_proxy.hpp"  // for attribute_proxy
-#include "cpp11/named_arg.hpp"        // for named_arg
-#include "cpp11/protect.hpp"          // for preserved
-#include "cpp11/r_complex.hpp"        // for r_complex
-#include "cpp11/r_vector.hpp"         // for r_vector, r_vector<>::proxy
-#include "cpp11/sexp.hpp"             // for sexp
+#include "cpp11/R.hpp"  // for SEXP, SEXPREC, Rf_allocVector, COMPLEX, COMPLEX_ELT, SET_COMPLEX_ELT
+#include "cpp11/as.hpp"         // for as_sexp
+#include "cpp11/protect.hpp"    // for safe
+#include "cpp11/r_complex.hpp"  // for r_complex
+#include "cpp11/r_vector.hpp"   // for r_vector, r_vector<>::proxy
+#include "cpp11/sexp.hpp"       // for sexp
 
 namespace cpp11 {
 
@@ -26,7 +23,7 @@ inline SEXPTYPE r_vector<r_complex>::get_sexptype() {
 template <>
 inline typename r_vector<r_complex>::underlying_type r_vector<r_complex>::get_elt(
     SEXP x, R_xlen_t i) {
-  return r_complex(COMPLEX_ELT(x, i));
+  return COMPLEX_ELT(x, i);
 }
 
 template <>
@@ -35,20 +32,20 @@ inline typename r_vector<r_complex>::underlying_type* r_vector<r_complex>::get_p
   if (is_altrep) {
     return nullptr;
   } else {
-    return reinterpret_cast<r_complex*>(COMPLEX(data));
+    return COMPLEX(data);
   }
 }
 
 template <>
 inline typename r_vector<r_complex>::underlying_type const*
 r_vector<r_complex>::get_const_p(bool is_altrep, SEXP data) {
-  return reinterpret_cast<const r_complex*>(COMPLEX_OR_NULL(data));
+  return COMPLEX_OR_NULL(data);
 }
 
 template <>
 inline void r_vector<r_complex>::get_region(SEXP x, R_xlen_t i, R_xlen_t n,
                                             typename r_vector::underlying_type* buf) {
-  COMPLEX_GET_REGION(x, i, n, reinterpret_cast<Rcomplex*>(buf));
+  COMPLEX_GET_REGION(x, i, n, buf);
 }
 
 template <>
@@ -61,9 +58,9 @@ typedef r_vector<r_complex> complexes;
 namespace writable {
 
 template <>
-inline void r_vector<r_complex>::set_elt(SEXP x, R_xlen_t i,
-                                         r_vector::underlying_type value) {
-  COMPLEX(x)[i] = static_cast<Rcomplex>(value);
+inline void r_vector<r_complex>::set_elt(
+    SEXP x, R_xlen_t i, typename cpp11::r_vector<r_complex>::underlying_type value) {
+  COMPLEX(x)[i] = value;
 }
 
 typedef r_vector<r_complex> complexes;
@@ -98,11 +95,8 @@ class r_vector<r_complex>::proxy {
   proxy(SEXP data, R_xlen_t index)
       : data_(data), index_(index), buf_(nullptr), is_altrep_(false) {}
 
-  proxy(SEXP data, R_xlen_t index, r_complex* buf, bool is_altrep)
-      : data_(data),
-        index_(index),
-        buf_(reinterpret_cast<Rcomplex*>(buf)),
-        is_altrep_(is_altrep) {}
+  proxy(SEXP data, R_xlen_t index, Rcomplex* buf, bool is_altrep)
+      : data_(data), index_(index), buf_(buf), is_altrep_(is_altrep) {}
 
   operator r_complex() const {
     if (is_altrep_ && buf_ != nullptr) {
@@ -219,4 +213,20 @@ inline std::complex<T>& operator+=(std::complex<T>& lhs, const cpp11::r_complex&
   return lhs;
 }
 
+// Add constructor for initializer_list
+template <>
+inline r_vector<r_complex>::r_vector(std::initializer_list<r_complex> il) {
+  R_xlen_t size = il.size();
+  SEXP data = PROTECT(Rf_allocVector(CPLXSXP, size));
+  auto it = il.begin();
+  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+    Rcomplex r;
+    r.r = it->real();
+    r.i = it->imag();
+    COMPLEX(data)[i] = r;
+  }
+  UNPROTECT(1);
+  data_ = data;
+}
+
 }  // namespace cpp11

inst/include/cpp11/matrix.hpp

@@ -3,12 +3,11 @@
 #include <iterator>
 #include <string>  // for string
 
-#include "cpp11/R.hpp"          // for SEXP, SEXPREC, R_xlen_t, INT...
-#include "cpp11/r_bool.hpp"     // for r_bool
-#include "cpp11/r_complex.hpp"  // for r_complex
-#include "cpp11/r_string.hpp"   // for r_string
-#include "cpp11/r_vector.hpp"   // for r_vector
-#include "cpp11/sexp.hpp"       // for sexp
+#include "cpp11/R.hpp"         // for SEXP, SEXPREC, R_xlen_t, INT...
+#include "cpp11/r_bool.hpp"    // for r_bool
+#include "cpp11/r_string.hpp"  // for r_string
+#include "cpp11/r_vector.hpp"  // for r_vector
+#include "cpp11/sexp.hpp"      // for sexp
 
 namespace cpp11 {
 
@@ -215,8 +214,6 @@ template <typename S = by_column>
 using logicals_matrix = matrix<r_vector<r_bool>, r_bool, S>;
 template <typename S = by_column>
 using strings_matrix = matrix<r_vector<r_string>, r_string, S>;
-template <typename S = by_column>
-using complex_matrix = matrix<r_vector<r_complex>, r_complex, S>;
 
 namespace writable {
 template <typename S = by_column>
@@ -227,8 +224,6 @@ template <typename S = by_column>
 using logicals_matrix = matrix<r_vector<r_bool>, r_vector<r_bool>::proxy, S>;
 template <typename S = by_column>
 using strings_matrix = matrix<r_vector<r_string>, r_vector<r_string>::proxy, S>;
-template <typename S = by_column>
-using complex_matrix = matrix<r_vector<r_complex>, r_vector<r_complex>::proxy, S>;
 }  // namespace writable
 
 // TODO: Add tests for Matrix class

inst/include/cpp11/r_complex.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <complex>  // for complex
+#include <complex>             // for complex
 #include <ostream>
-#include <type_traits>  // for is_convertible, enable_if
+#include <type_traits>         // for is_convertible, enable_if
 
 #include "R_ext/Arith.h"       // for NA_REAL
 #include "R_ext/Complex.h"     // for Rcomplex
@@ -16,46 +16,120 @@ namespace cpp11 {
 
 class r_complex {
  public:
-  r_complex() : r_(NA_REAL), i_(NA_REAL) {}
-  r_complex(double r, double i) : r_(r), i_(i) {}
-  r_complex(const std::complex<double>& c) : r_(c.real()), i_(c.imag()) {}
-  r_complex(const Rcomplex& rc) : r_(rc.r), i_(rc.i) {}
+  r_complex() = default;
+  r_complex(SEXP data) : data_(data) {}
+  r_complex(double real, double imag) : data_(safe[Rf_allocVector](CPLXSXP, 1)) {
+    COMPLEX(data_)[0].r = real;
+    COMPLEX(data_)[0].i = imag;
+  }
+  r_complex(const std::complex<double>& data) : r_complex(data.real(), data.imag()) {}
+  r_complex(const Rcomplex& data) : r_complex(data.r, data.i) {}
 
-  double real() const { return r_; }
-  double imag() const { return i_; }
+  operator SEXP() const { return data_; }
+  operator sexp() const { return data_; }
+  operator std::complex<double>() const {
+    return {COMPLEX(data_)[0].r, COMPLEX(data_)[0].i};
+  }
+  operator Rcomplex() const {
+    Rcomplex r;
+    r.r = real();
+    r.i = imag();
+    return r;
+  }
 
-  operator std::complex<double>() const { return std::complex<double>(r_, i_); }
-  operator Rcomplex() const { return {r_, i_}; }
+  double real() const { return COMPLEX(data_)[0].r; }
+  double imag() const { return COMPLEX(data_)[0].i; }
 
-  bool operator==(const r_complex& other) const {
-    return r_ == other.r_ && i_ == other.i_;
+  bool operator==(const r_complex& rhs) const {
+    return real() == rhs.real() && imag() == rhs.imag();
   }
 
- private:
-  double r_;
-  double i_;
-};
+  bool operator!=(const r_complex& rhs) const { return !(*this == rhs); }
 
-// Specialization for r_complex
-template <>
-inline void writable::r_vector<r_complex>::push_back(r_complex value) {
-  while (this->length_ >= this->capacity_) {
-    this->reserve(this->capacity_ == 0 ? 1 : this->capacity_ * 2);
+  r_complex& operator+=(const r_complex& rhs) {
+    *this = r_complex(real() + rhs.real(), imag() + rhs.imag());
+    return *this;
+  }
+
+  r_complex& operator-=(const r_complex& rhs) {
+    *this = r_complex(real() - rhs.real(), imag() - rhs.imag());
+    return *this;
+  }
+
+  r_complex& operator*=(const r_complex& rhs) {
+    std::complex<double> lhs = *this;
+    lhs *= static_cast<std::complex<double>>(rhs);
+    *this = r_complex(lhs.real(), lhs.imag());
+    return *this;
+  }
+
+  r_complex& operator/=(const r_complex& rhs) {
+    std::complex<double> lhs = *this;
+    lhs /= static_cast<std::complex<double>>(rhs);
+    *this = r_complex(lhs.real(), lhs.imag());
+    return *this;
+  }
+
+  friend r_complex operator+(r_complex lhs, const r_complex& rhs) {
+    lhs += rhs;
+    return lhs;
   }
 
-  if (this->data_p_ != nullptr) {
-    this->data_p_[this->length_] = static_cast<Rcomplex>(value);
-  } else {
-    set_elt(this->data_, this->length_, value);
+  friend r_complex operator-(r_complex lhs, const r_complex& rhs) {
+    lhs -= rhs;
+    return lhs;
   }
 
-  ++this->length_;
+  friend r_complex operator*(r_complex lhs, const r_complex& rhs) {
+    lhs *= rhs;
+    return lhs;
+  }
+
+  friend r_complex operator/(r_complex lhs, const r_complex& rhs) {
+    lhs /= rhs;
+    return lhs;
+  }
+
+ private:
+  sexp data_ = R_NilValue;
+};
+
+inline SEXP as_sexp(const r_complex& from) {
+  sexp res;
+  unwind_protect([&] {
+    res = Rf_allocVector(CPLXSXP, 1);
+    COMPLEX(res)[0].r = from.real();
+    COMPLEX(res)[0].i = from.imag();
+  });
+
+  return res;
+}
+
+inline SEXP as_sexp(std::initializer_list<r_complex> il) {
+  R_xlen_t size = il.size();
+
+  sexp data;
+  unwind_protect([&] {
+    data = Rf_allocVector(CPLXSXP, size);
+    auto it = il.begin();
+    for (R_xlen_t i = 0; i < size; ++i, ++it) {
+      COMPLEX(data)[i].r = it->real();
+      COMPLEX(data)[i].i = it->imag();
+    }
+  });
+  return data;
 }
 
-// Specialization for std::complex<double>
 template <>
-inline void writable::r_vector<r_complex>::push_back(const std::complex<double>& value) {
-  this->push_back(r_complex(value.real(), value.imag()));
+inline r_complex na() {
+  return r_complex(NA_REAL, NA_REAL);
 }
 
+namespace traits {
+template <>
+struct get_underlying_type<r_complex> {
+  using type = Rcomplex;
+};
+}  // namespace traits
+
 }  // namespace cpp11

inst/include/cpp11/r_vector.hpp

@@ -18,6 +18,7 @@
 #include "cpp11/attribute_proxy.hpp"  // for attribute_proxy
 #include "cpp11/named_arg.hpp"        // for named_arg
 #include "cpp11/protect.hpp"          // for store
+#include "cpp11/r_complex.hpp"        // for r_complex
 #include "cpp11/r_string.hpp"         // for r_string
 #include "cpp11/sexp.hpp"             // for sexp
 
@@ -30,7 +31,6 @@ template <typename T>
 class r_vector;
 }  // namespace writable
 
-// Declarations
 template <typename T>
 class r_vector {
  public:
@@ -60,6 +60,7 @@ class r_vector {
   r_vector(const r_vector& x);
   r_vector(r_vector<T>&& x);
   r_vector(const writable::r_vector<T>& x);
+  r_vector(std::initializer_list<T> il);
   r_vector(named_arg) = delete;
 
   r_vector& operator=(const r_vector& rhs);
@@ -238,7 +239,7 @@ class r_vector : public cpp11::r_vector<T> {
   /// Implemented in `strings.hpp`
   void push_back(const named_arg& value);
   // Implemented in `complexes.hpp`
-  void push_back(const std::complex<double>& value);
+  void push_back(const Rcomplex& value);
   void pop_back();
 
   void resize(R_xlen_t count);

inst/include/cpp11/sexp.hpp

@@ -2,8 +2,8 @@
 
 #include <stddef.h>  // for size_t
 
-#include <string>  // for string, basic_string
 #include <complex>  // for complex
+#include <string>   // for string, basic_string
 
 #include "cpp11/R.hpp"                // for SEXP, SEXPREC, REAL_ELT, R_NilV...
 #include "cpp11/attribute_proxy.hpp"  // for attribute_proxy