numpy · ngoldbaum · Nov 2, 2023 · Jul 13, 2023 · Jul 13, 2023 · Jul 13, 2023
diff --git a/doc/release/upcoming_changes/24224.change.rst b/doc/release/upcoming_changes/24224.change.rst
@@ -0,0 +1,7 @@
+Default integer now 64bit on 64bit windows
+------------------------------------------
+The default NumPy integer is now 64bit on all 64bit systems as the
+historic 32bit default on windows was a common source of issues.
+Most users should not notice this, the main issues may occur
+with code interfacing with libraries written in a compiled language
+like C.  For more information see :ref:`migration_windows_int64`.
diff --git a/doc/source/numpy_2_0_migration_guide.rst b/doc/source/numpy_2_0_migration_guide.rst
@@ -2,13 +2,48 @@
 NumPy 2.0 Migration Guide
 *************************
 
-This document contains a set of instructions on how to update your code to work with
-the Numpy 2.0 Python API. Most of the changes are trivial, and require the end user
-to use a different name/module to access a given function/constant.
+This document contains a set of instructions on how to update your code to
+work with Numpy 2.0.
+
+
+.. _migration_windows_int64:
+
+Windows default integer
+=======================
+The default integer used by NumPy is now 64bit on all 64bit systems (and
+32bit on 32bit system).  For historic reasons related to Python 2 it was
+previously equivalent to the C ``long`` type.
+The default integer is now equivalent to ``np.intp``.
+
+Most end-users should not be affected by this change.  Some operations will
+use more memory, but some operations may actually become faster.
+If you experience issues due to calling a library written in a compiled
+language it may help to explicitly cast to a ``long``, for example with:
+``arr = arr.astype("long", copy=False)``.
+
+Libraries interfacing with compiled code that are written in C, Cython, or
+a similar language may require updating to accomodate user input if they
+are using the ``long`` or equivalent type on the C-side.
+In this case, you may wish to use ``intp`` and cast user input or support
+both ``long`` and ``intp`` (to better support NumPy 1.x as well).
+When creating a new integer array in C or Cython, the new ``NPY_DEFAULT_INT``
+macro will evaluate to either ``NPY_LONG`` or ``NPY_INTP`` depending on the
+NumPy version.
+
+Note that the NumPy random API is not affected by this change.
+
+Namespace changes
+=================
+
+In NumPy 2.0 certain functions, modules, and constants were moved or removed
+to make the NumPy namespace more userfriendly by removing unnecessary or
+outdated functionality and clarifying which parts of NumPy are considered
+private.
+Please see the tables below for guidance on migration.  For most changes this
+means replacing it with a backwards compatible alternative. 
 
 Please refer to `NEP 52 <https://numpy.org/neps/nep-0052-python-api-cleanup.html>`_ for more details.
 
-
 Main namespace
 --------------
 

diff --git a/numpy/__init__.cython-30.pxd b/numpy/__init__.cython-30.pxd
@@ -82,6 +82,7 @@ cdef extern from "numpy/arrayobject.h":
         NPY_COMPLEX512
 
         NPY_INTP
+        NPY_DEFAULT_INT  # Not a compile time constant (normally)!
 
     ctypedef enum NPY_ORDER:
         NPY_ANYORDER
@@ -777,12 +778,7 @@ ctypedef npy_float64    float64_t
 ctypedef float complex  complex64_t
 ctypedef double complex complex128_t
 
-# The int types are mapped a bit surprising --
-# numpy.int corresponds to 'l' and numpy.long to 'q'
-ctypedef npy_long       int_t
 ctypedef npy_longlong   longlong_t
-
-ctypedef npy_ulong      uint_t
 ctypedef npy_ulonglong  ulonglong_t
 
 ctypedef npy_intp       intp_t

diff --git a/numpy/__init__.pxd b/numpy/__init__.pxd
@@ -79,6 +79,7 @@ cdef extern from "numpy/arrayobject.h":
         NPY_COMPLEX512
 
         NPY_INTP
+        NPY_DEFAULT_INT
 
     ctypedef enum NPY_ORDER:
         NPY_ANYORDER
@@ -699,12 +700,7 @@ ctypedef npy_float64    float64_t
 ctypedef float complex  complex64_t
 ctypedef double complex complex128_t
 
-# The int types are mapped a bit surprising --
-# numpy.int corresponds to 'l' and numpy.long to 'q'
-ctypedef npy_long       int_t
 ctypedef npy_longlong   longlong_t
-
-ctypedef npy_ulong      uint_t
 ctypedef npy_ulonglong  ulonglong_t
 
 ctypedef npy_intp       intp_t

diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi
@@ -2858,7 +2858,7 @@ byte = signedinteger[_NBitByte]
 short = signedinteger[_NBitShort]
 intc = signedinteger[_NBitIntC]
 intp = signedinteger[_NBitIntP]
