use SAME_VALUE_CAST flag for one inner loop variant

numpy · mattip · Feb 17, 2025 · Feb 17, 2025 · May 15, 2025 · May 29, 2025
commit 7cad6af78867261aad42928492a446026698f888
diff --git a/TODO_same_value b/TODO_same_value
@@ -1,14 +1,12 @@
 - Check where PyArray_CopyObject, PyArray_NewCopy, PyArray_CopyInto, array_datetime_as_string, PyArray_Concatenate, PyArray_where are used, do we need a 'same_value' equivalents?
-- Is the comment in multiarray/common.c about NPY_DEFAULT_ASSIGN_CASTING warning still correct?
-- In PyArray_FromArray(arr, newtype, flags) shoule there be a SAME_VALUE flag?
+- In PyArray_FromArray(arr, newtype, flags) should there be a SAME_VALUE flag?
 - Examine places where PyArray_CastingConverter is used and add SAME_VALUE handling
-  - array_astype: now errors, need to fix
   - array_datetime_as_string:
   - array_copyto: 
-  - PyArray_AssignArray (called with a cast arg)
+  - PyArray_AssignArray with wheremask (called with a cast arg)
+  - PyArray_AssignRawScalar with/without wheremask
   - PyArray_ConcatenateInto (called with a cast arg)
   - PyArray_EinsteinSum (called with a cast arg)
   - NpyIter_AdvancedNew (called with a cast arg)
-
+In CanCast, make sure user defined and datetime dtypes will fail with SAME_VALUE
 ----
-latest commit: `git grep UNSAFE_CASTING` up to `numpy/_core/src/multiarray/multiarraymodule.c`
diff --git a/numpy/_core/include/numpy/dtype_api.h b/numpy/_core/include/numpy/dtype_api.h
@@ -107,6 +107,12 @@ typedef struct PyArrayMethod_Context_tag {
 
     /* Operand descriptors, filled in by resolve_descriptors */
     PyArray_Descr *const *descriptors;
+    void * padding;
+    /* 
+     * Optional flag to pass information into the inner loop
+     * If set, it will be NPY_CASTING
+     */
+    uint64_t flags;
     /* Structure may grow (this is harmless for DType authors) */
 } PyArrayMethod_Context;
 
@@ -144,6 +150,11 @@ typedef struct {
 #define NPY_METH_contiguous_indexed_loop 9
 #define _NPY_METH_static_data 10
 
+/*
+ * Constants for same_value casting
+ */
+#define NPY_SAME_VALUE_OVERFLOW -31
+
 
 /*
  * The resolve descriptors function, must be able to handle NULL values for

diff --git a/numpy/_core/src/multiarray/array_assign_array.c b/numpy/_core/src/multiarray/array_assign_array.c
@@ -131,6 +131,10 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
         npy_clear_floatstatus_barrier((char*)&src_data);
     }
 
+    if (same_value_cast) {
+        cast_info.context.flags |= NPY_SAME_VALUE_CASTING;
+    }
+
     /* Ensure number of elements exceeds threshold for threading */
     if (!(method_flags & NPY_METH_REQUIRES_PYAPI)) {
         npy_intp nitems = 1, i;
@@ -149,6 +153,9 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
                                 args, &shape_it[0], strides,
                                 cast_info.auxdata);
         if (result < 0) {
+            if (result == NPY_SAME_VALUE_OVERFLOW) {
+                goto same_value_overflow;
+            }
             goto fail;
         }
     } NPY_RAW_ITER_TWO_NEXT(idim, ndim, coord, shape_it,
@@ -166,6 +173,8 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
     }
 
     return 0;
+same_value_overflow:
+    PyErr_SetString(PyExc_ValueError, "overflow in 'same_value' cast");
 fail:
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);

diff --git a/numpy/_core/src/multiarray/array_method.c b/numpy/_core/src/multiarray/array_method.c
@@ -797,6 +797,7 @@ boundarraymethod__simple_strided_call(
             .caller = NULL,
             .method = self->method,
             .descriptors = descrs,
+            .flags = 0,
     };
     PyArrayMethod_StridedLoop *strided_loop = NULL;
     NpyAuxData *loop_data = NULL;

diff --git a/numpy/_core/src/multiarray/dtype_transfer.c b/numpy/_core/src/multiarray/dtype_transfer.c
@@ -2910,8 +2910,6 @@ _clear_cast_info_after_get_loop_failure(NPY_cast_info *cast_info)
  * TODO: Expand the view functionality for general offsets, not just 0:
  *       Partial casts could be skipped also for `view_offset != 0`.
  *
- * The `out_needs_api` flag must be initialized.
- *
  * NOTE: In theory casting errors here could be slightly misleading in case
  *       of a multi-step casting scenario. It should be possible to improve
  *       this in the future.

