virtuelle Umgebungen teil20 und teil20a
This commit is contained in:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,121 @@
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
b_ = np.bool_()
|
||||
dt = np.datetime64(0, "D")
|
||||
td = np.timedelta64(0, "D")
|
||||
|
||||
AR_b: np.ndarray[Any, np.dtype[np.bool_]]
|
||||
AR_u: np.ndarray[Any, np.dtype[np.uint32]]
|
||||
AR_i: np.ndarray[Any, np.dtype[np.int64]]
|
||||
AR_f: np.ndarray[Any, np.dtype[np.float64]]
|
||||
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
|
||||
|
||||
ANY: Any
|
||||
|
||||
AR_LIKE_b: list[bool]
|
||||
AR_LIKE_u: list[np.uint32]
|
||||
AR_LIKE_i: list[int]
|
||||
AR_LIKE_f: list[float]
|
||||
AR_LIKE_c: list[complex]
|
||||
AR_LIKE_m: list[np.timedelta64]
|
||||
AR_LIKE_M: list[np.datetime64]
|
||||
|
||||
# Array subtraction
|
||||
|
||||
# NOTE: mypys `NoReturn` errors are, unfortunately, not that great
|
||||
_1 = AR_b - AR_LIKE_b # E: Need type annotation
|
||||
_2 = AR_LIKE_b - AR_b # E: Need type annotation
|
||||
AR_i - bytes() # E: No overload variant
|
||||
|
||||
AR_f - AR_LIKE_m # E: Unsupported operand types
|
||||
AR_f - AR_LIKE_M # E: Unsupported operand types
|
||||
AR_c - AR_LIKE_m # E: Unsupported operand types
|
||||
AR_c - AR_LIKE_M # E: Unsupported operand types
|
||||
|
||||
AR_m - AR_LIKE_f # E: Unsupported operand types
|
||||
AR_M - AR_LIKE_f # E: Unsupported operand types
|
||||
AR_m - AR_LIKE_c # E: Unsupported operand types
|
||||
AR_M - AR_LIKE_c # E: Unsupported operand types
|
||||
|
||||
AR_m - AR_LIKE_M # E: Unsupported operand types
|
||||
AR_LIKE_m - AR_M # E: Unsupported operand types
|
||||
|
||||
# array floor division
|
||||
|
||||
AR_M // AR_LIKE_b # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_u # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_i # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_f # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_c # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_m # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_M # E: Unsupported operand types
|
||||
|
||||
AR_b // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_u // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_i // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_f // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_c // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_m // AR_LIKE_M # E: Unsupported operand types
|
||||
AR_M // AR_LIKE_M # E: Unsupported operand types
|
||||
|
||||
_3 = AR_m // AR_LIKE_b # E: Need type annotation
|
||||
AR_m // AR_LIKE_c # E: Unsupported operand types
|
||||
|
||||
AR_b // AR_LIKE_m # E: Unsupported operand types
|
||||
AR_u // AR_LIKE_m # E: Unsupported operand types
|
||||
AR_i // AR_LIKE_m # E: Unsupported operand types
|
||||
AR_f // AR_LIKE_m # E: Unsupported operand types
|
||||
AR_c // AR_LIKE_m # E: Unsupported operand types
|
||||
|
||||
# Array multiplication
|
||||
|
||||
AR_b *= AR_LIKE_u # E: incompatible type
|
||||
AR_b *= AR_LIKE_i # E: incompatible type
|
||||
AR_b *= AR_LIKE_f # E: incompatible type
|
||||
AR_b *= AR_LIKE_c # E: incompatible type
|
||||
AR_b *= AR_LIKE_m # E: incompatible type
|
||||
|
||||
AR_u *= AR_LIKE_i # E: incompatible type
|
||||
AR_u *= AR_LIKE_f # E: incompatible type
|
||||
AR_u *= AR_LIKE_c # E: incompatible type
|
||||
AR_u *= AR_LIKE_m # E: incompatible type
|
||||
|
||||
AR_i *= AR_LIKE_f # E: incompatible type
|
||||
AR_i *= AR_LIKE_c # E: incompatible type
|
||||
AR_i *= AR_LIKE_m # E: incompatible type
|
||||
|
||||
AR_f *= AR_LIKE_c # E: incompatible type
|
||||
AR_f *= AR_LIKE_m # E: incompatible type
|
||||
|
||||
# Array power
|
||||
|
||||
AR_b **= AR_LIKE_b # E: Invalid self argument
|
||||
AR_b **= AR_LIKE_u # E: Invalid self argument
|
||||
AR_b **= AR_LIKE_i # E: Invalid self argument
|
||||
AR_b **= AR_LIKE_f # E: Invalid self argument
|
||||
AR_b **= AR_LIKE_c # E: Invalid self argument
|
||||
|
||||
AR_u **= AR_LIKE_i # E: incompatible type
|
||||
AR_u **= AR_LIKE_f # E: incompatible type
|
||||
AR_u **= AR_LIKE_c # E: incompatible type
|
||||
|
||||
AR_i **= AR_LIKE_f # E: incompatible type
|
||||
AR_i **= AR_LIKE_c # E: incompatible type
|
||||
|
||||
AR_f **= AR_LIKE_c # E: incompatible type
|
||||
|
||||
# Scalars
|
||||
|
||||
b_ - b_ # E: No overload variant
|
||||
|
||||
dt + dt # E: Unsupported operand types
|
||||
td - dt # E: Unsupported operand types
|
||||
td % 1 # E: Unsupported operand types
|
||||
td / dt # E: No overload
|
||||
td % dt # E: Unsupported operand types
|
||||
|
||||
-b_ # E: Unsupported operand type
|
||||
+b_ # E: Unsupported operand type
|
@@ -0,0 +1,33 @@
|
||||
import numpy as np
|
||||
|
||||
a: np.ndarray
|
||||
generator = (i for i in range(10))
|
||||
|
||||
np.require(a, requirements=1) # E: No overload variant
|
||||
np.require(a, requirements="TEST") # E: incompatible type
|
||||
|
||||
np.zeros("test") # E: incompatible type
|
||||
np.zeros() # E: require at least one argument
|
||||
|
||||
np.ones("test") # E: incompatible type
|
||||
np.ones() # E: require at least one argument
|
||||
|
||||
np.array(0, float, True) # E: No overload variant
|
||||
|
||||
np.linspace(None, 'bob') # E: No overload variant
|
||||
np.linspace(0, 2, num=10.0) # E: No overload variant
|
||||
np.linspace(0, 2, endpoint='True') # E: No overload variant
|
||||
np.linspace(0, 2, retstep=b'False') # E: No overload variant
|
||||
np.linspace(0, 2, dtype=0) # E: No overload variant
|
||||
np.linspace(0, 2, axis=None) # E: No overload variant
|
||||
|
||||
np.logspace(None, 'bob') # E: No overload variant
|
||||
np.logspace(0, 2, base=None) # E: No overload variant
|
||||
|
||||
np.geomspace(None, 'bob') # E: No overload variant
|
||||
|
||||
np.stack(generator) # E: No overload variant
|
||||
np.hstack({1, 2}) # E: No overload variant
|
||||
np.vstack(1) # E: No overload variant
|
||||
|
||||
np.array([1], like=1) # E: No overload variant
|
@@ -0,0 +1,16 @@
|
||||
import numpy as np
|
||||
from numpy._typing import ArrayLike
|
||||
|
||||
|
||||
class A:
|
||||
pass
|
||||
|
||||
|
||||
x1: ArrayLike = (i for i in range(10)) # E: Incompatible types in assignment
|
||||
x2: ArrayLike = A() # E: Incompatible types in assignment
|
||||
x3: ArrayLike = {1: "foo", 2: "bar"} # E: Incompatible types in assignment
|
||||
|
||||
scalar = np.int64(1)
|
||||
scalar.__array__(dtype=np.float64) # E: No overload variant
|
||||
array = np.array([1])
|
||||
array.__array__(dtype=np.float64) # E: No overload variant
|
@@ -0,0 +1,6 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_i8: npt.NDArray[np.int64]
|
||||
|
||||
np.pad(AR_i8, 2, mode="bob") # E: No overload variant
|
@@ -0,0 +1,14 @@
|
||||
from collections.abc import Callable
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR: np.ndarray
|
||||
func1: Callable[[Any], str]
|
||||
func2: Callable[[np.integer[Any]], str]
|
||||
|
||||
np.array2string(AR, style=None) # E: Unexpected keyword argument
|
||||
np.array2string(AR, legacy="1.14") # E: incompatible type
|
||||
np.array2string(AR, sign="*") # E: incompatible type
|
||||
np.array2string(AR, floatmode="default") # E: incompatible type
|
||||
np.array2string(AR, formatter={"A": func1}) # E: incompatible type
|
||||
np.array2string(AR, formatter={"float": func2}) # E: Incompatible types
|
@@ -0,0 +1,14 @@
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_i8: np.ndarray[Any, np.dtype[np.int64]]
|
||||
ar_iter = np.lib.Arrayterator(AR_i8)
|
||||
|
||||
np.lib.Arrayterator(np.int64()) # E: incompatible type
|
||||
ar_iter.shape = (10, 5) # E: is read-only
|
||||
ar_iter[None] # E: Invalid index type
|
||||
ar_iter[None, 1] # E: Invalid index type
|
||||
ar_iter[np.intp()] # E: Invalid index type
|
||||
ar_iter[np.intp(), ...] # E: Invalid index type
|
||||
ar_iter[AR_i8] # E: Invalid index type
|
||||
ar_iter[AR_i8, :] # E: Invalid index type
|
@@ -0,0 +1,20 @@
|
||||
import numpy as np
|
||||
|
||||
i8 = np.int64()
|
||||
i4 = np.int32()
|
||||
u8 = np.uint64()
|
||||
b_ = np.bool_()
|
||||
i = int()
|
||||
|
||||
f8 = np.float64()
|
||||
|
||||
b_ >> f8 # E: No overload variant
|
||||
i8 << f8 # E: No overload variant
|
||||
i | f8 # E: Unsupported operand types
|
||||
i8 ^ f8 # E: No overload variant
|
||||
u8 & f8 # E: No overload variant
|
||||
~f8 # E: Unsupported operand type
|
||||
|
||||
# mypys' error message for `NoReturn` is unfortunately pretty bad
|
||||
# TODO: Re-enable this once we add support for numerical precision for `number`s
|
||||
# a = u8 | 0 # E: Need type annotation
|
@@ -0,0 +1,66 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_U: npt.NDArray[np.str_]
|
||||
AR_S: npt.NDArray[np.bytes_]
|
||||
|
||||
np.char.equal(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.not_equal(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.greater_equal(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.less_equal(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.greater(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.less(AR_U, AR_S) # E: incompatible type
|
||||
|
||||
np.char.encode(AR_S) # E: incompatible type
|
||||
np.char.decode(AR_U) # E: incompatible type
|
||||
|
||||
np.char.join(AR_U, b"_") # E: incompatible type
|
||||
np.char.join(AR_S, "_") # E: incompatible type
|
||||
|
||||
np.char.ljust(AR_U, 5, fillchar=b"a") # E: incompatible type
|
||||
np.char.ljust(AR_S, 5, fillchar="a") # E: incompatible type
|
||||
np.char.rjust(AR_U, 5, fillchar=b"a") # E: incompatible type
|
||||
np.char.rjust(AR_S, 5, fillchar="a") # E: incompatible type
|
||||
|
||||
np.char.lstrip(AR_U, chars=b"a") # E: incompatible type
|
||||
np.char.lstrip(AR_S, chars="a") # E: incompatible type
|
||||
np.char.strip(AR_U, chars=b"a") # E: incompatible type
|
||||
np.char.strip(AR_S, chars="a") # E: incompatible type
|
||||
np.char.rstrip(AR_U, chars=b"a") # E: incompatible type
|
||||
np.char.rstrip(AR_S, chars="a") # E: incompatible type
|
||||
|
||||
np.char.partition(AR_U, b"a") # E: incompatible type
|
||||
np.char.partition(AR_S, "a") # E: incompatible type
|
||||
np.char.rpartition(AR_U, b"a") # E: incompatible type
|
||||
np.char.rpartition(AR_S, "a") # E: incompatible type
|
||||
|
||||
np.char.replace(AR_U, b"_", b"-") # E: incompatible type
|
||||
np.char.replace(AR_S, "_", "-") # E: incompatible type
|
||||
|
||||
np.char.split(AR_U, b"_") # E: incompatible type
|
||||
np.char.split(AR_S, "_") # E: incompatible type
|
||||
np.char.rsplit(AR_U, b"_") # E: incompatible type
|
||||
np.char.rsplit(AR_S, "_") # E: incompatible type
|
||||
|
||||
np.char.count(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.count(AR_S, "a", end=9) # E: incompatible type
|
||||
|
||||
np.char.endswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.endswith(AR_S, "a", end=9) # E: incompatible type
|
||||
np.char.startswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.startswith(AR_S, "a", end=9) # E: incompatible type
|
||||
|
||||
np.char.find(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.find(AR_S, "a", end=9) # E: incompatible type
|
||||
np.char.rfind(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.rfind(AR_S, "a", end=9) # E: incompatible type
|
||||
|
||||
np.char.index(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.index(AR_S, "a", end=9) # E: incompatible type
|
||||
np.char.rindex(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
np.char.rindex(AR_S, "a", end=9) # E: incompatible type
|
@@ -0,0 +1,62 @@
|
||||
import numpy as np
|
||||
from typing import Any
|
||||
|
||||
AR_U: np.chararray[Any, np.dtype[np.str_]]
|
||||
AR_S: np.chararray[Any, np.dtype[np.bytes_]]
|
||||
|
||||
AR_S.encode() # E: Invalid self argument
|
||||
AR_U.decode() # E: Invalid self argument
|
||||
|
||||
AR_U.join(b"_") # E: incompatible type
|
||||
AR_S.join("_") # E: incompatible type
|
||||
|
||||
AR_U.ljust(5, fillchar=b"a") # E: incompatible type
|
||||
AR_S.ljust(5, fillchar="a") # E: incompatible type
|
||||
AR_U.rjust(5, fillchar=b"a") # E: incompatible type
|
||||
AR_S.rjust(5, fillchar="a") # E: incompatible type
|
||||
|
||||
AR_U.lstrip(chars=b"a") # E: incompatible type
|
||||
AR_S.lstrip(chars="a") # E: incompatible type
|
||||
AR_U.strip(chars=b"a") # E: incompatible type
|
||||
AR_S.strip(chars="a") # E: incompatible type
|
||||
AR_U.rstrip(chars=b"a") # E: incompatible type
|
||||
AR_S.rstrip(chars="a") # E: incompatible type
|
||||
|
||||
AR_U.partition(b"a") # E: incompatible type
|
||||
AR_S.partition("a") # E: incompatible type
|
||||
AR_U.rpartition(b"a") # E: incompatible type
|
||||
AR_S.rpartition("a") # E: incompatible type
|
||||
|
||||
AR_U.replace(b"_", b"-") # E: incompatible type
|
||||
AR_S.replace("_", "-") # E: incompatible type
|
||||
|
||||
AR_U.split(b"_") # E: incompatible type
|
||||
AR_S.split("_") # E: incompatible type
|
||||
AR_S.split(1) # E: incompatible type
|
||||
AR_U.rsplit(b"_") # E: incompatible type
|
||||
AR_S.rsplit("_") # E: incompatible type
|
||||
|
||||
AR_U.count(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.count("a", end=9) # E: incompatible type
|
||||
|
||||
AR_U.endswith(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.endswith("a", end=9) # E: incompatible type
|
||||
AR_U.startswith(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.startswith("a", end=9) # E: incompatible type
|
||||
|
||||
AR_U.find(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.find("a", end=9) # E: incompatible type
|
||||
AR_U.rfind(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.rfind("a", end=9) # E: incompatible type
|
||||
|
||||
AR_U.index(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.index("a", end=9) # E: incompatible type
|
||||
AR_U.rindex(b"a", start=[1, 2, 3]) # E: incompatible type
|
||||
AR_S.rindex("a", end=9) # E: incompatible type
|
||||
|
||||
AR_U == AR_S # E: Unsupported operand types
|
||||
AR_U != AR_S # E: Unsupported operand types
|
||||
AR_U >= AR_S # E: Unsupported operand types
|
||||
AR_U <= AR_S # E: Unsupported operand types
|
||||
AR_U > AR_S # E: Unsupported operand types
|
||||
AR_U < AR_S # E: Unsupported operand types
|
@@ -0,0 +1,27 @@
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_i: np.ndarray[Any, np.dtype[np.int64]]
|
||||
AR_f: np.ndarray[Any, np.dtype[np.float64]]
|
||||
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
|
||||
|
||||
AR_f > AR_m # E: Unsupported operand types
|
||||
AR_c > AR_m # E: Unsupported operand types
|
||||
|
||||
AR_m > AR_f # E: Unsupported operand types
|
||||
AR_m > AR_c # E: Unsupported operand types
|
||||
|
||||
AR_i > AR_M # E: Unsupported operand types
|
||||
AR_f > AR_M # E: Unsupported operand types
|
||||
AR_m > AR_M # E: Unsupported operand types
|
||||
|
||||
AR_M > AR_i # E: Unsupported operand types
|
||||
AR_M > AR_f # E: Unsupported operand types
|
||||
AR_M > AR_m # E: Unsupported operand types
|
||||
|
||||
AR_i > str() # E: No overload variant
|
||||
AR_i > bytes() # E: No overload variant
|
||||
str() > AR_M # E: Unsupported operand types
|
||||
bytes() > AR_M # E: Unsupported operand types
|
@@ -0,0 +1,7 @@
|
||||
import numpy as np
|
||||
|
||||
np.Inf = np.Inf # E: Cannot assign to final
|
||||
np.ALLOW_THREADS = np.ALLOW_THREADS # E: Cannot assign to final
|
||||
np.little_endian = np.little_endian # E: Cannot assign to final
|
||||
np.UFUNC_PYVALS_NAME = "bob" # E: Incompatible types
|
||||
np.CLIP = 2 # E: Incompatible types
|
@@ -0,0 +1,15 @@
|
||||
from pathlib import Path
|
||||
import numpy as np
|
||||
|
||||
path: Path
|
||||
d1: np.DataSource
|
||||
|
||||
d1.abspath(path) # E: incompatible type
|
||||
d1.abspath(b"...") # E: incompatible type
|
||||
|
||||
d1.exists(path) # E: incompatible type
|
||||
d1.exists(b"...") # E: incompatible type
|
||||
|
||||
d1.open(path, "r") # E: incompatible type
|
||||
d1.open(b"...", encoding="utf8") # E: incompatible type
|
||||
d1.open(None, newline="/n") # E: incompatible type
|
@@ -0,0 +1,20 @@
|
||||
import numpy as np
|
||||
|
||||
|
||||
class Test1:
|
||||
not_dtype = np.dtype(float)
|
||||
|
||||
|
||||
class Test2:
|
||||
dtype = float
|
||||
|
||||
|
||||
np.dtype(Test1()) # E: No overload variant of "dtype" matches
|
||||
np.dtype(Test2()) # E: incompatible type
|
||||
|
||||
np.dtype( # E: No overload variant of "dtype" matches
|
||||
{
|
||||
"field1": (float, 1),
|
||||
"field2": (int, 3),
|
||||
}
|
||||
)
|
@@ -0,0 +1,12 @@
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_i: np.ndarray[Any, np.dtype[np.int64]]
|
||||
AR_f: np.ndarray[Any, np.dtype[np.float64]]
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
|
||||
AR_U: np.ndarray[Any, np.dtype[np.str_]]
|
||||
|
||||
np.einsum("i,i->i", AR_i, AR_m) # E: incompatible type
|
||||
np.einsum("i,i->i", AR_f, AR_f, dtype=np.int32) # E: incompatible type
|
||||
np.einsum("i,i->i", AR_i, AR_i, out=AR_U) # E: Value of type variable "_ArrayType" of "einsum" cannot be
|
||||
np.einsum("i,i->i", AR_i, AR_i, out=AR_U, casting="unsafe") # E: No overload variant
|
@@ -0,0 +1,11 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
|
||||
# NOTE: Mypy bug presumably due to the special-casing of heterogeneous tuples;
|
||||
# xref numpy/numpy#20901
|
||||
#
|
||||
# The expected output should be no different than, e.g., when using a
|
||||
# list instead of a tuple
|
||||
np.concatenate(([1], AR_f8)) # E: Argument 1 to "concatenate" has incompatible type
|
@@ -0,0 +1,25 @@
|
||||
from typing import Any
|
||||
|
||||
import numpy as np
|
||||
from numpy._typing import _SupportsArray
|
||||
|
||||
|
||||
class Index:
|
||||
def __index__(self) -> int:
|
||||
...
|
||||
|
||||
|
||||
a: "np.flatiter[np.ndarray]"
|
||||
supports_array: _SupportsArray
|
||||
|
||||
a.base = Any # E: Property "base" defined in "flatiter" is read-only
|
||||
a.coords = Any # E: Property "coords" defined in "flatiter" is read-only
|
||||
a.index = Any # E: Property "index" defined in "flatiter" is read-only
|
||||
a.copy(order='C') # E: Unexpected keyword argument
|
||||
|
||||
# NOTE: Contrary to `ndarray.__getitem__` its counterpart in `flatiter`
|
||||
# does not accept objects with the `__array__` or `__index__` protocols;
|
||||
# boolean indexing is just plain broken (gh-17175)
|
||||
a[np.bool_()] # E: No overload variant of "__getitem__"
|
||||
a[Index()] # E: No overload variant of "__getitem__"
|
||||
a[supports_array] # E: No overload variant of "__getitem__"
|
@@ -0,0 +1,161 @@
|
||||
"""Tests for :mod:`numpy.core.fromnumeric`."""
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
A = np.array(True, ndmin=2, dtype=bool)
|
||||
A.setflags(write=False)
|
||||
AR_U: npt.NDArray[np.str_]
|
||||
|
||||
a = np.bool_(True)
|
||||
|
||||
np.take(a, None) # E: No overload variant
|
||||
np.take(a, axis=1.0) # E: No overload variant
|
||||
np.take(A, out=1) # E: No overload variant
|
||||
np.take(A, mode="bob") # E: No overload variant
|
||||
|
||||
np.reshape(a, None) # E: No overload variant
|
||||
np.reshape(A, 1, order="bob") # E: No overload variant
|
||||
|
||||
np.choose(a, None) # E: No overload variant
|
||||
np.choose(a, out=1.0) # E: No overload variant
|
||||
np.choose(A, mode="bob") # E: No overload variant
|
||||
|
||||
np.repeat(a, None) # E: No overload variant
|
||||
np.repeat(A, 1, axis=1.0) # E: No overload variant
|
||||
|
||||
np.swapaxes(A, None, 1) # E: No overload variant
|
||||
np.swapaxes(A, 1, [0]) # E: No overload variant
|
||||
|
||||
np.transpose(A, axes=1.0) # E: No overload variant
|
||||
|
||||
np.partition(a, None) # E: No overload variant
|
||||
np.partition( # E: No overload variant
|
||||
a, 0, axis="bob"
|
||||
)
|
||||
np.partition( # E: No overload variant
|
||||
A, 0, kind="bob"
|
||||
)
|
||||
np.partition(
|
||||
A, 0, order=range(5) # E: Argument "order" to "partition" has incompatible type
|
||||
)
|
||||
|
||||
np.argpartition(
|
||||
a, None # E: incompatible type
|
||||
)
|
||||
np.argpartition(
|
||||
a, 0, axis="bob" # E: incompatible type
|
||||
)
|
||||
np.argpartition(
|
||||
A, 0, kind="bob" # E: incompatible type
|
||||
)
|
||||
np.argpartition(
|
||||
A, 0, order=range(5) # E: Argument "order" to "argpartition" has incompatible type
|
||||
)
|
||||
|
||||
np.sort(A, axis="bob") # E: No overload variant
|
||||
np.sort(A, kind="bob") # E: No overload variant
|
||||
np.sort(A, order=range(5)) # E: Argument "order" to "sort" has incompatible type
|
||||
|
||||
np.argsort(A, axis="bob") # E: Argument "axis" to "argsort" has incompatible type
|
||||
np.argsort(A, kind="bob") # E: Argument "kind" to "argsort" has incompatible type
|
||||
np.argsort(A, order=range(5)) # E: Argument "order" to "argsort" has incompatible type
|
||||
|
||||
np.argmax(A, axis="bob") # E: No overload variant of "argmax" matches argument type
|
||||
np.argmax(A, kind="bob") # E: No overload variant of "argmax" matches argument type
|
||||
|
||||
np.argmin(A, axis="bob") # E: No overload variant of "argmin" matches argument type
|
||||
np.argmin(A, kind="bob") # E: No overload variant of "argmin" matches argument type
|
||||
|
||||
np.searchsorted( # E: No overload variant of "searchsorted" matches argument type
|
||||
A[0], 0, side="bob"
|
||||
)
|
||||
np.searchsorted( # E: No overload variant of "searchsorted" matches argument type
|
||||
A[0], 0, sorter=1.0
|
||||
)
|
||||
|
||||
np.resize(A, 1.0) # E: No overload variant
|
||||
|
||||
np.squeeze(A, 1.0) # E: No overload variant of "squeeze" matches argument type
|
||||
|
||||
np.diagonal(A, offset=None) # E: No overload variant
|
||||
np.diagonal(A, axis1="bob") # E: No overload variant
|
||||
np.diagonal(A, axis2=[]) # E: No overload variant
|
||||
|
||||
np.trace(A, offset=None) # E: No overload variant
|
||||
np.trace(A, axis1="bob") # E: No overload variant
|
||||
np.trace(A, axis2=[]) # E: No overload variant
|
||||
|
||||
np.ravel(a, order="bob") # E: No overload variant
|
||||
|
||||
np.compress( # E: No overload variant
|
||||
[True], A, axis=1.0
|
||||
)
|
||||
|
||||
np.clip(a, 1, 2, out=1) # E: No overload variant of "clip" matches argument type
|
||||
|
||||
np.sum(a, axis=1.0) # E: No overload variant
|
||||
np.sum(a, keepdims=1.0) # E: No overload variant
|
||||
np.sum(a, initial=[1]) # E: No overload variant
|
||||
|
||||
np.all(a, axis=1.0) # E: No overload variant
|
||||
np.all(a, keepdims=1.0) # E: No overload variant
|
||||
np.all(a, out=1.0) # E: No overload variant
|
||||
|
||||
np.any(a, axis=1.0) # E: No overload variant
|
||||
np.any(a, keepdims=1.0) # E: No overload variant
|
||||
np.any(a, out=1.0) # E: No overload variant
|
||||
|
||||
np.cumsum(a, axis=1.0) # E: No overload variant
|
||||
np.cumsum(a, dtype=1.0) # E: No overload variant
|
||||
np.cumsum(a, out=1.0) # E: No overload variant
|
||||
|
||||
np.ptp(a, axis=1.0) # E: No overload variant
|
||||
np.ptp(a, keepdims=1.0) # E: No overload variant
|
||||
np.ptp(a, out=1.0) # E: No overload variant
|
||||
|
||||
np.amax(a, axis=1.0) # E: No overload variant
|
||||
np.amax(a, keepdims=1.0) # E: No overload variant
|
||||
np.amax(a, out=1.0) # E: No overload variant
|
||||
np.amax(a, initial=[1.0]) # E: No overload variant
|
||||
np.amax(a, where=[1.0]) # E: incompatible type
|
||||
|
||||
np.amin(a, axis=1.0) # E: No overload variant
|
||||
np.amin(a, keepdims=1.0) # E: No overload variant
|
||||
np.amin(a, out=1.0) # E: No overload variant
|
||||
np.amin(a, initial=[1.0]) # E: No overload variant
|
||||
np.amin(a, where=[1.0]) # E: incompatible type
|
||||
|
||||
np.prod(a, axis=1.0) # E: No overload variant
|
||||
np.prod(a, out=False) # E: No overload variant
|
||||
np.prod(a, keepdims=1.0) # E: No overload variant
|
||||
np.prod(a, initial=int) # E: No overload variant
|
||||
np.prod(a, where=1.0) # E: No overload variant
|
||||
np.prod(AR_U) # E: incompatible type
|
||||
|
||||
np.cumprod(a, axis=1.0) # E: No overload variant
|
||||
np.cumprod(a, out=False) # E: No overload variant
|
||||
np.cumprod(AR_U) # E: incompatible type
|
||||
|
||||
np.size(a, axis=1.0) # E: Argument "axis" to "size" has incompatible type
|
||||
|
||||
np.around(a, decimals=1.0) # E: No overload variant
|
||||
np.around(a, out=type) # E: No overload variant
|
||||
np.around(AR_U) # E: incompatible type
|
||||
|
||||
np.mean(a, axis=1.0) # E: No overload variant
|
||||
np.mean(a, out=False) # E: No overload variant
|
||||
np.mean(a, keepdims=1.0) # E: No overload variant
|
||||
np.mean(AR_U) # E: incompatible type
|
||||
|
||||
np.std(a, axis=1.0) # E: No overload variant
|
||||
np.std(a, out=False) # E: No overload variant
|
||||
np.std(a, ddof='test') # E: No overload variant
|
||||
np.std(a, keepdims=1.0) # E: No overload variant
|
||||
np.std(AR_U) # E: incompatible type
|
||||
|
||||
np.var(a, axis=1.0) # E: No overload variant
|
||||
np.var(a, out=False) # E: No overload variant
|
||||
np.var(a, ddof='test') # E: No overload variant
|
||||
np.var(a, keepdims=1.0) # E: No overload variant
|
||||
np.var(AR_U) # E: incompatible type
|
@@ -0,0 +1,12 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_i8: npt.NDArray[np.int64]
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
|
||||
np.histogram_bin_edges(AR_i8, range=(0, 1, 2)) # E: incompatible type
|
||||
|
||||
np.histogram(AR_i8, range=(0, 1, 2)) # E: incompatible type
|
||||
|
||||
np.histogramdd(AR_i8, range=(0, 1)) # E: incompatible type
|
||||
np.histogramdd(AR_i8, range=[(0, 1, 2)]) # E: incompatible type
|
@@ -0,0 +1,14 @@
|
||||
import numpy as np
|
||||
|
||||
AR_LIKE_i: list[int]
|
||||
AR_LIKE_f: list[float]
|
||||
|
||||
np.ndindex([1, 2, 3]) # E: No overload variant
|
||||
np.unravel_index(AR_LIKE_f, (1, 2, 3)) # E: incompatible type
|
||||
np.ravel_multi_index(AR_LIKE_i, (1, 2, 3), mode="bob") # E: No overload variant
|
||||
np.mgrid[1] # E: Invalid index type
|
||||
np.mgrid[...] # E: Invalid index type
|
||||
np.ogrid[1] # E: Invalid index type
|
||||
np.ogrid[...] # E: Invalid index type
|
||||
np.fill_diagonal(AR_LIKE_f, 2) # E: incompatible type
|
||||
np.diag_indices(1.0) # E: incompatible type
|
@@ -0,0 +1,53 @@
|
||||
from typing import Any
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
AR_c16: npt.NDArray[np.complex128]
|
||||
AR_m: npt.NDArray[np.timedelta64]
|
||||
AR_M: npt.NDArray[np.datetime64]
|
||||
AR_O: npt.NDArray[np.object_]
|
||||
|
||||
def func(a: int) -> None: ...
|
||||
|
||||
np.average(AR_m) # E: incompatible type
|
||||
np.select(1, [AR_f8]) # E: incompatible type
|
||||
np.angle(AR_m) # E: incompatible type
|
||||
np.unwrap(AR_m) # E: incompatible type
|
||||
np.unwrap(AR_c16) # E: incompatible type
|
||||
np.trim_zeros(1) # E: incompatible type
|
||||
np.place(1, [True], 1.5) # E: incompatible type
|
||||
np.vectorize(1) # E: incompatible type
|
||||
np.add_newdoc("__main__", 1.5, "docstring") # E: incompatible type
|
||||
np.place(AR_f8, slice(None), 5) # E: incompatible type
|
||||
|
||||
np.interp(AR_f8, AR_c16, AR_f8) # E: incompatible type
|
||||
np.interp(AR_c16, AR_f8, AR_f8) # E: incompatible type
|
||||
np.interp(AR_f8, AR_f8, AR_f8, period=AR_c16) # E: No overload variant
|
||||
np.interp(AR_f8, AR_f8, AR_O) # E: incompatible type
|
||||
|
||||
np.cov(AR_m) # E: incompatible type
|
||||
np.cov(AR_O) # E: incompatible type
|
||||
np.corrcoef(AR_m) # E: incompatible type
|
||||
np.corrcoef(AR_O) # E: incompatible type
|
||||
np.corrcoef(AR_f8, bias=True) # E: No overload variant
|
||||
np.corrcoef(AR_f8, ddof=2) # E: No overload variant
|
||||
np.blackman(1j) # E: incompatible type
|
||||
np.bartlett(1j) # E: incompatible type
|
||||
np.hanning(1j) # E: incompatible type
|
||||
np.hamming(1j) # E: incompatible type
|
||||
np.hamming(AR_c16) # E: incompatible type
|
||||
np.kaiser(1j, 1) # E: incompatible type
|
||||
np.sinc(AR_O) # E: incompatible type
|
||||
np.median(AR_M) # E: incompatible type
|
||||
|
||||
np.add_newdoc_ufunc(func, "docstring") # E: incompatible type
|
||||
np.percentile(AR_f8, 50j) # E: No overload variant
|
||||
np.percentile(AR_f8, 50, interpolation="bob") # E: No overload variant
|
||||
np.quantile(AR_f8, 0.5j) # E: No overload variant
|
||||
np.quantile(AR_f8, 0.5, interpolation="bob") # E: No overload variant
|
||||
np.meshgrid(AR_f8, AR_f8, indexing="bob") # E: incompatible type
|
||||
np.delete(AR_f8, AR_f8) # E: incompatible type
|
||||
np.insert(AR_f8, AR_f8, 1.5) # E: incompatible type
|
||||
np.digitize(AR_f8, 1j) # E: No overload variant
|
@@ -0,0 +1,29 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
AR_c16: npt.NDArray[np.complex128]
|
||||
AR_O: npt.NDArray[np.object_]
|
||||
AR_U: npt.NDArray[np.str_]
|
||||
|
||||
poly_obj: np.poly1d
|
||||
|
||||
np.polyint(AR_U) # E: incompatible type
|
||||
np.polyint(AR_f8, m=1j) # E: No overload variant
|
||||
|
||||
np.polyder(AR_U) # E: incompatible type
|
||||
np.polyder(AR_f8, m=1j) # E: No overload variant
|
||||
|
||||
np.polyfit(AR_O, AR_f8, 1) # E: incompatible type
|
||||
np.polyfit(AR_f8, AR_f8, 1, rcond=1j) # E: No overload variant
|
||||
np.polyfit(AR_f8, AR_f8, 1, w=AR_c16) # E: incompatible type
|
||||
np.polyfit(AR_f8, AR_f8, 1, cov="bob") # E: No overload variant
|
||||
|
||||
np.polyval(AR_f8, AR_U) # E: incompatible type
|
||||
np.polyadd(AR_f8, AR_U) # E: incompatible type
|
||||
np.polysub(AR_f8, AR_U) # E: incompatible type
|
||||
np.polymul(AR_f8, AR_U) # E: incompatible type
|
||||
np.polydiv(AR_f8, AR_U) # E: incompatible type
|
||||
|
||||
5**poly_obj # E: No overload variant
|
||||
hash(poly_obj)
|
@@ -0,0 +1,13 @@
|
||||
import numpy as np
|
||||
|
||||
np.deprecate(1) # E: No overload variant
|
||||
|
||||
np.deprecate_with_doc(1) # E: incompatible type
|
||||
|
||||
np.byte_bounds(1) # E: incompatible type
|
||||
|
||||
np.who(1) # E: incompatible type
|
||||
|
||||
np.lookfor(None) # E: incompatible type
|
||||
|
||||
np.safe_eval(None) # E: incompatible type
|
@@ -0,0 +1,6 @@
|
||||
from numpy.lib import NumpyVersion
|
||||
|
||||
version: NumpyVersion
|
||||
|
||||
NumpyVersion(b"1.8.0") # E: incompatible type
|
||||
version >= b"1.8.0" # E: Unsupported operand types
|
@@ -0,0 +1,48 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
AR_O: npt.NDArray[np.object_]
|
||||
AR_M: npt.NDArray[np.datetime64]
|
||||
|
||||
np.linalg.tensorsolve(AR_O, AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.solve(AR_O, AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.tensorinv(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.inv(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.matrix_power(AR_M, 5) # E: incompatible type
|
||||
|
||||
np.linalg.cholesky(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.qr(AR_O) # E: incompatible type
|
||||
np.linalg.qr(AR_f8, mode="bob") # E: No overload variant
|
||||
|
||||
np.linalg.eigvals(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.eigvalsh(AR_O) # E: incompatible type
|
||||
np.linalg.eigvalsh(AR_O, UPLO="bob") # E: No overload variant
|
||||
|
||||
np.linalg.eig(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.eigh(AR_O) # E: incompatible type
|
||||
np.linalg.eigh(AR_O, UPLO="bob") # E: No overload variant
|
||||
|
||||
np.linalg.svd(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.cond(AR_O) # E: incompatible type
|
||||
np.linalg.cond(AR_f8, p="bob") # E: incompatible type
|
||||
|
||||
np.linalg.matrix_rank(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.pinv(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.slogdet(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.det(AR_O) # E: incompatible type
|
||||
|
||||
np.linalg.norm(AR_f8, ord="bob") # E: No overload variant
|
||||
|
||||
np.linalg.multi_dot([AR_M]) # E: incompatible type
|
@@ -0,0 +1,5 @@
|
||||
import numpy as np
|
||||
|
||||
with open("file.txt", "r") as f:
|
||||
np.memmap(f) # E: No overload variant
|
||||
np.memmap("test.txt", shape=[10, 5]) # E: No overload variant
|
@@ -0,0 +1,18 @@
|
||||
import numpy as np
|
||||
|
||||
np.testing.bob # E: Module has no attribute
|
||||
np.bob # E: Module has no attribute
|
||||
|
||||
# Stdlib modules in the namespace by accident
|
||||
np.warnings # E: Module has no attribute
|
||||
np.sys # E: Module has no attribute
|
||||
np.os # E: Module has no attribute
|
||||
np.math # E: Module has no attribute
|
||||
|
||||
# Public sub-modules that are not imported to their parent module by default;
|
||||
# e.g. one must first execute `import numpy.lib.recfunctions`
|
||||
np.lib.recfunctions # E: Module has no attribute
|
||||
|
||||
np.__NUMPY_SETUP__ # E: Module has no attribute
|
||||
np.__deprecated_attrs__ # E: Module has no attribute
|
||||
np.__expired_functions__ # E: Module has no attribute
|
@@ -0,0 +1,55 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
i8: np.int64
|
||||
|
||||
AR_b: npt.NDArray[np.bool_]
|
||||
AR_u1: npt.NDArray[np.uint8]
|
||||
AR_i8: npt.NDArray[np.int64]
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
AR_M: npt.NDArray[np.datetime64]
|
||||
|
||||
M: np.datetime64
|
||||
|
||||
AR_LIKE_f: list[float]
|
||||
|
||||
def func(a: int) -> None: ...
|
||||
|
||||
np.where(AR_b, 1) # E: No overload variant
|
||||
|
||||
np.can_cast(AR_f8, 1) # E: incompatible type
|
||||
|
||||
np.vdot(AR_M, AR_M) # E: incompatible type
|
||||
|
||||
np.copyto(AR_LIKE_f, AR_f8) # E: incompatible type
|
||||
|
||||
np.putmask(AR_LIKE_f, [True, True, False], 1.5) # E: incompatible type
|
||||
|
||||
np.packbits(AR_f8) # E: incompatible type
|
||||
np.packbits(AR_u1, bitorder=">") # E: incompatible type
|
||||
|
||||
np.unpackbits(AR_i8) # E: incompatible type
|
||||
np.unpackbits(AR_u1, bitorder=">") # E: incompatible type
|
||||
|
||||
np.shares_memory(1, 1, max_work=i8) # E: incompatible type
|
||||
np.may_share_memory(1, 1, max_work=i8) # E: incompatible type
|
||||
|
||||
np.arange(M) # E: No overload variant
|
||||
np.arange(stop=10) # E: No overload variant
|
||||
|
||||
np.datetime_data(int) # E: incompatible type
|
||||
|
||||
np.busday_offset("2012", 10) # E: No overload variant
|
||||
|
||||
np.datetime_as_string("2012") # E: No overload variant
|
||||
|
||||
np.compare_chararrays("a", b"a", "==", False) # E: No overload variant
|
||||
|
||||
np.add_docstring(func, None) # E: incompatible type
|
||||
|
||||
np.nested_iters([AR_i8, AR_i8]) # E: Missing positional argument
|
||||
np.nested_iters([AR_i8, AR_i8], 0) # E: incompatible type
|
||||
np.nested_iters([AR_i8, AR_i8], [0]) # E: incompatible type
|
||||
np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["test"]) # E: incompatible type
|
||||
np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["test"]]) # E: incompatible type
|
||||
np.nested_iters([AR_i8, AR_i8], [[0], [1]], buffersize=1.0) # E: incompatible type
|
@@ -0,0 +1,11 @@
|
||||
import numpy as np
|
||||
|
||||
# Ban setting dtype since mutating the type of the array in place
|
||||
# makes having ndarray be generic over dtype impossible. Generally
|
||||
# users should use `ndarray.view` in this situation anyway. See
|
||||
#
|
||||
# https://github.com/numpy/numpy-stubs/issues/7
|
||||
#
|
||||
# for more context.
|
||||
float_array = np.array([1.0])
|
||||
float_array.dtype = np.bool_ # E: Property "dtype" defined in "ndarray" is read-only
|
@@ -0,0 +1,43 @@
|
||||
"""
|
||||
Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
|
||||
|
||||
More extensive tests are performed for the methods'
|
||||
function-based counterpart in `../from_numeric.py`.
|
||||
|
||||
"""
|
||||
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
f8: np.float64
|
||||
AR_f8: np.ndarray[Any, np.dtype[np.float64]]
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
|
||||
AR_b: np.ndarray[Any, np.dtype[np.bool_]]
|
||||
|
||||
ctypes_obj = AR_f8.ctypes
|
||||
|
||||
reveal_type(ctypes_obj.get_data()) # E: has no attribute
|
||||
reveal_type(ctypes_obj.get_shape()) # E: has no attribute
|
||||
reveal_type(ctypes_obj.get_strides()) # E: has no attribute
|
||||
reveal_type(ctypes_obj.get_as_parameter()) # E: has no attribute
|
||||
|
||||
f8.argpartition(0) # E: has no attribute
|
||||
f8.diagonal() # E: has no attribute
|
||||
f8.dot(1) # E: has no attribute
|
||||
f8.nonzero() # E: has no attribute
|
||||
f8.partition(0) # E: has no attribute
|
||||
f8.put(0, 2) # E: has no attribute
|
||||
f8.setfield(2, np.float64) # E: has no attribute
|
||||
f8.sort() # E: has no attribute
|
||||
f8.trace() # E: has no attribute
|
||||
|
||||
AR_M.__int__() # E: Invalid self argument
|
||||
AR_M.__float__() # E: Invalid self argument
|
||||
AR_M.__complex__() # E: Invalid self argument
|
||||
AR_b.__index__() # E: Invalid self argument
|
||||
|
||||
AR_f8[1.5] # E: No overload variant
|
||||
AR_f8["field_a"] # E: No overload variant
|
||||
AR_f8[["field_a", "field_b"]] # E: Invalid index type
|
||||
|
||||
AR_f8.__array_finalize__(object()) # E: incompatible type
|
@@ -0,0 +1,8 @@
|
||||
import numpy as np
|
||||
|
||||
class Test(np.nditer): ... # E: Cannot inherit from final class
|
||||
|
||||
np.nditer([0, 1], flags=["test"]) # E: incompatible type
|
||||
np.nditer([0, 1], op_flags=[["test"]]) # E: incompatible type
|
||||
np.nditer([0, 1], itershape=(1.0,)) # E: incompatible type
|
||||
np.nditer([0, 1], buffersize=1.0) # E: incompatible type
|
@@ -0,0 +1,17 @@
|
||||
from collections.abc import Sequence
|
||||
from numpy._typing import _NestedSequence
|
||||
|
||||
a: Sequence[float]
|
||||
b: list[complex]
|
||||
c: tuple[str, ...]
|
||||
d: int
|
||||
e: str
|
||||
|
||||
def func(a: _NestedSequence[int]) -> None:
|
||||
...
|
||||
|
||||
reveal_type(func(a)) # E: incompatible type
|
||||
reveal_type(func(b)) # E: incompatible type
|
||||
reveal_type(func(c)) # E: incompatible type
|
||||
reveal_type(func(d)) # E: incompatible type
|
||||
reveal_type(func(e)) # E: incompatible type
|
@@ -0,0 +1,30 @@
|
||||
import pathlib
|
||||
from typing import IO
|
||||
|
||||
import numpy.typing as npt
|
||||
import numpy as np
|
||||
|
||||
str_path: str
|
||||
bytes_path: bytes
|
||||
pathlib_path: pathlib.Path
|
||||
str_file: IO[str]
|
||||
AR_i8: npt.NDArray[np.int64]
|
||||
|
||||
np.load(str_file) # E: incompatible type
|
||||
|
||||
np.save(bytes_path, AR_i8) # E: incompatible type
|
||||
np.save(str_file, AR_i8) # E: incompatible type
|
||||
|
||||
np.savez(bytes_path, AR_i8) # E: incompatible type
|
||||
np.savez(str_file, AR_i8) # E: incompatible type
|
||||
|
||||
np.savez_compressed(bytes_path, AR_i8) # E: incompatible type
|
||||
np.savez_compressed(str_file, AR_i8) # E: incompatible type
|
||||
|
||||
np.loadtxt(bytes_path) # E: incompatible type
|
||||
|
||||
np.fromregex(bytes_path, ".", np.int64) # E: No overload variant
|
||||
|
||||
np.recfromtxt(bytes_path) # E: incompatible type
|
||||
|
||||
np.recfromcsv(bytes_path) # E: incompatible type
|
@@ -0,0 +1,11 @@
|
||||
import numpy as np
|
||||
|
||||
# Technically this works, but probably shouldn't. See
|
||||
#
|
||||
# https://github.com/numpy/numpy/issues/16366
|
||||
#
|
||||
np.maximum_sctype(1) # E: No overload variant
|
||||
|
||||
np.issubsctype(1, np.int64) # E: incompatible type
|
||||
|
||||
np.issubdtype(1, np.int64) # E: incompatible type
|
@@ -0,0 +1,61 @@
|
||||
import numpy as np
|
||||
from typing import Any
|
||||
|
||||
SEED_FLOAT: float = 457.3
|
||||
SEED_ARR_FLOAT: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0, 2, 3, 4])
|
||||
SEED_ARRLIKE_FLOAT: list[float] = [1.0, 2.0, 3.0, 4.0]
|
||||
SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
|
||||
SEED_STR: str = "String seeding not allowed"
|
||||
# default rng
|
||||
np.random.default_rng(SEED_FLOAT) # E: incompatible type
|
||||
np.random.default_rng(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.default_rng(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.default_rng(SEED_STR) # E: incompatible type
|
||||
|
||||
# Seed Sequence
|
||||
np.random.SeedSequence(SEED_FLOAT) # E: incompatible type
|
||||
np.random.SeedSequence(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.SeedSequence(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.SeedSequence(SEED_SEED_SEQ) # E: incompatible type
|
||||
np.random.SeedSequence(SEED_STR) # E: incompatible type
|
||||
|
||||
seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence()
|
||||
seed_seq.spawn(11.5) # E: incompatible type
|
||||
seed_seq.generate_state(3.14) # E: incompatible type
|
||||
seed_seq.generate_state(3, np.uint8) # E: incompatible type
|
||||
seed_seq.generate_state(3, "uint8") # E: incompatible type
|
||||
seed_seq.generate_state(3, "u1") # E: incompatible type
|
||||
seed_seq.generate_state(3, np.uint16) # E: incompatible type
|
||||
seed_seq.generate_state(3, "uint16") # E: incompatible type
|
||||
seed_seq.generate_state(3, "u2") # E: incompatible type
|
||||
seed_seq.generate_state(3, np.int32) # E: incompatible type
|
||||
seed_seq.generate_state(3, "int32") # E: incompatible type
|
||||
seed_seq.generate_state(3, "i4") # E: incompatible type
|
||||
|
||||
# Bit Generators
|
||||
np.random.MT19937(SEED_FLOAT) # E: incompatible type
|
||||
np.random.MT19937(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.MT19937(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.MT19937(SEED_STR) # E: incompatible type
|
||||
|
||||
np.random.PCG64(SEED_FLOAT) # E: incompatible type
|
||||
np.random.PCG64(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.PCG64(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.PCG64(SEED_STR) # E: incompatible type
|
||||
|
||||
np.random.Philox(SEED_FLOAT) # E: incompatible type
|
||||
np.random.Philox(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.Philox(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.Philox(SEED_STR) # E: incompatible type
|
||||
|
||||
np.random.SFC64(SEED_FLOAT) # E: incompatible type
|
||||
np.random.SFC64(SEED_ARR_FLOAT) # E: incompatible type
|
||||
np.random.SFC64(SEED_ARRLIKE_FLOAT) # E: incompatible type
|
||||
np.random.SFC64(SEED_STR) # E: incompatible type
|
||||
|
||||
# Generator
|
||||
np.random.Generator(None) # E: incompatible type
|
||||
np.random.Generator(12333283902830213) # E: incompatible type
|
||||
np.random.Generator("OxFEEDF00D") # E: incompatible type
|
||||
np.random.Generator([123, 234]) # E: incompatible type
|
||||
np.random.Generator(np.array([123, 234], dtype="u4")) # E: incompatible type
|
@@ -0,0 +1,17 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_i8: npt.NDArray[np.int64]
|
||||
|
||||
np.rec.fromarrays(1) # E: No overload variant
|
||||
np.rec.fromarrays([1, 2, 3], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
|
||||
|
||||
np.rec.fromrecords(AR_i8) # E: incompatible type
|
||||
np.rec.fromrecords([(1.5,)], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
|
||||
|
||||
np.rec.fromstring("string", dtype=[("f8", "f8")]) # E: No overload variant
|
||||
np.rec.fromstring(b"bytes") # E: No overload variant
|
||||
np.rec.fromstring(b"(1.5,)", dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
|
||||
|
||||
with open("test", "r") as f:
|
||||
np.rec.fromfile(f, dtype=[("f8", "f8")]) # E: No overload variant
|
@@ -0,0 +1,92 @@
|
||||
import sys
|
||||
import numpy as np
|
||||
|
||||
f2: np.float16
|
||||
f8: np.float64
|
||||
c8: np.complex64
|
||||
|
||||
# Construction
|
||||
|
||||
np.float32(3j) # E: incompatible type
|
||||
|
||||
# Technically the following examples are valid NumPy code. But they
|
||||
# are not considered a best practice, and people who wish to use the
|
||||
# stubs should instead do
|
||||
#
|
||||
# np.array([1.0, 0.0, 0.0], dtype=np.float32)
|
||||
# np.array([], dtype=np.complex64)
|
||||
#
|
||||
# See e.g. the discussion on the mailing list
|
||||
#
|
||||
# https://mail.python.org/pipermail/numpy-discussion/2020-April/080566.html
|
||||
#
|
||||
# and the issue
|
||||
#
|
||||
# https://github.com/numpy/numpy-stubs/issues/41
|
||||
#
|
||||
# for more context.
|
||||
np.float32([1.0, 0.0, 0.0]) # E: incompatible type
|
||||
np.complex64([]) # E: incompatible type
|
||||
|
||||
np.complex64(1, 2) # E: Too many arguments
|
||||
# TODO: protocols (can't check for non-existent protocols w/ __getattr__)
|
||||
|
||||
np.datetime64(0) # E: No overload variant
|
||||
|
||||
class A:
|
||||
def __float__(self):
|
||||
return 1.0
|
||||
|
||||
|
||||
np.int8(A()) # E: incompatible type
|
||||
np.int16(A()) # E: incompatible type
|
||||
np.int32(A()) # E: incompatible type
|
||||
np.int64(A()) # E: incompatible type
|
||||
np.uint8(A()) # E: incompatible type
|
||||
np.uint16(A()) # E: incompatible type
|
||||
np.uint32(A()) # E: incompatible type
|
||||
np.uint64(A()) # E: incompatible type
|
||||
|
||||
np.void("test") # E: No overload variant
|
||||
np.void("test", dtype=None) # E: No overload variant
|
||||
|
||||
np.generic(1) # E: Cannot instantiate abstract class
|
||||
np.number(1) # E: Cannot instantiate abstract class
|
||||
np.integer(1) # E: Cannot instantiate abstract class
|
||||
np.inexact(1) # E: Cannot instantiate abstract class
|
||||
np.character("test") # E: Cannot instantiate abstract class
|
||||
np.flexible(b"test") # E: Cannot instantiate abstract class
|
||||
|
||||
np.float64(value=0.0) # E: Unexpected keyword argument
|
||||
np.int64(value=0) # E: Unexpected keyword argument
|
||||
np.uint64(value=0) # E: Unexpected keyword argument
|
||||
np.complex128(value=0.0j) # E: Unexpected keyword argument
|
||||
np.str_(value='bob') # E: No overload variant
|
||||
np.bytes_(value=b'test') # E: No overload variant
|
||||
np.void(value=b'test') # E: No overload variant
|
||||
np.bool_(value=True) # E: Unexpected keyword argument
|
||||
np.datetime64(value="2019") # E: No overload variant
|
||||
np.timedelta64(value=0) # E: Unexpected keyword argument
|
||||
|
||||
np.bytes_(b"hello", encoding='utf-8') # E: No overload variant
|
||||
np.str_("hello", encoding='utf-8') # E: No overload variant
|
||||
|
||||
f8.item(1) # E: incompatible type
|
||||
f8.item((0, 1)) # E: incompatible type
|
||||
f8.squeeze(axis=1) # E: incompatible type
|
||||
f8.squeeze(axis=(0, 1)) # E: incompatible type
|
||||
f8.transpose(1) # E: incompatible type
|
||||
|
||||
def func(a: np.float32) -> None: ...
|
||||
|
||||
func(f2) # E: incompatible type
|
||||
func(f8) # E: incompatible type
|
||||
|
||||
round(c8) # E: No overload variant
|
||||
|
||||
c8.__getnewargs__() # E: Invalid self argument
|
||||
f2.__getnewargs__() # E: Invalid self argument
|
||||
f2.hex() # E: Invalid self argument
|
||||
np.float16.fromhex("0x0.0p+0") # E: Invalid self argument
|
||||
f2.__trunc__() # E: Invalid self argument
|
||||
f2.__getformat__("float") # E: Invalid self argument
|
@@ -0,0 +1,8 @@
|
||||
import numpy as np
|
||||
|
||||
class DTypeLike:
|
||||
dtype: np.dtype[np.int_]
|
||||
|
||||
dtype_like: DTypeLike
|
||||
|
||||
np.expand_dims(dtype_like, (5, 10)) # E: No overload variant
|
@@ -0,0 +1,9 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
|
||||
np.lib.stride_tricks.as_strided(AR_f8, shape=8) # E: No overload variant
|
||||
np.lib.stride_tricks.as_strided(AR_f8, strides=8) # E: No overload variant
|
||||
|
||||
np.lib.stride_tricks.sliding_window_view(AR_f8, axis=(1,)) # E: No overload variant
|
@@ -0,0 +1,28 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_U: npt.NDArray[np.str_]
|
||||
|
||||
def func() -> bool: ...
|
||||
|
||||
np.testing.assert_(True, msg=1) # E: incompatible type
|
||||
np.testing.build_err_msg(1, "test") # E: incompatible type
|
||||
np.testing.assert_almost_equal(AR_U, AR_U) # E: incompatible type
|
||||
np.testing.assert_approx_equal([1, 2, 3], [1, 2, 3]) # E: incompatible type
|
||||
np.testing.assert_array_almost_equal(AR_U, AR_U) # E: incompatible type
|
||||
np.testing.assert_array_less(AR_U, AR_U) # E: incompatible type
|
||||
np.testing.assert_string_equal(b"a", b"a") # E: incompatible type
|
||||
|
||||
np.testing.assert_raises(expected_exception=TypeError, callable=func) # E: No overload variant
|
||||
np.testing.assert_raises_regex(expected_exception=TypeError, expected_regex="T", callable=func) # E: No overload variant
|
||||
|
||||
np.testing.assert_allclose(AR_U, AR_U) # E: incompatible type
|
||||
np.testing.assert_array_almost_equal_nulp(AR_U, AR_U) # E: incompatible type
|
||||
np.testing.assert_array_max_ulp(AR_U, AR_U) # E: incompatible type
|
||||
|
||||
np.testing.assert_warns(warning_class=RuntimeWarning, func=func) # E: No overload variant
|
||||
np.testing.assert_no_warnings(func=func) # E: No overload variant
|
||||
np.testing.assert_no_warnings(func, None) # E: Too many arguments
|
||||
np.testing.assert_no_warnings(func, test=None) # E: Unexpected keyword argument
|
||||
|
||||
np.testing.assert_no_gc_cycles(func=func) # E: No overload variant
|
@@ -0,0 +1,37 @@
|
||||
from typing import Any, TypeVar
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
|
||||
def func1(ar: npt.NDArray[Any], a: int) -> npt.NDArray[np.str_]:
|
||||
pass
|
||||
|
||||
|
||||
def func2(ar: npt.NDArray[Any], a: float) -> float:
|
||||
pass
|
||||
|
||||
|
||||
AR_b: npt.NDArray[np.bool_]
|
||||
AR_m: npt.NDArray[np.timedelta64]
|
||||
|
||||
AR_LIKE_b: list[bool]
|
||||
|
||||
np.eye(10, M=20.0) # E: No overload variant
|
||||
np.eye(10, k=2.5, dtype=int) # E: No overload variant
|
||||
|
||||
np.diag(AR_b, k=0.5) # E: No overload variant
|
||||
np.diagflat(AR_b, k=0.5) # E: No overload variant
|
||||
|
||||
np.tri(10, M=20.0) # E: No overload variant
|
||||
np.tri(10, k=2.5, dtype=int) # E: No overload variant
|
||||
|
||||
np.tril(AR_b, k=0.5) # E: No overload variant
|
||||
np.triu(AR_b, k=0.5) # E: No overload variant
|
||||
|
||||
np.vander(AR_m) # E: incompatible type
|
||||
|
||||
np.histogram2d(AR_m) # E: No overload variant
|
||||
|
||||
np.mask_indices(10, func1) # E: incompatible type
|
||||
np.mask_indices(10, func2, 10.5) # E: incompatible type
|
@@ -0,0 +1,13 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
DTYPE_i8: np.dtype[np.int64]
|
||||
|
||||
np.mintypecode(DTYPE_i8) # E: incompatible type
|
||||
np.iscomplexobj(DTYPE_i8) # E: incompatible type
|
||||
np.isrealobj(DTYPE_i8) # E: incompatible type
|
||||
|
||||
np.typename(DTYPE_i8) # E: No overload variant
|
||||
np.typename("invalid") # E: No overload variant
|
||||
|
||||
np.common_type(np.timedelta64()) # E: incompatible type
|
@@ -0,0 +1,21 @@
|
||||
"""Typing tests for `numpy.core._ufunc_config`."""
|
||||
|
||||
import numpy as np
|
||||
|
||||
def func1(a: str, b: int, c: float) -> None: ...
|
||||
def func2(a: str, *, b: int) -> None: ...
|
||||
|
||||
class Write1:
|
||||
def write1(self, a: str) -> None: ...
|
||||
|
||||
class Write2:
|
||||
def write(self, a: str, b: str) -> None: ...
|
||||
|
||||
class Write3:
|
||||
def write(self, *, a: str) -> None: ...
|
||||
|
||||
np.seterrcall(func1) # E: Argument 1 to "seterrcall" has incompatible type
|
||||
np.seterrcall(func2) # E: Argument 1 to "seterrcall" has incompatible type
|
||||
np.seterrcall(Write1()) # E: Argument 1 to "seterrcall" has incompatible type
|
||||
np.seterrcall(Write2()) # E: Argument 1 to "seterrcall" has incompatible type
|
||||
np.seterrcall(Write3()) # E: Argument 1 to "seterrcall" has incompatible type
|
@@ -0,0 +1,21 @@
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_c: np.ndarray[Any, np.dtype[np.complex128]]
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]]
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
|
||||
AR_O: np.ndarray[Any, np.dtype[np.object_]]
|
||||
|
||||
np.fix(AR_c) # E: incompatible type
|
||||
np.fix(AR_m) # E: incompatible type
|
||||
np.fix(AR_M) # E: incompatible type
|
||||
|
||||
np.isposinf(AR_c) # E: incompatible type
|
||||
np.isposinf(AR_m) # E: incompatible type
|
||||
np.isposinf(AR_M) # E: incompatible type
|
||||
np.isposinf(AR_O) # E: incompatible type
|
||||
|
||||
np.isneginf(AR_c) # E: incompatible type
|
||||
np.isneginf(AR_m) # E: incompatible type
|
||||
np.isneginf(AR_M) # E: incompatible type
|
||||
np.isneginf(AR_O) # E: incompatible type
|
@@ -0,0 +1,41 @@
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
AR_f8: npt.NDArray[np.float64]
|
||||
|
||||
np.sin.nin + "foo" # E: Unsupported operand types
|
||||
np.sin(1, foo="bar") # E: No overload variant
|
||||
|
||||
np.abs(None) # E: No overload variant
|
||||
|
||||
np.add(1, 1, 1) # E: No overload variant
|
||||
np.add(1, 1, axis=0) # E: No overload variant
|
||||
|
||||
np.matmul(AR_f8, AR_f8, where=True) # E: No overload variant
|
||||
|
||||
np.frexp(AR_f8, out=None) # E: No overload variant
|
||||
np.frexp(AR_f8, out=AR_f8) # E: No overload variant
|
||||
|
||||
np.absolute.outer() # E: "None" not callable
|
||||
np.frexp.outer() # E: "None" not callable
|
||||
np.divmod.outer() # E: "None" not callable
|
||||
np.matmul.outer() # E: "None" not callable
|
||||
|
||||
np.absolute.reduceat() # E: "None" not callable
|
||||
np.frexp.reduceat() # E: "None" not callable
|
||||
np.divmod.reduceat() # E: "None" not callable
|
||||
np.matmul.reduceat() # E: "None" not callable
|
||||
|
||||
np.absolute.reduce() # E: "None" not callable
|
||||
np.frexp.reduce() # E: "None" not callable
|
||||
np.divmod.reduce() # E: "None" not callable
|
||||
np.matmul.reduce() # E: "None" not callable
|
||||
|
||||
np.absolute.accumulate() # E: "None" not callable
|
||||
np.frexp.accumulate() # E: "None" not callable
|
||||
np.divmod.accumulate() # E: "None" not callable
|
||||
np.matmul.accumulate() # E: "None" not callable
|
||||
|
||||
np.frexp.at() # E: "None" not callable
|
||||
np.divmod.at() # E: "None" not callable
|
||||
np.matmul.at() # E: "None" not callable
|
@@ -0,0 +1,5 @@
|
||||
import numpy as np
|
||||
|
||||
np.AxisError(1.0) # E: No overload variant
|
||||
np.AxisError(1, ndim=2.0) # E: No overload variant
|
||||
np.AxisError(2, msg_prefix=404) # E: No overload variant
|
@@ -0,0 +1,17 @@
|
||||
import numpy as np
|
||||
|
||||
reveal_type(np.uint128())
|
||||
reveal_type(np.uint256())
|
||||
|
||||
reveal_type(np.int128())
|
||||
reveal_type(np.int256())
|
||||
|
||||
reveal_type(np.float80())
|
||||
reveal_type(np.float96())
|
||||
reveal_type(np.float128())
|
||||
reveal_type(np.float256())
|
||||
|
||||
reveal_type(np.complex160())
|
||||
reveal_type(np.complex192())
|
||||
reveal_type(np.complex256())
|
||||
reveal_type(np.complex512())
|
@@ -0,0 +1,10 @@
|
||||
[mypy]
|
||||
plugins = numpy.typing.mypy_plugin
|
||||
show_absolute_path = True
|
||||
implicit_reexport = False
|
||||
|
||||
[mypy-numpy]
|
||||
ignore_errors = True
|
||||
|
||||
[mypy-numpy.*]
|
||||
ignore_errors = True
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,594 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
c16 = np.complex128(1)
|
||||
f8 = np.float64(1)
|
||||
i8 = np.int64(1)
|
||||
u8 = np.uint64(1)
|
||||
|
||||
c8 = np.complex64(1)
|
||||
f4 = np.float32(1)
|
||||
i4 = np.int32(1)
|
||||
u4 = np.uint32(1)
|
||||
|
||||
dt = np.datetime64(1, "D")
|
||||
td = np.timedelta64(1, "D")
|
||||
|
||||
b_ = np.bool_(1)
|
||||
|
||||
b = bool(1)
|
||||
c = complex(1)
|
||||
f = float(1)
|
||||
i = int(1)
|
||||
|
||||
|
||||
class Object:
|
||||
def __array__(self) -> np.ndarray[Any, np.dtype[np.object_]]:
|
||||
ret = np.empty((), dtype=object)
|
||||
ret[()] = self
|
||||
return ret
|
||||
|
||||
def __sub__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __rsub__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __floordiv__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __rfloordiv__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __mul__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __rmul__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __pow__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
def __rpow__(self, value: Any) -> Object:
|
||||
return self
|
||||
|
||||
|
||||
AR_b: np.ndarray[Any, np.dtype[np.bool_]] = np.array([True])
|
||||
AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32)
|
||||
AR_i: np.ndarray[Any, np.dtype[np.int64]] = np.array([1])
|
||||
AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0])
|
||||
AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1j])
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64(1, "D")])
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64(1, "D")])
|
||||
AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([Object()])
|
||||
|
||||
AR_LIKE_b = [True]
|
||||
AR_LIKE_u = [np.uint32(1)]
|
||||
AR_LIKE_i = [1]
|
||||
AR_LIKE_f = [1.0]
|
||||
AR_LIKE_c = [1j]
|
||||
AR_LIKE_m = [np.timedelta64(1, "D")]
|
||||
AR_LIKE_M = [np.datetime64(1, "D")]
|
||||
AR_LIKE_O = [Object()]
|
||||
|
||||
# Array subtractions
|
||||
|
||||
AR_b - AR_LIKE_u
|
||||
AR_b - AR_LIKE_i
|
||||
AR_b - AR_LIKE_f
|
||||
AR_b - AR_LIKE_c
|
||||
AR_b - AR_LIKE_m
|
||||
AR_b - AR_LIKE_O
|
||||
|
||||
AR_LIKE_u - AR_b
|
||||
AR_LIKE_i - AR_b
|
||||
AR_LIKE_f - AR_b
|
||||
AR_LIKE_c - AR_b
|
||||
AR_LIKE_m - AR_b
|
||||
AR_LIKE_M - AR_b
|
||||
AR_LIKE_O - AR_b
|
||||
|
||||
AR_u - AR_LIKE_b
|
||||
AR_u - AR_LIKE_u
|
||||
AR_u - AR_LIKE_i
|
||||
AR_u - AR_LIKE_f
|
||||
AR_u - AR_LIKE_c
|
||||
AR_u - AR_LIKE_m
|
||||
AR_u - AR_LIKE_O
|
||||
|
||||
AR_LIKE_b - AR_u
|
||||
AR_LIKE_u - AR_u
|
||||
AR_LIKE_i - AR_u
|
||||
AR_LIKE_f - AR_u
|
||||
AR_LIKE_c - AR_u
|
||||
AR_LIKE_m - AR_u
|
||||
AR_LIKE_M - AR_u
|
||||
AR_LIKE_O - AR_u
|
||||
|
||||
AR_i - AR_LIKE_b
|
||||
AR_i - AR_LIKE_u
|
||||
AR_i - AR_LIKE_i
|
||||
AR_i - AR_LIKE_f
|
||||
AR_i - AR_LIKE_c
|
||||
AR_i - AR_LIKE_m
|
||||
AR_i - AR_LIKE_O
|
||||
|
||||
AR_LIKE_b - AR_i
|
||||
AR_LIKE_u - AR_i
|
||||
AR_LIKE_i - AR_i
|
||||
AR_LIKE_f - AR_i
|
||||
AR_LIKE_c - AR_i
|
||||
AR_LIKE_m - AR_i
|
||||
AR_LIKE_M - AR_i
|
||||
AR_LIKE_O - AR_i
|
||||
|
||||
AR_f - AR_LIKE_b
|
||||
AR_f - AR_LIKE_u
|
||||
AR_f - AR_LIKE_i
|
||||
AR_f - AR_LIKE_f
|
||||
AR_f - AR_LIKE_c
|
||||
AR_f - AR_LIKE_O
|
||||
|
||||
AR_LIKE_b - AR_f
|
||||
AR_LIKE_u - AR_f
|
||||
AR_LIKE_i - AR_f
|
||||
AR_LIKE_f - AR_f
|
||||
AR_LIKE_c - AR_f
|
||||
AR_LIKE_O - AR_f
|
||||
|
||||
AR_c - AR_LIKE_b
|
||||
AR_c - AR_LIKE_u
|
||||
AR_c - AR_LIKE_i
|
||||
AR_c - AR_LIKE_f
|
||||
AR_c - AR_LIKE_c
|
||||
AR_c - AR_LIKE_O
|
||||
|
||||
AR_LIKE_b - AR_c
|
||||
AR_LIKE_u - AR_c
|
||||
AR_LIKE_i - AR_c
|
||||
AR_LIKE_f - AR_c
|
||||
AR_LIKE_c - AR_c
|
||||
AR_LIKE_O - AR_c
|
||||
|
||||
AR_m - AR_LIKE_b
|
||||
AR_m - AR_LIKE_u
|
||||
AR_m - AR_LIKE_i
|
||||
AR_m - AR_LIKE_m
|
||||
|
||||
AR_LIKE_b - AR_m
|
||||
AR_LIKE_u - AR_m
|
||||
AR_LIKE_i - AR_m
|
||||
AR_LIKE_m - AR_m
|
||||
AR_LIKE_M - AR_m
|
||||
|
||||
AR_M - AR_LIKE_b
|
||||
AR_M - AR_LIKE_u
|
||||
AR_M - AR_LIKE_i
|
||||
AR_M - AR_LIKE_m
|
||||
AR_M - AR_LIKE_M
|
||||
|
||||
AR_LIKE_M - AR_M
|
||||
|
||||
AR_O - AR_LIKE_b
|
||||
AR_O - AR_LIKE_u
|
||||
AR_O - AR_LIKE_i
|
||||
AR_O - AR_LIKE_f
|
||||
AR_O - AR_LIKE_c
|
||||
AR_O - AR_LIKE_O
|
||||
|
||||
AR_LIKE_b - AR_O
|
||||
AR_LIKE_u - AR_O
|
||||
AR_LIKE_i - AR_O
|
||||
AR_LIKE_f - AR_O
|
||||
AR_LIKE_c - AR_O
|
||||
AR_LIKE_O - AR_O
|
||||
|
||||
AR_u += AR_b
|
||||
AR_u += AR_u
|
||||
AR_u += 1 # Allowed during runtime as long as the object is 0D and >=0
|
||||
|
||||
# Array floor division
|
||||
|
||||
AR_b // AR_LIKE_b
|
||||
AR_b // AR_LIKE_u
|
||||
AR_b // AR_LIKE_i
|
||||
AR_b // AR_LIKE_f
|
||||
AR_b // AR_LIKE_O
|
||||
|
||||
AR_LIKE_b // AR_b
|
||||
AR_LIKE_u // AR_b
|
||||
AR_LIKE_i // AR_b
|
||||
AR_LIKE_f // AR_b
|
||||
AR_LIKE_O // AR_b
|
||||
|
||||
AR_u // AR_LIKE_b
|
||||
AR_u // AR_LIKE_u
|
||||
AR_u // AR_LIKE_i
|
||||
AR_u // AR_LIKE_f
|
||||
AR_u // AR_LIKE_O
|
||||
|
||||
AR_LIKE_b // AR_u
|
||||
AR_LIKE_u // AR_u
|
||||
AR_LIKE_i // AR_u
|
||||
AR_LIKE_f // AR_u
|
||||
AR_LIKE_m // AR_u
|
||||
AR_LIKE_O // AR_u
|
||||
|
||||
AR_i // AR_LIKE_b
|
||||
AR_i // AR_LIKE_u
|
||||
AR_i // AR_LIKE_i
|
||||
AR_i // AR_LIKE_f
|
||||
AR_i // AR_LIKE_O
|
||||
|
||||
AR_LIKE_b // AR_i
|
||||
AR_LIKE_u // AR_i
|
||||
AR_LIKE_i // AR_i
|
||||
AR_LIKE_f // AR_i
|
||||
AR_LIKE_m // AR_i
|
||||
AR_LIKE_O // AR_i
|
||||
|
||||
AR_f // AR_LIKE_b
|
||||
AR_f // AR_LIKE_u
|
||||
AR_f // AR_LIKE_i
|
||||
AR_f // AR_LIKE_f
|
||||
AR_f // AR_LIKE_O
|
||||
|
||||
AR_LIKE_b // AR_f
|
||||
AR_LIKE_u // AR_f
|
||||
AR_LIKE_i // AR_f
|
||||
AR_LIKE_f // AR_f
|
||||
AR_LIKE_m // AR_f
|
||||
AR_LIKE_O // AR_f
|
||||
|
||||
AR_m // AR_LIKE_u
|
||||
AR_m // AR_LIKE_i
|
||||
AR_m // AR_LIKE_f
|
||||
AR_m // AR_LIKE_m
|
||||
|
||||
AR_LIKE_m // AR_m
|
||||
|
||||
AR_O // AR_LIKE_b
|
||||
AR_O // AR_LIKE_u
|
||||
AR_O // AR_LIKE_i
|
||||
AR_O // AR_LIKE_f
|
||||
AR_O // AR_LIKE_O
|
||||
|
||||
AR_LIKE_b // AR_O
|
||||
AR_LIKE_u // AR_O
|
||||
AR_LIKE_i // AR_O
|
||||
AR_LIKE_f // AR_O
|
||||
AR_LIKE_O // AR_O
|
||||
|
||||
# Inplace multiplication
|
||||
|
||||
AR_b *= AR_LIKE_b
|
||||
|
||||
AR_u *= AR_LIKE_b
|
||||
AR_u *= AR_LIKE_u
|
||||
|
||||
AR_i *= AR_LIKE_b
|
||||
AR_i *= AR_LIKE_u
|
||||
AR_i *= AR_LIKE_i
|
||||
|
||||
AR_f *= AR_LIKE_b
|
||||
AR_f *= AR_LIKE_u
|
||||
AR_f *= AR_LIKE_i
|
||||
AR_f *= AR_LIKE_f
|
||||
|
||||
AR_c *= AR_LIKE_b
|
||||
AR_c *= AR_LIKE_u
|
||||
AR_c *= AR_LIKE_i
|
||||
AR_c *= AR_LIKE_f
|
||||
AR_c *= AR_LIKE_c
|
||||
|
||||
AR_m *= AR_LIKE_b
|
||||
AR_m *= AR_LIKE_u
|
||||
AR_m *= AR_LIKE_i
|
||||
AR_m *= AR_LIKE_f
|
||||
|
||||
AR_O *= AR_LIKE_b
|
||||
AR_O *= AR_LIKE_u
|
||||
AR_O *= AR_LIKE_i
|
||||
AR_O *= AR_LIKE_f
|
||||
AR_O *= AR_LIKE_c
|
||||
AR_O *= AR_LIKE_O
|
||||
|
||||
# Inplace power
|
||||
|
||||
AR_u **= AR_LIKE_b
|
||||
AR_u **= AR_LIKE_u
|
||||
|
||||
AR_i **= AR_LIKE_b
|
||||
AR_i **= AR_LIKE_u
|
||||
AR_i **= AR_LIKE_i
|
||||
|
||||
AR_f **= AR_LIKE_b
|
||||
AR_f **= AR_LIKE_u
|
||||
AR_f **= AR_LIKE_i
|
||||
AR_f **= AR_LIKE_f
|
||||
|
||||
AR_c **= AR_LIKE_b
|
||||
AR_c **= AR_LIKE_u
|
||||
AR_c **= AR_LIKE_i
|
||||
AR_c **= AR_LIKE_f
|
||||
AR_c **= AR_LIKE_c
|
||||
|
||||
AR_O **= AR_LIKE_b
|
||||
AR_O **= AR_LIKE_u
|
||||
AR_O **= AR_LIKE_i
|
||||
AR_O **= AR_LIKE_f
|
||||
AR_O **= AR_LIKE_c
|
||||
AR_O **= AR_LIKE_O
|
||||
|
||||
# unary ops
|
||||
|
||||
-c16
|
||||
-c8
|
||||
-f8
|
||||
-f4
|
||||
-i8
|
||||
-i4
|
||||
with pytest.warns(RuntimeWarning):
|
||||
-u8
|
||||
-u4
|
||||
-td
|
||||
-AR_f
|
||||
|
||||
+c16
|
||||
+c8
|
||||
+f8
|
||||
+f4
|
||||
+i8
|
||||
+i4
|
||||
+u8
|
||||
+u4
|
||||
+td
|
||||
+AR_f
|
||||
|
||||
abs(c16)
|
||||
abs(c8)
|
||||
abs(f8)
|
||||
abs(f4)
|
||||
abs(i8)
|
||||
abs(i4)
|
||||
abs(u8)
|
||||
abs(u4)
|
||||
abs(td)
|
||||
abs(b_)
|
||||
abs(AR_f)
|
||||
|
||||
# Time structures
|
||||
|
||||
dt + td
|
||||
dt + i
|
||||
dt + i4
|
||||
dt + i8
|
||||
dt - dt
|
||||
dt - i
|
||||
dt - i4
|
||||
dt - i8
|
||||
|
||||
td + td
|
||||
td + i
|
||||
td + i4
|
||||
td + i8
|
||||
td - td
|
||||
td - i
|
||||
td - i4
|
||||
td - i8
|
||||
td / f
|
||||
td / f4
|
||||
td / f8
|
||||
td / td
|
||||
td // td
|
||||
td % td
|
||||
|
||||
|
||||
# boolean
|
||||
|
||||
b_ / b
|
||||
b_ / b_
|
||||
b_ / i
|
||||
b_ / i8
|
||||
b_ / i4
|
||||
b_ / u8
|
||||
b_ / u4
|
||||
b_ / f
|
||||
b_ / f8
|
||||
b_ / f4
|
||||
b_ / c
|
||||
b_ / c16
|
||||
b_ / c8
|
||||
|
||||
b / b_
|
||||
b_ / b_
|
||||
i / b_
|
||||
i8 / b_
|
||||
i4 / b_
|
||||
u8 / b_
|
||||
u4 / b_
|
||||
f / b_
|
||||
f8 / b_
|
||||
f4 / b_
|
||||
c / b_
|
||||
c16 / b_
|
||||
c8 / b_
|
||||
|
||||
# Complex
|
||||
|
||||
c16 + c16
|
||||
c16 + f8
|
||||
c16 + i8
|
||||
c16 + c8
|
||||
c16 + f4
|
||||
c16 + i4
|
||||
c16 + b_
|
||||
c16 + b
|
||||
c16 + c
|
||||
c16 + f
|
||||
c16 + i
|
||||
c16 + AR_f
|
||||
|
||||
c16 + c16
|
||||
f8 + c16
|
||||
i8 + c16
|
||||
c8 + c16
|
||||
f4 + c16
|
||||
i4 + c16
|
||||
b_ + c16
|
||||
b + c16
|
||||
c + c16
|
||||
f + c16
|
||||
i + c16
|
||||
AR_f + c16
|
||||
|
||||
c8 + c16
|
||||
c8 + f8
|
||||
c8 + i8
|
||||
c8 + c8
|
||||
c8 + f4
|
||||
c8 + i4
|
||||
c8 + b_
|
||||
c8 + b
|
||||
c8 + c
|
||||
c8 + f
|
||||
c8 + i
|
||||
c8 + AR_f
|
||||
|
||||
c16 + c8
|
||||
f8 + c8
|
||||
i8 + c8
|
||||
c8 + c8
|
||||
f4 + c8
|
||||
i4 + c8
|
||||
b_ + c8
|
||||
b + c8
|
||||
c + c8
|
||||
f + c8
|
||||
i + c8
|
||||
AR_f + c8
|
||||
|
||||
# Float
|
||||
|
||||
f8 + f8
|
||||
f8 + i8
|
||||
f8 + f4
|
||||
f8 + i4
|
||||
f8 + b_
|
||||
f8 + b
|
||||
f8 + c
|
||||
f8 + f
|
||||
f8 + i
|
||||
f8 + AR_f
|
||||
|
||||
f8 + f8
|
||||
i8 + f8
|
||||
f4 + f8
|
||||
i4 + f8
|
||||
b_ + f8
|
||||
b + f8
|
||||
c + f8
|
||||
f + f8
|
||||
i + f8
|
||||
AR_f + f8
|
||||
|
||||
f4 + f8
|
||||
f4 + i8
|
||||
f4 + f4
|
||||
f4 + i4
|
||||
f4 + b_
|
||||
f4 + b
|
||||
f4 + c
|
||||
f4 + f
|
||||
f4 + i
|
||||
f4 + AR_f
|
||||
|
||||
f8 + f4
|
||||
i8 + f4
|
||||
f4 + f4
|
||||
i4 + f4
|
||||
b_ + f4
|
||||
b + f4
|
||||
c + f4
|
||||
f + f4
|
||||
i + f4
|
||||
AR_f + f4
|
||||
|
||||
# Int
|
||||
|
||||
i8 + i8
|
||||
i8 + u8
|
||||
i8 + i4
|
||||
i8 + u4
|
||||
i8 + b_
|
||||
i8 + b
|
||||
i8 + c
|
||||
i8 + f
|
||||
i8 + i
|
||||
i8 + AR_f
|
||||
|
||||
u8 + u8
|
||||
u8 + i4
|
||||
u8 + u4
|
||||
u8 + b_
|
||||
u8 + b
|
||||
u8 + c
|
||||
u8 + f
|
||||
u8 + i
|
||||
u8 + AR_f
|
||||
|
||||
i8 + i8
|
||||
u8 + i8
|
||||
i4 + i8
|
||||
u4 + i8
|
||||
b_ + i8
|
||||
b + i8
|
||||
c + i8
|
||||
f + i8
|
||||
i + i8
|
||||
AR_f + i8
|
||||
|
||||
u8 + u8
|
||||
i4 + u8
|
||||
u4 + u8
|
||||
b_ + u8
|
||||
b + u8
|
||||
c + u8
|
||||
f + u8
|
||||
i + u8
|
||||
AR_f + u8
|
||||
|
||||
i4 + i8
|
||||
i4 + i4
|
||||
i4 + i
|
||||
i4 + b_
|
||||
i4 + b
|
||||
i4 + AR_f
|
||||
|
||||
u4 + i8
|
||||
u4 + i4
|
||||
u4 + u8
|
||||
u4 + u4
|
||||
u4 + i
|
||||
u4 + b_
|
||||
u4 + b
|
||||
u4 + AR_f
|
||||
|
||||
i8 + i4
|
||||
i4 + i4
|
||||
i + i4
|
||||
b_ + i4
|
||||
b + i4
|
||||
AR_f + i4
|
||||
|
||||
i8 + u4
|
||||
i4 + u4
|
||||
u8 + u4
|
||||
u4 + u4
|
||||
b_ + u4
|
||||
b + u4
|
||||
i + u4
|
||||
AR_f + u4
|
@@ -0,0 +1,137 @@
|
||||
import sys
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
|
||||
class Index:
|
||||
def __index__(self) -> int:
|
||||
return 0
|
||||
|
||||
|
||||
class SubClass(np.ndarray):
|
||||
pass
|
||||
|
||||
|
||||
def func(i: int, j: int, **kwargs: Any) -> SubClass:
|
||||
return B
|
||||
|
||||
|
||||
i8 = np.int64(1)
|
||||
|
||||
A = np.array([1])
|
||||
B = A.view(SubClass).copy()
|
||||
B_stack = np.array([[1], [1]]).view(SubClass)
|
||||
C = [1]
|
||||
|
||||
np.ndarray(Index())
|
||||
np.ndarray([Index()])
|
||||
|
||||
np.array(1, dtype=float)
|
||||
np.array(1, copy=False)
|
||||
np.array(1, order='F')
|
||||
np.array(1, order=None)
|
||||
np.array(1, subok=True)
|
||||
np.array(1, ndmin=3)
|
||||
np.array(1, str, copy=True, order='C', subok=False, ndmin=2)
|
||||
|
||||
np.asarray(A)
|
||||
np.asarray(B)
|
||||
np.asarray(C)
|
||||
|
||||
np.asanyarray(A)
|
||||
np.asanyarray(B)
|
||||
np.asanyarray(B, dtype=int)
|
||||
np.asanyarray(C)
|
||||
|
||||
np.ascontiguousarray(A)
|
||||
np.ascontiguousarray(B)
|
||||
np.ascontiguousarray(C)
|
||||
|
||||
np.asfortranarray(A)
|
||||
np.asfortranarray(B)
|
||||
np.asfortranarray(C)
|
||||
|
||||
np.require(A)
|
||||
np.require(B)
|
||||
np.require(B, dtype=int)
|
||||
np.require(B, requirements=None)
|
||||
np.require(B, requirements="E")
|
||||
np.require(B, requirements=["ENSUREARRAY"])
|
||||
np.require(B, requirements={"F", "E"})
|
||||
np.require(B, requirements=["C", "OWNDATA"])
|
||||
np.require(B, requirements="W")
|
||||
np.require(B, requirements="A")
|
||||
np.require(C)
|
||||
|
||||
np.linspace(0, 2)
|
||||
np.linspace(0.5, [0, 1, 2])
|
||||
np.linspace([0, 1, 2], 3)
|
||||
np.linspace(0j, 2)
|
||||
np.linspace(0, 2, num=10)
|
||||
np.linspace(0, 2, endpoint=True)
|
||||
np.linspace(0, 2, retstep=True)
|
||||
np.linspace(0j, 2j, retstep=True)
|
||||
np.linspace(0, 2, dtype=bool)
|
||||
np.linspace([0, 1], [2, 3], axis=Index())
|
||||
|
||||
np.logspace(0, 2, base=2)
|
||||
np.logspace(0, 2, base=2)
|
||||
np.logspace(0, 2, base=[1j, 2j], num=2)
|
||||
|
||||
np.geomspace(1, 2)
|
||||
|
||||
np.zeros_like(A)
|
||||
np.zeros_like(C)
|
||||
np.zeros_like(B)
|
||||
np.zeros_like(B, dtype=np.int64)
|
||||
|
||||
np.ones_like(A)
|
||||
np.ones_like(C)
|
||||
np.ones_like(B)
|
||||
np.ones_like(B, dtype=np.int64)
|
||||
|
||||
np.empty_like(A)
|
||||
np.empty_like(C)
|
||||
np.empty_like(B)
|
||||
np.empty_like(B, dtype=np.int64)
|
||||
|
||||
np.full_like(A, i8)
|
||||
np.full_like(C, i8)
|
||||
np.full_like(B, i8)
|
||||
np.full_like(B, i8, dtype=np.int64)
|
||||
|
||||
np.ones(1)
|
||||
np.ones([1, 1, 1])
|
||||
|
||||
np.full(1, i8)
|
||||
np.full([1, 1, 1], i8)
|
||||
|
||||
np.indices([1, 2, 3])
|
||||
np.indices([1, 2, 3], sparse=True)
|
||||
|
||||
np.fromfunction(func, (3, 5))
|
||||
|
||||
np.identity(10)
|
||||
|
||||
np.atleast_1d(C)
|
||||
np.atleast_1d(A)
|
||||
np.atleast_1d(C, C)
|
||||
np.atleast_1d(C, A)
|
||||
np.atleast_1d(A, A)
|
||||
|
||||
np.atleast_2d(C)
|
||||
|
||||
np.atleast_3d(C)
|
||||
|
||||
np.vstack([C, C])
|
||||
np.vstack([C, A])
|
||||
np.vstack([A, A])
|
||||
|
||||
np.hstack([C, C])
|
||||
|
||||
np.stack([C, C])
|
||||
np.stack([C, C], axis=0)
|
||||
np.stack([C, C], out=B_stack)
|
||||
|
||||
np.block([[C, C], [C, C]])
|
||||
np.block(A)
|
@@ -0,0 +1,41 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import numpy as np
|
||||
from numpy._typing import ArrayLike, _SupportsArray
|
||||
|
||||
x1: ArrayLike = True
|
||||
x2: ArrayLike = 5
|
||||
x3: ArrayLike = 1.0
|
||||
x4: ArrayLike = 1 + 1j
|
||||
x5: ArrayLike = np.int8(1)
|
||||
x6: ArrayLike = np.float64(1)
|
||||
x7: ArrayLike = np.complex128(1)
|
||||
x8: ArrayLike = np.array([1, 2, 3])
|
||||
x9: ArrayLike = [1, 2, 3]
|
||||
x10: ArrayLike = (1, 2, 3)
|
||||
x11: ArrayLike = "foo"
|
||||
x12: ArrayLike = memoryview(b'foo')
|
||||
|
||||
|
||||
class A:
|
||||
def __array__(self, dtype: None | np.dtype[Any] = None) -> np.ndarray:
|
||||
return np.array([1, 2, 3])
|
||||
|
||||
|
||||
x13: ArrayLike = A()
|
||||
|
||||
scalar: _SupportsArray = np.int64(1)
|
||||
scalar.__array__()
|
||||
array: _SupportsArray = np.array(1)
|
||||
array.__array__()
|
||||
|
||||
a: _SupportsArray = A()
|
||||
a.__array__()
|
||||
a.__array__()
|
||||
|
||||
# Escape hatch for when you mean to make something like an object
|
||||
# array.
|
||||
object_array_scalar: Any = (i for i in range(10))
|
||||
np.array(object_array_scalar)
|
@@ -0,0 +1,37 @@
|
||||
import numpy as np
|
||||
|
||||
AR = np.arange(10)
|
||||
AR.setflags(write=False)
|
||||
|
||||
with np.printoptions():
|
||||
np.set_printoptions(
|
||||
precision=1,
|
||||
threshold=2,
|
||||
edgeitems=3,
|
||||
linewidth=4,
|
||||
suppress=False,
|
||||
nanstr="Bob",
|
||||
infstr="Bill",
|
||||
formatter={},
|
||||
sign="+",
|
||||
floatmode="unique",
|
||||
)
|
||||
np.get_printoptions()
|
||||
str(AR)
|
||||
|
||||
np.array2string(
|
||||
AR,
|
||||
max_line_width=5,
|
||||
precision=2,
|
||||
suppress_small=True,
|
||||
separator=";",
|
||||
prefix="test",
|
||||
threshold=5,
|
||||
floatmode="fixed",
|
||||
suffix="?",
|
||||
legacy="1.13",
|
||||
)
|
||||
np.format_float_scientific(1, precision=5)
|
||||
np.format_float_positional(1, trim="k")
|
||||
np.array_repr(AR)
|
||||
np.array_str(AR)
|
@@ -0,0 +1,27 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_i8: np.ndarray[Any, np.dtype[np.int_]] = np.arange(10)
|
||||
ar_iter = np.lib.Arrayterator(AR_i8)
|
||||
|
||||
ar_iter.var
|
||||
ar_iter.buf_size
|
||||
ar_iter.start
|
||||
ar_iter.stop
|
||||
ar_iter.step
|
||||
ar_iter.shape
|
||||
ar_iter.flat
|
||||
|
||||
ar_iter.__array__()
|
||||
|
||||
for i in ar_iter:
|
||||
pass
|
||||
|
||||
ar_iter[0]
|
||||
ar_iter[...]
|
||||
ar_iter[:]
|
||||
ar_iter[0, 0, 0]
|
||||
ar_iter[..., 0, :]
|
@@ -0,0 +1,131 @@
|
||||
import numpy as np
|
||||
|
||||
i8 = np.int64(1)
|
||||
u8 = np.uint64(1)
|
||||
|
||||
i4 = np.int32(1)
|
||||
u4 = np.uint32(1)
|
||||
|
||||
b_ = np.bool_(1)
|
||||
|
||||
b = bool(1)
|
||||
i = int(1)
|
||||
|
||||
AR = np.array([0, 1, 2], dtype=np.int32)
|
||||
AR.setflags(write=False)
|
||||
|
||||
|
||||
i8 << i8
|
||||
i8 >> i8
|
||||
i8 | i8
|
||||
i8 ^ i8
|
||||
i8 & i8
|
||||
|
||||
i8 << AR
|
||||
i8 >> AR
|
||||
i8 | AR
|
||||
i8 ^ AR
|
||||
i8 & AR
|
||||
|
||||
i4 << i4
|
||||
i4 >> i4
|
||||
i4 | i4
|
||||
i4 ^ i4
|
||||
i4 & i4
|
||||
|
||||
i8 << i4
|
||||
i8 >> i4
|
||||
i8 | i4
|
||||
i8 ^ i4
|
||||
i8 & i4
|
||||
|
||||
i8 << i
|
||||
i8 >> i
|
||||
i8 | i
|
||||
i8 ^ i
|
||||
i8 & i
|
||||
|
||||
i8 << b_
|
||||
i8 >> b_
|
||||
i8 | b_
|
||||
i8 ^ b_
|
||||
i8 & b_
|
||||
|
||||
i8 << b
|
||||
i8 >> b
|
||||
i8 | b
|
||||
i8 ^ b
|
||||
i8 & b
|
||||
|
||||
u8 << u8
|
||||
u8 >> u8
|
||||
u8 | u8
|
||||
u8 ^ u8
|
||||
u8 & u8
|
||||
|
||||
u8 << AR
|
||||
u8 >> AR
|
||||
u8 | AR
|
||||
u8 ^ AR
|
||||
u8 & AR
|
||||
|
||||
u4 << u4
|
||||
u4 >> u4
|
||||
u4 | u4
|
||||
u4 ^ u4
|
||||
u4 & u4
|
||||
|
||||
u4 << i4
|
||||
u4 >> i4
|
||||
u4 | i4
|
||||
u4 ^ i4
|
||||
u4 & i4
|
||||
|
||||
u4 << i
|
||||
u4 >> i
|
||||
u4 | i
|
||||
u4 ^ i
|
||||
u4 & i
|
||||
|
||||
u8 << b_
|
||||
u8 >> b_
|
||||
u8 | b_
|
||||
u8 ^ b_
|
||||
u8 & b_
|
||||
|
||||
u8 << b
|
||||
u8 >> b
|
||||
u8 | b
|
||||
u8 ^ b
|
||||
u8 & b
|
||||
|
||||
b_ << b_
|
||||
b_ >> b_
|
||||
b_ | b_
|
||||
b_ ^ b_
|
||||
b_ & b_
|
||||
|
||||
b_ << AR
|
||||
b_ >> AR
|
||||
b_ | AR
|
||||
b_ ^ AR
|
||||
b_ & AR
|
||||
|
||||
b_ << b
|
||||
b_ >> b
|
||||
b_ | b
|
||||
b_ ^ b
|
||||
b_ & b
|
||||
|
||||
b_ << i
|
||||
b_ >> i
|
||||
b_ | i
|
||||
b_ ^ i
|
||||
b_ & i
|
||||
|
||||
~i8
|
||||
~i4
|
||||
~u8
|
||||
~u4
|
||||
~b_
|
||||
~AR
|
@@ -0,0 +1,301 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
c16 = np.complex128()
|
||||
f8 = np.float64()
|
||||
i8 = np.int64()
|
||||
u8 = np.uint64()
|
||||
|
||||
c8 = np.complex64()
|
||||
f4 = np.float32()
|
||||
i4 = np.int32()
|
||||
u4 = np.uint32()
|
||||
|
||||
dt = np.datetime64(0, "D")
|
||||
td = np.timedelta64(0, "D")
|
||||
|
||||
b_ = np.bool_()
|
||||
|
||||
b = bool()
|
||||
c = complex()
|
||||
f = float()
|
||||
i = int()
|
||||
|
||||
SEQ = (0, 1, 2, 3, 4)
|
||||
|
||||
AR_b: np.ndarray[Any, np.dtype[np.bool_]] = np.array([True])
|
||||
AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32)
|
||||
AR_i: np.ndarray[Any, np.dtype[np.int_]] = np.array([1])
|
||||
AR_f: np.ndarray[Any, np.dtype[np.float_]] = np.array([1.0])
|
||||
AR_c: np.ndarray[Any, np.dtype[np.complex_]] = np.array([1.0j])
|
||||
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64("1")])
|
||||
AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64("1")])
|
||||
AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([1], dtype=object)
|
||||
|
||||
# Arrays
|
||||
|
||||
AR_b > AR_b
|
||||
AR_b > AR_u
|
||||
AR_b > AR_i
|
||||
AR_b > AR_f
|
||||
AR_b > AR_c
|
||||
|
||||
AR_u > AR_b
|
||||
AR_u > AR_u
|
||||
AR_u > AR_i
|
||||
AR_u > AR_f
|
||||
AR_u > AR_c
|
||||
|
||||
AR_i > AR_b
|
||||
AR_i > AR_u
|
||||
AR_i > AR_i
|
||||
AR_i > AR_f
|
||||
AR_i > AR_c
|
||||
|
||||
AR_f > AR_b
|
||||
AR_f > AR_u
|
||||
AR_f > AR_i
|
||||
AR_f > AR_f
|
||||
AR_f > AR_c
|
||||
|
||||
AR_c > AR_b
|
||||
AR_c > AR_u
|
||||
AR_c > AR_i
|
||||
AR_c > AR_f
|
||||
AR_c > AR_c
|
||||
|
||||
AR_m > AR_b
|
||||
AR_m > AR_u
|
||||
AR_m > AR_i
|
||||
AR_b > AR_m
|
||||
AR_u > AR_m
|
||||
AR_i > AR_m
|
||||
|
||||
AR_M > AR_M
|
||||
|
||||
AR_O > AR_O
|
||||
1 > AR_O
|
||||
AR_O > 1
|
||||
|
||||
# Time structures
|
||||
|
||||
dt > dt
|
||||
|
||||
td > td
|
||||
td > i
|
||||
td > i4
|
||||
td > i8
|
||||
td > AR_i
|
||||
td > SEQ
|
||||
|
||||
# boolean
|
||||
|
||||
b_ > b
|
||||
b_ > b_
|
||||
b_ > i
|
||||
b_ > i8
|
||||
b_ > i4
|
||||
b_ > u8
|
||||
b_ > u4
|
||||
b_ > f
|
||||
b_ > f8
|
||||
b_ > f4
|
||||
b_ > c
|
||||
b_ > c16
|
||||
b_ > c8
|
||||
b_ > AR_i
|
||||
b_ > SEQ
|
||||
|
||||
# Complex
|
||||
|
||||
c16 > c16
|
||||
c16 > f8
|
||||
c16 > i8
|
||||
c16 > c8
|
||||
c16 > f4
|
||||
c16 > i4
|
||||
c16 > b_
|
||||
c16 > b
|
||||
c16 > c
|
||||
c16 > f
|
||||
c16 > i
|
||||
c16 > AR_i
|
||||
c16 > SEQ
|
||||
|
||||
c16 > c16
|
||||
f8 > c16
|
||||
i8 > c16
|
||||
c8 > c16
|
||||
f4 > c16
|
||||
i4 > c16
|
||||
b_ > c16
|
||||
b > c16
|
||||
c > c16
|
||||
f > c16
|
||||
i > c16
|
||||
AR_i > c16
|
||||
SEQ > c16
|
||||
|
||||
c8 > c16
|
||||
c8 > f8
|
||||
c8 > i8
|
||||
c8 > c8
|
||||
c8 > f4
|
||||
c8 > i4
|
||||
c8 > b_
|
||||
c8 > b
|
||||
c8 > c
|
||||
c8 > f
|
||||
c8 > i
|
||||
c8 > AR_i
|
||||
c8 > SEQ
|
||||
|
||||
c16 > c8
|
||||
f8 > c8
|
||||
i8 > c8
|
||||
c8 > c8
|
||||
f4 > c8
|
||||
i4 > c8
|
||||
b_ > c8
|
||||
b > c8
|
||||
c > c8
|
||||
f > c8
|
||||
i > c8
|
||||
AR_i > c8
|
||||
SEQ > c8
|
||||
|
||||
# Float
|
||||
|
||||
f8 > f8
|
||||
f8 > i8
|
||||
f8 > f4
|
||||
f8 > i4
|
||||
f8 > b_
|
||||
f8 > b
|
||||
f8 > c
|
||||
f8 > f
|
||||
f8 > i
|
||||
f8 > AR_i
|
||||
f8 > SEQ
|
||||
|
||||
f8 > f8
|
||||
i8 > f8
|
||||
f4 > f8
|
||||
i4 > f8
|
||||
b_ > f8
|
||||
b > f8
|
||||
c > f8
|
||||
f > f8
|
||||
i > f8
|
||||
AR_i > f8
|
||||
SEQ > f8
|
||||
|
||||
f4 > f8
|
||||
f4 > i8
|
||||
f4 > f4
|
||||
f4 > i4
|
||||
f4 > b_
|
||||
f4 > b
|
||||
f4 > c
|
||||
f4 > f
|
||||
f4 > i
|
||||
f4 > AR_i
|
||||
f4 > SEQ
|
||||
|
||||
f8 > f4
|
||||
i8 > f4
|
||||
f4 > f4
|
||||
i4 > f4
|
||||
b_ > f4
|
||||
b > f4
|
||||
c > f4
|
||||
f > f4
|
||||
i > f4
|
||||
AR_i > f4
|
||||
SEQ > f4
|
||||
|
||||
# Int
|
||||
|
||||
i8 > i8
|
||||
i8 > u8
|
||||
i8 > i4
|
||||
i8 > u4
|
||||
i8 > b_
|
||||
i8 > b
|
||||
i8 > c
|
||||
i8 > f
|
||||
i8 > i
|
||||
i8 > AR_i
|
||||
i8 > SEQ
|
||||
|
||||
u8 > u8
|
||||
u8 > i4
|
||||
u8 > u4
|
||||
u8 > b_
|
||||
u8 > b
|
||||
u8 > c
|
||||
u8 > f
|
||||
u8 > i
|
||||
u8 > AR_i
|
||||
u8 > SEQ
|
||||
|
||||
i8 > i8
|
||||
u8 > i8
|
||||
i4 > i8
|
||||
u4 > i8
|
||||
b_ > i8
|
||||
b > i8
|
||||
c > i8
|
||||
f > i8
|
||||
i > i8
|
||||
AR_i > i8
|
||||
SEQ > i8
|
||||
|
||||
u8 > u8
|
||||
i4 > u8
|
||||
u4 > u8
|
||||
b_ > u8
|
||||
b > u8
|
||||
c > u8
|
||||
f > u8
|
||||
i > u8
|
||||
AR_i > u8
|
||||
SEQ > u8
|
||||
|
||||
i4 > i8
|
||||
i4 > i4
|
||||
i4 > i
|
||||
i4 > b_
|
||||
i4 > b
|
||||
i4 > AR_i
|
||||
i4 > SEQ
|
||||
|
||||
u4 > i8
|
||||
u4 > i4
|
||||
u4 > u8
|
||||
u4 > u4
|
||||
u4 > i
|
||||
u4 > b_
|
||||
u4 > b
|
||||
u4 > AR_i
|
||||
u4 > SEQ
|
||||
|
||||
i8 > i4
|
||||
i4 > i4
|
||||
i > i4
|
||||
b_ > i4
|
||||
b > i4
|
||||
AR_i > i4
|
||||
SEQ > i4
|
||||
|
||||
i8 > u4
|
||||
i4 > u4
|
||||
u8 > u4
|
||||
u4 > u4
|
||||
b_ > u4
|
||||
b > u4
|
||||
i > u4
|
||||
AR_i > u4
|
||||
SEQ > u4
|
@@ -0,0 +1,57 @@
|
||||
import numpy as np
|
||||
|
||||
dtype_obj = np.dtype(np.str_)
|
||||
void_dtype_obj = np.dtype([("f0", np.float64), ("f1", np.float32)])
|
||||
|
||||
np.dtype(dtype=np.int64)
|
||||
np.dtype(int)
|
||||
np.dtype("int")
|
||||
np.dtype(None)
|
||||
|
||||
np.dtype((int, 2))
|
||||
np.dtype((int, (1,)))
|
||||
|
||||
np.dtype({"names": ["a", "b"], "formats": [int, float]})
|
||||
np.dtype({"names": ["a"], "formats": [int], "titles": [object]})
|
||||
np.dtype({"names": ["a"], "formats": [int], "titles": [object()]})
|
||||
|
||||
np.dtype([("name", np.str_, 16), ("grades", np.float64, (2,)), ("age", "int32")])
|
||||
|
||||
np.dtype(
|
||||
{
|
||||
"names": ["a", "b"],
|
||||
"formats": [int, float],
|
||||
"itemsize": 9,
|
||||
"aligned": False,
|
||||
"titles": ["x", "y"],
|
||||
"offsets": [0, 1],
|
||||
}
|
||||
)
|
||||
|
||||
np.dtype((np.float_, float))
|
||||
|
||||
|
||||
class Test:
|
||||
dtype = np.dtype(float)
|
||||
|
||||
|
||||
np.dtype(Test())
|
||||
|
||||
# Methods and attributes
|
||||
dtype_obj.base
|
||||
dtype_obj.subdtype
|
||||
dtype_obj.newbyteorder()
|
||||
dtype_obj.type
|
||||
dtype_obj.name
|
||||
dtype_obj.names
|
||||
|
||||
dtype_obj * 0
|
||||
dtype_obj * 2
|
||||
|
||||
0 * dtype_obj
|
||||
2 * dtype_obj
|
||||
|
||||
void_dtype_obj["f0"]
|
||||
void_dtype_obj[0]
|
||||
void_dtype_obj[["f0", "f1"]]
|
||||
void_dtype_obj[["f0"]]
|
@@ -0,0 +1,36 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import numpy as np
|
||||
|
||||
AR_LIKE_b = [True, True, True]
|
||||
AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)]
|
||||
AR_LIKE_i = [1, 2, 3]
|
||||
AR_LIKE_f = [1.0, 2.0, 3.0]
|
||||
AR_LIKE_c = [1j, 2j, 3j]
|
||||
AR_LIKE_U = ["1", "2", "3"]
|
||||
|
||||
OUT_f: np.ndarray[Any, np.dtype[np.float64]] = np.empty(3, dtype=np.float64)
|
||||
OUT_c: np.ndarray[Any, np.dtype[np.complex128]] = np.empty(3, dtype=np.complex128)
|
||||
|
||||
np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b)
|
||||
np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u)
|
||||
np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i)
|
||||
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f)
|
||||
np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c)
|
||||
np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i)
|
||||
np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)
|
||||
|
||||
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16")
|
||||
np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe")
|
||||
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, out=OUT_c)
|
||||
np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=int, casting="unsafe", out=OUT_f)
|
||||
|
||||
np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b)
|
||||
np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u)
|
||||
np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i)
|
||||
np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f)
|
||||
np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c)
|
||||
np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i)
|
||||
np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)
|
@@ -0,0 +1,16 @@
|
||||
import numpy as np
|
||||
|
||||
a = np.empty((2, 2)).flat
|
||||
|
||||
a.base
|
||||
a.copy()
|
||||
a.coords
|
||||
a.index
|
||||
iter(a)
|
||||
next(a)
|
||||
a[0]
|
||||
a[[0, 1, 2]]
|
||||
a[...]
|
||||
a[:]
|
||||
a.__array__()
|
||||
a.__array__(np.dtype(np.float64))
|
@@ -0,0 +1,260 @@
|
||||
"""Tests for :mod:`numpy.core.fromnumeric`."""
|
||||
|
||||
import numpy as np
|
||||
|
||||
A = np.array(True, ndmin=2, dtype=bool)
|
||||
B = np.array(1.0, ndmin=2, dtype=np.float32)
|
||||
A.setflags(write=False)
|
||||
B.setflags(write=False)
|
||||
|
||||
a = np.bool_(True)
|
||||
b = np.float32(1.0)
|
||||
c = 1.0
|
||||
d = np.array(1.0, dtype=np.float32) # writeable
|
||||
|
||||
np.take(a, 0)
|
||||
np.take(b, 0)
|
||||
np.take(c, 0)
|
||||
np.take(A, 0)
|
||||
np.take(B, 0)
|
||||
np.take(A, [0])
|
||||
np.take(B, [0])
|
||||
|
||||
np.reshape(a, 1)
|
||||
np.reshape(b, 1)
|
||||
np.reshape(c, 1)
|
||||
np.reshape(A, 1)
|
||||
np.reshape(B, 1)
|
||||
|
||||
np.choose(a, [True, True])
|
||||
np.choose(A, [1.0, 1.0])
|
||||
|
||||
np.repeat(a, 1)
|
||||
np.repeat(b, 1)
|
||||
np.repeat(c, 1)
|
||||
np.repeat(A, 1)
|
||||
np.repeat(B, 1)
|
||||
|
||||
np.swapaxes(A, 0, 0)
|
||||
np.swapaxes(B, 0, 0)
|
||||
|
||||
np.transpose(a)
|
||||
np.transpose(b)
|
||||
np.transpose(c)
|
||||
np.transpose(A)
|
||||
np.transpose(B)
|
||||
|
||||
np.partition(a, 0, axis=None)
|
||||
np.partition(b, 0, axis=None)
|
||||
np.partition(c, 0, axis=None)
|
||||
np.partition(A, 0)
|
||||
np.partition(B, 0)
|
||||
|
||||
np.argpartition(a, 0)
|
||||
np.argpartition(b, 0)
|
||||
np.argpartition(c, 0)
|
||||
np.argpartition(A, 0)
|
||||
np.argpartition(B, 0)
|
||||
|
||||
np.sort(A, 0)
|
||||
np.sort(B, 0)
|
||||
|
||||
np.argsort(A, 0)
|
||||
np.argsort(B, 0)
|
||||
|
||||
np.argmax(A)
|
||||
np.argmax(B)
|
||||
np.argmax(A, axis=0)
|
||||
np.argmax(B, axis=0)
|
||||
|
||||
np.argmin(A)
|
||||
np.argmin(B)
|
||||
np.argmin(A, axis=0)
|
||||
np.argmin(B, axis=0)
|
||||
|
||||
np.searchsorted(A[0], 0)
|
||||
np.searchsorted(B[0], 0)
|
||||
np.searchsorted(A[0], [0])
|
||||
np.searchsorted(B[0], [0])
|
||||
|
||||
np.resize(a, (5, 5))
|
||||
np.resize(b, (5, 5))
|
||||
np.resize(c, (5, 5))
|
||||
np.resize(A, (5, 5))
|
||||
np.resize(B, (5, 5))
|
||||
|
||||
np.squeeze(a)
|
||||
np.squeeze(b)
|
||||
np.squeeze(c)
|
||||
np.squeeze(A)
|
||||
np.squeeze(B)
|
||||
|
||||
np.diagonal(A)
|
||||
np.diagonal(B)
|
||||
|
||||
np.trace(A)
|
||||
np.trace(B)
|
||||
|
||||
np.ravel(a)
|
||||
np.ravel(b)
|
||||
np.ravel(c)
|
||||
np.ravel(A)
|
||||
np.ravel(B)
|
||||
|
||||
np.nonzero(A)
|
||||
np.nonzero(B)
|
||||
|
||||
np.shape(a)
|
||||
np.shape(b)
|
||||
np.shape(c)
|
||||
np.shape(A)
|
||||
np.shape(B)
|
||||
|
||||
np.compress([True], a)
|
||||
np.compress([True], b)
|
||||
np.compress([True], c)
|
||||
np.compress([True], A)
|
||||
np.compress([True], B)
|
||||
|
||||
np.clip(a, 0, 1.0)
|
||||
np.clip(b, -1, 1)
|
||||
np.clip(a, 0, None)
|
||||
np.clip(b, None, 1)
|
||||
np.clip(c, 0, 1)
|
||||
np.clip(A, 0, 1)
|
||||
np.clip(B, 0, 1)
|
||||
np.clip(B, [0, 1], [1, 2])
|
||||
|
||||
np.sum(a)
|
||||
np.sum(b)
|
||||
np.sum(c)
|
||||
np.sum(A)
|
||||
np.sum(B)
|
||||
np.sum(A, axis=0)
|
||||
np.sum(B, axis=0)
|
||||
|
||||
np.all(a)
|
||||
np.all(b)
|
||||
np.all(c)
|
||||
np.all(A)
|
||||
np.all(B)
|
||||
np.all(A, axis=0)
|
||||
np.all(B, axis=0)
|
||||
np.all(A, keepdims=True)
|
||||
np.all(B, keepdims=True)
|
||||
|
||||
np.any(a)
|
||||
np.any(b)
|
||||
np.any(c)
|
||||
np.any(A)
|
||||
np.any(B)
|
||||
np.any(A, axis=0)
|
||||
np.any(B, axis=0)
|
||||
np.any(A, keepdims=True)
|
||||
np.any(B, keepdims=True)
|
||||
|
||||
np.cumsum(a)
|
||||
np.cumsum(b)
|
||||
np.cumsum(c)
|
||||
np.cumsum(A)
|
||||
np.cumsum(B)
|
||||
|
||||
np.ptp(b)
|
||||
np.ptp(c)
|
||||
np.ptp(B)
|
||||
np.ptp(B, axis=0)
|
||||
np.ptp(B, keepdims=True)
|
||||
|
||||
np.amax(a)
|
||||
np.amax(b)
|
||||
np.amax(c)
|
||||
np.amax(A)
|
||||
np.amax(B)
|
||||
np.amax(A, axis=0)
|
||||
np.amax(B, axis=0)
|
||||
np.amax(A, keepdims=True)
|
||||
np.amax(B, keepdims=True)
|
||||
|
||||
np.amin(a)
|
||||
np.amin(b)
|
||||
np.amin(c)
|
||||
np.amin(A)
|
||||
np.amin(B)
|
||||
np.amin(A, axis=0)
|
||||
np.amin(B, axis=0)
|
||||
np.amin(A, keepdims=True)
|
||||
np.amin(B, keepdims=True)
|
||||
|
||||
np.prod(a)
|
||||
np.prod(b)
|
||||
np.prod(c)
|
||||
np.prod(A)
|
||||
np.prod(B)
|
||||
np.prod(a, dtype=None)
|
||||
np.prod(A, dtype=None)
|
||||
np.prod(A, axis=0)
|
||||
np.prod(B, axis=0)
|
||||
np.prod(A, keepdims=True)
|
||||
np.prod(B, keepdims=True)
|
||||
np.prod(b, out=d)
|
||||
np.prod(B, out=d)
|
||||
|
||||
np.cumprod(a)
|
||||
np.cumprod(b)
|
||||
np.cumprod(c)
|
||||
np.cumprod(A)
|
||||
np.cumprod(B)
|
||||
|
||||
np.ndim(a)
|
||||
np.ndim(b)
|
||||
np.ndim(c)
|
||||
np.ndim(A)
|
||||
np.ndim(B)
|
||||
|
||||
np.size(a)
|
||||
np.size(b)
|
||||
np.size(c)
|
||||
np.size(A)
|
||||
np.size(B)
|
||||
|
||||
np.around(a)
|
||||
np.around(b)
|
||||
np.around(c)
|
||||
np.around(A)
|
||||
np.around(B)
|
||||
|
||||
np.mean(a)
|
||||
np.mean(b)
|
||||
np.mean(c)
|
||||
np.mean(A)
|
||||
np.mean(B)
|
||||
np.mean(A, axis=0)
|
||||
np.mean(B, axis=0)
|
||||
np.mean(A, keepdims=True)
|
||||
np.mean(B, keepdims=True)
|
||||
np.mean(b, out=d)
|
||||
np.mean(B, out=d)
|
||||
|
||||
np.std(a)
|
||||
np.std(b)
|
||||
np.std(c)
|
||||
np.std(A)
|
||||
np.std(B)
|
||||
np.std(A, axis=0)
|
||||
np.std(B, axis=0)
|
||||
np.std(A, keepdims=True)
|
||||
np.std(B, keepdims=True)
|
||||
np.std(b, out=d)
|
||||
np.std(B, out=d)
|
||||
|
||||
np.var(a)
|
||||
np.var(b)
|
||||
np.var(c)
|
||||
np.var(A)
|
||||
np.var(B)
|
||||
np.var(A, axis=0)
|
||||
np.var(B, axis=0)
|
||||
np.var(A, keepdims=True)
|
||||
np.var(B, keepdims=True)
|
||||
np.var(b, out=d)
|
||||
np.var(B, out=d)
|
@@ -0,0 +1,64 @@
|
||||
from __future__ import annotations
|
||||
from typing import Any
|
||||
import numpy as np
|
||||
|
||||
AR_LIKE_b = [[True, True], [True, True]]
|
||||
AR_LIKE_i = [[1, 2], [3, 4]]
|
||||
AR_LIKE_f = [[1.0, 2.0], [3.0, 4.0]]
|
||||
AR_LIKE_U = [["1", "2"], ["3", "4"]]
|
||||
|
||||
AR_i8: np.ndarray[Any, np.dtype[np.int64]] = np.array(AR_LIKE_i, dtype=np.int64)
|
||||
|
||||
np.ndenumerate(AR_i8)
|
||||
np.ndenumerate(AR_LIKE_f)
|
||||
np.ndenumerate(AR_LIKE_U)
|
||||
|
||||
np.ndenumerate(AR_i8).iter
|
||||
np.ndenumerate(AR_LIKE_f).iter
|
||||
np.ndenumerate(AR_LIKE_U).iter
|
||||
|
||||
next(np.ndenumerate(AR_i8))
|
||||
next(np.ndenumerate(AR_LIKE_f))
|
||||
next(np.ndenumerate(AR_LIKE_U))
|
||||
|
||||
iter(np.ndenumerate(AR_i8))
|
||||
iter(np.ndenumerate(AR_LIKE_f))
|
||||
iter(np.ndenumerate(AR_LIKE_U))
|
||||
|
||||
iter(np.ndindex(1, 2, 3))
|
||||
next(np.ndindex(1, 2, 3))
|
||||
|
||||
np.unravel_index([22, 41, 37], (7, 6))
|
||||
np.unravel_index([31, 41, 13], (7, 6), order='F')
|
||||
np.unravel_index(1621, (6, 7, 8, 9))
|
||||
|
||||
np.ravel_multi_index(AR_LIKE_i, (7, 6))
|
||||
np.ravel_multi_index(AR_LIKE_i, (7, 6), order='F')
|
||||
np.ravel_multi_index(AR_LIKE_i, (4, 6), mode='clip')
|
||||
np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=('clip', 'wrap'))
|
||||
np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9))
|
||||
|
||||
np.mgrid[1:1:2]
|
||||
np.mgrid[1:1:2, None:10]
|
||||
|
||||
np.ogrid[1:1:2]
|
||||
np.ogrid[1:1:2, None:10]
|
||||
|
||||
np.index_exp[0:1]
|
||||
np.index_exp[0:1, None:3]
|
||||
np.index_exp[0, 0:1, ..., [0, 1, 3]]
|
||||
|
||||
np.s_[0:1]
|
||||
np.s_[0:1, None:3]
|
||||
np.s_[0, 0:1, ..., [0, 1, 3]]
|
||||
|
||||
np.ix_(AR_LIKE_b[0])
|
||||
np.ix_(AR_LIKE_i[0], AR_LIKE_f[0])
|
||||
np.ix_(AR_i8[0])
|
||||
|
||||
np.fill_diagonal(AR_i8, 5)
|
||||
|
||||
np.diag_indices(4)
|
||||
np.diag_indices(2, 3)
|
||||
|
||||
np.diag_indices_from(AR_i8)
|
@@ -0,0 +1,25 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from io import StringIO
|
||||
|
||||
import numpy as np
|
||||
|
||||
FILE = StringIO()
|
||||
AR = np.arange(10, dtype=np.float64)
|
||||
|
||||
def func(a: int) -> bool: ...
|
||||
|
||||
np.deprecate(func)
|
||||
np.deprecate()
|
||||
|
||||
np.deprecate_with_doc("test")
|
||||
np.deprecate_with_doc(None)
|
||||
|
||||
np.byte_bounds(AR)
|
||||
np.byte_bounds(np.float64())
|
||||
|
||||
np.info(1, output=FILE)
|
||||
|
||||
np.source(np.interp, output=FILE)
|
||||
|
||||
np.lookfor("binary representation", output=FILE)
|
@@ -0,0 +1,18 @@
|
||||
from numpy.lib import NumpyVersion
|
||||
|
||||
version = NumpyVersion("1.8.0")
|
||||
|
||||
version.vstring
|
||||
version.version
|
||||
version.major
|
||||
version.minor
|
||||
version.bugfix
|
||||
version.pre_release
|
||||
version.is_devversion
|
||||
|
||||
version == version
|
||||
version != version
|
||||
version < "1.8.0"
|
||||
version <= version
|
||||
version > version
|
||||
version >= "1.8.0"
|
@@ -0,0 +1,47 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from functools import partial
|
||||
from collections.abc import Callable
|
||||
|
||||
import pytest # type: ignore
|
||||
import numpy as np
|
||||
|
||||
AR = np.array(0)
|
||||
AR.setflags(write=False)
|
||||
|
||||
KACF = frozenset({None, "K", "A", "C", "F"})
|
||||
ACF = frozenset({None, "A", "C", "F"})
|
||||
CF = frozenset({None, "C", "F"})
|
||||
|
||||
order_list: list[tuple[frozenset, Callable]] = [
|
||||
(KACF, partial(np.ndarray, 1)),
|
||||
(KACF, AR.tobytes),
|
||||
(KACF, partial(AR.astype, int)),
|
||||
(KACF, AR.copy),
|
||||
(ACF, partial(AR.reshape, 1)),
|
||||
(KACF, AR.flatten),
|
||||
(KACF, AR.ravel),
|
||||
(KACF, partial(np.array, 1)),
|
||||
(CF, partial(np.zeros, 1)),
|
||||
(CF, partial(np.ones, 1)),
|
||||
(CF, partial(np.empty, 1)),
|
||||
(CF, partial(np.full, 1, 1)),
|
||||
(KACF, partial(np.zeros_like, AR)),
|
||||
(KACF, partial(np.ones_like, AR)),
|
||||
(KACF, partial(np.empty_like, AR)),
|
||||
(KACF, partial(np.full_like, AR, 1)),
|
||||
(KACF, partial(np.add, 1, 1)), # i.e. np.ufunc.__call__
|
||||
(ACF, partial(np.reshape, AR, 1)),
|
||||
(KACF, partial(np.ravel, AR)),
|
||||
(KACF, partial(np.asarray, 1)),
|
||||
(KACF, partial(np.asanyarray, 1)),
|
||||
]
|
||||
|
||||
for order_set, func in order_list:
|
||||
for order in order_set:
|
||||
func(order=order)
|
||||
|
||||
invalid_orders = KACF - order_set
|
||||
for order in invalid_orders:
|
||||
with pytest.raises(ValueError):
|
||||
func(order=order)
|
@@ -0,0 +1,149 @@
|
||||
import numpy as np
|
||||
|
||||
f8 = np.float64(1)
|
||||
i8 = np.int64(1)
|
||||
u8 = np.uint64(1)
|
||||
|
||||
f4 = np.float32(1)
|
||||
i4 = np.int32(1)
|
||||
u4 = np.uint32(1)
|
||||
|
||||
td = np.timedelta64(1, "D")
|
||||
b_ = np.bool_(1)
|
||||
|
||||
b = bool(1)
|
||||
f = float(1)
|
||||
i = int(1)
|
||||
|
||||
AR = np.array([1], dtype=np.bool_)
|
||||
AR.setflags(write=False)
|
||||
|
||||
AR2 = np.array([1], dtype=np.timedelta64)
|
||||
AR2.setflags(write=False)
|
||||
|
||||
# Time structures
|
||||
|
||||
td % td
|
||||
td % AR2
|
||||
AR2 % td
|
||||
|
||||
divmod(td, td)
|
||||
divmod(td, AR2)
|
||||
divmod(AR2, td)
|
||||
|
||||
# Bool
|
||||
|
||||
b_ % b
|
||||
b_ % i
|
||||
b_ % f
|
||||
b_ % b_
|
||||
b_ % i8
|
||||
b_ % u8
|
||||
b_ % f8
|
||||
b_ % AR
|
||||
|
||||
divmod(b_, b)
|
||||
divmod(b_, i)
|
||||
divmod(b_, f)
|
||||
divmod(b_, b_)
|
||||
divmod(b_, i8)
|
||||
divmod(b_, u8)
|
||||
divmod(b_, f8)
|
||||
divmod(b_, AR)
|
||||
|
||||
b % b_
|
||||
i % b_
|
||||
f % b_
|
||||
b_ % b_
|
||||
i8 % b_
|
||||
u8 % b_
|
||||
f8 % b_
|
||||
AR % b_
|
||||
|
||||
divmod(b, b_)
|
||||
divmod(i, b_)
|
||||
divmod(f, b_)
|
||||
divmod(b_, b_)
|
||||
divmod(i8, b_)
|
||||
divmod(u8, b_)
|
||||
divmod(f8, b_)
|
||||
divmod(AR, b_)
|
||||
|
||||
# int
|
||||
|
||||
i8 % b
|
||||
i8 % i
|
||||
i8 % f
|
||||
i8 % i8
|
||||
i8 % f8
|
||||
i4 % i8
|
||||
i4 % f8
|
||||
i4 % i4
|
||||
i4 % f4
|
||||
i8 % AR
|
||||
|
||||
divmod(i8, b)
|
||||
divmod(i8, i)
|
||||
divmod(i8, f)
|
||||
divmod(i8, i8)
|
||||
divmod(i8, f8)
|
||||
divmod(i8, i4)
|
||||
divmod(i8, f4)
|
||||
divmod(i4, i4)
|
||||
divmod(i4, f4)
|
||||
divmod(i8, AR)
|
||||
|
||||
b % i8
|
||||
i % i8
|
||||
f % i8
|
||||
i8 % i8
|
||||
f8 % i8
|
||||
i8 % i4
|
||||
f8 % i4
|
||||
i4 % i4
|
||||
f4 % i4
|
||||
AR % i8
|
||||
|
||||
divmod(b, i8)
|
||||
divmod(i, i8)
|
||||
divmod(f, i8)
|
||||
divmod(i8, i8)
|
||||
divmod(f8, i8)
|
||||
divmod(i4, i8)
|
||||
divmod(f4, i8)
|
||||
divmod(i4, i4)
|
||||
divmod(f4, i4)
|
||||
divmod(AR, i8)
|
||||
|
||||
# float
|
||||
|
||||
f8 % b
|
||||
f8 % i
|
||||
f8 % f
|
||||
i8 % f4
|
||||
f4 % f4
|
||||
f8 % AR
|
||||
|
||||
divmod(f8, b)
|
||||
divmod(f8, i)
|
||||
divmod(f8, f)
|
||||
divmod(f8, f8)
|
||||
divmod(f8, f4)
|
||||
divmod(f4, f4)
|
||||
divmod(f8, AR)
|
||||
|
||||
b % f8
|
||||
i % f8
|
||||
f % f8
|
||||
f8 % f8
|
||||
f8 % f8
|
||||
f4 % f4
|
||||
AR % f8
|
||||
|
||||
divmod(b, f8)
|
||||
divmod(i, f8)
|
||||
divmod(f, f8)
|
||||
divmod(f8, f8)
|
||||
divmod(f4, f8)
|
||||
divmod(f4, f4)
|
||||
divmod(AR, f8)
|
@@ -0,0 +1,43 @@
|
||||
import numpy as np
|
||||
from numpy import f2py
|
||||
|
||||
np.char
|
||||
np.ctypeslib
|
||||
np.emath
|
||||
np.fft
|
||||
np.lib
|
||||
np.linalg
|
||||
np.ma
|
||||
np.matrixlib
|
||||
np.polynomial
|
||||
np.random
|
||||
np.rec
|
||||
np.testing
|
||||
np.version
|
||||
|
||||
np.lib.format
|
||||
np.lib.mixins
|
||||
np.lib.scimath
|
||||
np.lib.stride_tricks
|
||||
np.ma.extras
|
||||
np.polynomial.chebyshev
|
||||
np.polynomial.hermite
|
||||
np.polynomial.hermite_e
|
||||
np.polynomial.laguerre
|
||||
np.polynomial.legendre
|
||||
np.polynomial.polynomial
|
||||
|
||||
np.__path__
|
||||
np.__version__
|
||||
np.__git_version__
|
||||
|
||||
np.__all__
|
||||
np.char.__all__
|
||||
np.ctypeslib.__all__
|
||||
np.emath.__all__
|
||||
np.lib.__all__
|
||||
np.ma.__all__
|
||||
np.random.__all__
|
||||
np.rec.__all__
|
||||
np.testing.__all__
|
||||
f2py.__all__
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user