codekingpro/portable-devtools
114k
1from collections.abc import Callable, MutableSequence
2from typing import Any, Literal, TypeAlias, TypeVar, overload
3
4import numpy as np
5from numpy import dtype, float32, float64, int64
6from numpy._typing import (
7 ArrayLike,
8 DTypeLike,
9 NDArray,
10 _ArrayLikeFloat_co,
11 _ArrayLikeInt_co,
12 _BoolCodes,
13 _DoubleCodes,
14 _DTypeLike,
15 _DTypeLikeBool,
16 _Float32Codes,
17 _Float64Codes,
18 _FloatLike_co,
19 _Int8Codes,
20 _Int16Codes,
21 _Int32Codes,
22 _Int64Codes,
23 _IntPCodes,
24 _ShapeLike,
25 _SingleCodes,
26 _SupportsDType,
27 _UInt8Codes,
28 _UInt16Codes,
29 _UInt32Codes,
30 _UInt64Codes,
31 _UIntPCodes,
32)
33from numpy.random import BitGenerator, RandomState, SeedSequence
34
35_IntegerT = TypeVar("_IntegerT", bound=np.integer)
36
37_DTypeLikeFloat32: TypeAlias = (
38 dtype[float32]
39 | _SupportsDType[dtype[float32]]
40 | type[float32]
41 | _Float32Codes
42 | _SingleCodes
43)
44
45_DTypeLikeFloat64: TypeAlias = (
46 dtype[float64]
47 | _SupportsDType[dtype[float64]]
48 | type[float]
49 | type[float64]
50 | _Float64Codes
51 | _DoubleCodes
52)
53
54class Generator:
55 def __init__(self, bit_generator: BitGenerator) -> None: ...
56 def __repr__(self) -> str: ...
57 def __str__(self) -> str: ...
58 def __getstate__(self) -> None: ...
59 def __setstate__(self, state: dict[str, Any] | None) -> None: ...
60 def __reduce__(self) -> tuple[
61 Callable[[BitGenerator], Generator],
62 tuple[BitGenerator],
63 None]: ...
64 @property
65 def bit_generator(self) -> BitGenerator: ...
66 def spawn(self, n_children: int) -> list[Generator]: ...
67 def bytes(self, length: int) -> bytes: ...
68 @overload
69 def standard_normal( # type: ignore[misc]
70 self,
71 size: None = None,
72 dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
73 out: None = None,
74 ) -> float: ...
75 @overload
76 def standard_normal( # type: ignore[misc]
77 self,
78 size: _ShapeLike | None = None,
79 ) -> NDArray[float64]: ...
80 @overload
81 def standard_normal( # type: ignore[misc]
82 self,
83 *,
84 out: NDArray[float64] | None = None,
85 ) -> NDArray[float64]: ...
86 @overload
87 def standard_normal( # type: ignore[misc]
88 self,
89 size: _ShapeLike | None = None,
90 dtype: _DTypeLikeFloat32 = ...,
91 out: NDArray[float32] | None = None,
92 ) -> NDArray[float32]: ...
93 @overload
94 def standard_normal( # type: ignore[misc]
95 self,
96 size: _ShapeLike | None = None,
97 dtype: _DTypeLikeFloat64 = ...,
98 out: NDArray[float64] | None = None,
99 ) -> NDArray[float64]: ...
100 @overload
101 def permutation(self, x: int, axis: int = 0) -> NDArray[int64]: ...
102 @overload
103 def permutation(self, x: ArrayLike, axis: int = 0) -> NDArray[Any]: ...
104 @overload
105 def standard_exponential( # type: ignore[misc]
106 self,
107 size: None = None,
108 dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
109 method: Literal["zig", "inv"] = "zig",
110 out: None = None,
111 ) -> float: ...
112 @overload
113 def standard_exponential(
114 self,
115 size: _ShapeLike | None = None,
116 ) -> NDArray[float64]: ...
117 @overload
118 def standard_exponential(
119 self,
120 *,
121 out: NDArray[float64] | None = None,
122 ) -> NDArray[float64]: ...
123 @overload
124 def standard_exponential(
125 self,
126 size: _ShapeLike | None = None,
127 *,
128 method: Literal["zig", "inv"] = "zig",
129 out: NDArray[float64] | None = None,
130 ) -> NDArray[float64]: ...
131 @overload
132 def standard_exponential(
133 self,
134 size: _ShapeLike | None = None,
135 dtype: _DTypeLikeFloat32 = ...,
136 method: Literal["zig", "inv"] = "zig",
137 out: NDArray[float32] | None = None,
138 ) -> NDArray[float32]: ...
139 @overload
140 def standard_exponential(
141 self,
142 size: _ShapeLike | None = None,
143 dtype: _DTypeLikeFloat64 = ...,
144 method: Literal["zig", "inv"] = "zig",
145 out: NDArray[float64] | None = None,
146 ) -> NDArray[float64]: ...
147 @overload
148 def random( # type: ignore[misc]
149 self,
150 size: None = None,
151 dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
152 out: None = None,
153 ) -> float: ...
154 @overload
155 def random(
156 self,
157 *,
158 out: NDArray[float64] | None = None,
159 ) -> NDArray[float64]: ...
160 @overload
161 def random(
162 self,
163 size: _ShapeLike | None = None,
164 *,
165 out: NDArray[float64] | None = None,
166 ) -> NDArray[float64]: ...
167 @overload
168 def random(
169 self,
170 size: _ShapeLike | None = None,
171 dtype: _DTypeLikeFloat32 = ...,
172 out: NDArray[float32] | None = None,
173 ) -> NDArray[float32]: ...
174 @overload
175 def random(
176 self,
177 size: _ShapeLike | None = None,
178 dtype: _DTypeLikeFloat64 = ...,
179 out: NDArray[float64] | None = None,
180 ) -> NDArray[float64]: ...
181 @overload
182 def beta(
183 self,
184 a: _FloatLike_co,
185 b: _FloatLike_co,
186 size: None = None,
187 ) -> float: ... # type: ignore[misc]
188 @overload
189 def beta(
190 self,
191 a: _ArrayLikeFloat_co,
192 b: _ArrayLikeFloat_co,
193 size: _ShapeLike | None = None
194 ) -> NDArray[float64]: ...
195 @overload
196 def exponential(self, scale: _FloatLike_co = 1.0, size: None = None) -> float: ... # type: ignore[misc]
197 @overload
198 def exponential(self, scale: _ArrayLikeFloat_co = 1.0, size: _ShapeLike | None = None) -> NDArray[float64]: ...
199
200 #
201 @overload
202 def integers(
203 self,
204 low: int,
205 high: int | None = None,
206 size: None = None,
207 dtype: _DTypeLike[np.int64] | _Int64Codes = ...,
208 endpoint: bool = False,
209 ) -> np.int64: ...
210 @overload
211 def integers(
212 self,
213 low: int,
214 high: int | None = None,
215 size: None = None,
216 *,
217 dtype: type[bool],
218 endpoint: bool = False,
219 ) -> bool: ...
220 @overload
221 def integers(
222 self,
223 low: int,
224 high: int | None = None,
225 size: None = None,
226 *,
227 dtype: type[int],
228 endpoint: bool = False,
229 ) -> int: ...
230 @overload
231 def integers(
232 self,
233 low: int,
234 high: int | None = None,
235 size: None = None,
236 *,
237 dtype: _DTypeLike[np.bool] | _BoolCodes,
238 endpoint: bool = False,
239 ) -> np.bool: ...
240 @overload
241 def integers(
242 self,
243 low: int,
244 high: int | None = None,
245 size: None = None,
246 *,
247 dtype: _DTypeLike[_IntegerT],
248 endpoint: bool = False,
249 ) -> _IntegerT: ...
250 @overload
251 def integers(
252 self,
253 low: _ArrayLikeInt_co,
254 high: _ArrayLikeInt_co | None = None,
255 size: _ShapeLike | None = None,
256 dtype: _DTypeLike[np.int64] | _Int64Codes = ...,
257 endpoint: bool = False,
258 ) -> NDArray[np.int64]: ...
259 @overload
260 def integers(
261 self,
262 low: _ArrayLikeInt_co,
263 high: _ArrayLikeInt_co | None = None,
264 size: _ShapeLike | None = None,
265 *,
266 dtype: _DTypeLikeBool,
267 endpoint: bool = False,
268 ) -> NDArray[np.bool]: ...
269 @overload
270 def integers(
271 self,
272 low: _ArrayLikeInt_co,
273 high: _ArrayLikeInt_co | None = None,
274 size: _ShapeLike | None = None,
275 *,
276 dtype: _DTypeLike[_IntegerT],
277 endpoint: bool = False,
278 ) -> NDArray[_IntegerT]: ...
279 @overload
280 def integers(
281 self,
282 low: int,
283 high: int | None = None,
284 size: None = None,
285 *,
286 dtype: _Int8Codes,
287 endpoint: bool = False,
288 ) -> np.int8: ...
289 @overload
290 def integers(
291 self,
292 low: _ArrayLikeInt_co,
293 high: _ArrayLikeInt_co | None = None,
294 size: _ShapeLike | None = None,
295 *,
296 dtype: _Int8Codes,
297 endpoint: bool = False,
298 ) -> NDArray[np.int8]: ...
299 @overload
300 def integers(
301 self,
302 low: int,
303 high: int | None = None,
304 size: None = None,
305 *,
306 dtype: _UInt8Codes,
307 endpoint: bool = False,
308 ) -> np.uint8: ...
309 @overload
310 def integers(
311 self,
312 low: _ArrayLikeInt_co,
313 high: _ArrayLikeInt_co | None = None,
314 size: _ShapeLike | None = None,
315 *,
316 dtype: _UInt8Codes,
317 endpoint: bool = False,
318 ) -> NDArray[np.uint8]: ...
319 @overload
320 def integers(
321 self,
322 low: int,
323 high: int | None = None,
324 size: None = None,
325 *,
326 dtype: _Int16Codes,
327 endpoint: bool = False,
328 ) -> np.int16: ...
329 @overload
330 def integers(
331 self,
332 low: _ArrayLikeInt_co,
333 high: _ArrayLikeInt_co | None = None,
334 size: _ShapeLike | None = None,
335 *,
336 dtype: _Int16Codes,
337 endpoint: bool = False,
338 ) -> NDArray[np.int16]: ...
339 @overload
340 def integers(
341 self,
342 low: int,
343 high: int | None = None,
344 size: None = None,
345 *,
346 dtype: _UInt16Codes,
347 endpoint: bool = False,
348 ) -> np.uint16: ...
349 @overload
350 def integers(
351 self,
352 low: _ArrayLikeInt_co,
353 high: _ArrayLikeInt_co | None = None,
354 size: _ShapeLike | None = None,
355 *,
356 dtype: _UInt16Codes,
357 endpoint: bool = False,
358 ) -> NDArray[np.uint16]: ...
359 @overload
360 def integers(
361 self,
362 low: int,
363 high: int | None = None,
364 size: None = None,
365 *,
366 dtype: _Int32Codes,
367 endpoint: bool = False,
368 ) -> np.int32: ...
369 @overload
370 def integers(
371 self,
372 low: _ArrayLikeInt_co,
373 high: _ArrayLikeInt_co | None = None,
374 size: _ShapeLike | None = None,
375 *,
376 dtype: _Int32Codes,
377 endpoint: bool = False,
378 ) -> NDArray[np.int32]: ...
379 @overload
380 def integers(
381 self,
382 low: int,
383 high: int | None = None,
384 size: None = None,
385 *,
386 dtype: _UInt32Codes,
387 endpoint: bool = False,
388 ) -> np.uint32: ...
389 @overload
390 def integers(
391 self,
392 low: _ArrayLikeInt_co,
393 high: _ArrayLikeInt_co | None = None,
394 size: _ShapeLike | None = None,
395 *,
396 dtype: _UInt32Codes,
397 endpoint: bool = False,
398 ) -> NDArray[np.uint32]: ...
399 @overload
400 def integers(
401 self,
402 low: int,
403 high: int | None = None,
404 size: None = None,
405 *,
406 dtype: _UInt64Codes,
407 endpoint: bool = False,
408 ) -> np.uint64: ...
409 @overload
410 def integers(
411 self,
412 low: _ArrayLikeInt_co,
413 high: _ArrayLikeInt_co | None = None,
414 size: _ShapeLike | None = None,
415 *,
416 dtype: _UInt64Codes,
417 endpoint: bool = False,
418 ) -> NDArray[np.uint64]: ...
419 @overload
420 def integers(
421 self,
422 low: int,
423 high: int | None = None,
424 size: None = None,
425 *,
426 dtype: _IntPCodes,
427 endpoint: bool = False,
428 ) -> np.intp: ...
429 @overload
430 def integers(
431 self,
432 low: _ArrayLikeInt_co,
433 high: _ArrayLikeInt_co | None = None,
434 size: _ShapeLike | None = None,
435 *,
436 dtype: _IntPCodes,
437 endpoint: bool = False,
438 ) -> NDArray[np.intp]: ...
439 @overload
440 def integers(
441 self,
442 low: int,
443 high: int | None = None,
444 size: None = None,
445 *,
446 dtype: _UIntPCodes,
447 endpoint: bool = False,
448 ) -> np.uintp: ...
449 @overload
450 def integers(
451 self,
452 low: _ArrayLikeInt_co,
453 high: _ArrayLikeInt_co | None = None,
454 size: _ShapeLike | None = None,
455 *,
456 dtype: _UIntPCodes,
457 endpoint: bool = False,
458 ) -> NDArray[np.uintp]: ...
459 @overload
460 def integers(
461 self,
462 low: int,
463 high: int | None = None,
464 size: None = None,
465 dtype: DTypeLike | None = ...,
466 endpoint: bool = False,
467 ) -> Any: ...
468 @overload
469 def integers(
470 self,
471 low: _ArrayLikeInt_co,
472 high: _ArrayLikeInt_co | None = None,
473 size: _ShapeLike | None = None,
474 dtype: DTypeLike | None = ...,
475 endpoint: bool = False,
476 ) -> NDArray[Any]: ...
477
478 # TODO: Use a TypeVar _T here to get away from Any output?
479 # Should be int->NDArray[int64], ArrayLike[_T] -> _T | NDArray[Any]
480 @overload
481 def choice(
482 self,
483 a: int,
484 size: None = None,
485 replace: bool = True,
486 p: _ArrayLikeFloat_co | None = None,
487 axis: int = 0,
488 shuffle: bool = True,
489 ) -> int: ...
490 @overload
491 def choice(
492 self,
493 a: int,
494 size: _ShapeLike | None = None,
495 replace: bool = True,
496 p: _ArrayLikeFloat_co | None = None,
497 axis: int = 0,
498 shuffle: bool = True,
499 ) -> NDArray[int64]: ...
500 @overload
501 def choice(
502 self,
503 a: ArrayLike,
504 size: None = None,
505 replace: bool = True,
506 p: _ArrayLikeFloat_co | None = None,
507 axis: int = 0,
508 shuffle: bool = True,
509 ) -> Any: ...
510 @overload
511 def choice(
512 self,
513 a: ArrayLike,
514 size: _ShapeLike | None = None,
515 replace: bool = True,
516 p: _ArrayLikeFloat_co | None = None,
517 axis: int = 0,
518 shuffle: bool = True,
519 ) -> NDArray[Any]: ...
520 @overload
521 def uniform(
522 self,
523 low: _FloatLike_co = 0.0,
524 high: _FloatLike_co = 1.0,
525 size: None = None,
526 ) -> float: ... # type: ignore[misc]
527 @overload
528 def uniform(
529 self,
530 low: _ArrayLikeFloat_co = 0.0,
531 high: _ArrayLikeFloat_co = 1.0,
532 size: _ShapeLike | None = None,
533 ) -> NDArray[float64]: ...
534 @overload
535 def normal(
536 self,
537 loc: _FloatLike_co = 0.0,
538 scale: _FloatLike_co = 1.0,
539 size: None = None,
540 ) -> float: ... # type: ignore[misc]
541 @overload
542 def normal(
543 self,
544 loc: _ArrayLikeFloat_co = 0.0,
545 scale: _ArrayLikeFloat_co = 1.0,
546 size: _ShapeLike | None = None,
547 ) -> NDArray[float64]: ...
548 @overload
549 def standard_gamma( # type: ignore[misc]
550 self,
551 shape: _FloatLike_co,
552 size: None = None,
553 dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
554 out: None = None,
555 ) -> float: ...
556 @overload
557 def standard_gamma(
558 self,
559 shape: _ArrayLikeFloat_co,
560 size: _ShapeLike | None = None,
561 ) -> NDArray[float64]: ...
562 @overload
563 def standard_gamma(
564 self,
565 shape: _ArrayLikeFloat_co,
566 *,
567 out: NDArray[float64] | None = None,
568 ) -> NDArray[float64]: ...
569 @overload
570 def standard_gamma(
571 self,
572 shape: _ArrayLikeFloat_co,
573 size: _ShapeLike | None = None,
574 dtype: _DTypeLikeFloat32 = ...,
575 out: NDArray[float32] | None = None,
576 ) -> NDArray[float32]: ...
577 @overload
578 def standard_gamma(
579 self,
580 shape: _ArrayLikeFloat_co,
581 size: _ShapeLike | None = None,
582 dtype: _DTypeLikeFloat64 = ...,
583 out: NDArray[float64] | None = None,
584 ) -> NDArray[float64]: ...
585 @overload
586 def gamma(
587 self, shape: _FloatLike_co, scale: _FloatLike_co = 1.0, size: None = None
588 ) -> float: ... # type: ignore[misc]
589 @overload
590 def gamma(
591 self,
592 shape: _ArrayLikeFloat_co,
593 scale: _ArrayLikeFloat_co = 1.0,
594 size: _ShapeLike | None = None,
595 ) -> NDArray[float64]: ...
596 @overload
597 def f(
598 self, dfnum: _FloatLike_co, dfden: _FloatLike_co, size: None = None
599 ) -> float: ... # type: ignore[misc]
600 @overload
601 def f(
602 self,
603 dfnum: _ArrayLikeFloat_co,
604 dfden: _ArrayLikeFloat_co,
605 size: _ShapeLike | None = None
606 ) -> NDArray[float64]: ...
607 @overload
608 def noncentral_f(
609 self,
610 dfnum: _FloatLike_co,
611 dfden: _FloatLike_co,
612 nonc: _FloatLike_co,
613 size: None = None,
614 ) -> float: ... # type: ignore[misc]
615 @overload
616 def noncentral_f(
617 self,
618 dfnum: _ArrayLikeFloat_co,
619 dfden: _ArrayLikeFloat_co,
620 nonc: _ArrayLikeFloat_co,
621 size: _ShapeLike | None = None,
622 ) -> NDArray[float64]: ...
623 @overload
624 def chisquare(self, df: _FloatLike_co, size: None = None) -> float: ... # type: ignore[misc]
625 @overload
626 def chisquare(
627 self, df: _ArrayLikeFloat_co, size: _ShapeLike | None = None
628 ) -> NDArray[float64]: ...
629 @overload
630 def noncentral_chisquare(
631 self, df: _FloatLike_co, nonc: _FloatLike_co, size: None = None
632 ) -> float: ... # type: ignore[misc]
633 @overload
634 def noncentral_chisquare(
635 self,
636 df: _ArrayLikeFloat_co,
637 nonc: _ArrayLikeFloat_co,
638 size: _ShapeLike | None = None
639 ) -> NDArray[float64]: ...
640 @overload
641 def standard_t(self, df: _FloatLike_co, size: None = None) -> float: ... # type: ignore[misc]
642 @overload
643 def standard_t(
644 self, df: _ArrayLikeFloat_co, size: None = None
645 ) -> NDArray[float64]: ...
646 @overload
647 def standard_t(
648 self, df: _ArrayLikeFloat_co, size: _ShapeLike | None = None
649 ) -> NDArray[float64]: ...
650 @overload
651 def vonmises(
652 self, mu: _FloatLike_co, kappa: _FloatLike_co, size: None = None
653 ) -> float: ... # type: ignore[misc]
654 @overload
655 def vonmises(
656 self,
657 mu: _ArrayLikeFloat_co,
658 kappa: _ArrayLikeFloat_co,
659 size: _ShapeLike | None = None
660 ) -> NDArray[float64]: ...
661 @overload
662 def pareto(self, a: _FloatLike_co, size: None = None) -> float: ... # type: ignore[misc]
663 @overload
664 def pareto(
665 self, a: _ArrayLikeFloat_co, size: _ShapeLike | None = None
666 ) -> NDArray[float64]: ...
667 @overload
668 def weibull(self, a: _FloatLike_co, size: None = None) -> float: ... # type: ignore[misc]
669 @overload
670 def weibull(
671 self, a: _ArrayLikeFloat_co, size: _ShapeLike | None = None
672 ) -> NDArray[float64]: ...
673 @overload
674 def power(self, a: _FloatLike_co, size: None = None) -> float: ... # type: ignore[misc]
675 @overload
676 def power(
677 self, a: _ArrayLikeFloat_co, size: _ShapeLike | None = None
678 ) -> NDArray[float64]: ...
679 @overload
680 def standard_cauchy(self, size: None = None) -> float: ... # type: ignore[misc]
681 @overload
682 def standard_cauchy(self, size: _ShapeLike | None = None) -> NDArray[float64]: ...
683 @overload
684 def laplace(
685 self,
686 loc: _FloatLike_co = 0.0,
687 scale: _FloatLike_co = 1.0,
688 size: None = None,
689 ) -> float: ... # type: ignore[misc]
690 @overload
691 def laplace(
692 self,
693 loc: _ArrayLikeFloat_co = 0.0,
694 scale: _ArrayLikeFloat_co = 1.0,
695 size: _ShapeLike | None = None,
696 ) -> NDArray[float64]: ...
697 @overload
698 def gumbel(
699 self,
700 loc: _FloatLike_co = 0.0,
701 scale: _FloatLike_co = 1.0,
702 size: None = None,
703 ) -> float: ... # type: ignore[misc]
704 @overload
705 def gumbel(
706 self,
707 loc: _ArrayLikeFloat_co = 0.0,
708 scale: _ArrayLikeFloat_co = 1.0,
709 size: _ShapeLike | None = None,
710 ) -> NDArray[float64]: ...
711 @overload
712 def logistic(
713 self,
714 loc: _FloatLike_co = 0.0,
715 scale: _FloatLike_co = 1.0,
716 size: None = None,
717 ) -> float: ... # type: ignore[misc]
718 @overload
719 def logistic(
720 self,
721 loc: _ArrayLikeFloat_co = 0.0,
722 scale: _ArrayLikeFloat_co = 1.0,
723 size: _ShapeLike | None = None,
724 ) -> NDArray[float64]: ...
725 @overload
726 def lognormal(
727 self,
728 mean: _FloatLike_co = 0.0,
729 sigma: _FloatLike_co = 1.0,
730 size: None = None,
731 ) -> float: ... # type: ignore[misc]
732 @overload
733 def lognormal(
734 self,
735 mean: _ArrayLikeFloat_co = 0.0,
736 sigma: _ArrayLikeFloat_co = 1.0,
737 size: _ShapeLike | None = None,
738 ) -> NDArray[float64]: ...
739 @overload
740 def rayleigh(self, scale: _FloatLike_co = 1.0, size: None = None) -> float: ... # type: ignore[misc]
741 @overload
742 def rayleigh(
743 self, scale: _ArrayLikeFloat_co = 1.0, size: _ShapeLike | None = None
744 ) -> NDArray[float64]: ...
745 @overload
746 def wald(
747 self, mean: _FloatLike_co, scale: _FloatLike_co, size: None = None
748 ) -> float: ... # type: ignore[misc]
749 @overload
750 def wald(
751 self,
752 mean: _ArrayLikeFloat_co,
753 scale: _ArrayLikeFloat_co,
754 size: _ShapeLike | None = None
755 ) -> NDArray[float64]: ...
756 @overload
757 def triangular(
758 self,
759 left: _FloatLike_co,
760 mode: _FloatLike_co,
761 right: _FloatLike_co,
762 size: None = None,
763 ) -> float: ... # type: ignore[misc]
764 @overload
765 def triangular(
766 self,
767 left: _ArrayLikeFloat_co,
768 mode: _ArrayLikeFloat_co,
769 right: _ArrayLikeFloat_co,
770 size: _ShapeLike | None = None,
771 ) -> NDArray[float64]: ...
772 @overload
773 def binomial(self, n: int, p: _FloatLike_co, size: None = None) -> int: ... # type: ignore[misc]
774 @overload
775 def binomial(
776 self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: _ShapeLike | None = None
777 ) -> NDArray[int64]: ...
778 @overload
779 def negative_binomial(
780 self, n: _FloatLike_co, p: _FloatLike_co, size: None = None
781 ) -> int: ... # type: ignore[misc]
782 @overload
783 def negative_binomial(
784 self,
785 n: _ArrayLikeFloat_co,
786 p: _ArrayLikeFloat_co,
787 size: _ShapeLike | None = None
788 ) -> NDArray[int64]: ...
789 @overload
790 def poisson(self, lam: _FloatLike_co = 1.0, size: None = None) -> int: ... # type: ignore[misc]
791 @overload
792 def poisson(
793 self, lam: _ArrayLikeFloat_co = 1.0, size: _ShapeLike | None = None
794 ) -> NDArray[int64]: ...
795 @overload
796 def zipf(self, a: _FloatLike_co, size: None = None) -> int: ... # type: ignore[misc]
797 @overload
798 def zipf(
799 self, a: _ArrayLikeFloat_co, size: _ShapeLike | None = None
800 ) -> NDArray[int64]: ...
801 @overload
802 def geometric(self, p: _FloatLike_co, size: None = None) -> int: ... # type: ignore[misc]
803 @overload
804 def geometric(
805 self, p: _ArrayLikeFloat_co, size: _ShapeLike | None = None
806 ) -> NDArray[int64]: ...
807 @overload
808 def hypergeometric(
809 self, ngood: int, nbad: int, nsample: int, size: None = None
810 ) -> int: ... # type: ignore[misc]
811 @overload
812 def hypergeometric(
813 self,
814 ngood: _ArrayLikeInt_co,
815 nbad: _ArrayLikeInt_co,
816 nsample: _ArrayLikeInt_co,
817 size: _ShapeLike | None = None,
818 ) -> NDArray[int64]: ...
819 @overload
820 def logseries(self, p: _FloatLike_co, size: None = None) -> int: ... # type: ignore[misc]
821 @overload
822 def logseries(
823 self, p: _ArrayLikeFloat_co, size: _ShapeLike | None = None
824 ) -> NDArray[int64]: ...
825 def multivariate_normal(
826 self,
827 mean: _ArrayLikeFloat_co,
828 cov: _ArrayLikeFloat_co,
829 size: _ShapeLike | None = None,
830 check_valid: Literal["warn", "raise", "ignore"] = "warn",
831 tol: float = 1e-8,
832 *,
833 method: Literal["svd", "eigh", "cholesky"] = "svd",
834 ) -> NDArray[float64]: ...
835 def multinomial(
836 self, n: _ArrayLikeInt_co,
837 pvals: _ArrayLikeFloat_co,
838 size: _ShapeLike | None = None
839 ) -> NDArray[int64]: ...
840 def multivariate_hypergeometric(
841 self,
842 colors: _ArrayLikeInt_co,
843 nsample: int,
844 size: _ShapeLike | None = None,
845 method: Literal["marginals", "count"] = "marginals",
846 ) -> NDArray[int64]: ...
847 def dirichlet(
848 self, alpha: _ArrayLikeFloat_co, size: _ShapeLike | None = None
849 ) -> NDArray[float64]: ...
850 def permuted(
851 self, x: ArrayLike, *, axis: int | None = None, out: NDArray[Any] | None = None
852 ) -> NDArray[Any]: ...
853
854 # axis must be 0 for MutableSequence
855 @overload
856 def shuffle(self, /, x: np.ndarray, axis: int = 0) -> None: ...
857 @overload
858 def shuffle(self, /, x: MutableSequence[Any], axis: Literal[0] = 0) -> None: ...
859
860def default_rng(
861 seed: _ArrayLikeInt_co | SeedSequence | BitGenerator | Generator | RandomState | None = None
862) -> Generator: ...
863