Add a conjugate implementation for the scalar

Author: ngoldbaum

src/csrc/scalar.c

@@ -429,6 +429,34 @@ QuadPrecision_get_imag(QuadPrecisionObject *self, void *closure)
     return (PyObject *)QuadPrecision_raw_new(self->backend);
 }
 
+static PyObject *
+QuadPrecision_conjugate(QuadPrecisionObject *self, PyObject *args)
+{
+    PyArrayObject *out = NULL;
+    if (!PyArg_ParseTuple(args, "|O&:conjugate", PyArray_OutputConverter, &out)) {
+        return NULL;
+    }
+    if (out == NULL) {
+        return Py_NewRef(self);
+    }
+
+    PyArray_Descr *dtype = (PyArray_Descr *)new_quaddtype_instance(self->backend);
+    if (dtype == NULL) {
+        return NULL;
+    }
+    PyArrayObject *array = (PyArrayObject *)PyArray_SimpleNewFromDescr(0, NULL, dtype);
+    if (array == NULL) {
+        return NULL;
+    }
+    quad_value_store(PyArray_BYTES(array), &self->value, self->backend);
+    PyObject *result = PyArray_Conjugate(array, out);
+    Py_DECREF(array);
+    if (result == NULL || !PyArray_Check(result)) {
+        return result;
+    }
+    return PyArray_Return((PyArrayObject *)result);
+}
+
 // Method implementations for float compatibility
 static PyObject *
 QuadPrecision_is_integer(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
@@ -774,6 +802,10 @@ QuadPrecision_from_raw_bytes(PyObject *Py_UNUSED(module), PyObject *args)
 }
 
 static PyMethodDef QuadPrecision_methods[] = {
+    {"conj", (PyCFunction)QuadPrecision_conjugate, METH_VARARGS,
+     "Return the complex conjugate."},
+    {"conjugate", (PyCFunction)QuadPrecision_conjugate, METH_VARARGS,
+     "Return the complex conjugate."},
     {"is_integer", (PyCFunction)QuadPrecision_is_integer, METH_NOARGS,
      "Return True if the value is an integer."},
     {"as_integer_ratio", (PyCFunction)QuadPrecision_as_integer_ratio, METH_NOARGS,

tests/test_quaddtype.py

@@ -3697,6 +3697,57 @@ def test_array_conjugate_method():
     np.testing.assert_array_equal(result.astype(float), [1.5, -2.5, 0.0])
 
 
+@pytest.mark.parametrize("backend", ["sleef", "longdouble"])
+def test_object_conjugate_preserves_values_and_backend(backend):
+    dtype = QuadPrecDType(backend=backend)
+    objects = np.array([1.5, 2.5], dtype=dtype).astype(object)
+
+    result = np.conjugate(objects)
+
+    np.testing.assert_array_equal(result, objects, strict=True)
+    for scalar in result:
+        assert scalar.dtype == dtype
+
+
+@pytest.mark.parametrize("backend", ["sleef", "longdouble"])
+@pytest.mark.parametrize("method", ["conj", "conjugate"])
+@pytest.mark.parametrize("value", [1.5, -0.0, np.inf, np.nan])
+@pytest.mark.parametrize("args", [(), (None,)])
+def test_scalar_conjugate_preserves_values_and_backend(backend, method, value, args):
+    scalar = QuadPrecision(value, backend=backend)
+
+    result = getattr(scalar, method)(*args)
+
+    assert result.dtype == scalar.dtype
+    np.testing.assert_array_equal(float(result), value)
+    assert np.signbit(float(result)) == np.signbit(value)
+
+
+@pytest.mark.parametrize("backend", ["sleef", "longdouble"])
+@pytest.mark.parametrize("method", ["conj", "conjugate"])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64, object, QuadPrecDType])
+def test_scalar_conjugate_with_out(backend, method, dtype):
+    scalar = QuadPrecision(1.5, backend=backend)
+    out = np.empty((), dtype=scalar.dtype if dtype is QuadPrecDType else dtype)
+    reference_out = np.empty((), dtype=np.float64 if dtype is QuadPrecDType else dtype)
+
+    result = getattr(scalar, method)(out)
+    expected = getattr(np.float64(1.5), method)(reference_out)
+
+    np.testing.assert_array_equal(float(result), float(expected))
+    np.testing.assert_array_equal(out.astype(np.float64), reference_out.astype(np.float64))
+    if dtype is object or dtype is QuadPrecDType:
+        assert result.dtype == scalar.dtype
+
+
+@pytest.mark.parametrize("backend", ["sleef", "longdouble"])
+@pytest.mark.parametrize("method", ["conj", "conjugate"])
+@pytest.mark.parametrize("args", [(1,), (None, None), (np.empty((), dtype=np.int64),)])
+def test_scalar_conjugate_rejects_invalid_out(backend, method, args):
+    for scalar in [QuadPrecision(1.5, backend=backend), np.float64(1.5)]:
+        with pytest.raises(TypeError):
+            getattr(scalar, method)(*args)
+
 @pytest.mark.parametrize("x1,x2,expected", [
     # Basic Pythagorean triples
     (3.0, 4.0, 5.0),