trying to add push_back for cplx

Author: pachadotdev

inst/include/cpp11/complexes.hpp

@@ -26,7 +26,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 COMPLEX_ELT(x, i);
+  return r_complex(COMPLEX_ELT(x, i));
 }
 
 template <>
@@ -35,20 +35,20 @@ inline typename r_vector<r_complex>::underlying_type* r_vector<r_complex>::get_p
   if (is_altrep) {
     return nullptr;
   } else {
-    return COMPLEX(data);
+    return reinterpret_cast<r_complex*>(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 COMPLEX_OR_NULL(data);
+  return reinterpret_cast<const r_complex*>(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, buf);
+  COMPLEX_GET_REGION(x, i, n, reinterpret_cast<Rcomplex*>(buf));
 }
 
 template <>
@@ -63,7 +63,7 @@ namespace writable {
 template <>
 inline void r_vector<r_complex>::set_elt(
     SEXP x, R_xlen_t i, typename r_vector<r_complex>::underlying_type value) {
-  SET_COMPLEX_ELT(x, i, value);
+  SET_COMPLEX_ELT(x, i, static_cast<Rcomplex>(value));
 }
 
 typedef r_vector<r_complex> complexes;

inst/include/cpp11/r_complex.hpp

@@ -4,151 +4,60 @@
 #include <ostream>
 #include <type_traits>  // for is_convertible, enable_if
 
-#include "R_ext/Arith.h"      // for NA_REAL
-#include "R_ext/Complex.h"    // for Rcomplex
-#include "cpp11/R.hpp"        // for SEXP, SEXPREC, ...
-#include "cpp11/as.hpp"       // for as_sexp
-#include "cpp11/protect.hpp"  // for unwind_protect, preserved
-#include "cpp11/sexp.hpp"     // for sexp
+#include "R_ext/Arith.h"       // for NA_REAL
+#include "R_ext/Complex.h"     // for Rcomplex
+#include "cpp11/R.hpp"         // for SEXP, SEXPREC, ...
+#include "cpp11/as.hpp"        // for as_sexp
+#include "cpp11/protect.hpp"   // for unwind_protect, preserved
+#include "cpp11/r_vector.hpp"  // for r_vector
+#include "cpp11/sexp.hpp"      // for sexp
 
 namespace cpp11 {
 
 class r_complex {
  public:
-  r_complex() = default;
+  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(SEXP data) {
-    if (Rf_isComplex(data) && Rf_xlength(data) == 1) {
-      Rcomplex elt = COMPLEX_ELT(data, 0);
-      real_ = elt.r;
-      imag_ = elt.i;
-    } else {
-      throw std::invalid_argument("Invalid r_complex value");
-    }
-  }
-
-  r_complex(double real, double imag) : real_(real), imag_(imag) {}
-
-  explicit r_complex(Rcomplex value) : real_(value.r), imag_(value.i) {}
-  explicit r_complex(std::complex<double> value)
-      : real_(value.real()), imag_(value.imag()) {}
-
-  explicit operator Rcomplex() const { return Rcomplex{real_, imag_}; }
-  explicit operator std::complex<double>() const {
-    return std::complex<double>(real_, imag_);
-  }
-
-  double real() const { return real_; }
-  double imag() const { return imag_; }
-
-  r_complex& operator+=(const r_complex& other) {
-    real_ += other.real_;
-    imag_ += other.imag_;
-    return *this;
-  }
-
-  r_complex& operator-=(const r_complex& other) {
-    real_ -= other.real_;
-    imag_ -= other.imag_;
-    return *this;
-  }
+  double real() const { return r_; }
+  double imag() const { return i_; }
 
-  r_complex& operator*=(const r_complex& other) {
-    double r = real_ * other.real_ - imag_ * other.imag_;
-    double i = real_ * other.imag_ + imag_ * other.real_;
-    real_ = r;
-    imag_ = i;
-    return *this;
-  }
+  operator std::complex<double>() const { return std::complex<double>(r_, i_); }
+  operator Rcomplex() const { return {r_, i_}; }
 
-  r_complex& operator/=(const r_complex& other) {
-    double denom = other.real_ * other.real_ + other.imag_ * other.imag_;
-    double r = (real_ * other.real_ + imag_ * other.imag_) / denom;
-    double i = (imag_ * other.real_ - real_ * other.imag_) / denom;
-    real_ = r;
-    imag_ = i;
-    return *this;
+  bool operator==(const r_complex& other) const {
+    return r_ == other.r_ && i_ == other.i_;
   }
 
  private:
-  double real_;
-  double imag_;
+  double r_;
+  double i_;
 };
 
-inline r_complex operator+(r_complex lhs, const r_complex& rhs) {
-  lhs += rhs;
-  return lhs;
-}
-
-inline r_complex operator-(r_complex lhs, const r_complex& rhs) {
-  lhs -= rhs;
-  return lhs;
-}
-
-inline r_complex operator*(r_complex lhs, const r_complex& rhs) {
-  lhs *= rhs;
-  return lhs;
-}
-
-inline r_complex operator/(r_complex lhs, const r_complex& rhs) {
-  lhs /= rhs;
-  return lhs;
-}
-
-inline bool operator==(const r_complex& x, const r_complex& y) {
-  return (x.real() == y.real()) && (x.imag() == y.imag());
-}
-
-inline std::ostream& operator<<(std::ostream& os, const r_complex& value) {
-  os << value.real() << "+" << value.imag() << "i";
-  return os;
-}
-
+// Specialization for r_complex
 template <>
-inline r_complex na() {
-  return r_complex(NA_REAL, NA_REAL);
-}
-
-template <>
-inline bool is_na(const r_complex& x) {
-  return ISNA(x.real()) || ISNA(x.imag());
-}
-
-template <typename T>
-struct is_r_complex : std::false_type {};
+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);
+  }
 
-template <>
-struct is_r_complex<r_complex> : std::true_type {};
+  Rcomplex r_value = static_cast<Rcomplex>(value);
 
-template <typename T, typename R = void>
-using enable_if_r_complex = std::enable_if_t<is_r_complex<T>::value, R>;
+  if (this->data_p_ != nullptr) {
+    this->data_p_[this->length_] = r_value;
+  } else {
+    this->set_elt(this->data_, this->length_, r_value);
+  }
 
-template <typename T>
-enable_if_r_complex<T, SEXP> as_sexp(T from) {
-  SEXP res = PROTECT(Rf_allocVector(CPLXSXP, 1));
-  Rcomplex* r = COMPLEX(res);
-  r[0].r = from.real();
-  r[0].i = from.imag();
-  UNPROTECT(1);
-  return res;
+  ++this->length_;
 }
 
-namespace traits {
+// Specialization for std::complex<double>
 template <>
-struct get_underlying_type<r_complex> {
-  using type = Rcomplex;
-};
-}  // namespace traits
-
-// Define operator+ for std::complex<double> and r_complex
-inline std::complex<double> operator+(const std::complex<double>& lhs,
-                                      const r_complex& rhs) {
-  return std::complex<double>(lhs.real() + rhs.real(), lhs.imag() + rhs.imag());
-}
-
-inline std::complex<double> operator+(const r_complex& lhs,
-                                      const std::complex<double>& rhs) {
-  return std::complex<double>(lhs.real() + rhs.real(), lhs.imag() + rhs.imag());
+inline void writable::r_vector<r_complex>::push_back(const std::complex<double>& value) {
+  this->push_back(r_complex(value.real(), value.imag()));
 }
 
 }  // namespace cpp11