added more unary func

Author: SwayamInSync

quaddtype/numpy_quaddtype/src/dtype.c

@@ -50,19 +50,21 @@ quad_store(char *data_ptr, void *x, QuadBackendType backend)
 QuadPrecDTypeObject *
 new_quaddtype_instance(QuadBackendType backend)
 {
+    QuadBackendType target_backend = backend;
     if (backend != BACKEND_SLEEF && backend != BACKEND_LONGDOUBLE) {
         PyErr_SetString(PyExc_TypeError, "Backend must be sleef or longdouble");
         return NULL;
+        // target_backend = BACKEND_SLEEF;
     }
 
     QuadPrecDTypeObject *new = (QuadPrecDTypeObject *)PyArrayDescr_Type.tp_new(
             (PyTypeObject *)&QuadPrecDType, NULL, NULL);
     if (new == NULL) {
         return NULL;
     }
-    new->base.elsize = (backend == BACKEND_SLEEF) ? sizeof(Sleef_quad) : sizeof(long double);
-    new->base.alignment = (backend == BACKEND_SLEEF) ? _Alignof(Sleef_quad) : _Alignof(long double);
-    new->backend = backend;
+    new->base.elsize = (target_backend == BACKEND_SLEEF) ? sizeof(Sleef_quad) : sizeof(long double);
+    new->base.alignment = (target_backend == BACKEND_SLEEF) ? _Alignof(Sleef_quad) : _Alignof(long double);
+    new->backend = target_backend;
     return new;
 }
 

quaddtype/numpy_quaddtype/src/ops.hpp

@@ -110,6 +110,49 @@ quad_exp2(Sleef_quad *op, Sleef_quad *out)
     return 0;
 }
 
+static inline int
+quad_sin(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_sinq1_u10(*op);
+    return 0;
+}
+
+static inline int
+quad_cos(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_cosq1_u10(*op);
+    return 0;
+}
+
+static inline int
+quad_tan(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_tanq1_u10(*op);
+    return 0;
+}
+
+static inline int
+quad_asin(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_asinq1_u10(*op);
+    return 0;
+}
+
+static inline int
+quad_acos(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_acosq1_u10(*op);
+    return 0;
+}
+
+static inline int
+quad_atan(Sleef_quad *op, Sleef_quad *out)
+{
+    *out = Sleef_atanq1_u10(*op);
+    return 0;
+}
+
+
 // Unary long double operations
 typedef int (*unary_op_longdouble_def)(long double *, long double *);
 
@@ -218,6 +261,48 @@ ld_exp2(long double *op, long double *out)
     return 0;
 }
 
+static inline int
+ld_sin(long double *op, long double *out)
+{
+    *out = sinl(*op);
+    return 0;
+}
+
+static inline int
+ld_cos(long double *op, long double *out)
+{
+    *out = cosl(*op);
+    return 0;
+}
+
+static inline int
+ld_tan(long double *op, long double *out)
+{
+    *out = tanl(*op);
+    return 0;
+}
+
+static inline int
+ld_asin(long double *op, long double *out)
+{
+    *out = asinl(*op);
+    return 0;
+}
+
+static inline int
+ld_acos(long double *op, long double *out)
+{
+    *out = acosl(*op);
+    return 0;
+}
+
+static inline int
+ld_atan(long double *op, long double *out)
+{
+    *out = atanl(*op);
+    return 0;
+}
+
 // Binary Quad operations
 typedef int (*binary_op_quad_def)(Sleef_quad *, Sleef_quad *, Sleef_quad *);
 
@@ -277,6 +362,13 @@ quad_maximum(Sleef_quad *out, Sleef_quad *in1, Sleef_quad *in2)
     return 0;
 }
 
+static inline int
+quad_atan2(Sleef_quad *out, Sleef_quad *in1, Sleef_quad *in2)
+{
+    *out = Sleef_atan2q1_u10(*in1, *in2);
+    return 0;
+}
+
 // Binary long double operations
 typedef int (*binary_op_longdouble_def)(long double *, long double *, long double *);
 
@@ -336,6 +428,13 @@ ld_maximum(long double *out, long double *in1, long double *in2)
     return 0;
 }
 
+static inline int
+ld_atan2(long double *out, long double *in1, long double *in2)
+{
+    *out = atan2l(*in1, *in2);
+    return 0;
+}
+
 // comparison quad functions
 typedef npy_bool (*cmp_quad_def)(const Sleef_quad *, const Sleef_quad *);
 

quaddtype/numpy_quaddtype/src/scalar.c

@@ -232,6 +232,6 @@ PyTypeObject QuadPrecision_Type = {
 int
 init_quadprecision_scalar(void)
 {
-    QuadPrecision_Type.tp_base = &PyFloat_Type; // this is not working (subclassing to np.floating)
+    // QuadPrecision_Type.tp_base = &PyFloatingArrType_Type;
     return PyType_Ready(&QuadPrecision_Type);
 }

quaddtype/numpy_quaddtype/src/umath.cpp

@@ -217,6 +217,24 @@ init_quad_unary_ops(PyObject *numpy)
     if (create_quad_unary_ufunc<quad_exp2, ld_exp2>(numpy, "exp2") < 0) {
         return -1;
     }
+    if (create_quad_unary_ufunc<quad_sin, ld_sin>(numpy, "sin") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_cos, ld_cos>(numpy, "cos") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_tan, ld_tan>(numpy, "tan") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_asin, ld_asin>(numpy, "arcsin") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_acos, ld_acos>(numpy, "arccos") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_atan, ld_atan>(numpy, "arctan") < 0) {
+        return -1;
+    }
     return 0;
 }
 
@@ -315,7 +333,6 @@ static int
 quad_ufunc_promoter(PyUFuncObject *ufunc, PyArray_DTypeMeta *op_dtypes[],
                     PyArray_DTypeMeta *signature[], PyArray_DTypeMeta *new_op_dtypes[])
 {
-
     int nin = ufunc->nin;
     int nargs = ufunc->nargs;
     PyArray_DTypeMeta *common = NULL;
@@ -473,6 +490,9 @@ init_quad_binary_ops(PyObject *numpy)
     if (create_quad_binary_ufunc<quad_maximum, ld_maximum>(numpy, "maximum") < 0) {
         return -1;
     }
+    if (create_quad_binary_ufunc<quad_atan2, ld_atan2>(numpy, "arctan2") < 0) {
+        return -1;
+    }
     return 0;
 }