Team Ai
Datasetpublic

codekingpro/portable-devtools

sourceHugging Faceupdated 5mo agoView on Hugging Face
1likes14kdownloads
rootpythonuser_packagesPython313site-packagesnumpytypingtestsdatarevealma.pyi
ma.pyi1099 linesDownload Raw Back to reveal
1from typing import Any, Generic, Literal, NoReturn, TypeAlias, TypeVar, assert_type
2
3import numpy as np
4from numpy import dtype, generic
5from numpy._typing import NDArray, _AnyShape
6
7_ScalarT = TypeVar("_ScalarT", bound=generic)
8_ScalarT_co = TypeVar("_ScalarT_co", bound=generic, covariant=True)
9
10MaskedArray: TypeAlias = np.ma.MaskedArray[_AnyShape, dtype[_ScalarT]]
11_NoMaskType: TypeAlias = np.bool[Literal[False]]
12_Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]]
13
14class MaskedArraySubclass(MaskedArray[_ScalarT_co]): ...
15
16class IntoMaskedArraySubClass(Generic[_ScalarT_co]):
17    def __array__(self) -> MaskedArraySubclass[_ScalarT_co]: ...
18
19MaskedArraySubclassC: TypeAlias = MaskedArraySubclass[np.complex128]
20
21AR_b: NDArray[np.bool]
22AR_f4: NDArray[np.float32]
23AR_i8: NDArray[np.int64]
24AR_u4: NDArray[np.uint32]
25AR_dt64: NDArray[np.datetime64]
26AR_td64: NDArray[np.timedelta64]
27AR_o: NDArray[np.timedelta64]
28
29AR_LIKE_b: list[bool]
30AR_LIKE_u: list[np.uint32]
31AR_LIKE_i: list[int]
32AR_LIKE_f: list[float]
33AR_LIKE_c: list[complex]
34AR_LIKE_td64: list[np.timedelta64]
35AR_LIKE_dt64: list[np.datetime64]
36AR_LIKE_o: list[np.object_]
37AR_number: NDArray[np.number]
38
39MAR_c8: MaskedArray[np.complex64]
40MAR_c16: MaskedArray[np.complex128]
41MAR_b: MaskedArray[np.bool]
42MAR_f4: MaskedArray[np.float32]
43MAR_f8: MaskedArray[np.float64]
44MAR_i8: MaskedArray[np.int64]
45MAR_u4: MaskedArray[np.uint32]
46MAR_dt64: MaskedArray[np.datetime64]
47MAR_td64: MaskedArray[np.timedelta64]
48MAR_o: MaskedArray[np.object_]
49MAR_s: MaskedArray[np.str_]
50MAR_byte: MaskedArray[np.bytes_]
51MAR_V: MaskedArray[np.void]
52MAR_floating: MaskedArray[np.floating]
53MAR_number: MaskedArray[np.number]
54
55MAR_subclass: MaskedArraySubclassC
56MAR_into_subclass: IntoMaskedArraySubClass[np.float32]
57
58MAR_1d: np.ma.MaskedArray[tuple[int], np.dtype]
59MAR_2d_f4: np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]]
60MAR_2d_V: np.ma.MaskedArray[tuple[int, int], np.dtype[np.void]]
61
62b: np.bool
63f4: np.float32
64f: float
65i: int
66
67assert_type(MAR_1d.shape, tuple[int])
68
69assert_type(MAR_f4.dtype, np.dtype[np.float32])
70
71assert_type(int(MAR_i8), int)
72assert_type(float(MAR_f4), float)
73
74assert_type(np.ma.min(MAR_b), np.bool)
75assert_type(np.ma.min(MAR_f4), np.float32)
76assert_type(np.ma.min(MAR_b, axis=0), Any)
77assert_type(np.ma.min(MAR_f4, axis=0), Any)
78assert_type(np.ma.min(MAR_b, keepdims=True), Any)
79assert_type(np.ma.min(MAR_f4, keepdims=True), Any)
80assert_type(np.ma.min(MAR_f4, out=MAR_subclass), MaskedArraySubclassC)
81assert_type(np.ma.min(MAR_f4, 0, MAR_subclass), MaskedArraySubclassC)
82assert_type(np.ma.min(MAR_f4, None, MAR_subclass), MaskedArraySubclassC)
83
84assert_type(MAR_b.min(), np.bool)
85assert_type(MAR_f4.min(), np.float32)
86assert_type(MAR_b.min(axis=0), Any)
87assert_type(MAR_f4.min(axis=0), Any)
88assert_type(MAR_b.min(keepdims=True), Any)
89assert_type(MAR_f4.min(keepdims=True), Any)
90assert_type(MAR_f4.min(out=MAR_subclass), MaskedArraySubclassC)
91assert_type(MAR_f4.min(0, MAR_subclass), MaskedArraySubclassC)
92assert_type(MAR_f4.min(None, MAR_subclass), MaskedArraySubclassC)
93
94assert_type(np.ma.max(MAR_b), np.bool)
95assert_type(np.ma.max(MAR_f4), np.float32)
96assert_type(np.ma.max(MAR_b, axis=0), Any)
97assert_type(np.ma.max(MAR_f4, axis=0), Any)
98assert_type(np.ma.max(MAR_b, keepdims=True), Any)
99assert_type(np.ma.max(MAR_f4, keepdims=True), Any)
100assert_type(np.ma.max(MAR_f4, out=MAR_subclass), MaskedArraySubclassC)
101assert_type(np.ma.max(MAR_f4, 0, MAR_subclass), MaskedArraySubclassC)
102assert_type(np.ma.max(MAR_f4, None, MAR_subclass), MaskedArraySubclassC)
103
104assert_type(MAR_b.max(), np.bool)
105assert_type(MAR_f4.max(), np.float32)
106assert_type(MAR_b.max(axis=0), Any)
107assert_type(MAR_f4.max(axis=0), Any)
108assert_type(MAR_b.max(keepdims=True), Any)
109assert_type(MAR_f4.max(keepdims=True), Any)
110assert_type(MAR_f4.max(out=MAR_subclass), MaskedArraySubclassC)
111assert_type(MAR_f4.max(0, MAR_subclass), MaskedArraySubclassC)
112assert_type(MAR_f4.max(None, MAR_subclass), MaskedArraySubclassC)
113
114assert_type(np.ma.ptp(MAR_b), np.bool)
115assert_type(np.ma.ptp(MAR_f4), np.float32)
116assert_type(np.ma.ptp(MAR_b, axis=0), Any)
117assert_type(np.ma.ptp(MAR_f4, axis=0), Any)
118assert_type(np.ma.ptp(MAR_b, keepdims=True), Any)
119assert_type(np.ma.ptp(MAR_f4, keepdims=True), Any)
120assert_type(np.ma.ptp(MAR_f4, out=MAR_subclass), MaskedArraySubclassC)
121assert_type(np.ma.ptp(MAR_f4, 0, MAR_subclass), MaskedArraySubclassC)
122assert_type(np.ma.ptp(MAR_f4, None, MAR_subclass), MaskedArraySubclassC)
123
124assert_type(MAR_b.ptp(), np.bool)
125assert_type(MAR_f4.ptp(), np.float32)
126assert_type(MAR_b.ptp(axis=0), Any)
127assert_type(MAR_f4.ptp(axis=0), Any)
128assert_type(MAR_b.ptp(keepdims=True), Any)
129assert_type(MAR_f4.ptp(keepdims=True), Any)
130assert_type(MAR_f4.ptp(out=MAR_subclass), MaskedArraySubclassC)
131assert_type(MAR_f4.ptp(0, MAR_subclass), MaskedArraySubclassC)
132assert_type(MAR_f4.ptp(None, MAR_subclass), MaskedArraySubclassC)
133
134assert_type(MAR_b.argmin(), np.intp)
135assert_type(MAR_f4.argmin(), np.intp)
136assert_type(MAR_f4.argmax(fill_value=6.28318, keepdims=False), np.intp)
137assert_type(MAR_b.argmin(axis=0), Any)
138assert_type(MAR_f4.argmin(axis=0), Any)
139assert_type(MAR_b.argmin(keepdims=True), Any)
140assert_type(MAR_f4.argmin(out=MAR_subclass), MaskedArraySubclassC)
141assert_type(MAR_f4.argmin(None, None, out=MAR_subclass), MaskedArraySubclassC)
142
143assert_type(np.ma.argmin(MAR_b), np.intp)
144assert_type(np.ma.argmin(MAR_f4), np.intp)
145assert_type(np.ma.argmin(MAR_f4, fill_value=6.28318, keepdims=False), np.intp)
146assert_type(np.ma.argmin(MAR_b, axis=0), Any)
147assert_type(np.ma.argmin(MAR_f4, axis=0), Any)
148assert_type(np.ma.argmin(MAR_b, keepdims=True), Any)
149assert_type(np.ma.argmin(MAR_f4, out=MAR_subclass), MaskedArraySubclassC)
150assert_type(np.ma.argmin(MAR_f4, None, None, out=MAR_subclass), MaskedArraySubclassC)
151
152assert_type(MAR_b.argmax(), np.intp)
153assert_type(MAR_f4.argmax(), np.intp)
154assert_type(MAR_f4.argmax(fill_value=6.28318, keepdims=False), np.intp)
155assert_type(MAR_b.argmax(axis=0), Any)
156assert_type(MAR_f4.argmax(axis=0), Any)
157assert_type(MAR_b.argmax(keepdims=True), Any)
158assert_type(MAR_f4.argmax(out=MAR_subclass), MaskedArraySubclassC)
159assert_type(MAR_f4.argmax(None, None, out=MAR_subclass), MaskedArraySubclassC)
160
161assert_type(np.ma.argmax(MAR_b), np.intp)
162assert_type(np.ma.argmax(MAR_f4), np.intp)
163assert_type(np.ma.argmax(MAR_f4, fill_value=6.28318, keepdims=False), np.intp)
164assert_type(np.ma.argmax(MAR_b, axis=0), Any)
165assert_type(np.ma.argmax(MAR_f4, axis=0), Any)
166assert_type(np.ma.argmax(MAR_b, keepdims=True), Any)
167assert_type(np.ma.argmax(MAR_f4, out=MAR_subclass), MaskedArraySubclassC)
168assert_type(np.ma.argmax(MAR_f4, None, None, out=MAR_subclass), MaskedArraySubclassC)
169
170assert_type(MAR_b.all(), np.bool)
171assert_type(MAR_f4.all(), np.bool)
172assert_type(MAR_f4.all(keepdims=False), np.bool)
173assert_type(MAR_b.all(axis=0), np.bool | MaskedArray[np.bool])
174assert_type(MAR_b.all(axis=0, keepdims=True), MaskedArray[np.bool])
175assert_type(MAR_b.all(0, None, True), MaskedArray[np.bool])
176assert_type(MAR_f4.all(axis=0), np.bool | MaskedArray[np.bool])
177assert_type(MAR_b.all(keepdims=True), MaskedArray[np.bool])
178assert_type(MAR_f4.all(out=MAR_subclass), MaskedArraySubclassC)
179assert_type(MAR_f4.all(None, out=MAR_subclass), MaskedArraySubclassC)
180
181assert_type(MAR_b.any(), np.bool)
182assert_type(MAR_f4.any(), np.bool)
183assert_type(MAR_f4.any(keepdims=False), np.bool)
184assert_type(MAR_b.any(axis=0), np.bool | MaskedArray[np.bool])
185assert_type(MAR_b.any(axis=0, keepdims=True), MaskedArray[np.bool])
186assert_type(MAR_b.any(0, None, True), MaskedArray[np.bool])
187assert_type(MAR_f4.any(axis=0), np.bool | MaskedArray[np.bool])
188assert_type(MAR_b.any(keepdims=True), MaskedArray[np.bool])
189assert_type(MAR_f4.any(out=MAR_subclass), MaskedArraySubclassC)
190assert_type(MAR_f4.any(None, out=MAR_subclass), MaskedArraySubclassC)
191
192assert_type(MAR_f4.sort(), None)
193assert_type(MAR_f4.sort(axis=0, kind="quicksort", order="K", endwith=False, fill_value=42., stable=False), None)
194
195assert_type(np.ma.sort(MAR_f4), MaskedArray[np.float32])
196assert_type(np.ma.sort(MAR_subclass), MaskedArraySubclassC)
197assert_type(np.ma.sort([[0, 1], [2, 3]]), NDArray[Any])
198assert_type(np.ma.sort(AR_f4), NDArray[np.float32])
199
200assert_type(MAR_f8.take(0), np.float64)
201assert_type(MAR_1d.take(0), Any)
202assert_type(MAR_f8.take([0]), MaskedArray[np.float64])
203assert_type(MAR_f8.take(0, out=MAR_subclass), MaskedArraySubclassC)
204assert_type(MAR_f8.take([0], out=MAR_subclass), MaskedArraySubclassC)
205
206assert_type(np.ma.take(f, 0), Any)
207assert_type(np.ma.take(f4, 0), np.float32)
208assert_type(np.ma.take(MAR_f8, 0), np.float64)
209assert_type(np.ma.take(AR_f4, 0), np.float32)
210assert_type(np.ma.take(MAR_1d, 0), Any)
211assert_type(np.ma.take(MAR_f8, [0]), MaskedArray[np.float64])
212assert_type(np.ma.take(AR_f4, [0]), MaskedArray[np.float32])
213assert_type(np.ma.take(MAR_f8, 0, out=MAR_subclass), MaskedArraySubclassC)
214assert_type(np.ma.take(MAR_f8, [0], out=MAR_subclass), MaskedArraySubclassC)
215assert_type(np.ma.take([1], [0]), MaskedArray[Any])
216assert_type(np.ma.take(np.eye(2), 1, axis=0), MaskedArray[np.float64])
217
218assert_type(MAR_f4.partition(1), None)
219assert_type(MAR_V.partition(1, axis=0, kind="introselect", order="K"), None)
220
221assert_type(MAR_f4.argpartition(1), MaskedArray[np.intp])
222assert_type(MAR_1d.argpartition(1, axis=0, kind="introselect", order="K"), MaskedArray[np.intp])
223
224assert_type(np.ma.ndim(f4), int)
225assert_type(np.ma.ndim(MAR_b), int)
226assert_type(np.ma.ndim(AR_f4), int)
227
228assert_type(np.ma.size(b), int)
229assert_type(np.ma.size(MAR_f4, axis=0), int)
230assert_type(np.ma.size(AR_f4), int)
231
232assert_type(np.ma.is_masked(MAR_f4), bool)
233
234assert_type(MAR_f4.ids(), tuple[int, int])
235
236assert_type(MAR_f4.iscontiguous(), bool)
237
238assert_type(MAR_f4 >= 3, MaskedArray[np.bool])
239assert_type(MAR_i8 >= AR_td64, MaskedArray[np.bool])
240assert_type(MAR_b >= AR_td64, MaskedArray[np.bool])
241assert_type(MAR_td64 >= AR_td64, MaskedArray[np.bool])
242assert_type(MAR_dt64 >= AR_dt64, MaskedArray[np.bool])
243assert_type(MAR_o >= AR_o, MaskedArray[np.bool])
244assert_type(MAR_1d >= 0, MaskedArray[np.bool])
245assert_type(MAR_s >= MAR_s, MaskedArray[np.bool])
246assert_type(MAR_byte >= MAR_byte, MaskedArray[np.bool])
247
248assert_type(MAR_f4 > 3, MaskedArray[np.bool])
249assert_type(MAR_i8 > AR_td64, MaskedArray[np.bool])
250assert_type(MAR_b > AR_td64, MaskedArray[np.bool])
251assert_type(MAR_td64 > AR_td64, MaskedArray[np.bool])
252assert_type(MAR_dt64 > AR_dt64, MaskedArray[np.bool])
253assert_type(MAR_o > AR_o, MaskedArray[np.bool])
254assert_type(MAR_1d > 0, MaskedArray[np.bool])
255assert_type(MAR_s > MAR_s, MaskedArray[np.bool])
256assert_type(MAR_byte > MAR_byte, MaskedArray[np.bool])
257
258assert_type(MAR_f4 <= 3, MaskedArray[np.bool])
259assert_type(MAR_i8 <= AR_td64, MaskedArray[np.bool])
260assert_type(MAR_b <= AR_td64, MaskedArray[np.bool])
261assert_type(MAR_td64 <= AR_td64, MaskedArray[np.bool])
262assert_type(MAR_dt64 <= AR_dt64, MaskedArray[np.bool])
263assert_type(MAR_o <= AR_o, MaskedArray[np.bool])
264assert_type(MAR_1d <= 0, MaskedArray[np.bool])
265assert_type(MAR_s <= MAR_s, MaskedArray[np.bool])
266assert_type(MAR_byte <= MAR_byte, MaskedArray[np.bool])
267
268assert_type(MAR_f4 < 3, MaskedArray[np.bool])
269assert_type(MAR_i8 < AR_td64, MaskedArray[np.bool])
270assert_type(MAR_b < AR_td64, MaskedArray[np.bool])
271assert_type(MAR_td64 < AR_td64, MaskedArray[np.bool])
272assert_type(MAR_dt64 < AR_dt64, MaskedArray[np.bool])
273assert_type(MAR_o < AR_o, MaskedArray[np.bool])
274assert_type(MAR_1d < 0, MaskedArray[np.bool])
275assert_type(MAR_s < MAR_s, MaskedArray[np.bool])
276assert_type(MAR_byte < MAR_byte, MaskedArray[np.bool])
277
278assert_type(MAR_f4 <= 3, MaskedArray[np.bool])
279assert_type(MAR_i8 <= AR_td64, MaskedArray[np.bool])
280assert_type(MAR_b <= AR_td64, MaskedArray[np.bool])
281assert_type(MAR_td64 <= AR_td64, MaskedArray[np.bool])
282assert_type(MAR_dt64 <= AR_dt64, MaskedArray[np.bool])
283assert_type(MAR_o <= AR_o, MaskedArray[np.bool])
284assert_type(MAR_1d <= 0, MaskedArray[np.bool])
285assert_type(MAR_s <= MAR_s, MaskedArray[np.bool])
286assert_type(MAR_byte <= MAR_byte, MaskedArray[np.bool])
287
288assert_type(MAR_byte.count(), int)
289assert_type(MAR_f4.count(axis=None), int)
290assert_type(MAR_f4.count(axis=0), NDArray[np.int_])
291assert_type(MAR_b.count(axis=(0, 1)), NDArray[np.int_])
292assert_type(MAR_o.count(keepdims=True), NDArray[np.int_])
293assert_type(MAR_o.count(axis=None, keepdims=True), NDArray[np.int_])
294assert_type(MAR_o.count(None, True), NDArray[np.int_])
295
296assert_type(np.ma.count(MAR_byte), int)
297assert_type(np.ma.count(MAR_byte, axis=None), int)
298assert_type(np.ma.count(MAR_f4, axis=0), NDArray[np.int_])
299assert_type(np.ma.count(MAR_b, axis=(0, 1)), NDArray[np.int_])
300assert_type(np.ma.count(MAR_o, keepdims=True), NDArray[np.int_])
301assert_type(np.ma.count(MAR_o, axis=None, keepdims=True), NDArray[np.int_])
302assert_type(np.ma.count(MAR_o, None, True), NDArray[np.int_])
303
304assert_type(MAR_f4.compressed(), np.ndarray[tuple[int], np.dtype[np.float32]])
305
306assert_type(MAR_f4.compress([True, False]), np.ma.MaskedArray[tuple[int], np.dtype[np.float32]])
307assert_type(MAR_f4.compress([True, False], axis=0), MaskedArray[np.float32])
308assert_type(MAR_f4.compress([True, False], axis=0, out=MAR_subclass), MaskedArraySubclassC)
309assert_type(MAR_f4.compress([True, False], 0, MAR_subclass), MaskedArraySubclassC)
310
311assert_type(np.ma.compressed(MAR_i8), np.ndarray[tuple[int], np.dtype[np.int64]])
312assert_type(np.ma.compressed([[1, 2, 3]]), np.ndarray[tuple[int], np.dtype])
313
314assert_type(MAR_f4.put([0, 4, 8], [10, 20, 30]), None)
315assert_type(MAR_f4.put(4, 999), None)
316assert_type(MAR_f4.put(4, 999, mode="clip"), None)
317
318assert_type(MAR_c8.__array_wrap__(AR_b), MaskedArray[np.bool])
319
320assert_type(np.ma.put(MAR_f4, [0, 4, 8], [10, 20, 30]), None)
321assert_type(np.ma.put(MAR_f4, 4, 999), None)
322assert_type(np.ma.put(MAR_f4, 4, 999, mode="clip"), None)
323
324assert_type(np.ma.putmask(MAR_f4, [True, False], [0, 1]), None)
325assert_type(np.ma.putmask(MAR_f4, np.False_, [0, 1]), None)
326
327assert_type(MAR_f4.filled(float("nan")), NDArray[np.float32])
328assert_type(MAR_i8.filled(), NDArray[np.int64])
329assert_type(MAR_1d.filled(), np.ndarray[tuple[int], np.dtype])
330
331assert_type(np.ma.filled(MAR_f4, float("nan")), NDArray[np.float32])
332assert_type(np.ma.filled([[1, 2, 3]]), NDArray[Any])
333# PyRight detects this one correctly, but mypy doesn't.
334# https://github.com/numpy/numpy/pull/28742#discussion_r2048968375
335assert_type(np.ma.filled(MAR_1d), np.ndarray[tuple[int], np.dtype])  # type: ignore[assert-type]
336
337assert_type(MAR_b.repeat(3), np.ma.MaskedArray[tuple[int], np.dtype[np.bool]])
338assert_type(MAR_2d_f4.repeat(MAR_i8), np.ma.MaskedArray[tuple[int], np.dtype[np.float32]])
339assert_type(MAR_2d_f4.repeat(MAR_i8, axis=None), np.ma.MaskedArray[tuple[int], np.dtype[np.float32]])
340assert_type(MAR_2d_f4.repeat(MAR_i8, axis=0), MaskedArray[np.float32])
341
342assert_type(np.ma.allequal(AR_f4, MAR_f4), bool)
343assert_type(np.ma.allequal(AR_f4, MAR_f4, fill_value=False), bool)
344
345assert_type(np.ma.allclose(AR_f4, MAR_f4), bool)
346assert_type(np.ma.allclose(AR_f4, MAR_f4, masked_equal=False), bool)
347assert_type(np.ma.allclose(AR_f4, MAR_f4, rtol=.4, atol=.3), bool)
348
349assert_type(MAR_2d_f4.ravel(), np.ma.MaskedArray[tuple[int], np.dtype[np.float32]])
350assert_type(MAR_1d.ravel(order="A"), np.ma.MaskedArray[tuple[int], np.dtype[Any]])
351
352assert_type(np.ma.getmask(MAR_f4), NDArray[np.bool] | _NoMaskType)
353# PyRight detects this one correctly, but mypy doesn't:
354# `Revealed type is "Union[numpy.ndarray[Any, Any], numpy.bool[Any]]"`
355assert_type(np.ma.getmask(MAR_1d), np.ndarray[tuple[int], np.dtype[np.bool]] | np.bool)  # type: ignore[assert-type]
356assert_type(np.ma.getmask(MAR_2d_f4), np.ndarray[tuple[int, int], np.dtype[np.bool]] | _NoMaskType)
357assert_type(np.ma.getmask([1, 2]), NDArray[np.bool] | _NoMaskType)
358assert_type(np.ma.getmask(np.int64(1)), _NoMaskType)
359
360assert_type(np.ma.is_mask(MAR_1d), bool)
361assert_type(np.ma.is_mask(AR_b), bool)
362
363def func(x: object) -> None:
364    if np.ma.is_mask(x):
365        assert_type(x, NDArray[np.bool])
366    else:
367        assert_type(x, object)
368
369assert_type(MAR_2d_f4.mT, np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
370
371assert_type(MAR_c16.real, MaskedArray[np.float64])
372assert_type(MAR_c16.imag, MaskedArray[np.float64])
373
374assert_type(MAR_2d_f4.baseclass, type[NDArray[Any]])
375
376assert_type(MAR_b.swapaxes(0, 1), MaskedArray[np.bool])
377assert_type(MAR_2d_f4.swapaxes(1, 0), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
378
379assert_type(MAR_2d_f4[AR_i8], MaskedArray[np.float32])
380assert_type(MAR_2d_f4[[1, 2, 3]], MaskedArray[np.float32])
381assert_type(MAR_2d_f4[1:], MaskedArray[np.float32])
382assert_type(MAR_2d_f4[:], MaskedArray[np.float32])
383assert_type(MAR_2d_f4[0, 0], Any)
384assert_type(MAR_2d_f4[:, np.newaxis], MaskedArray[np.float32])
385assert_type(MAR_2d_f4[..., -1], MaskedArray[np.float32])
386assert_type(MAR_2d_V["field_0"], np.ma.MaskedArray[tuple[int, int], np.dtype])
387assert_type(MAR_2d_V[["field_0", "field_1"]], np.ma.MaskedArray[tuple[int, int], np.dtype[np.void]])
388
389assert_type(np.ma.nomask, np.bool[Literal[False]])
390assert_type(np.ma.MaskType, type[np.bool])
391
392assert_type(MAR_1d.__setmask__([True, False]), None)
393assert_type(MAR_1d.__setmask__(np.False_), None)
394
395assert_type(MAR_2d_f4.harden_mask(), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
396assert_type(MAR_i8.harden_mask(), MaskedArray[np.int64])
397assert_type(MAR_2d_f4.soften_mask(), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
398assert_type(MAR_i8.soften_mask(), MaskedArray[np.int64])
399assert_type(MAR_f4.unshare_mask(), MaskedArray[np.float32])
400assert_type(MAR_b.shrink_mask(), MaskedArray[np.bool_])
401
402assert_type(MAR_i8.hardmask, bool)
403assert_type(MAR_i8.sharedmask, bool)
404
405assert_type(MAR_i8.recordmask, np.ma.MaskType | NDArray[np.ma.MaskType])
406assert_type(MAR_2d_f4.recordmask, np.ma.MaskType | np.ndarray[tuple[int, int], np.dtype[np.ma.MaskType]])
407
408assert_type(MAR_2d_f4.anom(), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
409assert_type(MAR_2d_f4.anom(axis=0, dtype=np.float16), np.ma.MaskedArray[tuple[int, int], np.dtype])
410assert_type(MAR_2d_f4.anom(0, np.float16), np.ma.MaskedArray[tuple[int, int], np.dtype])
411assert_type(MAR_2d_f4.anom(0, "float16"), np.ma.MaskedArray[tuple[int, int], np.dtype])
412
413assert_type(MAR_i8.fill_value, np.int64)
414
415assert_type(MAR_b.transpose(), MaskedArray[np.bool])
416assert_type(MAR_2d_f4.transpose(), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
417assert_type(MAR_2d_f4.transpose(1, 0), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
418assert_type(MAR_2d_f4.transpose((1, 0)), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
419assert_type(MAR_b.T, MaskedArray[np.bool])
420assert_type(MAR_2d_f4.T, np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
421
422assert_type(MAR_2d_f4.dot(1), MaskedArray[Any])
423assert_type(MAR_2d_f4.dot([1]), MaskedArray[Any])
424assert_type(MAR_2d_f4.dot(1, out=MAR_subclass), MaskedArraySubclassC)
425
426assert_type(MAR_2d_f4.nonzero(), tuple[_Array1D[np.intp], ...])
427assert_type(MAR_2d_f4.nonzero()[0], _Array1D[np.intp])
428
429assert_type(MAR_f8.trace(), Any)
430assert_type(MAR_f8.trace(out=MAR_subclass), MaskedArraySubclassC)
431assert_type(MAR_f8.trace(out=MAR_subclass, dtype=None), MaskedArraySubclassC)
432
433assert_type(MAR_f8.round(), MaskedArray[np.float64])
434assert_type(MAR_f8.round(out=MAR_subclass), MaskedArraySubclassC)
435
436assert_type(MAR_i8.reshape(None), MaskedArray[np.int64])
437assert_type(MAR_f8.reshape(-1), np.ma.MaskedArray[tuple[int], np.dtype[np.float64]])
438assert_type(MAR_c8.reshape(2, 3, 4, 5), np.ma.MaskedArray[tuple[int, int, int, int], np.dtype[np.complex64]])
439assert_type(MAR_td64.reshape(()), np.ma.MaskedArray[tuple[()], np.dtype[np.timedelta64]])
440assert_type(MAR_s.reshape([]), np.ma.MaskedArray[tuple[()], np.dtype[np.str_]])
441assert_type(MAR_V.reshape((480, 720, 4)), np.ma.MaskedArray[tuple[int, int, int], np.dtype[np.void]])
442
443assert_type(MAR_f8.cumprod(), MaskedArray[Any])
444assert_type(MAR_f8.cumprod(out=MAR_subclass), MaskedArraySubclassC)
445
446assert_type(MAR_f8.cumsum(), MaskedArray[Any])
447assert_type(MAR_f8.cumsum(out=MAR_subclass), MaskedArraySubclassC)
448
449assert_type(MAR_f8.view(), MaskedArray[np.float64])
450assert_type(MAR_f8.view(dtype=np.float32), MaskedArray[np.float32])
451assert_type(MAR_f8.view(dtype=np.dtype(np.float32)), MaskedArray[np.float32])
452assert_type(MAR_f8.view(dtype=np.float32, fill_value=0), MaskedArray[np.float32])
453assert_type(MAR_f8.view(type=np.ndarray), np.ndarray[Any, Any])
454assert_type(MAR_f8.view(None, np.ndarray), np.ndarray[Any, Any])
455assert_type(MAR_f8.view(dtype=np.ndarray), np.ndarray[Any, Any])
456assert_type(MAR_f8.view(dtype="float32"), MaskedArray[Any])
457assert_type(MAR_f8.view(dtype="float32", type=np.ndarray), np.ndarray[Any, Any])
458assert_type(MAR_2d_f4.view(dtype=np.float16), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float16]])
459assert_type(MAR_2d_f4.view(dtype=np.dtype(np.float16)), np.ma.MaskedArray[tuple[int, int], np.dtype[np.float16]])
460
461assert_type(MAR_f8.__deepcopy__(), MaskedArray[np.float64])
462
463assert_type(MAR_f8.argsort(), MaskedArray[np.intp])
464assert_type(MAR_f8.argsort(axis=0, kind="heap", order=("x", "y")), MaskedArray[np.intp])
465assert_type(MAR_f8.argsort(endwith=True, fill_value=1.5, stable=False), MaskedArray[np.intp])
466
467assert_type(MAR_2d_f4.flat, np.ma.core.MaskedIterator[tuple[int, int], np.dtype[np.float32]])
468assert_type(MAR_2d_f4.flat.ma, np.ma.MaskedArray[tuple[int, int], np.dtype[np.float32]])
469assert_type(MAR_2d_f4.flat[AR_i8], MaskedArray[np.float32])
470assert_type(MAR_2d_f4.flat[[1, 2, 3]], MaskedArray[np.float32])
471assert_type(MAR_2d_f4.flat[1:], MaskedArray[np.float32])
472assert_type(MAR_2d_f4.flat[:], MaskedArray[np.float32])
473assert_type(MAR_2d_f4.flat[0, 0], Any)
474assert_type(MAR_2d_f4.flat[:, np.newaxis], MaskedArray[np.float32])
475assert_type(MAR_2d_f4.flat[..., -1], MaskedArray[np.float32])
476
477def invalid_resize() -> None:
478    assert_type(MAR_f8.resize((1, 1)), NoReturn)  # type: ignore[arg-type]
479
480assert_type(np.ma.MaskedArray(AR_f4), MaskedArray[np.float32])
481assert_type(np.ma.MaskedArray(np.array([1, 2, 3]), [True, True, False], np.float16), MaskedArray[np.float16])
482assert_type(np.ma.MaskedArray(np.array([1, 2, 3]), dtype=np.float16), MaskedArray[np.float16])
483assert_type(np.ma.MaskedArray(np.array([1, 2, 3]), copy=True), MaskedArray[Any])
484# TODO: This one could be made more precise, the return type could be `MaskedArraySubclassC`
485assert_type(np.ma.MaskedArray(MAR_subclass), MaskedArray[np.complex128])
486# TODO: This one could be made more precise, the return type could be `MaskedArraySubclass[np.float32]`
487assert_type(np.ma.MaskedArray(MAR_into_subclass), MaskedArray[np.float32])
488
489# Masked Array addition
490
491assert_type(MAR_b + AR_LIKE_u, MaskedArray[np.uint32])
492assert_type(MAR_b + AR_LIKE_i, MaskedArray[np.signedinteger])
493assert_type(MAR_b + AR_LIKE_f, MaskedArray[np.floating])
494assert_type(MAR_b + AR_LIKE_c, MaskedArray[np.complexfloating])
495assert_type(MAR_b + AR_LIKE_td64, MaskedArray[np.timedelta64])
496assert_type(MAR_b + AR_LIKE_o, Any)
497
498assert_type(AR_LIKE_u + MAR_b, MaskedArray[np.uint32])
499assert_type(AR_LIKE_i + MAR_b, MaskedArray[np.signedinteger])
500assert_type(AR_LIKE_f + MAR_b, MaskedArray[np.floating])
501assert_type(AR_LIKE_c + MAR_b, MaskedArray[np.complexfloating])
502assert_type(AR_LIKE_td64 + MAR_b, MaskedArray[np.timedelta64])
503assert_type(AR_LIKE_dt64 + MAR_b, MaskedArray[np.datetime64])
504assert_type(AR_LIKE_o + MAR_b, Any)
505
506assert_type(MAR_u4 + AR_LIKE_b, MaskedArray[np.uint32])
507assert_type(MAR_u4 + AR_LIKE_u, MaskedArray[np.unsignedinteger])
508assert_type(MAR_u4 + AR_LIKE_i, MaskedArray[np.signedinteger])
509assert_type(MAR_u4 + AR_LIKE_f, MaskedArray[np.floating])
510assert_type(MAR_u4 + AR_LIKE_c, MaskedArray[np.complexfloating])
511assert_type(MAR_u4 + AR_LIKE_td64, MaskedArray[np.timedelta64])
512assert_type(MAR_u4 + AR_LIKE_o, Any)
513
514assert_type(AR_LIKE_b + MAR_u4, MaskedArray[np.uint32])
515assert_type(AR_LIKE_u + MAR_u4, MaskedArray[np.unsignedinteger])
516assert_type(AR_LIKE_i + MAR_u4, MaskedArray[np.signedinteger])
517assert_type(AR_LIKE_f + MAR_u4, MaskedArray[np.floating])
518assert_type(AR_LIKE_c + MAR_u4, MaskedArray[np.complexfloating])
519assert_type(AR_LIKE_td64 + MAR_u4, MaskedArray[np.timedelta64])
520assert_type(AR_LIKE_dt64 + MAR_u4, MaskedArray[np.datetime64])
521assert_type(AR_LIKE_o + MAR_u4, Any)
522
523assert_type(MAR_i8 + AR_LIKE_b, MaskedArray[np.int64])
524assert_type(MAR_i8 + AR_LIKE_u, MaskedArray[np.signedinteger])
525assert_type(MAR_i8 + AR_LIKE_i, MaskedArray[np.signedinteger])
526assert_type(MAR_i8 + AR_LIKE_f, MaskedArray[np.floating])
527assert_type(MAR_i8 + AR_LIKE_c, MaskedArray[np.complexfloating])
528assert_type(MAR_i8 + AR_LIKE_td64, MaskedArray[np.timedelta64])
529assert_type(MAR_i8 + AR_LIKE_o, Any)
530
531assert_type(AR_LIKE_b + MAR_i8, MaskedArray[np.int64])
532assert_type(AR_LIKE_u + MAR_i8, MaskedArray[np.signedinteger])
533assert_type(AR_LIKE_i + MAR_i8, MaskedArray[np.signedinteger])
534assert_type(AR_LIKE_f + MAR_i8, MaskedArray[np.floating])
535assert_type(AR_LIKE_c + MAR_i8, MaskedArray[np.complexfloating])
536assert_type(AR_LIKE_td64 + MAR_i8, MaskedArray[np.timedelta64])
537assert_type(AR_LIKE_dt64 + MAR_i8, MaskedArray[np.datetime64])
538assert_type(AR_LIKE_o + MAR_i8, Any)
539
540assert_type(MAR_f8 + AR_LIKE_b, MaskedArray[np.float64])
541assert_type(MAR_f8 + AR_LIKE_u, MaskedArray[np.float64])
542assert_type(MAR_f8 + AR_LIKE_i, MaskedArray[np.float64])
543assert_type(MAR_f8 + AR_LIKE_f, MaskedArray[np.float64])
544assert_type(MAR_f8 + AR_LIKE_c, MaskedArray[np.complexfloating])
545assert_type(MAR_f8 + AR_LIKE_o, Any)
546
547assert_type(AR_LIKE_b + MAR_f8, MaskedArray[np.float64])
548assert_type(AR_LIKE_u + MAR_f8, MaskedArray[np.float64])
549assert_type(AR_LIKE_i + MAR_f8, MaskedArray[np.float64])
550assert_type(AR_LIKE_f + MAR_f8, MaskedArray[np.float64])
551assert_type(AR_LIKE_c + MAR_f8, MaskedArray[np.complexfloating])
552assert_type(AR_LIKE_o + MAR_f8, Any)
553
554assert_type(MAR_c16 + AR_LIKE_b, MaskedArray[np.complex128])
555assert_type(MAR_c16 + AR_LIKE_u, MaskedArray[np.complex128])
556assert_type(MAR_c16 + AR_LIKE_i, MaskedArray[np.complex128])
557assert_type(MAR_c16 + AR_LIKE_f, MaskedArray[np.complex128])
558assert_type(MAR_c16 + AR_LIKE_c, MaskedArray[np.complex128])
559assert_type(MAR_c16 + AR_LIKE_o, Any)
560
561assert_type(AR_LIKE_b + MAR_c16, MaskedArray[np.complex128])
562assert_type(AR_LIKE_u + MAR_c16, MaskedArray[np.complex128])
563assert_type(AR_LIKE_i + MAR_c16, MaskedArray[np.complex128])
564assert_type(AR_LIKE_f + MAR_c16, MaskedArray[np.complex128])
565assert_type(AR_LIKE_c + MAR_c16, MaskedArray[np.complex128])
566assert_type(AR_LIKE_o + MAR_c16, Any)
567
568assert_type(MAR_td64 + AR_LIKE_b, MaskedArray[np.timedelta64])
569assert_type(MAR_td64 + AR_LIKE_u, MaskedArray[np.timedelta64])
570assert_type(MAR_td64 + AR_LIKE_i, MaskedArray[np.timedelta64])
571assert_type(MAR_td64 + AR_LIKE_td64, MaskedArray[np.timedelta64])
572assert_type(MAR_td64 + AR_LIKE_o, Any)
573
574assert_type(AR_LIKE_b + MAR_td64, MaskedArray[np.timedelta64])
575assert_type(AR_LIKE_u + MAR_td64, MaskedArray[np.timedelta64])
576assert_type(AR_LIKE_i + MAR_td64, MaskedArray[np.timedelta64])
577assert_type(AR_LIKE_td64 + MAR_td64, MaskedArray[np.timedelta64])
578assert_type(AR_LIKE_dt64 + MAR_td64, MaskedArray[np.datetime64])
579assert_type(AR_LIKE_o + MAR_td64, Any)
580
581assert_type(MAR_dt64 + AR_LIKE_b, MaskedArray[np.datetime64])
582assert_type(MAR_dt64 + AR_LIKE_u, MaskedArray[np.datetime64])
583assert_type(MAR_dt64 + AR_LIKE_i, MaskedArray[np.datetime64])
584assert_type(MAR_dt64 + AR_LIKE_td64, MaskedArray[np.datetime64])
585assert_type(MAR_dt64 + AR_LIKE_o, Any)
586
587assert_type(AR_LIKE_o + MAR_dt64, Any)
588
589assert_type(MAR_o + AR_LIKE_b, Any)
590assert_type(MAR_o + AR_LIKE_u, Any)
591assert_type(MAR_o + AR_LIKE_i, Any)
592assert_type(MAR_o + AR_LIKE_f, Any)
593assert_type(MAR_o + AR_LIKE_c, Any)
594assert_type(MAR_o + AR_LIKE_td64, Any)
595assert_type(MAR_o + AR_LIKE_dt64, Any)
596assert_type(MAR_o + AR_LIKE_o, Any)
597
598assert_type(AR_LIKE_b + MAR_o, Any)
599assert_type(AR_LIKE_u + MAR_o, Any)
600assert_type(AR_LIKE_i + MAR_o, Any)
601assert_type(AR_LIKE_f + MAR_o, Any)
602assert_type(AR_LIKE_c + MAR_o, Any)
603assert_type(AR_LIKE_td64 + MAR_o, Any)
604assert_type(AR_LIKE_dt64 + MAR_o, Any)
605assert_type(AR_LIKE_o + MAR_o, Any)
606
607# Masked Array subtraction
608# Keep in sync with numpy/typing/tests/data/reveal/arithmetic.pyi
609
610assert_type(MAR_number - AR_number, MaskedArray[np.number])
611
612assert_type(MAR_b - AR_LIKE_u, MaskedArray[np.uint32])
613assert_type(MAR_b - AR_LIKE_i, MaskedArray[np.signedinteger])
614assert_type(MAR_b - AR_LIKE_f, MaskedArray[np.floating])
615assert_type(MAR_b - AR_LIKE_c, MaskedArray[np.complexfloating])
616assert_type(MAR_b - AR_LIKE_td64, MaskedArray[np.timedelta64])
617assert_type(MAR_b - AR_LIKE_o, Any)
618
619assert_type(AR_LIKE_u - MAR_b, MaskedArray[np.uint32])
620assert_type(AR_LIKE_i - MAR_b, MaskedArray[np.signedinteger])
621assert_type(AR_LIKE_f - MAR_b, MaskedArray[np.floating])
622assert_type(AR_LIKE_c - MAR_b, MaskedArray[np.complexfloating])
623assert_type(AR_LIKE_td64 - MAR_b, MaskedArray[np.timedelta64])
624assert_type(AR_LIKE_dt64 - MAR_b, MaskedArray[np.datetime64])
625assert_type(AR_LIKE_o - MAR_b, Any)
626
627assert_type(MAR_u4 - AR_LIKE_b, MaskedArray[np.uint32])
628assert_type(MAR_u4 - AR_LIKE_u, MaskedArray[np.unsignedinteger])
629assert_type(MAR_u4 - AR_LIKE_i, MaskedArray[np.signedinteger])
630assert_type(MAR_u4 - AR_LIKE_f, MaskedArray[np.floating])
631assert_type(MAR_u4 - AR_LIKE_c, MaskedArray[np.complexfloating])
632assert_type(MAR_u4 - AR_LIKE_td64, MaskedArray[np.timedelta64])
633assert_type(MAR_u4 - AR_LIKE_o, Any)
634
635assert_type(AR_LIKE_b - MAR_u4, MaskedArray[np.uint32])
636assert_type(AR_LIKE_u - MAR_u4, MaskedArray[np.unsignedinteger])
637assert_type(AR_LIKE_i - MAR_u4, MaskedArray[np.signedinteger])
638assert_type(AR_LIKE_f - MAR_u4, MaskedArray[np.floating])
639assert_type(AR_LIKE_c - MAR_u4, MaskedArray[np.complexfloating])
640assert_type(AR_LIKE_td64 - MAR_u4, MaskedArray[np.timedelta64])
641assert_type(AR_LIKE_dt64 - MAR_u4, MaskedArray[np.datetime64])
642assert_type(AR_LIKE_o - MAR_u4, Any)
643
644assert_type(MAR_i8 - AR_LIKE_b, MaskedArray[np.int64])
645assert_type(MAR_i8 - AR_LIKE_u, MaskedArray[np.signedinteger])
646assert_type(MAR_i8 - AR_LIKE_i, MaskedArray[np.signedinteger])
647assert_type(MAR_i8 - AR_LIKE_f, MaskedArray[np.floating])
648assert_type(MAR_i8 - AR_LIKE_c, MaskedArray[np.complexfloating])
649assert_type(MAR_i8 - AR_LIKE_td64, MaskedArray[np.timedelta64])
650assert_type(MAR_i8 - AR_LIKE_o, Any)
651
652assert_type(AR_LIKE_b - MAR_i8, MaskedArray[np.int64])
653assert_type(AR_LIKE_u - MAR_i8, MaskedArray[np.signedinteger])
654assert_type(AR_LIKE_i - MAR_i8, MaskedArray[np.signedinteger])
655assert_type(AR_LIKE_f - MAR_i8, MaskedArray[np.floating])
656assert_type(AR_LIKE_c - MAR_i8, MaskedArray[np.complexfloating])
657assert_type(AR_LIKE_td64 - MAR_i8, MaskedArray[np.timedelta64])
658assert_type(AR_LIKE_dt64 - MAR_i8, MaskedArray[np.datetime64])
659assert_type(AR_LIKE_o - MAR_i8, Any)
660
661assert_type(MAR_f8 - AR_LIKE_b, MaskedArray[np.float64])
662assert_type(MAR_f8 - AR_LIKE_u, MaskedArray[np.float64])
663assert_type(MAR_f8 - AR_LIKE_i, MaskedArray[np.float64])
664assert_type(MAR_f8 - AR_LIKE_f, MaskedArray[np.float64])
665assert_type(MAR_f8 - AR_LIKE_c, MaskedArray[np.complexfloating])
666assert_type(MAR_f8 - AR_LIKE_o, Any)
667
668assert_type(AR_LIKE_b - MAR_f8, MaskedArray[np.float64])
669assert_type(AR_LIKE_u - MAR_f8, MaskedArray[np.float64])
670assert_type(AR_LIKE_i - MAR_f8, MaskedArray[np.float64])
671assert_type(AR_LIKE_f - MAR_f8, MaskedArray[np.float64])
672assert_type(AR_LIKE_c - MAR_f8, MaskedArray[np.complexfloating])
673assert_type(AR_LIKE_o - MAR_f8, Any)
674
675assert_type(MAR_c16 - AR_LIKE_b, MaskedArray[np.complex128])
676assert_type(MAR_c16 - AR_LIKE_u, MaskedArray[np.complex128])
677assert_type(MAR_c16 - AR_LIKE_i, MaskedArray[np.complex128])
678assert_type(MAR_c16 - AR_LIKE_f, MaskedArray[np.complex128])
679assert_type(MAR_c16 - AR_LIKE_c, MaskedArray[np.complex128])
680assert_type(MAR_c16 - AR_LIKE_o, Any)
681
682assert_type(AR_LIKE_b - MAR_c16, MaskedArray[np.complex128])
683assert_type(AR_LIKE_u - MAR_c16, MaskedArray[np.complex128])
684assert_type(AR_LIKE_i - MAR_c16, MaskedArray[np.complex128])
685assert_type(AR_LIKE_f - MAR_c16, MaskedArray[np.complex128])
686assert_type(AR_LIKE_c - MAR_c16, MaskedArray[np.complex128])
687assert_type(AR_LIKE_o - MAR_c16, Any)
688
689assert_type(MAR_td64 - AR_LIKE_b, MaskedArray[np.timedelta64])
690assert_type(MAR_td64 - AR_LIKE_u, MaskedArray[np.timedelta64])
691assert_type(MAR_td64 - AR_LIKE_i, MaskedArray[np.timedelta64])
692assert_type(MAR_td64 - AR_LIKE_td64, MaskedArray[np.timedelta64])
693assert_type(MAR_td64 - AR_LIKE_o, Any)
694
695assert_type(AR_LIKE_b - MAR_td64, MaskedArray[np.timedelta64])
696assert_type(AR_LIKE_u - MAR_td64, MaskedArray[np.timedelta64])
697assert_type(AR_LIKE_i - MAR_td64, MaskedArray[np.timedelta64])
698assert_type(AR_LIKE_td64 - MAR_td64, MaskedArray[np.timedelta64])
699assert_type(AR_LIKE_dt64 - MAR_td64, MaskedArray[np.datetime64])
700assert_type(AR_LIKE_o - MAR_td64, Any)
701
702assert_type(MAR_dt64 - AR_LIKE_b, MaskedArray[np.datetime64])
703assert_type(MAR_dt64 - AR_LIKE_u, MaskedArray[np.datetime64])
704assert_type(MAR_dt64 - AR_LIKE_i, MaskedArray[np.datetime64])
705assert_type(MAR_dt64 - AR_LIKE_td64, MaskedArray[np.datetime64])
706assert_type(MAR_dt64 - AR_LIKE_dt64, MaskedArray[np.timedelta64])
707assert_type(MAR_dt64 - AR_LIKE_o, Any)
708
709assert_type(AR_LIKE_dt64 - MAR_dt64, MaskedArray[np.timedelta64])
710assert_type(AR_LIKE_o - MAR_dt64, Any)
711
712assert_type(MAR_o - AR_LIKE_b, Any)
713assert_type(MAR_o - AR_LIKE_u, Any)
714assert_type(MAR_o - AR_LIKE_i, Any)
715assert_type(MAR_o - AR_LIKE_f, Any)
716assert_type(MAR_o - AR_LIKE_c, Any)
717assert_type(MAR_o - AR_LIKE_td64, Any)
718assert_type(MAR_o - AR_LIKE_dt64, Any)
719assert_type(MAR_o - AR_LIKE_o, Any)
720
721assert_type(AR_LIKE_b - MAR_o, Any)
722assert_type(AR_LIKE_u - MAR_o, Any)
723assert_type(AR_LIKE_i - MAR_o, Any)
724assert_type(AR_LIKE_f - MAR_o, Any)
725assert_type(AR_LIKE_c - MAR_o, Any)
726assert_type(AR_LIKE_td64 - MAR_o, Any)
727assert_type(AR_LIKE_dt64 - MAR_o, Any)
728assert_type(AR_LIKE_o - MAR_o, Any)
729
730# Masked Array multiplication
731
732assert_type(MAR_b * AR_LIKE_u, MaskedArray[np.uint32])
733assert_type(MAR_b * AR_LIKE_i, MaskedArray[np.signedinteger])
734assert_type(MAR_b * AR_LIKE_f, MaskedArray[np.floating])
735assert_type(MAR_b * AR_LIKE_c, MaskedArray[np.complexfloating])
736assert_type(MAR_b * AR_LIKE_td64, MaskedArray[np.timedelta64])
737assert_type(MAR_b * AR_LIKE_o, Any)
738
739# Ignore due to https://github.com/python/mypy/issues/19341
740assert_type(AR_LIKE_u * MAR_b, MaskedArray[np.uint32])  # type: ignore[assert-type]
741assert_type(AR_LIKE_i * MAR_b, MaskedArray[np.signedinteger])  # type: ignore[assert-type]
742assert_type(AR_LIKE_f * MAR_b, MaskedArray[np.floating])  # type: ignore[assert-type]
743assert_type(AR_LIKE_c * MAR_b, MaskedArray[np.complexfloating])  # type: ignore[assert-type]
744assert_type(AR_LIKE_td64 * MAR_b, MaskedArray[np.timedelta64])  # type: ignore[assert-type]
745assert_type(AR_LIKE_o * MAR_b, Any)  # type: ignore[assert-type]
746
747assert_type(MAR_u4 * AR_LIKE_b, MaskedArray[np.uint32])
748assert_type(MAR_u4 * AR_LIKE_u, MaskedArray[np.unsignedinteger])
749assert_type(MAR_u4 * AR_LIKE_i, MaskedArray[np.signedinteger])
750assert_type(MAR_u4 * AR_LIKE_f, MaskedArray[np.floating])
751assert_type(MAR_u4 * AR_LIKE_c, MaskedArray[np.complexfloating])
752assert_type(MAR_u4 * AR_LIKE_td64, MaskedArray[np.timedelta64])
753assert_type(MAR_u4 * AR_LIKE_o, Any)
754
755assert_type(MAR_i8 * AR_LIKE_b, MaskedArray[np.int64])
756assert_type(MAR_i8 * AR_LIKE_u, MaskedArray[np.signedinteger])
757assert_type(MAR_i8 * AR_LIKE_i, MaskedArray[np.signedinteger])
758assert_type(MAR_i8 * AR_LIKE_f, MaskedArray[np.floating])
759assert_type(MAR_i8 * AR_LIKE_c, MaskedArray[np.complexfloating])
760assert_type(MAR_i8 * AR_LIKE_td64, MaskedArray[np.timedelta64])
761assert_type(MAR_i8 * AR_LIKE_o, Any)
762
763assert_type(MAR_f8 * AR_LIKE_b, MaskedArray[np.float64])
764assert_type(MAR_f8 * AR_LIKE_u, MaskedArray[np.float64])
765assert_type(MAR_f8 * AR_LIKE_i, MaskedArray[np.float64])
766assert_type(MAR_f8 * AR_LIKE_f, MaskedArray[np.float64])
767assert_type(MAR_f8 * AR_LIKE_c, MaskedArray[np.complexfloating])
768assert_type(MAR_f8 * AR_LIKE_o, Any)
769
770# Ignore due to https://github.com/python/mypy/issues/19341
771assert_type(AR_LIKE_b * MAR_f8, MaskedArray[np.float64])  # type: ignore[assert-type]
772assert_type(AR_LIKE_u * MAR_f8, MaskedArray[np.float64])  # type: ignore[assert-type]
773assert_type(AR_LIKE_i * MAR_f8, MaskedArray[np.float64])  # type: ignore[assert-type]
774assert_type(AR_LIKE_f * MAR_f8, MaskedArray[np.float64])  # type: ignore[assert-type]
775assert_type(AR_LIKE_c * MAR_f8, MaskedArray[np.complexfloating])  # type: ignore[assert-type]
776assert_type(AR_LIKE_o * MAR_f8, Any)  # type: ignore[assert-type]
777
778assert_type(MAR_c16 * AR_LIKE_b, MaskedArray[np.complex128])
779assert_type(MAR_c16 * AR_LIKE_u, MaskedArray[np.complex128])
780assert_type(MAR_c16 * AR_LIKE_i, MaskedArray[np.complex128])
781assert_type(MAR_c16 * AR_LIKE_f, MaskedArray[np.complex128])
782assert_type(MAR_c16 * AR_LIKE_c, MaskedArray[np.complex128])
783assert_type(MAR_c16 * AR_LIKE_o, Any)
784
785# Ignore due to https://github.com/python/mypy/issues/19341
786assert_type(AR_LIKE_b * MAR_c16, MaskedArray[np.complex128])  # type: ignore[assert-type]
787assert_type(AR_LIKE_u * MAR_c16, MaskedArray[np.complex128])  # type: ignore[assert-type]
788assert_type(AR_LIKE_i * MAR_c16, MaskedArray[np.complex128])  # type: ignore[assert-type]
789assert_type(AR_LIKE_f * MAR_c16, MaskedArray[np.complex128])  # type: ignore[assert-type]
790assert_type(AR_LIKE_c * MAR_c16, MaskedArray[np.complex128])  # type: ignore[assert-type]
791assert_type(AR_LIKE_o * MAR_c16, Any)  # type: ignore[assert-type]
792
793assert_type(MAR_td64 * AR_LIKE_b, MaskedArray[np.timedelta64])
794assert_type(MAR_td64 * AR_LIKE_u, MaskedArray[np.timedelta64])
795assert_type(MAR_td64 * AR_LIKE_i, MaskedArray[np.timedelta64])
796assert_type(MAR_td64 * AR_LIKE_o, Any)
797
798# Ignore due to https://github.com/python/mypy/issues/19341
799assert_type(AR_LIKE_b * MAR_td64, MaskedArray[np.timedelta64])  # type: ignore[assert-type]
800assert_type(AR_LIKE_u * MAR_td64, MaskedArray[np.timedelta64])  # type: ignore[assert-type]
801assert_type(AR_LIKE_i * MAR_td64, MaskedArray[np.timedelta64])  # type: ignore[assert-type]
802assert_type(AR_LIKE_td64 * MAR_td64, MaskedArray[np.timedelta64])  # type: ignore[assert-type]
803assert_type(AR_LIKE_dt64 * MAR_td64, MaskedArray[np.datetime64])  # type: ignore[assert-type]
804assert_type(AR_LIKE_o * MAR_td64, Any)  # type: ignore[assert-type]
805
806assert_type(AR_LIKE_o * MAR_dt64, Any)  # type: ignore[assert-type]
807
808assert_type(MAR_o * AR_LIKE_b, Any)
809assert_type(MAR_o * AR_LIKE_u, Any)
810assert_type(MAR_o * AR_LIKE_i, Any)
811assert_type(MAR_o * AR_LIKE_f, Any)
812assert_type(MAR_o * AR_LIKE_c, Any)
813assert_type(MAR_o * AR_LIKE_td64, Any)
814assert_type(MAR_o * AR_LIKE_dt64, Any)
815assert_type(MAR_o * AR_LIKE_o, Any)
816
817# Ignore due to https://github.com/python/mypy/issues/19341
818assert_type(AR_LIKE_b * MAR_o, Any)  # type: ignore[assert-type]
819assert_type(AR_LIKE_u * MAR_o, Any)  # type: ignore[assert-type]
820assert_type(AR_LIKE_i * MAR_o, Any)  # type: ignore[assert-type]
821assert_type(AR_LIKE_f * MAR_o, Any)  # type: ignore[assert-type]
822assert_type(AR_LIKE_c * MAR_o, Any)  # type: ignore[assert-type]
823assert_type(AR_LIKE_td64 * MAR_o, Any)  # type: ignore[assert-type]
824assert_type(AR_LIKE_dt64 * MAR_o, Any)  # type: ignore[assert-type]
825assert_type(AR_LIKE_o * MAR_o, Any)  # type: ignore[assert-type]
826
827assert_type(MAR_f8.sum(), Any)
828assert_type(MAR_f8.sum(axis=0), Any)
829assert_type(MAR_f8.sum(keepdims=True), Any)
830assert_type(MAR_f8.sum(out=MAR_subclass), MaskedArraySubclassC)
831
832assert_type(MAR_f8.std(), Any)
833assert_type(MAR_f8.std(axis=0), Any)
834assert_type(MAR_f8.std(keepdims=True, mean=0.), Any)
835assert_type(MAR_f8.std(out=MAR_subclass), MaskedArraySubclassC)
836
837assert_type(MAR_f8.var(), Any)
838assert_type(MAR_f8.var(axis=0), Any)
839assert_type(MAR_f8.var(keepdims=True, mean=0.), Any)
840assert_type(MAR_f8.var(out=MAR_subclass), MaskedArraySubclassC)
841
842assert_type(MAR_f8.mean(), Any)
843assert_type(MAR_f8.mean(axis=0), Any)
844assert_type(MAR_f8.mean(keepdims=True), Any)
845assert_type(MAR_f8.mean(out=MAR_subclass), MaskedArraySubclassC)
846
847assert_type(MAR_f8.prod(), Any)
848assert_type(MAR_f8.prod(axis=0), Any)
849assert_type(MAR_f8.prod(keepdims=True), Any)
850assert_type(MAR_f8.prod(out=MAR_subclass), MaskedArraySubclassC)
851
852# MaskedArray "true" division
853
854assert_type(MAR_f8 / b, MaskedArray[np.float64])
855assert_type(MAR_f8 / i, MaskedArray[np.float64])
856assert_type(MAR_f8 / f, MaskedArray[np.float64])
857
858assert_type(b / MAR_f8, MaskedArray[np.float64])
859assert_type(i / MAR_f8, MaskedArray[np.float64])
860assert_type(f / MAR_f8, MaskedArray[np.float64])
861
862assert_type(MAR_b / AR_LIKE_b, MaskedArray[np.float64])
863assert_type(MAR_b / AR_LIKE_u, MaskedArray[np.float64])
864assert_type(MAR_b / AR_LIKE_i, MaskedArray[np.float64])
865assert_type(MAR_b / AR_LIKE_f, MaskedArray[np.float64])
866assert_type(MAR_b / AR_LIKE_o, Any)
867
868assert_type(AR_LIKE_b / MAR_b, MaskedArray[np.float64])
869assert_type(AR_LIKE_u / MAR_b, MaskedArray[np.float64])
870assert_type(AR_LIKE_i / MAR_b, MaskedArray[np.float64])
871assert_type(AR_LIKE_f / MAR_b, MaskedArray[np.float64])
872assert_type(AR_LIKE_o / MAR_b, Any)
873
874assert_type(MAR_u4 / AR_LIKE_b, MaskedArray[np.float64])
875assert_type(MAR_u4 / AR_LIKE_u, MaskedArray[np.float64])
876assert_type(MAR_u4 / AR_LIKE_i, MaskedArray[np.float64])
877assert_type(MAR_u4 / AR_LIKE_f, MaskedArray[np.float64])
878assert_type(MAR_u4 / AR_LIKE_o, Any)
879
880assert_type(AR_LIKE_b / MAR_u4, MaskedArray[np.float64])
881assert_type(AR_LIKE_u / MAR_u4, MaskedArray[np.float64])
882assert_type(AR_LIKE_i / MAR_u4, MaskedArray[np.float64])
883assert_type(AR_LIKE_f / MAR_u4, MaskedArray[np.float64])
884assert_type(AR_LIKE_td64 / MAR_u4, MaskedArray[np.timedelta64])
885assert_type(AR_LIKE_o / MAR_u4, Any)
886
887assert_type(MAR_i8 / AR_LIKE_b, MaskedArray[np.float64])
888assert_type(MAR_i8 / AR_LIKE_u, MaskedArray[np.float64])
889assert_type(MAR_i8 / AR_LIKE_i, MaskedArray[np.float64])
890assert_type(MAR_i8 / AR_LIKE_f, MaskedArray[np.float64])
891assert_type(MAR_i8 / AR_LIKE_o, Any)
892
893assert_type(AR_LIKE_b / MAR_i8, MaskedArray[np.float64])
894assert_type(AR_LIKE_u / MAR_i8, MaskedArray[np.float64])
895assert_type(AR_LIKE_i / MAR_i8, MaskedArray[np.float64])
896assert_type(AR_LIKE_f / MAR_i8, MaskedArray[np.float64])
897assert_type(AR_LIKE_td64 / MAR_i8, MaskedArray[np.timedelta64])
898assert_type(AR_LIKE_o / MAR_i8, Any)
899
900assert_type(MAR_f8 / AR_LIKE_b, MaskedArray[np.float64])
901assert_type(MAR_f8 / AR_LIKE_u, MaskedArray[np.float64])
902assert_type(MAR_f8 / AR_LIKE_i, MaskedArray[np.float64])
903assert_type(MAR_f8 / AR_LIKE_f, MaskedArray[np.float64])
904assert_type(MAR_f8 / AR_LIKE_o, Any)
905
906assert_type(AR_LIKE_b / MAR_f8, MaskedArray[np.float64])
907assert_type(AR_LIKE_u / MAR_f8, MaskedArray[np.float64])
908assert_type(AR_LIKE_i / MAR_f8, MaskedArray[np.float64])
909assert_type(AR_LIKE_f / MAR_f8, MaskedArray[np.float64])
910assert_type(AR_LIKE_td64 / MAR_f8, MaskedArray[np.timedelta64])
911assert_type(AR_LIKE_o / MAR_f8, Any)
912
913assert_type(MAR_td64 / AR_LIKE_u, MaskedArray[np.timedelta64])
914assert_type(MAR_td64 / AR_LIKE_i, MaskedArray[np.timedelta64])
915assert_type(MAR_td64 / AR_LIKE_f, MaskedArray[np.timedelta64])
916assert_type(MAR_td64 / AR_LIKE_td64, MaskedArray[np.float64])
917assert_type(MAR_td64 / AR_LIKE_o, Any)
918
919assert_type(AR_LIKE_td64 / MAR_td64, MaskedArray[np.float64])
920assert_type(AR_LIKE_o / MAR_td64, Any)
921
922assert_type(MAR_o / AR_LIKE_b, Any)
923assert_type(MAR_o / AR_LIKE_u, Any)
924assert_type(MAR_o / AR_LIKE_i, Any)
925assert_type(MAR_o / AR_LIKE_f, Any)
926assert_type(MAR_o / AR_LIKE_td64, Any)
927assert_type(MAR_o / AR_LIKE_dt64, Any)
928assert_type(MAR_o / AR_LIKE_o, Any)
929
930assert_type(AR_LIKE_b / MAR_o, Any)
931assert_type(AR_LIKE_u / MAR_o, Any)
932assert_type(AR_LIKE_i / MAR_o, Any)
933assert_type(AR_LIKE_f / MAR_o, Any)
934assert_type(AR_LIKE_td64 / MAR_o, Any)
935assert_type(AR_LIKE_dt64 / MAR_o, Any)
936assert_type(AR_LIKE_o / MAR_o, Any)
937
938# MaskedArray floor division
939
940assert_type(MAR_b // AR_LIKE_b, MaskedArray[np.int8])
941assert_type(MAR_b // AR_LIKE_u, MaskedArray[np.uint32])
942assert_type(MAR_b // AR_LIKE_i, MaskedArray[np.signedinteger])
943assert_type(MAR_b // AR_LIKE_f, MaskedArray[np.floating])
944assert_type(MAR_b // AR_LIKE_o, Any)
945
946assert_type(AR_LIKE_b // MAR_b, MaskedArray[np.int8])
947assert_type(AR_LIKE_u // MAR_b, MaskedArray[np.uint32])
948assert_type(AR_LIKE_i // MAR_b, MaskedArray[np.signedinteger])
949assert_type(AR_LIKE_f // MAR_b, MaskedArray[np.floating])
950assert_type(AR_LIKE_o // MAR_b, Any)
951
952assert_type(MAR_u4 // AR_LIKE_b, MaskedArray[np.uint32])
953assert_type(MAR_u4 // AR_LIKE_u, MaskedArray[np.unsignedinteger])
954assert_type(MAR_u4 // AR_LIKE_i, MaskedArray[np.signedinteger])
955assert_type(MAR_u4 // AR_LIKE_f, MaskedArray[np.floating])
956assert_type(MAR_u4 // AR_LIKE_o, Any)
957
958assert_type(AR_LIKE_b // MAR_u4, MaskedArray[np.uint32])
959assert_type(AR_LIKE_u // MAR_u4, MaskedArray[np.unsignedinteger])
960assert_type(AR_LIKE_i // MAR_u4, MaskedArray[np.signedinteger])
961assert_type(AR_LIKE_f // MAR_u4, MaskedArray[np.floating])
962assert_type(AR_LIKE_td64 // MAR_u4, MaskedArray[np.timedelta64])
963assert_type(AR_LIKE_o // MAR_u4, Any)
964
965assert_type(MAR_i8 // AR_LIKE_b, MaskedArray[np.int64])
966assert_type(MAR_i8 // AR_LIKE_u, MaskedArray[np.signedinteger])
967assert_type(MAR_i8 // AR_LIKE_i, MaskedArray[np.signedinteger])
968assert_type(MAR_i8 // AR_LIKE_f, MaskedArray[np.floating])
969assert_type(MAR_i8 // AR_LIKE_o, Any)
970
971assert_type(AR_LIKE_b // MAR_i8, MaskedArray[np.int64])
972assert_type(AR_LIKE_u // MAR_i8, MaskedArray[np.signedinteger])
973assert_type(AR_LIKE_i // MAR_i8, MaskedArray[np.signedinteger])
974assert_type(AR_LIKE_f // MAR_i8, MaskedArray[np.floating])
975assert_type(AR_LIKE_td64 // MAR_i8, MaskedArray[np.timedelta64])
976assert_type(AR_LIKE_o // MAR_i8, Any)
977
978assert_type(MAR_f8 // AR_LIKE_b, MaskedArray[np.float64])
979assert_type(MAR_f8 // AR_LIKE_u, MaskedArray[np.float64])
980assert_type(MAR_f8 // AR_LIKE_i, MaskedArray[np.float64])
981assert_type(MAR_f8 // AR_LIKE_f, MaskedArray[np.float64])
982assert_type(MAR_f8 // AR_LIKE_o, Any)
983
984assert_type(AR_LIKE_b // MAR_f8, MaskedArray[np.float64])
985assert_type(AR_LIKE_u // MAR_f8, MaskedArray[np.float64])
986assert_type(AR_LIKE_i // MAR_f8, MaskedArray[np.float64])
987assert_type(AR_LIKE_f // MAR_f8, MaskedArray[np.float64])
988assert_type(AR_LIKE_td64 // MAR_f8, MaskedArray[np.timedelta64])
989assert_type(AR_LIKE_o // MAR_f8, Any)
990
991assert_type(MAR_td64 // AR_LIKE_u, MaskedArray[np.timedelta64])
992assert_type(MAR_td64 // AR_LIKE_i, MaskedArray[np.timedelta64])
993assert_type(MAR_td64 // AR_LIKE_f, MaskedArray[np.timedelta64])
994assert_type(MAR_td64 // AR_LIKE_td64, MaskedArray[np.int64])
995assert_type(MAR_td64 // AR_LIKE_o, Any)
996
997assert_type(AR_LIKE_td64 // MAR_td64, MaskedArray[np.int64])
998assert_type(AR_LIKE_o // MAR_td64, Any)
999
1000assert_type(MAR_o // AR_LIKE_b, Any)
1001assert_type(MAR_o // AR_LIKE_u, Any)
1002assert_type(MAR_o // AR_LIKE_i, Any)
1003assert_type(MAR_o // AR_LIKE_f, Any)
1004assert_type(MAR_o // AR_LIKE_td64, Any)
1005assert_type(MAR_o // AR_LIKE_dt64, Any)
1006assert_type(MAR_o // AR_LIKE_o, Any)
1007
1008assert_type(AR_LIKE_b // MAR_o, Any)
1009assert_type(AR_LIKE_u // MAR_o, Any)
1010assert_type(AR_LIKE_i // MAR_o, Any)
1011assert_type(AR_LIKE_f // MAR_o, Any)
1012assert_type(AR_LIKE_td64 // MAR_o, Any)
1013assert_type(AR_LIKE_dt64 // MAR_o, Any)
1014assert_type(AR_LIKE_o // MAR_o, Any)
1015
1016# Masked Array power
1017
1018assert_type(MAR_b ** AR_LIKE_u, MaskedArray[np.uint32])
1019assert_type(MAR_b ** AR_LIKE_i, MaskedArray[np.signedinteger])
1020assert_type(MAR_b ** AR_LIKE_f, MaskedArray[np.floating])
1021assert_type(MAR_b ** AR_LIKE_c, MaskedArray[np.complexfloating])
1022assert_type(MAR_b ** AR_LIKE_o, Any)
1023
1024assert_type(AR_LIKE_u ** MAR_b, MaskedArray[np.uint32])
1025assert_type(AR_LIKE_i ** MAR_b, MaskedArray[np.signedinteger])
1026assert_type(AR_LIKE_f ** MAR_b, MaskedArray[np.floating])
1027assert_type(AR_LIKE_c ** MAR_b, MaskedArray[np.complexfloating])
1028assert_type(AR_LIKE_o ** MAR_b, Any)
1029
1030assert_type(MAR_u4 ** AR_LIKE_b, MaskedArray[np.uint32])
1031assert_type(MAR_u4 ** AR_LIKE_u, MaskedArray[np.unsignedinteger])
1032assert_type(MAR_u4 ** AR_LIKE_i, MaskedArray[np.signedinteger])
1033assert_type(MAR_u4 ** AR_LIKE_f, MaskedArray[np.floating])
1034assert_type(MAR_u4 ** AR_LIKE_c, MaskedArray[np.complexfloating])
1035assert_type(MAR_u4 ** AR_LIKE_o, Any)
1036
1037assert_type(AR_LIKE_b ** MAR_u4, MaskedArray[np.uint32])
1038assert_type(AR_LIKE_u ** MAR_u4, MaskedArray[np.unsignedinteger])
1039assert_type(AR_LIKE_i ** MAR_u4, MaskedArray[np.signedinteger])
1040assert_type(AR_LIKE_f ** MAR_u4, MaskedArray[np.floating])
1041assert_type(AR_LIKE_c ** MAR_u4, MaskedArray[np.complexfloating])
1042assert_type(AR_LIKE_o ** MAR_u4, Any)
1043
1044assert_type(MAR_i8 ** AR_LIKE_b, MaskedArray[np.int64])
1045assert_type(MAR_i8 ** AR_LIKE_u, MaskedArray[np.signedinteger])
1046assert_type(MAR_i8 ** AR_LIKE_i, MaskedArray[np.signedinteger])
1047assert_type(MAR_i8 ** AR_LIKE_f, MaskedArray[np.floating])
1048assert_type(MAR_i8 ** AR_LIKE_c, MaskedArray[np.complexfloating])
1049assert_type(MAR_i8 ** AR_LIKE_o, Any)
1050assert_type(MAR_i8 ** AR_LIKE_b, MaskedArray[np.int64])
1051
1052assert_type(AR_LIKE_u ** MAR_i8, MaskedArray[np.signedinteger])
1053assert_type(AR_LIKE_i ** MAR_i8, MaskedArray[np.signedinteger])
1054assert_type(AR_LIKE_f ** MAR_i8, MaskedArray[np.floating])
1055assert_type(AR_LIKE_c ** MAR_i8, MaskedArray[np.complexfloating])
1056assert_type(AR_LIKE_o ** MAR_i8, Any)
1057
1058assert_type(MAR_f8 ** AR_LIKE_b, MaskedArray[np.float64])
1059assert_type(MAR_f8 ** AR_LIKE_u, MaskedArray[np.float64])
1060assert_type(MAR_f8 ** AR_LIKE_i, MaskedArray[np.float64])
1061assert_type(MAR_f8 ** AR_LIKE_f, MaskedArray[np.float64])
1062assert_type(MAR_f8 ** AR_LIKE_c, MaskedArray[np.complexfloating])
1063assert_type(MAR_f8 ** AR_LIKE_o, Any)
1064
1065assert_type(AR_LIKE_b ** MAR_f8, MaskedArray[np.float64])
1066assert_type(AR_LIKE_u ** MAR_f8, MaskedArray[np.float64])
1067assert_type(AR_LIKE_i ** MAR_f8, MaskedArray[np.float64])
1068assert_type(AR_LIKE_f ** MAR_f8, MaskedArray[np.float64])
1069assert_type(AR_LIKE_c ** MAR_f8, MaskedArray[np.complexfloating])
1070assert_type(AR_LIKE_o ** MAR_f8, Any)
1071
1072assert_type(MAR_c16 ** AR_LIKE_b, MaskedArray[np.complex128])
1073assert_type(MAR_c16 ** AR_LIKE_u, MaskedArray[np.complex128])
1074assert_type(MAR_c16 ** AR_LIKE_i, MaskedArray[np.complex128])
1075assert_type(MAR_c16 ** AR_LIKE_f, MaskedArray[np.complex128])
1076assert_type(MAR_c16 ** AR_LIKE_c, MaskedArray[np.complex128])
1077assert_type(MAR_c16 ** AR_LIKE_o, Any)
1078
1079assert_type(AR_LIKE_b ** MAR_c16, MaskedArray[np.complex128])
1080assert_type(AR_LIKE_u ** MAR_c16, MaskedArray[np.complex128])
1081assert_type(AR_LIKE_i ** MAR_c16, MaskedArray[np.complex128])
1082assert_type(AR_LIKE_f ** MAR_c16, MaskedArray[np.complex128])
1083assert_type(AR_LIKE_c ** MAR_c16, MaskedArray[np.complex128])
1084assert_type(AR_LIKE_o ** MAR_c16, Any)
1085
1086assert_type(MAR_o ** AR_LIKE_b, Any)
1087assert_type(MAR_o ** AR_LIKE_u, Any)
1088assert_type(MAR_o ** AR_LIKE_i, Any)
1089assert_type(MAR_o ** AR_LIKE_f, Any)
1090assert_type(MAR_o ** AR_LIKE_c, Any)
1091assert_type(MAR_o ** AR_LIKE_o, Any)
1092
1093assert_type(AR_LIKE_b ** MAR_o, Any)
1094assert_type(AR_LIKE_u ** MAR_o, Any)
1095assert_type(AR_LIKE_i ** MAR_o, Any)
1096assert_type(AR_LIKE_f ** MAR_o, Any)
1097assert_type(AR_LIKE_c ** MAR_o, Any)
1098assert_type(AR_LIKE_o ** MAR_o, Any)
1099
codekingpro/portable-devtools · Team Ai