add (some) global numpy methods

numpy-mypy/numpy/__init__.pyi

@@ -4,7 +4,8 @@ methods are provided.
 """
 
 from typing import (Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Tuple, Type,
-                    TypeVar, Union)
+                    TypeVar, Union, Sized, overload)
+from numpy import random, linalg
 
 class dtype: ...
 _dtype = dtype
@@ -44,11 +45,14 @@ ShapeType = Union[int, Tuple[int, ...]]
 AxesType = Union[int, Tuple[int, ...]]
 OrderType = Union[str, Sequence[str]]
 DtypeType = Union[dtype, type]
+ArrayTypeAny = Union[_ArrayLike[Any], List[Any], Tuple[Any, ...]]
+ArrayTypeFloat = Union[_ArrayLike[float], List[float], Tuple[float, ...]]
 
 class flatiter(Generic[_S], Iterator[_S]):
     coords = ...  # type: ShapeType
     def copy(self) -> flatiter[_S]: ...
 
+
 class _ArrayLike(Generic[_S]):
     """
     "array-like" interface that both numpy.ndarray and all scalars (descendants of numpy.generic)
@@ -132,9 +136,9 @@ class _ArrayLike(Generic[_S]):
 
     def dumps(self) -> str: ...
 
-    def fill(self, value: _S) -> None: ...
+    def flatten(self, order: str='C') -> '_ArrayLike[Any]': ...
 
-    def flatten(self, order: str='C') -> '_ArrayLike[_S]': ...
+    def fill(self, value: _S) -> None: ...
 
     def getfield(self, dtype: DtypeType, offset: int=0) -> '_ArrayLike[Any]': ...
 
@@ -216,7 +220,7 @@ class _ArrayLike(Generic[_S]):
     def trace(self, offset: int=0, axis1: int=0, axis2: int=1,
               dtype: DtypeType=None, out: '_ArrayLike[_U]'=None) -> '_ArrayLike[Any]': ...
 
-    def transpose(self, axes: Optional[AxesType]) -> '_ArrayLike[_S]': ...
+    def transpose(self, axes: AxesType=None) -> '_ArrayLike[_S]': ...
 
     def var(self, axis: AxesType=None, dtype: DtypeType=None,
             out: '_ArrayLike[_U]'=None, ddof: int=0, keepdims: bool=False) -> '_ArrayLike[Any]': ...
@@ -377,55 +381,93 @@ class _ArrayLike(Generic[_S]):
 #
 
 class generic(_ArrayLike[_S], Generic[_S]): ...
-class bool_(generic[bool]): ...
+class bool_(generic[bool]):
+    def __init__(self, value : Any = None) -> None: ...
 bool8 = bool_
-class object_(generic[Any]): ...
+class object_(generic[Any]):
+    def __init__(self, value : Any = None) -> None: ...
 class number(generic[_S], Generic[_S]): ...
 class integer(number[int]): ...
 class signedinteger(integer): ...
