resolved reviews

Author: SwayamInSync

quaddtype/numpy_quaddtype/src/dragon4.c

@@ -1,3 +1,8 @@
+/*
+This code was extracted from NumPy and the original author was Allan Haldane(@ahaldane)
+Modifications are specific to support the SLEEF_QUAD
+*/
+
 #include <numpy/npy_common.h>
 #include <math.h>
 #include <stdio.h>

quaddtype/numpy_quaddtype/src/dtype.c

@@ -79,10 +79,15 @@ ensure_canonical(QuadPrecDTypeObject *self)
 static QuadPrecDTypeObject *
 common_instance(QuadPrecDTypeObject *dtype1, QuadPrecDTypeObject *dtype2)
 {
+    // if backend mismatch then return SLEEF one (safe to cast ld to quad)
     if (dtype1->backend != dtype2->backend) {
-        PyErr_SetString(PyExc_TypeError,
-                        "Cannot find common instance for QuadPrecDTypes with different backends");
-        return NULL;
+        if (dtype1->backend == BACKEND_SLEEF) {
+            Py_INCREF(dtype1);
+            return dtype1;
+        }
+
+        Py_INCREF(dtype2);
+        return dtype2;
     }
     Py_INCREF(dtype1);
     return dtype1;

quaddtype/numpy_quaddtype/src/scalar.c

@@ -76,39 +76,42 @@ QuadPrecision_from_object(PyObject *value, QuadBackendType backend)
             self->value.longdouble_value = (long double)val;
         }
     }
-    else if (Py_TYPE(value) == &QuadPrecision_Type)
-    {
-        // todo: not working for ld backend, getting garbage value not sure why?
+    else if (Py_TYPE(value) == &QuadPrecision_Type) {
+        Py_DECREF(self);  // discard the default one
         QuadPrecisionObject *quad_obj = (QuadPrecisionObject *)value;
-        // printf("%d %d\n", quad_obj->backend, backend);
-        // printf("%Lf\n", quad_obj->value.longdouble_value);
+
+        // create a new one with the same backend
+        QuadPrecisionObject *self = QuadPrecision_raw_new(quad_obj->backend);
         if (quad_obj->backend == BACKEND_SLEEF) {
             self->value.sleef_value = quad_obj->value.sleef_value;
         }
         else {
             self->value.longdouble_value = quad_obj->value.longdouble_value;
         }
+
+        return self;
     }
     else {
         PyObject *type_str = PyObject_Str((PyObject *)Py_TYPE(value));
         if (type_str != NULL) {
             const char *type_cstr = PyUnicode_AsUTF8(type_str);
             if (type_cstr != NULL) {
-                PyErr_Format(
-                        PyExc_TypeError,
-                        "QuadPrecision value must be a float, int or string, but got %s instead",
-                        type_cstr);
+                PyErr_Format(PyExc_TypeError,
+                             "QuadPrecision value must be a quad, float, int or string, but got %s "
+                             "instead",
+                             type_cstr);
             }
             else {
-                PyErr_SetString(PyExc_TypeError,
-                                "QuadPrecision value must be a float, int or string, but got an "
-                                "unknown type instead");
+                PyErr_SetString(
+                        PyExc_TypeError,
+                        "QuadPrecision value must be a quad, float, int or string, but got an "
+                        "unknown type instead");
             }
             Py_DECREF(type_str);
         }
         else {
             PyErr_SetString(PyExc_TypeError,
-                            "QuadPrecision value must be a float, int or string, but got an "
+                            "QuadPrecision value must be a quad, float, int or string, but got an "
                             "unknown type instead");
         }
         Py_DECREF(self);