passed all test for cplx :D

Author: pachadotdev

cpp11test/src/test-complex.cpp

@@ -357,17 +357,29 @@ context("complexes-C++") {
   }
 
   test_that("comparison operator works") {
-    cpp11::r_complex one{1, 1};
-    cpp11::r_complex two{2, 2};
-    cpp11::r_complex three{3, 3};
-
     using namespace cpp11;
-    cpp11::complexes base({one, two});
-    cpp11::complexes same_values({one, two});
-    cpp11::complexes diff_length({one});
-    cpp11::complexes diff_values({one, three});
 
-    expect_true(base == base);
+    // SEXP base = PROTECT(Rf_allocVector(CPLXSXP, 2));
+    // SEXP same_values = PROTECT(Rf_allocVector(CPLXSXP, 2));
+    // SEXP diff_length = PROTECT(Rf_allocVector(CPLXSXP, 1));
+    // SEXP diff_values = PROTECT(Rf_allocVector(CPLXSXP, 2));
+
+    cpp11::complexes base(Rf_allocVector(CPLXSXP, 2));
+    cpp11::complexes same_values(Rf_allocVector(CPLXSXP, 2));
+    cpp11::complexes diff_length(Rf_allocVector(CPLXSXP, 1));
+    cpp11::complexes diff_values(Rf_allocVector(CPLXSXP, 2));
+
+    COMPLEX(base)[0] = Rcomplex{1, 1};
+    COMPLEX(base)[1] = Rcomplex{2, 2};
+
+    COMPLEX(same_values)[0] = Rcomplex{1, 1};
+    COMPLEX(same_values)[1] = Rcomplex{2, 2};
+
+    COMPLEX(diff_length)[0] = Rcomplex{1, 1};
+
+    COMPLEX(diff_values)[0] = Rcomplex{1, 1};
+    COMPLEX(diff_values)[1] = Rcomplex{3, 3};
+
     expect_true(base == base);
     expect_true(base == same_values);
     expect_true(!(base == diff_length));
@@ -377,6 +389,8 @@ context("complexes-C++") {
     expect_true(!(base != same_values));
     expect_true(base != diff_length);
     expect_true(base != diff_values);
+
+    UNPROTECT(4);
   }
 
   test_that("proxy comparison works symmetrically") {

inst/include/cpp11/complexes.hpp

@@ -229,4 +229,19 @@ inline r_vector<r_complex>::r_vector(std::initializer_list<r_complex> il) {
   data_ = data;
 }
 
+// Comparison operators for r_vector<r_complex>
+template <>
+inline bool operator==(const r_vector<r_complex>& lhs, const r_vector<r_complex>& rhs) {
+  if (lhs.size() != rhs.size()) return false;
+  for (R_xlen_t i = 0; i < lhs.size(); ++i) {
+    if (!(lhs[i] == rhs[i])) return false;
+  }
+  return true;
+}
+
+template <>
+inline bool operator!=(const r_vector<r_complex>& lhs, const r_vector<r_complex>& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace cpp11

inst/include/cpp11/r_complex.hpp

@@ -1,23 +1,26 @@
 #pragma once
 
-#include <complex>             // for complex
-#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/r_vector.hpp"  // for r_vector
-#include "cpp11/sexp.hpp"      // for sexp
+#include <complex>  // for std::complex
+
+#include "cpp11/R.hpp"        // for SEXP, SEXPREC, Rf_mkCharCE, Rf_translateCharUTF8
+#include "cpp11/as.hpp"       // for as_sexp
+#include "cpp11/protect.hpp"  // for unwind_protect, protect, protect::function
+#include "cpp11/sexp.hpp"     // for sexp
 
 namespace cpp11 {
 
 class r_complex {
  public:
-  r_complex() = default;
-  r_complex(SEXP data) : data_(data) {}
+  r_complex() : data_(safe[Rf_allocVector](CPLXSXP, 1)) {
+    COMPLEX(data_)[0].r = 0;
+    COMPLEX(data_)[0].i = 0;
+  }
+  r_complex(SEXP data) : data_(data) {
+    if (data_ == R_NilValue) {
+      data_ = PROTECT(Rf_allocVector(CPLXSXP, 0));
+      UNPROTECT(1);
+    }
+  }
   r_complex(double real, double imag) : data_(safe[Rf_allocVector](CPLXSXP, 1)) {
     COMPLEX(data_)[0].r = real;
     COMPLEX(data_)[0].i = imag;
@@ -28,20 +31,38 @@ class r_complex {
   operator SEXP() const { return data_; }
   operator sexp() const { return data_; }
   operator std::complex<double>() const {
+    if (data_ == R_NilValue || Rf_length(data_) == 0) {
+      return {NA_REAL, NA_REAL};
+    }
     return {COMPLEX(data_)[0].r, COMPLEX(data_)[0].i};
   }
   operator Rcomplex() const {
     Rcomplex r;
-    r.r = real();
-    r.i = imag();
+    if (data_ == R_NilValue || Rf_length(data_) == 0) {
+      r.r = NA_REAL;
+      r.i = NA_REAL;
+    } else {
+      r.r = real();
+      r.i = imag();
+    }
     return r;
   }
 
-  double real() const { return COMPLEX(data_)[0].r; }
-  double imag() const { return COMPLEX(data_)[0].i; }
+  double real() const {
+    if (data_ == R_NilValue || Rf_length(data_) == 0) {
+      return NA_REAL;
+    }
+    return COMPLEX(data_)[0].r;
+  }
+  double imag() const {
+    if (data_ == R_NilValue || Rf_length(data_) == 0) {
+      return NA_REAL;
+    }
+    return COMPLEX(data_)[0].i;
+  }
 
   bool operator==(const r_complex& rhs) const {
-    return real() == rhs.real() && imag() == rhs.imag();
+    return (is_na() && rhs.is_na()) || (real() == rhs.real() && imag() == rhs.imag());
   }
 
   bool operator!=(const r_complex& rhs) const { return !(*this == rhs); }
@@ -90,6 +111,8 @@ class r_complex {
     return lhs;
   }
 
+  bool is_na() const { return R_IsNA(real()) || R_IsNA(imag()); }
+
  private:
   sexp data_ = R_NilValue;
 };