-int_ = signedinteger[_NBitInt]
+int_ = intp
 long = signedinteger[_NBitLong]
 longlong = signedinteger[_NBitLongLong]
 
@@ -2940,7 +2940,7 @@ ubyte = unsignedinteger[_NBitByte]
 ushort = unsignedinteger[_NBitShort]
 uintc = unsignedinteger[_NBitIntC]
 uintp = unsignedinteger[_NBitIntP]
-uint = unsignedinteger[_NBitInt]
+uint = uintp
 ulong = unsignedinteger[_NBitLong]
 ulonglong = unsignedinteger[_NBitLongLong]
 

diff --git a/numpy/_core/_add_newdocs_scalars.py b/numpy/_core/_add_newdocs_scalars.py
@@ -120,9 +120,12 @@ def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
     Signed integer type, compatible with C ``int``.
     """)
 
+# TODO: These docs probably need an if to highlight the default rather than
+#       the C-types (and be correct).
 add_newdoc_for_scalar_type('int_', [],
     """
-    Signed integer type, compatible with Python :class:`int` and C ``long``.
+    Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
+    systems.
     """)
 
 add_newdoc_for_scalar_type('longlong', [],
@@ -147,7 +150,8 @@ def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
 
 add_newdoc_for_scalar_type('uint', [],
     """
