feat: add np.full, np.flatnonzero, np.isin(int), np.unwrap

- Rename full_like → full (raw pointer API) to match numpy naming
- pylike full_like wrapper kept unchanged (correctly implements full_like semantics)
- Make isin and intersect1d templates for generic type support
- Add flatnonzero template
- Add unwrap with numpy-compatible algorithm (cumulative correction
  added to original values, avoiding floating-point error propagation)
- Add corresponding pybind11 wrappers and test bindings
- Add tests: test_full, test_flatnonzero, test_isin_int, test_unwrap
- Test count: 460 → 466

Author: peng.li24

numpy/core.h

@@ -45,9 +45,9 @@ inline void ones_like(T* dst, size_t n) {
     std::fill_n(dst, n, T(1));
 }
 
-/// numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)
+/// numpy.full(shape, fill_value, dtype=None, order='C')
 template<typename T>
-inline void full_like(T* dst, size_t n, T fill_value) {
+inline void full(T* dst, size_t n, T fill_value) {
     std::fill_n(dst, n, fill_value);
 }
 
@@ -662,18 +662,29 @@ inline ptrdiff_t argmin(const T* data, size_t n) {
 // ============================================================================
 
 /// numpy.isin(element, test_elements, assume_unique=False, invert=False)
-inline void isin(const double* arr, bool* dst, size_t n,
-                  const double* values, size_t nv) {
-    std::unordered_set<double> vs(values, values + nv);
+template<typename T>
+inline void isin(const T* arr, bool* dst, size_t n,
+                  const T* values, size_t nv) {
+    std::unordered_set<T> vs(values, values + nv);
     for (size_t i = 0; i < n; ++i) dst[i] = vs.count(arr[i]) > 0;
 }
 
+/// numpy.flatnonzero(a)
+template<typename T>
+inline std::vector<size_t> flatnonzero(const T* arr, size_t n) {
+    std::vector<size_t> idx;
+    for (size_t i = 0; i < n; ++i)
+        if (arr[i] != T(0)) idx.push_back(i);
+    return idx;
+}
+
 /// numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)
-inline std::vector<double> intersect1d(const double* a, size_t na,
-                                        const double* b, size_t nb) {
-    std::unordered_set<double> sa(a, a + na), sb(b, b + nb);
-    std::vector<double> inter;
-    for (double v : sa)
+template<typename T>
+inline std::vector<T> intersect1d(const T* a, size_t na,
+                                   const T* b, size_t nb) {
+    std::unordered_set<T> sa(a, a + na), sb(b, b + nb);
+    std::vector<T> inter;
+    for (T v : sa)
         if (sb.count(v)) inter.push_back(v);
     return inter;
 }
@@ -707,6 +718,26 @@ inline double safe_divide(double a, double b, double default_val = 0.0) {
     return b == 0.0 ? default_val : a / b;
 }
 
+/// numpy.unwrap(p, discont=None, axis=-1)
+/// 1D only: unwrap phase angles by correcting jumps > discont.
+template<typename T>
+inline void unwrap(const T* src, T* dst, size_t n, T discont = T(M_PI)) {
+    if (n == 0) return;
+    T period = T(2) * discont;
+    dst[0] = src[0];
+    T cum_correct = T(0);
+    for (size_t i = 1; i < n; ++i) {
+        T dd = src[i] - src[i - 1];
+        T ph_correct = T(0);
+        if (std::abs(dd) >= discont) {
+            T ddmod = dd - std::round(dd / period) * period;
+            ph_correct = ddmod - dd;
+        }
+        cum_correct += ph_correct;
+        dst[i] = src[i] + cum_correct;
+    }
+}
+
 // ============================================================================
 // astype conversions
 // ============================================================================

pycpp/core_py.h

@@ -43,7 +43,7 @@ template<typename T>
 py::array_t<T> full_like(const py::array_t<T>& arr, T fill_value) {
     auto buf = arr.request();
     py::array_t<T> result(buf.shape);
-    full_like(static_cast<T*>(result.request().ptr), buf.size, fill_value);
+    numpy::full(static_cast<T*>(result.request().ptr), buf.size, fill_value);
     return result;
 }
 
@@ -67,6 +67,13 @@ inline py::array_t<double> ones(const std::vector<py::ssize_t>& shape) {
     return result;
 }
 
+/// numpy.full(shape, fill_value, dtype=float, order='C')
+inline py::array_t<double> full(const std::vector<py::ssize_t>& shape, double fill_value) {
+    py::array_t<double> result(shape);
+    numpy::full(static_cast<double*>(result.request().ptr), result.request().size, fill_value);
+    return result;
+}
+
 // Bool specializations
 // NOTE: _bool suffix — dtype-specific wrappers; pybind11 cannot deduce template
 // argument from a Python dtype keyword, so each dtype needs its own binding.
@@ -870,12 +877,42 @@ py::ssize_t argmin(const py::array_t<T>& arr) {
 inline py::array_t<bool> isin(const py::array_t<double>& arr, const std::vector<double>& values) {
     auto buf = arr.request();
     py::array_t<bool> result(buf.shape);
-    isin(static_cast<const double*>(buf.ptr),
+    numpy::isin(static_cast<const double*>(buf.ptr),
                 static_cast<bool*>(result.request().ptr), buf.size,
                 values.data(), values.size());
     return result;
 }
 
+/// isin with int test_elements (e.g. np.isin(arr, [1, 3, 5]))
+inline py::array_t<bool> isin(const py::array_t<double>& arr, const std::vector<int>& values) {
+    auto buf = arr.request();
+    py::array_t<bool> result(buf.shape);
+    std::vector<double> dv(values.begin(), values.end());
+    numpy::isin(static_cast<const double*>(buf.ptr),
+                static_cast<bool*>(result.request().ptr), buf.size,
+                dv.data(), dv.size());
+    return result;
+}
+
+/// numpy.flatnonzero(a)
+inline py::array_t<py::ssize_t> flatnonzero(const py::array_t<double>& arr) {
+    auto buf = arr.request();
+    auto idx = numpy::flatnonzero(static_cast<const double*>(buf.ptr), buf.size);
+    py::array_t<py::ssize_t> result(idx.size());
+    std::copy(idx.begin(), idx.end(),
+              static_cast<py::ssize_t*>(result.request().ptr));
+    return result;
+}
+
+/// numpy.unwrap(p, discont=None, axis=-1) — 1D only
+inline py::array_t<double> unwrap(const py::array_t<double>& arr, double discont = M_PI) {
+    auto buf = arr.request();
+    py::array_t<double> result(buf.shape);
+    numpy::unwrap(static_cast<const double*>(buf.ptr),
+                  static_cast<double*>(result.request().ptr), buf.size, discont);
+    return result;
+}
+
 /// numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)
 inline py::array_t<double> intersect1d(const py::array_t<double>& a, const py::array_t<double>& b) {
     auto ba = a.request(), bb = b.request();

tests/module.cpp

@@ -70,6 +70,7 @@ PYBIND11_MODULE(numpycpp, m) {
     m.def("ones_like_bool", &numpy::ones_like_bool);
     m.def("zeros", &numpy::zeros);
     m.def("ones", &numpy::ones);
+	m.def("full", static_cast<py::array_t<double>(*)(const std::vector<py::ssize_t>&, double)>(&numpy::full));
 
     // -- astype ------------------------------------------------------------
     // NOTE: astype_int / astype_bool / astype_bool_from_int instead of a
@@ -213,7 +214,10 @@ PYBIND11_MODULE(numpycpp, m) {
 
     // -- Set operations ----------------------------------------------------
     m.def("isin", static_cast<py::array_t<bool>(*)(const py::array_t<double>&, const std::vector<double>&)>(&numpy::isin));
+	m.def("isin", static_cast<py::array_t<bool>(*)(const py::array_t<double>&, const std::vector<int>&)>(&numpy::isin));
     m.def("intersect1d", static_cast<py::array_t<double>(*)(const py::array_t<double>&, const py::array_t<double>&)>(&numpy::intersect1d));
+	m.def("flatnonzero", static_cast<py::array_t<py::ssize_t>(*)(const py::array_t<double>&)>(&numpy::flatnonzero));
+	m.def("unwrap", static_cast<py::array_t<double>(*)(const py::array_t<double>&, double)>(&numpy::unwrap), py::arg("arr"), py::arg("discont") = M_PI);
 
     // -- Interpolation -----------------------------------------------------
     m.def("interp", static_cast<py::array_t<double>(*)(const py::array_t<double>&, const py::array_t<double>&, const py::array_t<double>&)>(&numpy::interp));

tests/test_all.py

@@ -430,6 +430,11 @@ def test_zeros(shape, cpp):
 def test_ones(shape, cpp):
     assert_bit_aligned(cpp.ones(shape), np.ones(shape), f"ones{shape}")
 
+@pytest.mark.parametrize("shape,fill_val", [((5,), 3.14), ((2, 3), -1.0), ((4,), 0.0)])
+def test_full(shape, fill_val, cpp):
+    assert_bit_aligned(cpp.full(list(shape), fill_val),
+                       np.full(shape, fill_val), f"full{shape}_{fill_val}")
+
 
 # ============================================================================
 # 7. Bool-specialized creation
@@ -688,6 +693,23 @@ def test_isin(cpp):
     a = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
     assert_bit_aligned(cpp.isin(a, [2.0, 4.0, 6.0]), np.isin(a, [2.0, 4.0, 6.0]), "isin")
 
+def test_isin_int(cpp):
+    a = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    assert_bit_aligned(cpp.isin(a, [2, 4, 6]), np.isin(a, [2, 4, 6]), "isin_int")
+
+def test_flatnonzero(cpp):
+    a = np.array([0.0, 1.0, 0.0, 2.0, 0.0, 3.0])
+    assert_bit_aligned(cpp.flatnonzero(a), np.flatnonzero(a), "flatnonzero")
+    # all zeros
+    a2 = np.array([0.0, 0.0, 0.0])
+    assert_bit_aligned(cpp.flatnonzero(a2), np.flatnonzero(a2), "flatnonzero zeros")
+
+def test_unwrap(cpp):
+    a = np.array([0.0, 0.5, 0.8, -0.9, -0.5, 0.2])
+    assert_bit_aligned(cpp.unwrap(a), np.unwrap(a), "unwrap")
+    a2 = np.array([0.0, 2.5, 5.0, -2.5, -5.0]) * np.pi
+    assert_bit_aligned(cpp.unwrap(a2), np.unwrap(a2), "unwrap_large")
+
 def test_intersect1d(cpp):
     a, b = np.array([1.0, 2.0, 3.0, 4.0]), np.array([3.0, 4.0, 5.0, 6.0])
     cpp_r = np.sort(np.asarray(cpp.intersect1d(a, b)))