Datasetpublic
codekingpro/portable-devtools

sourceHugging Faceupdated 5mo agoView on Hugging Face
1likes15kdownloads
rootpythonuser_packagesPython313site-packagesnumpy_corefunction_base.pyi
function_base.pyi277 linesDownload Raw Back to _core
1from _typeshed import Incomplete
2from typing import Literal as L, SupportsIndex, TypeAlias, TypeVar, overload
3
4import numpy as np
5from numpy._typing import (
6    DTypeLike,
7    NDArray,
8    _ArrayLikeComplex_co,
9    _ArrayLikeFloat_co,
10    _DTypeLike,
11)
12from numpy._typing._array_like import _DualArrayLike
13
14__all__ = ["geomspace", "linspace", "logspace"]
15
16_ScalarT = TypeVar("_ScalarT", bound=np.generic)
17
18_ToArrayFloat64: TypeAlias = _DualArrayLike[np.dtype[np.float64 | np.integer | np.bool], float]
19
20@overload
21def linspace(
22    start: _ToArrayFloat64,
23    stop: _ToArrayFloat64,
24    num: SupportsIndex = 50,
25    endpoint: bool = True,
26    retstep: L[False] = False,
27    dtype: None = None,
28    axis: SupportsIndex = 0,
29    *,
30    device: L["cpu"] | None = None,
31) -> NDArray[np.float64]: ...
32@overload
33def linspace(
34    start: _ArrayLikeFloat_co,
35    stop: _ArrayLikeFloat_co,
36    num: SupportsIndex = 50,
37    endpoint: bool = True,
38    retstep: L[False] = False,
39    dtype: None = None,
40    axis: SupportsIndex = 0,
41    *,
42    device: L["cpu"] | None = None,
43) -> NDArray[np.floating]: ...
44@overload
45def linspace(
46    start: _ArrayLikeComplex_co,
47    stop: _ArrayLikeComplex_co,
48    num: SupportsIndex = 50,
49    endpoint: bool = True,
50    retstep: L[False] = False,
51    dtype: None = None,
52    axis: SupportsIndex = 0,
53    *,
54    device: L["cpu"] | None = None,
55) -> NDArray[np.complexfloating]: ...
56@overload
57def linspace(
58    start: _ArrayLikeComplex_co,
59    stop: _ArrayLikeComplex_co,
60    num: SupportsIndex,
61    endpoint: bool,
62    retstep: L[False],
63    dtype: _DTypeLike[_ScalarT],
64    axis: SupportsIndex = 0,
65    *,
66    device: L["cpu"] | None = None,
67) -> NDArray[_ScalarT]: ...
68@overload
69def linspace(
70    start: _ArrayLikeComplex_co,
71    stop: _ArrayLikeComplex_co,
72    num: SupportsIndex = 50,
73    endpoint: bool = True,
74    retstep: L[False] = False,
75    *,
76    dtype: _DTypeLike[_ScalarT],
77    axis: SupportsIndex = 0,
78    device: L["cpu"] | None = None,
79) -> NDArray[_ScalarT]: ...
80@overload
81def linspace(
82    start: _ArrayLikeComplex_co,
83    stop: _ArrayLikeComplex_co,
84    num: SupportsIndex = 50,
85    endpoint: bool = True,
86    retstep: L[False] = False,
87    dtype: DTypeLike | None = None,
88    axis: SupportsIndex = 0,
89    *,
90    device: L["cpu"] | None = None,
91) -> NDArray[Incomplete]: ...
92@overload
93def linspace(
94    start: _ToArrayFloat64,
95    stop: _ToArrayFloat64,
96    num: SupportsIndex = 50,
97    endpoint: bool = True,
98    *,
99    retstep: L[True],
100    dtype: None = None,
101    axis: SupportsIndex = 0,
102    device: L["cpu"] | None = None,
103) -> tuple[NDArray[np.float64], np.float64]: ...
104@overload
105def linspace(
106    start: _ArrayLikeFloat_co,
107    stop: _ArrayLikeFloat_co,
108    num: SupportsIndex = 50,
109    endpoint: bool = True,
110    *,
111    retstep: L[True],
112    dtype: None = None,
113    axis: SupportsIndex = 0,
114    device: L["cpu"] | None = None,
115) -> tuple[NDArray[np.floating], np.floating]: ...
116@overload
117def linspace(
118    start: _ArrayLikeComplex_co,
119    stop: _ArrayLikeComplex_co,
120    num: SupportsIndex = 50,
121    endpoint: bool = True,
122    *,
123    retstep: L[True],
124    dtype: None = None,
125    axis: SupportsIndex = 0,
126    device: L["cpu"] | None = None,
127) -> tuple[NDArray[np.complexfloating], np.complexfloating]: ...
128@overload
129def linspace(
130    start: _ArrayLikeComplex_co,
131    stop: _ArrayLikeComplex_co,
132    num: SupportsIndex = 50,
133    endpoint: bool = True,
134    *,
135    retstep: L[True],
136    dtype: _DTypeLike[_ScalarT],
137    axis: SupportsIndex = 0,
138    device: L["cpu"] | None = None,
139) -> tuple[NDArray[_ScalarT], _ScalarT]: ...
140@overload
141def linspace(
142    start: _ArrayLikeComplex_co,
143    stop: _ArrayLikeComplex_co,
144    num: SupportsIndex = 50,
145    endpoint: bool = True,
146    *,
147    retstep: L[True],
148    dtype: DTypeLike | None = None,
149    axis: SupportsIndex = 0,
150    device: L["cpu"] | None = None,
151) -> tuple[NDArray[Incomplete], Incomplete]: ...
152
153@overload
154def logspace(
155    start: _ToArrayFloat64,
156    stop: _ToArrayFloat64,
157    num: SupportsIndex = 50,
158    endpoint: bool = True,
159    base: _ToArrayFloat64 = 10.0,
160    dtype: None = None,
161    axis: SupportsIndex = 0,
162) -> NDArray[np.float64]: ...
163@overload
164def logspace(
165    start: _ArrayLikeFloat_co,
166    stop: _ArrayLikeFloat_co,
167    num: SupportsIndex = 50,
168    endpoint: bool = True,
169    base: _ArrayLikeFloat_co = 10.0,
170    dtype: None = None,
171    axis: SupportsIndex = 0,
172) -> NDArray[np.floating]: ...
173@overload
174def logspace(
175    start: _ArrayLikeComplex_co,
176    stop: _ArrayLikeComplex_co,
177    num: SupportsIndex = 50,
178    endpoint: bool = True,
179    base: _ArrayLikeComplex_co = 10.0,
180    dtype: None = None,
181    axis: SupportsIndex = 0,
182) -> NDArray[np.complexfloating]: ...
183@overload
184def logspace(
185    start: _ArrayLikeComplex_co,
186    stop: _ArrayLikeComplex_co,
187    num: SupportsIndex,
188    endpoint: bool,
189    base: _ArrayLikeComplex_co,
190    dtype: _DTypeLike[_ScalarT],
191    axis: SupportsIndex = 0,
192) -> NDArray[_ScalarT]: ...
193@overload
194def logspace(
195    start: _ArrayLikeComplex_co,
196    stop: _ArrayLikeComplex_co,
197    num: SupportsIndex = 50,
198    endpoint: bool = True,
199    base: _ArrayLikeComplex_co = 10.0,
200    *,
201    dtype: _DTypeLike[_ScalarT],
202    axis: SupportsIndex = 0,
203) -> NDArray[_ScalarT]: ...
204@overload
205def logspace(
206    start: _ArrayLikeComplex_co,
207    stop: _ArrayLikeComplex_co,
208    num: SupportsIndex = 50,
209    endpoint: bool = True,
210    base: _ArrayLikeComplex_co = 10.0,
211    dtype: DTypeLike | None = None,
212    axis: SupportsIndex = 0,
213) -> NDArray[Incomplete]: ...
214
215@overload
216def geomspace(
217    start: _ToArrayFloat64,
218    stop: _ToArrayFloat64,
219    num: SupportsIndex = 50,
220    endpoint: bool = True,
221    dtype: None = None,
222    axis: SupportsIndex = 0,
223) -> NDArray[np.float64]: ...
224@overload
225def geomspace(
226    start: _ArrayLikeFloat_co,
227    stop: _ArrayLikeFloat_co,
228    num: SupportsIndex = 50,
229    endpoint: bool = True,
230    dtype: None = None,
231    axis: SupportsIndex = 0,
232) -> NDArray[np.floating]: ...
233@overload
234def geomspace(
235    start: _ArrayLikeComplex_co,
236    stop: _ArrayLikeComplex_co,
237    num: SupportsIndex = 50,
238    endpoint: bool = True,
239    dtype: None = None,
240    axis: SupportsIndex = 0,
241) -> NDArray[np.complexfloating]: ...
242@overload
243def geomspace(
244    start: _ArrayLikeComplex_co,
245    stop: _ArrayLikeComplex_co,
246    num: SupportsIndex,
247    endpoint: bool,
248    dtype: _DTypeLike[_ScalarT],
249    axis: SupportsIndex = 0,
250) -> NDArray[_ScalarT]: ...
251@overload
252def geomspace(
253    start: _ArrayLikeComplex_co,
254    stop: _ArrayLikeComplex_co,
255    num: SupportsIndex = 50,
256    endpoint: bool = True,
257    *,
258    dtype: _DTypeLike[_ScalarT],
259    axis: SupportsIndex = 0,
260) -> NDArray[_ScalarT]: ...
261@overload
262def geomspace(
263    start: _ArrayLikeComplex_co,
264    stop: _ArrayLikeComplex_co,
265    num: SupportsIndex = 50,
266    endpoint: bool = True,
267    dtype: DTypeLike | None = None,
268    axis: SupportsIndex = 0,
269) -> NDArray[Incomplete]: ...
270
271def add_newdoc(
272    place: str,
273    obj: str,
274    doc: str | tuple[str, str] | list[tuple[str, str]],
275    warn_on_python: bool = True,
276) -> None: ...
277