diff --git a/numpy/_core/src/multiarray/dtype_transfer.h b/numpy/_core/src/multiarray/dtype_transfer.h
@@ -44,6 +44,9 @@ NPY_cast_info_init(NPY_cast_info *cast_info)
 
     // TODO: Delete this again probably maybe create a new minimal init macro
     cast_info->context.caller = NULL;
+
+    cast_info->context.padding = NULL;
+    cast_info->context.flags = 0;
 }
 
 

diff --git a/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src b/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src
@@ -899,6 +899,7 @@ static GCC_CAST_OPT_LEVEL int
 #endif
 
     /*printf("@prefix@_cast_@name1@_to_@name2@\n");*/
+    int same_value_casting = ((context->flags & NPY_SAME_VALUE_CASTING) == NPY_SAME_VALUE_CASTING);
 
     while (N--) {
 #if @aligned@
@@ -939,7 +940,12 @@ static GCC_CAST_OPT_LEVEL int
 #  elif !@aligned@
     dst_value = _CONVERT_FN(src_value);
 #  else
-    *(_TYPE2 *)dst = _CONVERT_FN(*(_TYPE1 *)src);
+        *(_TYPE2 *)dst = _CONVERT_FN(*(_TYPE1 *)src);
+        if (same_value_casting) {
+            if (*(_TYPE2 *)dst != *(_TYPE1 *)src) {
+                return NPY_SAME_VALUE_OVERFLOW;
+            }
+    }
 #  endif
 #endif
 

diff --git a/numpy/_core/src/umath/legacy_array_method.c b/numpy/_core/src/umath/legacy_array_method.c
@@ -440,9 +440,10 @@ PyArray_NewLegacyWrappingArrayMethod(PyUFuncObject *ufunc,
         }
 
         PyArrayMethod_Context context = {
-                (PyObject *)ufunc,
-                bound_res->method,
-                descrs,
+            .caller = (PyObject *)ufunc,
+            .method = bound_res->method,
+            .descriptors = descrs,
+            .flags = 0,
         };
 
         int ret = get_initial_from_ufunc(&context, 0, context.method->legacy_initial);

diff --git a/numpy/_core/src/umath/ufunc_object.c b/numpy/_core/src/umath/ufunc_object.c
@@ -2088,6 +2088,7 @@ PyUFunc_GeneralizedFunctionInternal(PyUFuncObject *ufunc,
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = operation_descrs,
+        .flags = 0,
     };
     PyArrayMethod_StridedLoop *strided_loop;
     NPY_ARRAYMETHOD_FLAGS flags = 0;
@@ -2207,6 +2208,7 @@ PyUFunc_GenericFunctionInternal(PyUFuncObject *ufunc,
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = operation_descrs,
+        .flags = 0,
     };
 
     /* Do the ufunc loop */
@@ -2557,6 +2559,7 @@ PyUFunc_Reduce(PyUFuncObject *ufunc,
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = descrs,
+        .flags = 0,
     };
 
     PyArrayObject *result = PyUFunc_ReduceWrapper(&context,
@@ -2633,6 +2636,7 @@ PyUFunc_Accumulate(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *out,
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = descrs,
+        .flags = 0,
     };
 
     ndim = PyArray_NDIM(arr);
@@ -3065,6 +3069,7 @@ PyUFunc_Reduceat(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *ind,
         .caller = (PyObject *)ufunc,
         .method = ufuncimpl,
         .descriptors = descrs,
+        .flags = 0,
     };
 
     ndim = PyArray_NDIM(arr);
@@ -5903,9 +5908,10 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
     }
 
     PyArrayMethod_Context context = {
-            .caller = (PyObject *)ufunc,
-            .method = ufuncimpl,
-            .descriptors = operation_descrs,
+        .caller = (PyObject *)ufunc,
+        .method = ufuncimpl,
+        .descriptors = operation_descrs,
+        .flags = 0,
     };
 
     /* Use contiguous strides; if there is such a loop it may be faster */

diff --git a/numpy/_core/tests/test_casting_unittests.py b/numpy/_core/tests/test_casting_unittests.py
@@ -848,8 +848,7 @@ def test_same_value(self, from_dtype, to_dtype):
         arr2 = np.array([0] * 10, dtype=to_dtype)
         assert_equal(arr1.astype(to_dtype, casting='same_value'), arr2, strict=True)
         arr1[0] = top1
-        if 1:
-        # with pytest.raises(ValueError):
+        with pytest.raises(ValueError):
             # Casting float to float with overflow should raise RuntimeWarning (fperror)
             # Casting float to int with overflow sometimes raises RuntimeWarning (fperror)
             # Casting with overflow  and 'same_value', should raise ValueError