TST: Attempt #2 at fixing the int-related failure on 32-bit systems

Author: Bas van Beek

numpy/typing/tests/data/pass/ndarray_misc.py

@@ -11,131 +11,131 @@
 
 class SubClass(np.ndarray): ...
 
-i8 = np.int64(1)
-A = np.array([[1]], dtype=np.int64)
-B0 = np.empty((), dtype=np.int64).view(SubClass)
-B1 = np.empty((1,), dtype=np.int64).view(SubClass)
-B2 = np.empty((1, 1), dtype=np.int64).view(SubClass)
-C = np.array([0, 1, 2], dtype=np.int64)
+i4 = np.int32(1)
+A = np.array([[1]], dtype=np.int32)
+B0 = np.empty((), dtype=np.int32).view(SubClass)
+B1 = np.empty((1,), dtype=np.int32).view(SubClass)
+B2 = np.empty((1, 1), dtype=np.int32).view(SubClass)
+C = np.array([0, 1, 2], dtype=np.int32)
 D = np.empty(3).view(SubClass)
 
-i8.all()
+i4.all()
 A.all()
 A.all(axis=0)
 A.all(keepdims=True)
 A.all(out=B0)
 
-i8.any()
+i4.any()
 A.any()
 A.any(axis=0)
 A.any(keepdims=True)
 A.any(out=B0)
 
-i8.argmax()
+i4.argmax()
 A.argmax()
 A.argmax(axis=0)
 A.argmax(out=B0)
 
-i8.argmin()
+i4.argmin()
 A.argmin()
 A.argmin(axis=0)
 A.argmin(out=B0)
 
-i8.argsort()
+i4.argsort()
 A.argsort()
 
-i8.choose([()])
-_choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)
+i4.choose([()])
+_choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)
 C.choose(_choices)
 C.choose(_choices, out=D)
 
-i8.clip(1)
+i4.clip(1)
 A.clip(1)
 A.clip(None, 1)
 A.clip(1, out=B2)
 A.clip(None, 1, out=B2)
 
-i8.compress([1])
+i4.compress([1])
 A.compress([1])
 A.compress([1], out=B1)
 
-i8.conj()
+i4.conj()
 A.conj()
 B0.conj()
 
-i8.conjugate()
+i4.conjugate()
 A.conjugate()
 B0.conjugate()
 
-i8.cumprod()
+i4.cumprod()
 A.cumprod()
 A.cumprod(out=B1)
 
-i8.cumsum()
+i4.cumsum()
 A.cumsum()
 A.cumsum(out=B1)
 
-i8.max()
+i4.max()
 A.max()
 A.max(axis=0)
 A.max(keepdims=True)
 A.max(out=B0)
 
-i8.mean()
+i4.mean()
 A.mean()
 A.mean(axis=0)
 A.mean(keepdims=True)
 A.mean(out=B0)
 
-i8.min()
+i4.min()
 A.min()
 A.min(axis=0)
 A.min(keepdims=True)
 A.min(out=B0)
 
-i8.newbyteorder()
+i4.newbyteorder()
 A.newbyteorder()
 B0.newbyteorder('|')
 
-i8.prod()
+i4.prod()
 A.prod()
 A.prod(axis=0)
 A.prod(keepdims=True)
 A.prod(out=B0)
 
-i8.ptp()
+i4.ptp()
 A.ptp()
 A.ptp(axis=0)
 A.ptp(keepdims=True)
 A.astype(int).ptp(out=B0)
 
-i8.round()
+i4.round()
 A.round()
 A.round(out=B2)
 
-i8.repeat(1)
+i4.repeat(1)
 A.repeat(1)
 B0.repeat(1)
 
-i8.std()
+i4.std()
 A.std()
 A.std(axis=0)
 A.std(keepdims=True)
 A.std(out=B0.astype(np.float64))
 
-i8.sum()
+i4.sum()
 A.sum()
 A.sum(axis=0)
 A.sum(keepdims=True)
 A.sum(out=B0)
 
-i8.take(0)
+i4.take(0)
 A.take(0)
 A.take([0])
 A.take(0, out=B0)
 A.take([0], out=B1)
 
-i8.var()
+i4.var()
 A.var()
 A.var(axis=0)
 A.var(keepdims=True)