-    Unsigned integer type, compatible with C ``unsigned long``.
+    Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
+    systems.
     """)
 
 add_newdoc_for_scalar_type('ulonglong', [],

diff --git a/numpy/_core/_type_aliases.py b/numpy/_core/_type_aliases.py
@@ -51,8 +51,9 @@
     "single": "float32",
     "csingle": "complex64",
     "half": "float16",
-    "int_": "long",
-    "uint": "ulong",
+    # Default integer:
+    "int_": "intp",
+    "uint": "uintp",
 }
 
 for k, v in _aliases.items():

diff --git a/numpy/_core/code_generators/generate_numpy_api.py b/numpy/_core/code_generators/generate_numpy_api.py
@@ -26,16 +26,24 @@
 #else
 
 #if defined(PY_ARRAY_UNIQUE_SYMBOL)
-#define PyArray_API PY_ARRAY_UNIQUE_SYMBOL
+    #define PyArray_API PY_ARRAY_UNIQUE_SYMBOL
+    #define _NPY_VERSION_CONCAT_HELPER2(x, y) x ## y
+    #define _NPY_VERSION_CONCAT_HELPER(arg) \
+        _NPY_VERSION_CONCAT_HELPER2(arg, PyArray_RUNTIME_VERSION)
+    #define PyArray_RUNTIME_VERSION \
+        _NPY_VERSION_CONCAT_HELPER(PY_ARRAY_UNIQUE_SYMBOL)
 #endif
 
 #if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY)
 extern void **PyArray_API;
+extern int PyArray_RUNTIME_VERSION;
 #else
 #if defined(PY_ARRAY_UNIQUE_SYMBOL)
 void **PyArray_API;
+int PyArray_RUNTIME_VERSION;
 #else
-static void **PyArray_API=NULL;
+static void **PyArray_API = NULL;
+static int PyArray_RUNTIME_VERSION = 0;
 #endif
 #endif
 
@@ -85,15 +93,16 @@
              (int) NPY_VERSION, (int) PyArray_GetNDArrayCVersion());
       return -1;
   }
-  if (NPY_FEATURE_VERSION > PyArray_GetNDArrayCFeatureVersion()) {
+  PyArray_RUNTIME_VERSION = (int)PyArray_GetNDArrayCFeatureVersion();
+  if (NPY_FEATURE_VERSION > PyArray_RUNTIME_VERSION) {
       PyErr_Format(PyExc_RuntimeError, "module compiled against "\
              "API version 0x%%x but this version of numpy is 0x%%x . "\
              "Check the section C-API incompatibility at the "\
              "Troubleshooting ImportError section at "\
              "https://numpy.org/devdocs/user/troubleshooting-importerror.html"\
              "#c-api-incompatibility "\
               "for indications on how to solve this problem .", \
-             (int) NPY_FEATURE_VERSION, (int) PyArray_GetNDArrayCFeatureVersion());
+             (int)NPY_FEATURE_VERSION, PyArray_RUNTIME_VERSION);
       return -1;
   }
 

diff --git a/numpy/_core/code_generators/generate_umath.py b/numpy/_core/code_generators/generate_umath.py
@@ -94,7 +94,13 @@ def finish_signature(self, nin, nout):
 
 
 def _check_order(types1, types2):
-    dtype_order = allP + "O"
+    """
+    Helper to check that the loop types are ordered. The legacy type resolver
+    (and potentially downstream) may pick use the first loop to which operands
+    can be cast safely.
+    """
+    # Insert kK (int64) after all other ints (assumes long long isn't larger)
+    dtype_order = bints + 'kK' + times + flts + cmplxP + "O"
     for t1, t2 in zip(types1, types2):
         # We have no opinion on object or time ordering for now:
         if t1 in "OP" or t2 in "OP":
@@ -275,6 +281,10 @@ def english_upper(s):
     'I': 'uint',
     'l': 'long',
     'L': 'ulong',
+    # We sometimes need int64, but we have no obvious char for it, use k and
+    # define it as `int64` below.
+    'k': 'int64',
+    'K': 'uint64',
     'q': 'longlong',
     'Q': 'ulonglong',
     'e': 'half',
@@ -330,13 +340,8 @@ def english_upper(s):
 no_bool_times_obj = ints + inexact
 
 # Find which code corresponds to int64.
-int64 = ''
-uint64 = ''
-for code in 'bhilq':
-    if struct.calcsize(code) == 8:
-        int64 = code
-        uint64 = english_upper(code)
-        break
+int64 = 'k'
+uint64 = 'K'
 
 # This dictionary describes all the ufunc implementations, generating
 # all the function names and their corresponding ufunc signatures.  TD is
@@ -1090,12 +1095,12 @@ def english_upper(s):
           None,
           [TypeDescription('e', None, 'ei', 'e'),
           TypeDescription('f', None, 'fi', 'f', dispatch='loops_exponent_log'),
-          TypeDescription('e', FuncNameSuffix('long'), 'el', 'e'),
-          TypeDescription('f', FuncNameSuffix('long'), 'fl', 'f'),
+          TypeDescription('e', FuncNameSuffix('int64'), 'e'+int64, 'e'),
+          TypeDescription('f', FuncNameSuffix('int64'), 'f'+int64, 'f'),
           TypeDescription('d', None, 'di', 'd', dispatch='loops_exponent_log'),
-          TypeDescription('d', FuncNameSuffix('long'), 'dl', 'd'),
+          TypeDescription('d', FuncNameSuffix('int64'), 'd'+int64, 'd'),
           TypeDescription('g', None, 'gi', 'g'),
-          TypeDescription('g', FuncNameSuffix('long'), 'gl', 'g'),
+          TypeDescription('g', FuncNameSuffix('int64'), 'g'+int64, 'g'),
           ],
           ),
 'frexp' :

diff --git a/numpy/_core/include/numpy/ndarraytypes.h b/numpy/_core/include/numpy/ndarraytypes.h
@@ -1486,6 +1486,13 @@ PyArrayNeighborhoodIter_Next2D(PyArrayNeighborhoodIterObject* iter);
 
 /* The default array type */
 #define NPY_DEFAULT_TYPE NPY_DOUBLE
+/* default integer type */
+#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION
+    #define NPY_DEFAULT_INT NPY_INTP
+#else
+    #define NPY_DEFAULT_INT  \
+        (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? NPY_INTP : NPY_LONG)
+#endif
 
 /*
  * All sorts of useful ways to look into a PyArrayObject. It is recommended

diff --git a/numpy/_core/include/numpy/npy_common.h b/numpy/_core/include/numpy/npy_common.h
@@ -228,16 +228,7 @@ typedef Py_uintptr_t npy_uintp;
  *      functions use different formatting codes that are portably specified
  *      according to the Python documentation. See issue gh-2388.
  */
-#if NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_INT
-        #define NPY_INTP NPY_INT
-        #define NPY_UINTP NPY_UINT
-        #define PyIntpArrType_Type PyIntArrType_Type
-        #define PyUIntpArrType_Type PyUIntArrType_Type
-        #define NPY_MAX_INTP NPY_MAX_INT
-        #define NPY_MIN_INTP NPY_MIN_INT
-        #define NPY_MAX_UINTP NPY_MAX_UINT
-        #define NPY_INTP_FMT "d"
-#elif NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONG
+#if NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONG
         #define NPY_INTP NPY_LONG
         #define NPY_UINTP NPY_ULONG
         #define PyIntpArrType_Type PyLongArrType_Type
@@ -246,6 +237,16 @@ typedef Py_uintptr_t npy_uintp;
         #define NPY_MIN_INTP NPY_MIN_LONG
         #define NPY_MAX_UINTP NPY_MAX_ULONG
         #define NPY_INTP_FMT "ld"
+#elif NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_INT
+        /* NumPy always prefers long over int if the size is identical! */
+        #define NPY_INTP NPY_INT
+        #define NPY_UINTP NPY_UINT
+        #define PyIntpArrType_Type PyIntArrType_Type
+        #define PyUIntpArrType_Type PyUIntArrType_Type
+        #define NPY_MAX_INTP NPY_MAX_INT
+        #define NPY_MIN_INTP NPY_MIN_INT
+        #define NPY_MAX_UINTP NPY_MAX_UINT
+        #define NPY_INTP_FMT "d"
 #elif defined(PY_LONG_LONG) && (NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONGLONG)
         #define NPY_INTP NPY_LONGLONG
         #define NPY_UINTP NPY_ULONGLONG

diff --git a/numpy/_core/src/multiarray/abstractdtypes.c b/numpy/_core/src/multiarray/abstractdtypes.c
@@ -16,7 +16,7 @@
 static inline PyArray_Descr *
 int_default_descriptor(PyArray_DTypeMeta* NPY_UNUSED(cls))
 {
-    return PyArray_DescrFromType(NPY_LONG);
+    return PyArray_DescrFromType(NPY_INTP);
 }
 
 static PyArray_Descr *
@@ -33,8 +33,8 @@ discover_descriptor_from_pyint(
         PyErr_Clear();
     }
     else {
-        if (NPY_MIN_LONG <= value && value <= NPY_MAX_LONG) {
-            return PyArray_DescrFromType(NPY_LONG);
+        if (NPY_MIN_INTP <= value && value <= NPY_MAX_INTP) {
+            return PyArray_DescrFromType(NPY_INTP);
         }
         return PyArray_DescrFromType(NPY_LONGLONG);
     }
@@ -153,7 +153,7 @@ int_common_dtype(PyArray_DTypeMeta *NPY_UNUSED(cls), PyArray_DTypeMeta *other)
     if (NPY_DT_is_legacy(other) && other->type_num < NPY_NTYPES) {
         if (other->type_num == NPY_BOOL) {
             /* Use the default integer for bools: */
-            return PyArray_DTypeFromTypeNum(NPY_LONG);
+            return PyArray_DTypeFromTypeNum(NPY_INTP);
         }
     }
     else if (NPY_DT_is_legacy(other)) {
@@ -184,7 +184,7 @@ int_common_dtype(PyArray_DTypeMeta *NPY_UNUSED(cls), PyArray_DTypeMeta *other)
             return res;
         }
         /* And finally, we will try the default integer, just for sports... */
-        PyArray_DTypeMeta *default_int = PyArray_DTypeFromTypeNum(NPY_LONG);
+        PyArray_DTypeMeta *default_int = PyArray_DTypeFromTypeNum(NPY_INTP);
         res = NPY_DT_CALL_common_dtype(other, default_int);
         Py_DECREF(default_int);
         if (res == NULL) {

diff --git a/numpy/_core/src/multiarray/ctors.c b/numpy/_core/src/multiarray/ctors.c
@@ -3223,7 +3223,7 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr
 
     if (!dtype) {
         /* intentionally made to be at least NPY_LONG */
-        dtype = PyArray_DescrFromType(NPY_LONG);
+        dtype = PyArray_DescrFromType(NPY_INTP);
         Py_SETREF(dtype, PyArray_DescrFromObject(start, dtype));
         if (dtype == NULL) {
             goto fail;

diff --git a/numpy/_core/src/multiarray/descriptor.c b/numpy/_core/src/multiarray/descriptor.c
@@ -1542,7 +1542,7 @@ _convert_from_type(PyObject *obj) {
         return PyArray_DescrFromTypeObject(obj);
     }
     else if (typ == &PyLong_Type) {
-        return PyArray_DescrFromType(NPY_LONG);
+        return PyArray_DescrFromType(NPY_INTP);
     }
     else if (typ == &PyFloat_Type) {
         return PyArray_DescrFromType(NPY_DOUBLE);

diff --git a/numpy/_core/src/umath/_operand_flag_tests.c b/numpy/_core/src/umath/_operand_flag_tests.c
@@ -25,7 +25,7 @@ inplace_add(char **args, npy_intp const *dimensions, npy_intp const *steps, void
     npy_intp in2_step = steps[1];
 
     for (i = 0; i < n; i++) {
-        (*(long *)in1) = *(long*)in1 + *(long*)in2;
+        (*(npy_intp *)in1) = *(npy_intp*)in1 + *(npy_intp*)in2;
         in1 += in1_step;
         in2 += in2_step;
     }
@@ -36,7 +36,7 @@ inplace_add(char **args, npy_intp const *dimensions, npy_intp const *steps, void
 PyUFuncGenericFunction funcs[1] = {&inplace_add};
 
 /* These are the input and return dtypes of logit.*/
-static char types[2] = {NPY_LONG, NPY_LONG};
+static char types[2] = {NPY_INTP, NPY_INTP};
 
 static void *data[1] = {NULL};