numpy
diff --git a/‎benchmarks/benchmarks/bench_function_base.py
Lines changed: 14 additions & 0 deletions b/‎benchmarks/benchmarks/bench_function_base.py
Lines changed: 14 additions & 0 deletions
diff --git a/‎doc/source/user/basics.creation.rst
Lines changed: 8 additions & 8 deletions b/‎doc/source/user/basics.creation.rst
Lines changed: 8 additions & 8 deletions
diff --git a/‎numpy/__init__.py
Lines changed: 2 additions & 2 deletions b/‎numpy/__init__.py
Lines changed: 2 additions & 2 deletions
diff --git a/‎numpy/_core/code_generators/ufunc_docstrings.py
Lines changed: 1 addition & 1 deletion b/‎numpy/_core/code_generators/ufunc_docstrings.py
Lines changed: 1 addition & 1 deletion
diff --git a/‎numpy/_core/multiarray.py
Lines changed: 7 additions & 51 deletions b/‎numpy/_core/multiarray.py
Lines changed: 7 additions & 51 deletions
@@ -2,6 +2,13 @@
 
 import numpy as np
 
+try:
+    # SkipNotImplemented is available since 6.0
+    from asv_runner.benchmarks.mark import SkipNotImplemented
+except ImportError:
+    SkipNotImplemented = NotImplementedError
+
+
 class Linspace(Benchmark):
     def setup(self):
         self.d = np.array([1, 2, 3])
@@ -169,6 +176,13 @@ def reversed(size, dtype):
         """
         Returns an array that's in descending order.
         """
+        dtype = np.dtype(dtype)
+        try:
+            with np.errstate(over="raise"):
+                res = dtype.type(size-1)
+        except (OverflowError, FloatingPointError):
+            raise SkipNotImplemented("Cannot construct arange for this size.")
+
         return np.arange(size-1, -1, -1, dtype=dtype)
 
     @staticmethod
 
@@ -43,14 +43,14 @@ When you use :func:`numpy.array` to define a new array, you should
 consider the :doc:`dtype <basics.types>` of the elements in the array,
 which can be specified explicitly. This feature gives you
 more control over the underlying data structures and how the elements
-are handled in C/C++ functions. If you are not careful with ``dtype``
-assignments, you can get unwanted overflow, as such 
-
-::
-
-  >>> a = np.array([127, 128, 129], dtype=np.int8)
-  >>> a
-  array([ 127, -128, -127], dtype=int8)
+are handled in C/C++ functions.
+When values do not fit and you are using a ``dtype``, NumPy may raise an
+error::
+
+  >>> np.array([127, 128, 129], dtype=np.int8)
+  Traceback (most recent call last):
+  ...
+  OverflowError: Python integer 128 out of bounds for int8
 
 An 8-bit signed integer represents integers from -128 to 127.
 Assigning the ``int8`` array to integers outside of this range results
 
@@ -510,9 +510,9 @@ def hugepage_setup():
     # it is tidier organized.
     _core.multiarray._multiarray_umath._reload_guard()
 
-    # TODO: Switch to defaulting to "weak".
+    # TODO: Remove the environment variable entirely now that it is "weak"
     _core._set_promotion_state(
-        os.environ.get("NPY_PROMOTION_STATE", "legacy"))
+        os.environ.get("NPY_PROMOTION_STATE", "weak"))
 
     # Tell PyInstaller where to find hook-numpy.py
     def _pyinstaller_hooks_dir():
 
@@ -1893,7 +1893,7 @@ def add_newdoc(place, name, doc):
     result and can lead to unexpected results in some cases (see
     :ref:`Casting Rules <ufuncs.casting>`):
 
-    >>> a = np.left_shift(np.uint8(255), 1) # Expect 254
+    >>> a = np.left_shift(np.uint8(255), np.int64(1))  # Expect 254
     >>> print(a, type(a)) # Unexpected result due to upcasting
     510 <class 'numpy.int64'>
     >>> b = np.left_shift(np.uint8(255), np.uint8(1))
 
@@ -511,14 +511,12 @@ def can_cast(from_, to, casting=None):
     can_cast(from_, to, casting='safe')
 
     Returns True if cast between data types can occur according to the
-    casting rule.  If from is a scalar or array scalar, also returns
-    True if the scalar value can be cast without overflow or truncation
-    to an integer.
+    casting rule.
 
     Parameters
     ----------
-    from_ : dtype, dtype specifier, scalar, or array
-        Data type, scalar, or array to cast from.
+    from_ : dtype, dtype specifier, NumPy scalar, or array
+        Data type, NumPy scalar, or array to cast from.
     to : dtype or dtype specifier
         Data type to cast to.
     casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
@@ -548,6 +546,10 @@ def can_cast(from_, to, casting=None):
        that the string dtype length is long enough to store the maximum
        integer/float value converted.
 
+    .. versionchanged:: 2.0
+       This function does not support Python scalars anymore and does not
+       apply any value-based logic for 0-D arrays and NumPy scalars.
+
     See also
     --------
     dtype, result_type
@@ -570,52 +572,6 @@ def can_cast(from_, to, casting=None):
     >>> np.can_cast('i4', 'S4')
     False
 
-    Casting scalars
-
-    >>> np.can_cast(100, 'i1')
-    True
-    >>> np.can_cast(150, 'i1')
-    False
-    >>> np.can_cast(150, 'u1')
-    True
-
-    >>> np.can_cast(3.5e100, np.float32)
-    False
-    >>> np.can_cast(1000.0, np.float32)
-    True
-
-    Array scalar checks the value, array does not
-
-    >>> np.can_cast(np.array(1000.0), np.float32)
-    True
-    >>> np.can_cast(np.array([1000.0]), np.float32)
-    False
-
-    Using the casting rules
-
-    >>> np.can_cast('i8', 'i8', 'no')
-    True
-    >>> np.can_cast('<i8', '>i8', 'no')
-    False
-
-    >>> np.can_cast('<i8', '>i8', 'equiv')
-    True
-    >>> np.can_cast('<i4', '>i8', 'equiv')
-    False
-
-    >>> np.can_cast('<i4', '>i8', 'safe')
-    True
-    >>> np.can_cast('<i8', '>i4', 'safe')
-    False
-
-    >>> np.can_cast('<i8', '>i4', 'same_kind')
-    True
-    >>> np.can_cast('<i8', '>u4', 'same_kind')
-    False
-
-    >>> np.can_cast('<i8', '>u4', 'unsafe')
-    True
-
     """
     return (from_,)