Fix numpy 2 doctests

Author: jarrodmillman

advanced/advanced_numpy/index.rst

@@ -312,7 +312,9 @@ Casting
     >>> y + 1
     array([2, 3, 4, 5], dtype=int8)
     >>> y + 256
-    array([257, 258, 259, 260], dtype=int16)
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    OverflowError: Python integer 256 out of bounds for int8
     >>> y + 256.0
     array([257.,  258.,  259.,  260.])
     >>> y + np.array([256], dtype=np.int32)
@@ -507,9 +509,9 @@ Main point
     (3, 1)
     >>> byte_offset = 3 * 1 + 1 * 2  # to find x[1, 2]
     >>> x.flat[byte_offset]
-    6
+    np.int8(6)
     >>> x[1, 2]
-    6
+    np.int8(6)
 
 simple, **flexible**
 
@@ -1343,18 +1345,12 @@ Array siblings: :class:`chararray`, :class:`maskedarray`
 :class:`chararray`: vectorized string operations
 --------------------------------------------------
 
->>> x = np.array(['a', '  bbb', '  ccc']).view(np.chararray)
->>> x.lstrip(' ')
-chararray(['a', 'bbb', 'ccc'],
-      dtype='...')
+>>> x = np.char.asarray(['a', '  bbb', '  ccc'])
+>>> x
+chararray(['a', '  bbb', '  ccc'], dtype='<U5')
 >>> x.upper()
-chararray(['A', '  BBB', '  CCC'],
-      dtype='...')
+chararray(['A', '  BBB', '  CCC'], dtype='<U5')
 
-.. note::
-
-   ``.view()`` has a second meaning: it can make an ndarray an instance
-   of a specialized ndarray subclass
 
 :class:`masked_array` missing data
 ------------------------------------
@@ -1376,9 +1372,9 @@ One way to describe this is to create a masked array::
 Masked mean ignores masked data::
 
     >>> mx.mean()
-    2.75
+    np.float64(2.75)
     >>> np.mean(mx)
-    2.75
+    np.float64(2.75)
 
 .. warning:: Not all NumPy functions respect masks, for instance
    ``np.dot``, so check the return types.
@@ -1588,7 +1584,7 @@ Good bug report
 3. Version of NumPy/SciPy
 
    >>> print(np.__version__)
-   1...
+   2...
 
    **Check that the following is what you expect**
 

advanced/image_processing/index.rst

@@ -137,7 +137,7 @@ Increase contrast by setting min and max values::
     <matplotlib.image.AxesImage object at 0x...>
     >>> # Remove axes and ticks
     >>> plt.axis('off')
-    (-0.5, 1023.5, 767.5, -0.5)
+    (np.float64(-0.5), np.float64(1023.5), np.float64(767.5), np.float64(-0.5))
 
 Draw contour lines::
 
@@ -190,7 +190,7 @@ Images are arrays: use the whole ``numpy`` machinery.
 
     >>> face = sp.datasets.face(gray=True)
     >>> face[0, 40]