-class byte(signedinteger): ...
-class short(signedinteger): ...
-class intc(signedinteger): ...
-class int_(signedinteger): ...
-class longlong(signedinteger): ...
-class int8(signedinteger): ...
-class int16(signedinteger): ...
-class int32(signedinteger): ...
-class int64(signedinteger): ...
+class byte(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class short(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class intc(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class int_(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class longlong(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class int8(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class int16(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class int32(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class int64(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
 class unsignedinteger(integer): ...
-class ubyte(unsignedinteger): ...
-class ushort(unsignedinteger): ...
-class uintc(unsignedinteger): ...
-class uint(unsignedinteger): ...
-class ulonglong(unsignedinteger): ...
-class uint8(signedinteger): ...
-class uint16(signedinteger): ...
-class uint32(signedinteger): ...
-class uint64(signedinteger): ...
+class ubyte(unsignedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class ushort(unsignedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uintc(unsignedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uint(unsignedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class ulonglong(unsignedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uint8(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uint16(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uint32(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
+class uint64(signedinteger):
+    def __init__(self, value : Any = None) -> None: ...
 class inexact(number[float]): ...
 class floating(inexact): ...
-class half(floating): ...
-class single(floating): ...
-class float_(floating): ...
-class longfloat_(floating): ...
-class float16(floating): ...
-class float32(floating): ...
-class float64(floating): ...
-class float128(floating): ...
-class complextfloating(inexact): ...
-class csingle(complextfloating): ...
-class complex_(complextfloating): ...
-class clongfloat(complextfloating): ...
-class complex64(complextfloating): ...
-class complex128(complextfloating): ...
-class complex256(complextfloating): ...
+class half(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class single(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class float_(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class longfloat(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class float16(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class float32(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class float64(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class float128(floating):
+    def __init__(self, value : Any = None) -> None: ...
+class complexfloating(inexact): ...
+class csingle(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
+class complex_(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
+class clongfloat(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
+class complex64(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
+class complex128(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
+class complex256(complexfloating):
+    def __init__(self, value : Any = None) -> None: ...
 class flexible(generic[_S], Generic[_S]): ...
 class character(flexible[str]): ...
-class str_(character): ...
-class unicode_(character): ...
-class void(flexible[None]): ...
+class str_(character):
+    def __init__(self, value : Any = None) -> None: ...
+class unicode_(character):
+    def __init__(self, value : Any = None) -> None: ...
+class void(flexible[None]):
+    def __init__(self, value : Any) -> None: ...
 
-class ndarray(_ArrayLike[_S], Generic[_S]):
+
+class ndarray(_ArrayLike[_S], Generic[_S], Sized):
     """numpy.ndarray"""
     ctypes = None    # type: Any  # TODO Implement ctypes type hint
 
@@ -434,18 +476,50 @@ class ndarray(_ArrayLike[_S], Generic[_S]):
                  buffer: Any=None, offset: int=None,
                  strides: Tuple[int, ...]=None, order: str=None) -> None: ...
 
-#
-# Array creation routines
-#
+    # repeat ArrayLike magic method for proper type
+    def __add__(self, value: object) -> 'ndarray[Any]': ...
+    def __sub__(self, value: object) -> 'ndarray[Any]': ...
+    def __mul__(self, value: object) -> 'ndarray[Any]': ...
+    def __matmul__(self, value: '_ArrayLike[Any]') -> 'ndarray[Any]': ...
+    def __array__(self, dtype: DtypeType=None) -> 'ndarray[Any]': ...
+    #def __getitem__(self, key: Any) -> _S: ...
+    #def __getslice__(self, i: Any, j: Any) -> ndarray[_S]: ...
+    def __getitem__(self, key: Any) -> ndarray[_S]: ...
+    def __copy__(self) -> 'ndarray[_S]': ...
+    def __iter__(self) -> Iterator['ndarray[_S]']: ...
+    def __pow__(self, value: object) -> 'ndarray[Any]': ...
+    def __pos__(self) -> 'ndarray[_S]': ...
+    def __neg__(self) -> 'ndarray[_S]': ...
+    def __ge__(self, value: object) -> 'ndarray[bool]': ...
+    def __gt__(self, value: object) -> 'ndarray[bool]': ...
+    def __le__(self, value: object) -> 'ndarray[bool]': ...
+    def __lt__(self, value: object) -> 'ndarray[bool]': ...
+    def __eq__(self, value: object) -> 'ndarray[bool]': ...  # type: ignore
+    def __ne__(self, value: object) -> 'ndarray[bool]': ...  # type: ignore
+
+    def copy(self, order: str='C') -> 'ndarray[_S]': ...
+    def flatten(self, order: str='C') -> 'ndarray[Any]': ...
+    def dot(self, b: '_ArrayLike[Any]', out: '_ArrayLike[Any]'=None) -> 'ndarray[Any]': ...
+    def transpose(self, axes: AxesType=None) -> 'ndarray[_S]': ...
+    def reshape(self, newshape: ShapeType, order: str='C') -> ndarray[_S]: ...
+
+
+# global attributes
+pi: float
+inf: float
+nan: float
+
 
+# Array creation routines
 def array(object: Any, dtype: Any=None, copy: bool=True,
           order: str=None, subok: bool=False,
           ndmin: int=0) -> ndarray[Any]: ...
 def asarray(a: Any, dtype: DtypeType=None, order: str=None) -> ndarray[Any]: ...
+def asfarray(a: Any, dtype: DtypeType=float64, order: str=None) -> ndarray[float]: ...
 def asanyarray(a: Any, dtype: DtypeType=None, order: str=None) -> ndarray[Any]: ...  # TODO figure out a way to restrict the return type
-def asmatrix(data: Any, dtype: DtypeType=None) -> Any: ...  # TODO define matrix
+def asmatrix(data: Any, dtype: DtypeType=None) -> matrix[Any]: ...
 def ascontiguousarray(a: Any, dtype: DtypeType=None) -> ndarray[Any]: ...
-def copy(a: Any, order: str=None)	-> ndarray[Any]: ...
+def copy(a: Any, order: str=None) -> ndarray[Any]: ...
 def empty(shape: ShapeType, dtype: DtypeType=float, order: str='C') -> ndarray[Any]: ...
 def empty_like(a: Any, dtype: Any=None, order: str='K', subok: bool=True) -> ndarray[Any]: ...
 def eye(N: int, M: int=None, k: int=0, dtype: DtypeType=float) -> ndarray[Any]: ...
@@ -468,3 +542,103 @@ def ones(shape: ShapeType, dtype: Optional[DtypeType]=..., order: str='C') -> nd
 def ones_like(a: Any, dtype: Any=None, order: str='K', subok: bool=True) -> ndarray[Any]: ...
 def zeros(shape: ShapeType, dtype: DtypeType=float, order: str='C') -> ndarray[Any]: ...
 def zeros_like(a: Any, dtype: Any=None, order: str='K', subok: bool=True) -> ndarray[Any]: ...
+
+#
+# Global array routines (incomplete)
+
+@overload
+def abs(x: float, out: float=None) -> float: ...
+@overload
+def abs(x: _ArrayLike[complexfloating], out: ndarray[_U]=None) -> ndarray[float]: ...
+def all(a: _ArrayLike[_S], axis: AxesType=None, out: '_ArrayLike[_U]'=None,
+        keepdims: bool=False) -> Union['ndarray[_U]', 'ndarray[bool]']: ...
+def argmax(a: _ArrayLike[_U], axis: int=None,
+        out: ndarray[_U]=None) -> Union[ndarray[_U], ndarray[int]]: ...
+def argmin(a: _ArrayLike[_U], axis: int=None,
+        out: ndarray[_U]=None) -> Union[ndarray[_U], ndarray[int]]: ...
+def argsort(a: _ArrayLike[Any], axis: int=None, kind: str='quicksort',
+            order: OrderType=None) -> ndarray[int]: ...
+def concatenate(s: Sequence[_ArrayLike[_S]], axis: AxesType=None) -> ndarray[_S]: ...
+def copyto(dst: ndarray[Any], src: _ArrayLike[Any], caseting: str='same_kind',
+           where: _ArrayLike[bool]=None) -> None: ...
+def delete(arr: _ArrayLike[Any], obj: Union[int, Sequence[int]], axis: AxesType=None) -> ndarray[Any]: ...
+@overload
+def deg2rad(x: float, out: float=None) -> float: ...
+@overload
+def deg2rad(x: ArrayTypeFloat, out: ndarray[float]=None) -> ndarray[float]: ...
+def diag(v: _ArrayLike[Any], k:int=None) -> ndarray[Any]: ...
+def diff(a: ArrayTypeAny, n: int=1, axis: AxesType=-1) -> ndarray[Any]: ...
+def dot(a: _ArrayLike[Any], b: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def hstack(tup: Sequence[_ArrayLike[_S]]) -> ndarray[_S]: ...
+def insert(arr: _ArrayLike[Any], obj: Union[int, Sequence[int]], values: Union[Any, _ArrayLike[Any]],
+                axis: AxesType=None) -> ndarray[Any]: ...
+def mean(a: ArrayTypeFloat, axis: AxesType=None, dtype: Any=None,
+             out: ndarray[_U]=None, keepdims: bool=False) -> ndarray[float]: ...
+def median(a: ArrayTypeFloat, axis: AxesType=None, out: ndarray[_U]=None,
+           overwrite_input: bool=False, keepdims: bool=False) -> ndarray[float]: ...
+def min(a: _ArrayLike[_U], axis: AxesType=None, out: ndarray[_U]=None) -> ndarray[_U]: ...
+def max(a: _ArrayLike[_U], axis: AxesType=None, out: ndarray[_U]=None) -> ndarray[_U]: ...
+def nan_to_num(x: _ArrayLike[Any]) -> ndarray[Any]: ...
+def tile(A: _ArrayLike[_S], reps: Union[int, Sequence[int]]) -> ndarray[_S]: ...
+@overload
+def rad2deg(x: float, out: float=None) -> float: ...
+@overload
+def rad2deg(x: ArrayTypeFloat, out: ndarray[float]=None) -> ndarray[float]: ...
+def reshape(a: _ArrayLike[_S], newshape: ShapeType, order: str='C') -> ndarray[Any]: ...
+def repeat(a: _ArrayLike[_S], repeats: Union[int, Sequence[int]], axis: int=None) -> ndarray[_S]: ...
+def squeeze(a: _ArrayLike[_S], axis: AxesType=None) -> ndarray[_S]: ...
+@overload
+def square(v: float, out: float=None) -> float: ...
+@overload
+def square(v: ArrayTypeAny, out: ndarray[_U]=None) -> ndarray[Any]: ...
+@overload
+def sqrt(x: float, out: float=None) -> float: ...
+@overload
+def sqrt(x: ArrayTypeFloat, out: ndarray[_U]=None) -> ndarray[float]: ...
+def sum(a: ArrayTypeAny, axis: AxesType=None, dtype: DtypeType=None, out: ndarray[_U]=None,
+            keepdims: bool=False) -> ndarray[Any]: ...
+def trace(a: _ArrayLike[Any], offset: int=0, axis1: int=0, axis2: int=1,
+          dtype: DtypeType=None, out: ndarray[_U]=None) -> ndarray[Any]: ...
+def resize(a: _ArrayLike[_S], new_shape: ShapeType, refcheck: bool=True) -> None: ...
+def vstack(tup: Sequence[_ArrayLike[_S]]) -> ndarray[_S]: ...
+def where(condition: _ArrayLike[Any], x: _ArrayLike[Any]=None, y: _ArrayLike[Any]=None) -> ndarray[Any]: ...
+
+def save(file: Any, arr: _ArrayLike[Any], allow_pickle: bool=None, fix_imports: bool=None) -> None: ...
+def savez(file: str, *args: Any, **kwargs: Any) -> None: ...
+def savez_compressed(file: str, *args: Any, **kwargs: Any) -> None: ...
+def savetxt(fname: Any, X: _ArrayLike[Any], fmt: Union[str, Sequence[str]]=None, delimiter: str=None,
+            newline: str=None, header: str=None, footer: str=None, comments: str=None) -> None: ...
+def load(file: Any, mmap_mode: str=None, allow_pickle: bool=None, fix_imports: bool=None,
+         encoding: str='ASCII') -> Any: ...
+
+def sin(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def sinh(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def arcsin(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def cos(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def arccos(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def tan(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def tanh(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def arctan(x: _ArrayLike[Any], out: ndarray[Any]=None) -> ndarray[Any]: ...
+def arctan2(x1: _ArrayLike[float], x2: _ArrayLike[float], out: ndarray[float]=None) -> ndarray[float]: ...
+
+def unwrap(p: _ArrayLike[float], discont: float=3.141592653589793, axis:AxesType=-1) -> ndarray[float]: ...
+def imag(val: _ArrayLike[Any]) -> ndarray[Any]: ...
+def real(val: _ArrayLike[Any]) -> ndarray[Any]: ...
+
+def gradient(f: _ArrayLike[Any], *args: Any, edge_order: int=1, axis: AxesType=None) -> ndarray[float]: ...
+def std(a: _ArrayLike[float], axis: AxesType=None, dtype: DtypeType=None,
+        out: _ArrayLike[_U]=None, ddof: int=0, keepdims: bool=False) -> _ArrayLike[floating]: ...
+def var(a: _ArrayLike[float], axis: AxesType=None, dtype: DtypeType=None,
+        out: _ArrayLike[_U]=None, ddof: int=0, keepdims: bool=False) -> _ArrayLike[Any]: ...
+
+class matrix(_ArrayLike[_S], Generic[_S]):
+    """numpy.matrix"""
+    ctypes = None    # type: Any
+
+    T = None   # type: matrix[_S]
+
+    def __init__(self, data: Any, dtype: DtypeType=None,
+                 copy: bool=None) -> None: ...
+
+    def transpose(self, axes: AxesType=None) -> matrix[_S]: ...
+

numpy-mypy/numpy/linalg/__init__.pyi

@@ -0,0 +1,15 @@
+
+from typing import (Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Tuple, Type,
+                    TypeVar, Union, Sized, overload)
+from numpy import _ArrayLike, ndarray, AxesType
+
+def cond(x: _ArrayLike[Any], p: str=None) -> float: ...
+@overload
+def norm(x: float, ord: Union[str, float]=None, axis: AxesType=None, keepdims: bool=False) -> float: ...
+@overload
+def norm(x: _ArrayLike[Any], ord: Union[str, float]=None, axis: AxesType=None, keepdims: bool=False) -> ndarray[float]: ...
+
+def qr(a: _ArrayLike[Any], mode: str='reduced') -> Tuple[ndarray[Any], ndarray[Any], ndarray[Any]]: ...
+def svd(a: _ArrayLike[Any], full_matrices: bool=True, compute_uv: bool=True) -> Tuple[ndarray[Any],
+        ndarray[Any], ndarray[Any]]: ...
+def pinv(a: _ArrayLike[Any], rcond: float=1e-15) -> ndarray[Any]: ...

numpy-mypy/numpy/random/__init__.pyi

@@ -0,0 +1,6 @@
+from numpy import ndarray, DtypeType, ShapeType
+
+def rand(*args: int) -> ndarray[float]: ...
+def ranf(*args: int) -> ndarray[float]: ...
+def random(size: ShapeType=None) -> float: ...
+def randint(low: int, high: int=None, size: ShapeType=None, dtype: DtypeType=int) -> ndarray[int]: ...