virtuelle Umgebungen teil20 und teil20a

This commit is contained in:
2023-09-01 15:57:01 +02:00
parent 69da4cda15
commit c9aee44812
8197 changed files with 1603063 additions and 0 deletions

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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),
}
)

View File

@@ -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

View File

@@ -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

View File

@@ -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__"

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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)

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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())

View File

@@ -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

View File

@@ -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

View File

@@ -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)

View File

@@ -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)

View File

@@ -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)

View File

@@ -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, :]

View File

@@ -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

View File

@@ -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

View File

@@ -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"]]

View File

@@ -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)

View File

@@ -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))

View File

@@ -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)

View File

@@ -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)

View File

@@ -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)

View 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"

View File

@@ -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)

View File

@@ -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)

View File

@@ -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