-    127
+    np.uint8(127)
     >>> # Slicing
     >>> face[10:13, 20:23]
     array([[141, 153, 145],
@@ -222,9 +222,9 @@ Statistical information
 
     >>> face = sp.datasets.face(gray=True)
     >>> face.mean()
-    113.48026784261067
+    np.float64(113.48026784261067)
     >>> face.max(), face.min()
-    (250, 0)
+    (np.uint8(250), np.uint8(0))
 
 
 ``np.histogram``
@@ -653,9 +653,9 @@ Use mathematical morphology to clean up the result::
         >>> eroded_tmp = sp.ndimage.binary_erosion(tmp)
         >>> reconstruct_final = np.logical_not(sp.ndimage.binary_propagation(eroded_tmp, mask=tmp))
         >>> np.abs(mask - close_img).mean()
-        0.00640699...
+        np.float64(0.00640699...)
         >>> np.abs(mask - reconstruct_final).mean()
-        0.00082232...
+        np.float64(0.00082232...)
 
 .. topic:: **Exercise**
     :class: green

advanced/mathematical_optimization/index.rst

@@ -180,9 +180,9 @@ Brent's method to find the minimum of a function:
     True
     >>> x_min = result.x
     >>> x_min
-    0.50...
+    np.float64(0.50...)
     >>> x_min - 0.5
-    5.8...e-09
+    np.float64(5.8...e-09)
 
 
 .. |1d_optim_1| image:: auto_examples/images/sphx_glr_plot_1d_optim_001.png
@@ -824,7 +824,7 @@ handy.
    given, and a gradient computed numerically:
 
     >>> sp.optimize.check_grad(f, jacobian, [2, -1])
-    2.384185791015625e-07
+    np.float64(2.384185791015625e-07)
 
    See also :func:`scipy.optimize.approx_fprime` to find your errors.
 
@@ -897,7 +897,7 @@ if we compute the norm ourselves and use a good generic optimizer
     ...     return np.sum(f(x)**2)
     >>> result = sp.optimize.minimize(g, x0, method="BFGS")
     >>> result.fun
-    2.6940...e-11
+    np.float64(2.6940...e-11)
 
 BFGS needs more function calls, and gives a less precise result.
 

advanced/scipy_sparse/dia_array.rst

@@ -63,15 +63,15 @@ Examples
     >>> mtx.offsets
     array([ 0, -1,  2], dtype=int32)
     >>> print(mtx)
-      (0, 0)        1
-      (1, 1)        2
-      (2, 2)        3
-      (3, 3)        4
-      (1, 0)        5
-      (2, 1)        6
-      (3, 2)        7
-      (0, 2)        11
-      (1, 3)        12
+    (np.int32(0), np.int32(0))	1
+    (np.int32(1), np.int32(1))	2
+    (np.int32(2), np.int32(2))	3
+    (np.int32(3), np.int32(3))	4
+    (np.int32(1), np.int32(0))	5
+    (np.int32(2), np.int32(1))	6
+    (np.int32(3), np.int32(2))	7
+    (np.int32(0), np.int32(2))	11
+    (np.int32(1), np.int32(3))	12
     >>> mtx.toarray()
     array([[ 1,  0, 11,  0],
            [ 5,  2,  0, 12],

advanced/scipy_sparse/dok_array.rst

@@ -46,7 +46,7 @@ Examples
 * slicing and indexing::
 
     >>> mtx[1, 1]
-    0.0
+    np.float64(0.0)
     >>> mtx[[1], 1:3]
     <1x2 sparse array of type '<... 'numpy.float64'>'
           with 1 stored elements in Dictionary Of Keys format>

intro/numpy/advanced_operations.rst

@@ -25,7 +25,7 @@ For example, :math:`3x^2 + 2x - 1`::
 
     >>> p = np.poly1d([3, 2, -1])
     >>> p(0)
-    -1
+    np.int64(-1)
     >>> p.roots
     array([-1.        ,  0.33333333])
     >>> p.order
@@ -60,7 +60,7 @@ e.g. the Chebyshev basis.
 
     >>> p = np.polynomial.Polynomial([-1, 2, 3]) # coefs in different order!
     >>> p(0)
-    -1.0
+    np.float64(-1.0)
     >>> p.roots()
     array([-1.        ,  0.33333333])
     >>> p.degree()  # In general polynomials do not always expose 'order'

intro/numpy/array_object.rst

@@ -463,7 +463,7 @@ other Python sequences (e.g. lists):
     >>> a
     array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
     >>> a[0], a[2], a[-1]
-    (0, 2, 9)
+    (np.int64(0), np.int64(2), np.int64(9))
 
 .. warning::
 
@@ -487,7 +487,7 @@ For multidimensional arrays, indices are tuples of integers:
            [0, 1, 0],
            [0, 0, 2]])
     >>> a[1, 1]
-    1
+    np.int64(1)
     >>> a[2, 1] = 10 # third line, second column
     >>> a
     array([[ 0,  0,  0],

intro/numpy/elaborate_arrays.rst

@@ -97,14 +97,14 @@ Floating-point numbers:
 ::
 
     >>> np.finfo(np.float32).eps
-    1.1920929e-07
+    np.float32(1.1920929e-07)
     >>> np.finfo(np.float64).eps
-    2.2204460492503131e-16
+    np.float64(2.220446049250313e-16)
 
     >>> np.float32(1e-8) + np.float32(1) == 1
-    True
+    np.True_
     >>> np.float64(1e-8) + np.float64(1) == 1
-    False
+    np.False_
 
 Complex floating-point numbers:
 
@@ -173,11 +173,11 @@ Field access works by indexing with field names::
     >>> samples['value']
     array([0.37,  0.11,  0.13,  0.37,  0.11,  0.13])
     >>> samples[0]
-    (b'ALFA', 1., 0.37)
+    np.void((b'ALFA', 1.0, 0.37), dtype=[('sensor_code', 'S4'), ('position', '<f8'), ('value', '<f8')])
 
     >>> samples[0]['sensor_code'] = 'TAU'
     >>> samples[0]
-    (b'TAU', 1., 0.37)
+    np.void((b'TAU', 1.0, 0.37), dtype=[('sensor_code', 'S4'), ('position', '<f8'), ('value', '<f8')])
 
 Multiple fields at once::
 

intro/numpy/operations.rst

@@ -208,9 +208,9 @@ Computing sums
 
     >>> x = np.array([1, 2, 3, 4])
     >>> np.sum(x)
-    10
+    np.int64(10)
     >>> x.sum()
-    10
+    np.int64(10)
 
 .. image:: images/reductions.png
    :align: right
@@ -226,11 +226,11 @@ Sum by rows and by columns:
     >>> x.sum(axis=0)   # columns (first dimension)
     array([3, 3])
     >>> x[:, 0].sum(), x[:, 1].sum()
-    (3, 3)
+    (np.int64(3), np.int64(3))
     >>> x.sum(axis=1)   # rows (second dimension)
     array([2, 4])
     >>> x[0, :].sum(), x[1, :].sum()
-    (2, 4)
+    (np.int64(2), np.int64(4))
 
 .. tip::
 
@@ -241,9 +241,9 @@ Sum by rows and by columns:
     >>> rng = np.random.default_rng(27446968)
     >>> x = rng.random((2, 2, 2))
     >>> x.sum(axis=2)[0, 1]
-    0.73415...
+    np.float64(0.73415...)
     >>> x[0, 1, :].sum()
-    0.73415...
+    np.float64(0.73415...)
 
 Other reductions
 ................
@@ -256,23 +256,23 @@ Other reductions
 
   >>> x = np.array([1, 3, 2])
   >>> x.min()
-  1
+  np.int64(1)
   >>> x.max()
-  3
+  np.int64(3)
 
   >>> x.argmin()  # index of minimum
-  0
+  np.int64(0)
   >>> x.argmax()  # index of maximum
-  1
+  np.int64(1)
 
 **Logical operations:**
 
 .. sourcecode:: pycon
 
   >>> np.all([True, True, False])
-  False
+  np.False_
   >>> np.any([True, True, False])
-  True
+  np.True_
 
 .. note::
 
@@ -282,15 +282,15 @@ Other reductions
 
       >>> a = np.zeros((100, 100))
       >>> np.any(a != 0)
-      False
+      np.False_
       >>> np.all(a == a)
-      True
+      np.True_
 
       >>> a = np.array([1, 2, 3, 2])
       >>> b = np.array([2, 2, 3, 2])
       >>> c = np.array([6, 4, 4, 5])
       >>> ((a <= b) & (b <= c)).all()
-      True
+      np.True_
 
 **Statistics:**
 
@@ -299,14 +299,14 @@ Other reductions
   >>> x = np.array([1, 2, 3, 1])
   >>> y = np.array([[1, 2, 3], [5, 6, 1]])
   >>> x.mean()
-  1.75
+  np.float64(1.75)
   >>> np.median(x)
-  1.5
+  np.float64(1.5)
   >>> np.median(y, axis=-1) # last axis
   array([2.,  5.])
 
   >>> x.std()          # full population standard dev.
-  0.82915619758884995
+  np.float64(0.82915619758884995)
 
 
 ... and many more (best to learn as you go).
@@ -709,20 +709,20 @@ Dimension shuffling
     >>> a.shape
     (4, 3, 2)
     >>> a[0, 2, 1]
-    5
+    np.int64(5)
     >>> b = a.transpose(1, 2, 0)
     >>> b.shape
     (3, 2, 4)
     >>> b[2, 1, 0]
-    5
+    np.int64(5)
 
 Also creates a view:
 
 .. sourcecode:: pycon
 
     >>> b[2, 1, 0] = -1
     >>> a[0, 2, 1]
-    -1
+    np.int64(-1)
 
 Resizing
 ........
@@ -817,7 +817,7 @@ Finding minima and maxima:
     >>> j_max = np.argmax(a)
     >>> j_min = np.argmin(a)
     >>> j_max, j_min
-    (0, 2)
+    (np.int64(0), np.int64(2))
 
 
 .. XXX: need a frame for summaries

intro/scipy/image_processing/image_processing.rst

@@ -40,7 +40,7 @@ Changing orientation, resolution, .. ::
     <matplotlib.image.AxesImage object at 0x...>
 
     >>> plt.axis('off')
-    (-0.5, 1023.5, 767.5, -0.5)
+    (np.float64(-0.5), np.float64(1023.5), np.float64(767.5), np.float64(-0.5))
 
     >>> # etc.