La EZ v pR (- x_ b˿ Ӱ dyQ Ӷ Vg <7 ܆u t7 $ MH l d" rqտ H)݄
/0 wپ }2} K D5z &R c M,}u c ? Ѡ p5 .b J3ʸ T[vv+ \[ U@ض Bi" 7oLe i Fγ >S R(D2 Z> B0$ y1 gW r-ެ
@樫 (a foe W - |&aY + M ?V#z?u?q?}n?k?Lh?e?Rc?`?Zw^?*+\?Y?RW?U?_S?XQ?߱O?M?3K?J?GH?F?jD?`C?(`A?j??>?x,>N>>q>>>j>>k>>Π>>F>>>'>\>#>u>J>*>_F>d>+>$>w> > >JK>y>|>iݿ>>I>;>ʾ>t>5<> ~>>>O>>>~3>T>ե>(>g~>ՠ>G/>>>F>J> >:n>bԓ>Q<>>x>~>>>^>Ј>D>l>1>>%>\D>@|>?y>Bv>Hs>Qp>#^m>mj>|g>md>a>^>$[>
Y>=3V>[S>P>M>J>~ H>UE>B>?>=>S:>7>"4>=22>T/>d,>m+*>m'>c$>N?">, > >m>t>F>>1*>
> >Y>>ʗ> >I=_={==^==&=_=g=='0===P6=˙=\= s==d=
=yo=/=6=.=fЍ=x=i'=܀=a1y=p=xIh=_==W=TO= G=>=N6=.=&= ==-H==<א<̀<<<.4V?4=3@4A4A4qB4C4D4udE4-CF4K"G4H4H41I4J4vK4\fL4HM4+N4aO4O4bP4ٽQ4R4ԊS4crT4ZU4CV4-W4ZX4Y4UY4Z4[4(\4_]4^4_4C`4va4alb40cc47[d4~Te4Of4Jg42Hh4Fi4Fj4Hk4Kl4MPm4Vn4^o48hp4sq4r4s4
t4u4 v4Cw4x4 z42{40S|4u}4~44v4@
4L4>4ق4v444lV44R4F44p4
I44"4_44Ќ4l4L4`4ԏ4坐4y4ݖ4%44r&4k44(44 44.4Q4N4t44\۶4H94̻4p44~X4w4p_4~444w E` m r u \zw 8x ky 5zz /
{ ԃ{ { 7| 3}| &| H| } C} g} ۇ} } a} g} ]} ~ ~ 4%~ 5~ C~ Q~ g^~ ij~ u~ >~ 2~ ~ r~ դ~ Ƭ~ N~ u~ C~ ~ ~ ~ k~ ~ ~ ~ ~ ~ t~ ~ ~ 6
< :# % ]( * .- z/ 1 3 5 7 9 ; = ? EA B D :F G NI J 8L M N LP Q R
T =U dV W X Y Z [ \ ] ^ ~_ _` ;a b b c od .e e f Lg g h ~ ~ 7~ ~ /~ 7~ ~
~
~ w~ G]~ >~ Y~ ,} 6} b} | O| 06{ x ?yjD?l[T?w'??o?Wp?xI?-3?x^j? ?N?R:e?4:>?l?*?%z?PՋt?4? e;?$"?zaWF}?GzB?Oq1?
OU?ߺH?7a?nV,? K?Xhw?հ<?Vp \?m?)?zP?ZcX?*;Q^?#*'g? U7?e&$ ?jJo?\Ȭ)?L&?FS?leZ&?g ?NIO??xRr!?P_hy?y6IJO?_5%?[X~?1>?bU? +À?PX?5:pɗ0?8d?;U?J?͓?)m?ېZ]G?/|!? ?iT??Wq?PF9 ?ߓ ^??ۮY?3 ???i?Z8o?
O5?ٸ?P?R9?igP?La;?L?!ވ?%o?{7=8?Ҁt ?DvC?6? =p\?;So&?mj?W?j?$O?z5Ѽ?Ҏ?C|P?yh|?%H?/ZM?f!w;??>ǭ? MAz? G?y?.?P9կ?TT}?g4K?#$O? Y?BM?6C;?B"_U?~t$?œ߉?52?Ҙl'?DɤT?<(i?qE8
?
Uī?OQM?o^?Sq͒?Gط5?zx?1zd}?:R!?Wg?~& ~k?=~-2?ZҿҶ?'|j_]?it?[?8R?uq b?#h?z|J?G~`?\!>?GF?vJ?l ?5hȩmE? 㭍?-l ?uG?1i%?調?M?e*|?zè?^V?4<%F?B}u?c-@c?n ? R=?Kr?*}T#?,"k>? R) ?K{o?vaӽ?命8?
t;I_? h?3xk?3Ӻ?b3?vZ9S?LJisk?M$a.?ftW?+ ?"@|?&#?p>_?1fҲ?
DE?} ?/?%,?0?5nl+,&?QG?b. ?,*(>?p_8?cU)?h*? 'wާ?dИۦ?ԭ<ڥ?]']ۤ?ݣ?=|?j ?.?ĥׁ?u? ̓0?"NR?
y? ڥ?d֔?^8
?0`4I?IrO*?O'?x
A?B?/)?7h`|?] ٨v? p?gC_e?T?yx;I< <[,L< Ŀk<4xV<=A[<'?}y<NG<~;[ xo6 xu{ f U Y> 9>{ pp CBw S( :5^ dܓ A N}8 ) Y fHq ն& |s f2 ,2Z tզ ޗ .n ZR' ӯB )[ l@u Pҍ ' T Ȉt (5w I' L/$; nXM ØT` OA r W , + jtȳ RfA Rnq ӊ< K Z W $eKs)
4 <=> )G 'Q A@Y .(5b X j z>lq {2Xx {~ JH҄ Cc` Qz %~ )Q \H srU b' Bk q-h nק
Ψ ;3K d)P ^٨ Tv $ Hx " $ 5. .& $ŗ :
Aޓ= ? ~) @ lѿ3 ;
@ UUUUUU? "@m{? ? @ @5 gG 8?SˆB?AAz?<ٰj_?$+ K?88C?J?llf?UUUUUU?dg?=
ףp=@n?[ m?h|?5?333333 @r ?$~?B>٬ @r鷯?Q ?Q ?9v?(\@ffffff@ 0C.@ 4@x&? @ ?UUUUUU? a@ X@ `@ |@ @ MA >@ @-DT! @h㈵> .A-DT! -DT!@3?r?q? 0@ 9B.? * ?,|l @yD@:5/?@@R2B@96SC@wz*E@r4dF@OOfq]@O b^@+NT_@ݭC#`@ ~{`@kbba@YSȐa@n b@1 Ib@5ca
c@ c@ͦ3
d@\>d@nz
e@s9 Je@FGGʪ f@yyuf@IJC g@Y&g@oFh@·h@aQL i@ai@ F~x*j@&P j@7k@!+k@VFl@ l@tVm@pZNm@k9ihn@HQOUn@a,~|o@b4nʼnp@+e Ip@cp@)Vp@* q@6Gaq@q@>m#FJq@FK.5r@b)C|r@Wrr@V]
s@rRs@GIqs@
>6qs@jB*t@ A=rt@fIw|t@d'-u@X+{
Mu@#
u@ ZGDu@;#(v@b%rv@iv{Իv@w@Ow@\&әw@}6-#w@h ͙.x@k?7yx@ 'x@_*y@Yy@1*y@^TTy@,{L`- A- PEp. I/ K/ PO 0 PPT0 PQ0 @U0 p\1 P]1 0^1 _2 _@2 `p2 a2 m2 n03 `|3 @3 L4 l4 p5 Й5 5 046 @H6 6 6 ,7 |7 7 $8 8 @ 9 l9 ` 9 `: %: `%: ?X; @[; k< (> > (? ? `@ ,`A `_A (B pB <C bC @D D @$E 0{E F F PF `F F 4G 0G G H PH pH H I TI I I (J @tJ `J J J J K K 4K LK dK @|K @K `K K L L `0L HL @tL L L L `L M M PM M P,N `N 0N N N O 8O 0PO hO |O pO O 0 P LP P P Q Q Q $R &R (S *S `+S ,T P/T 1T 5 U zR x $ ` FJ w ?;*3$" D X
l 4 E BDD d
GBI AAB
4 $ \AA ABDF @ H Di
C \ P Dp
D x \ BED D(D0|
(D ABBH Q
(D DBBC D
(A ABBE ` X l BBE D(D0h
(J BBBG I
(D BBBE V(D BBB 4 \ [ BBA A(H0F(A ABB A@
G h
H , 4 AG0
AF
AH q Aw
P h 4 e BGD m
DBH L
DBF 4 @ <Q ADD ^
CAE M
CAG x d AT
K H ` G BBB B(D0D8G`
8C0A(B BBBC K
8F0A(B BBBF ; lN 4 w AAG O
CAD I
CAC $ P W BDA LAB\ x $ BBE A(A0R
(D BBBI I
(D BBBE {(A EBB 4 AAG
CAH I
CAK $ ck BIC YABD 8 BEL E(A0A8E@8D0A(B BBBD [ BEL E(A0A8E@8D0A(B BBB8 ~ BEH A(A0b(D BBB 8 R` BBE A(A0J(D BBB 4 @ Le BDD E
GBH AAB x 2 D^
F I M bj H O BBE B(A0A8DP8D0A(B BBB P BHE A(D0JHfA\0D(A BBB T Db l p AG d $ ` BBB B(D0D8Hh
8A0A(B BBBF
8F0A(B BBBA @ BDD {
ABH Q
AEI A
CBE P 4 x BBA s
EBI A
BBC D
BBH H
IBM H m BBE E(D0A8G8D0A(B BBB D j
A H F(F0A8A@I E F(F0A8A@IL ' BBB B(D0D8Dp^xM_xApK
8A0A(B BBBD |
8A0A(B BBBB N8K0A(B BBB (
L $ L BEA A(D@(
(A ABBE m
(A ABBE (
$! BD V
EG k
EH 4 4
!e BGD m
DBH L
DBF , l
! AG0
DO O
AH 0
@#t BEG e
EBF lEB 4
#u BDD `
ABC AAB ( #x BED ^
EBH 4 ($ DE
G \
D L X $Q BEE B(A0A8G
8A0A(B BBBE ( + AAG
CAC H- d $0 QBB B(A0D8DP`HPt
8D0A(B BBBG H P \5 BBB B(H0D8GP6
8D0A(B BBBA D : BIA [
ABF L
ABA \
AEF D : BKD R
ABJ A
GBF Q
AEI L ,
; BEB B(A0A8GU
8A0A(B BBBE ( |
`AF AG0
AE A \
B( BEI A(G0u
(D ABBJ [
(D ABBD \
(D DBBH < TC/ AD h
AJ F
AA J
AM G
AH H DD yD F
AA < l @E AD A
AI G
AH V
AI G
AC ` F BAA D0
DABK i
AABC f
AABF `
CABA @ J
BIA Y
BBG Q
EBH qBB ( T Jk BD d
EA I
EB 8 L BEA G(G0s
(D ABBF d L BBE E(D0A8F
8A0A(B BBBH d
8A0A(B BBBJ $ RL D R
J k D RL D R
J k ( d S B]
A J
F I
G 0 X AJ0
AD R
AE nA H[ 0 D[ AJ`
AD R
AE nA ] L ]W BBB A(D0G@x
0A(A BBBF tHWP_HF@ p ^D D O
E k d _ BBB B(A0A8D@
8D0A(B BBBJ B
8C0A(B BBBB 8 b> BBA A(D0
(A ABBK d 4 d8 BBB B(A0A8DP
8F0A(B BBBA
8A0A(B BBBH H k BBB E(A0A8D@Y
8D0A(B BBBI P mJ BBD D0k
DBBA L
DBBD |
DBBD L < n BBA A(G@
(A ABBK
(C ABBH 8 o4 BBA A(D@
(A ABBD 8 qe BBA A(I@
(A ABBC H s BBB B(A0A8D`
8D0A(B BBBJ | P lz\ D d(Q0F8F@FHFPFXF`FhFpCxCCCCCCCCCCCCCCBO I
H c H L{ BBB B(D0D8D@R
8F0A(B BBBK ` } BBB B(A0A8D@
8F0A(B BBBH G8C0A(B BBB T L~ BAG
DBJ O
DBK S
DBG
DBA ` BBE A(C0
(D BBBD R
(D BBBD a
(D BBBE H < u BBB E(D0D8D@j
8F0A(B BBBH 7 BBB E(D0A8Gy
8D0A(B BBBC GZBDXB
DvCD{A DwC P 0 BBA D0
ABBE v
ABBE e
CBBD l K BBB E(A0D@k
0A(B BBBD t
0C(B BBBI v
0A(B BBBA H x7 BBE G(A0A8I`0
8D0A(B BBBH @ l Dj
B C
E 4 d BDG x
ABH q
CBJ L @E BBB E(D0A8M
8A0A(B BBBE L @C BBA D(Gp
(A ABBF
(A ABBD < @ At
K p
H ( ` BEA T
BBH D BBA b
BBE L
BBH q
BBC @ BDD0a
ABB V
ABG v
CBE \ T BBA A(L0
(D ABBK Q
(D ABBF d
(D ABBC d x BBB A(D0GP
0D(A BBBH T
0D(A BBBI XW`_XFP | BBB D(D0G@jHIPYHF@_
0D(A BBBG SHbPAXA`BhApDxBFAT@g
0D(A BBBK h BBB D(D0G@jHIPYHF@_
0D(A BBBG SHbPAXA`BhApDxBFAT@g
0D(A BBBK BBB D(D0G@jHIPYHF@_
0D(A BBBG SHbPAXA`BhApDxBFAT@g
0D(A BBBK | x BEA A(G@dHMP`HF@_
(D ABBA SHcPBXA`BhBpGxEFAQ@_
(D ABBG BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` BBB A(A0G@dHMP`HF@_
0D(A BBBH NHhPBXA`AhBpAxDBFQ@c
0D(A BBBH , BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH X BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH 8 BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH | ` BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG | BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG | `! < BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG ! l BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | p" l BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG " J BBB A(A0G@eHIPYHF@_
0D(A BBBJ OHfPBXA`BhBpAxBBAQ@[
0D(A BBBG x# d BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | $ d BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG $
BFB B(D0A8G`NhapBxFAEFABFQ`hEpkhF`_
8D0A(B BBBI hWp_hA`NhVp`hG` $% BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | % j BBB B(A0D8G`hPpRhF`_
8D0A(B BBBE Rh[pBxFFBFABFQ` 4& BEA A(GPuXX`BhBpAxEFAEBWPW
(D ABBD l
(D ABBK AXW`RXFP_
(D ABBH & BBB A(A0G@dHMP`HF@_
0D(A BBBH NHhPBXA`AhBpAxDBFQ@c
0D(A BBBH P' , BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` 4 ' , BDD r
ABA v
CBE 4 ( AD c
AG V
AI f
CG ` P( BBB A(G0
(D BBBD l
(D BBBB
(D BBBD H ( H$% BBE B(A0A8D@'
8D0A(B BBBK @ ) ;-- BBB B(A0J-0A(B BBB , D) * BHH h
CBA , t) + BHH h
CBA , ) H, BHH h
CBA , ) , BHH h
CBA , * - BHH h
CBA , 4* X. BHH h
CBA H d* /V BBB B(A0A8D`
8D0A(B BBBH @ * : BDD0i
ABJ V
ABG v
CBE * :: BFB B(A0D8Dp
8A0A(B BBBA |xW_xFp^
8A0A(B BBBH
8A0A(B BBBH xW_xApbxV`xGp + H yD
AD L + ( T> % G] l> 8 > I GED D(F0a(A ABBG8 > Y GED D(F0t(A ABBDH > Ԣ BEH H(KP
(E ABBK [(A AFB 8 D? I GED D(F0b(A ABBFT ? - BBE H(H0K@
0D(A BBBE m0A(A FBB 8 ? I GED D(F0b(A ABBF8 @ a GED D(F0v(A ABBJ< P@ ܤy GED D(G0O(A ABBH H @ BBE I(H0K8K`
8E0A(B BBBE 8 @ `I GED D(F0b(A ABBFH A t BBE B(H0H8KP
8F0A(B BBBD 8 dA I GED D(F0b(A ABBFH A AG@
AI t
AK 1
AF J
EI J
AE H A P AG0
AC q
AF B
AE J
EA J
AE 8B Ĭ GJ PB ̬ GJ hB Ԭ GJ B ܬ 0 B ج vAD@O
EAH ` B t$ D _ B D U B ( D c C D U (C D U ( @C AG0J
AM A lC DQ C S AG }A C د/ AG ]A C D U C B \ ] C (C D z ( D ` AG V
AI XA $ 8D İi BFG0IAK `D N AG DA D < DI D D3 D g
A D h AG _
AE l D BFB A(A0Gpg
0D(A BBBK V
0D(A BBBG /
0D(A BBBA HE & IX L dE
BFG E(D0A8J
8A0A(E BBBA 8 E R BED A(G`k
(A ABBD 0 E ka
L nJHA
G L < $F & AG
AL l
AK L
AC O
DE dF W AG AA F IO0
EA , F C AGP#
AD _
AH F AG@
DD F _ D Z G D ,G ( @G V BAG@CFB lG L@
M r
E 0 G MGG T
ABF h H G (Z BBB B(D0A8D@}
8D0A(B BBBE H H < BBB B(D0A8DPm
8D0A(B BBBE x \H BDB B(A0A8DP
8A0A(B BBBD C
8A0A(B BBBC a
8A0A(B BBBE x H BDB B(A0A8DP
8A0A(B BBBC B
8A0A(B BBBD `
8A0A(B BBBF ( TI I ACD g
AAG H I , BBB B(D0D8D`b
8A0A(B BBBH I BBB B(D0D8DP
8A0A(B BBBE
8A0A(B BBBC d
8A0A(B BBBB m
8A0A(B BBBA d dJ X{ BBB B(A0A8GP
8A0A(B BBBF I
8A0A(B BBBE x J p` BBE B(A0A8DPR
8K0A(B BBBI _
8A0A(B BBBG L
8A0A(B BBBJ , HK Tw KHE }ABH ` xK BIB B(A0D8D`n
8A0A(B BBBA S8A0A(B BBB d K 2 BBB B(D0A8Du
8A0A(B BBBH
8C0A(B BBBE L DL : BBB B(A0A8Gb
8A0A(B BBBC L L BBB F(D0D8G
8D0A(B BBBB L ` j " P" { -
h= x{ { o ` X
N x @ 06 } o 5 o o 3 o { 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v & 6 F V f v default_rng(seed=None)
Construct a new Generator with the default BitGenerator (PCG64).
Parameters
----------
seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional
A seed to initialize the `BitGenerator`. If None, then fresh,
unpredictable entropy will be pulled from the OS. If an ``int`` or
``array_like[ints]`` is passed, then it will be passed to
`SeedSequence` to derive the initial `BitGenerator` state. One may also
pass in a `SeedSequence` instance.
Additionally, when passed a `BitGenerator`, it will be wrapped by
`Generator`. If passed a `Generator`, it will be returned unaltered.
Returns
-------
Generator
The initialized generator object.
Notes
-----
If ``seed`` is not a `BitGenerator` or a `Generator`, a new `BitGenerator`
is instantiated. This function does not manage a default global instance.
See :ref:`seeding_and_entropy` for more information about seeding.
Examples
--------
``default_rng`` is the recommended constructor for the random number class
``Generator``. Here are several ways we can construct a random
number generator using ``default_rng`` and the ``Generator`` class.
Here we use ``default_rng`` to generate a random float:
>>> import numpy as np
>>> rng = np.random.default_rng(12345)
>>> print(rng)
Generator(PCG64)
>>> rfloat = rng.random()
>>> rfloat
0.22733602246716966
>>> type(rfloat)
Here we use ``default_rng`` to generate 3 random integers between 0
(inclusive) and 10 (exclusive):
>>> import numpy as np
>>> rng = np.random.default_rng(12345)
>>> rints = rng.integers(low=0, high=10, size=3)
>>> rints
array([6, 2, 7])
>>> type(rints[0])
Here we specify a seed so that we have reproducible results:
>>> import numpy as np
>>> rng = np.random.default_rng(seed=42)
>>> print(rng)
Generator(PCG64)
>>> arr1 = rng.random((3, 3))
>>> arr1
array([[0.77395605, 0.43887844, 0.85859792],
[0.69736803, 0.09417735, 0.97562235],
[0.7611397 , 0.78606431, 0.12811363]])
If we exit and restart our Python interpreter, we'll see that we
generate the same random numbers again:
>>> import numpy as np
>>> rng = np.random.default_rng(seed=42)
>>> arr2 = rng.random((3, 3))
>>> arr2
array([[0.77395605, 0.43887844, 0.85859792],
[0.69736803, 0.09417735, 0.97562235],
[0.7611397 , 0.78606431, 0.12811363]])
permutation(x, axis=0)
Randomly permute a sequence, or return a permuted range.
Parameters
----------
x : int or array_like
If `x` is an integer, randomly permute ``np.arange(x)``.
If `x` is an array, make a copy and shuffle the elements
randomly.
axis : int, optional
The axis which `x` is shuffled along. Default is 0.
Returns
-------
out : ndarray
Permuted sequence or array range.
Examples
--------
>>> rng = np.random.default_rng()
>>> rng.permutation(10)
array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random
>>> rng.permutation([1, 4, 9, 12, 15])
array([15, 1, 9, 4, 12]) # random
>>> arr = np.arange(9).reshape((3, 3))
>>> rng.permutation(arr)
array([[6, 7, 8], # random
[0, 1, 2],
[3, 4, 5]])
>>> rng.permutation("abc")
Traceback (most recent call last):
...
numpy.exceptions.AxisError: axis 0 is out of bounds for array of dimension 0
>>> arr = np.arange(9).reshape((3, 3))
>>> rng.permutation(arr, axis=1)
array([[0, 2, 1], # random
[3, 5, 4],
[6, 8, 7]])
shuffle(x, axis=0)
Modify an array or sequence in-place by shuffling its contents.
The order of sub-arrays is changed but their contents remains the same.
Parameters
----------
x : ndarray or MutableSequence
The array, list or mutable sequence to be shuffled.
axis : int, optional
The axis which `x` is shuffled along. Default is 0.
It is only supported on `ndarray` objects.
Returns
-------
None
See Also
--------
permuted
permutation
Notes
-----
An important distinction between methods ``shuffle`` and ``permuted`` is
how they both treat the ``axis`` parameter which can be found at
:ref:`generator-handling-axis-parameter`.
Examples
--------
>>> rng = np.random.default_rng()
>>> arr = np.arange(10)
>>> arr
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> rng.shuffle(arr)
>>> arr
array([2, 0, 7, 5, 1, 4, 8, 9, 3, 6]) # random
>>> arr = np.arange(9).reshape((3, 3))
>>> arr
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> rng.shuffle(arr)
>>> arr
array([[3, 4, 5], # random
[6, 7, 8],
[0, 1, 2]])
>>> arr = np.arange(9).reshape((3, 3))
>>> arr
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> rng.shuffle(arr, axis=1)
>>> arr
array([[2, 0, 1], # random
[5, 3, 4],
[8, 6, 7]])
permuted(x, axis=None, out=None)
Randomly permute `x` along axis `axis`.
Unlike `shuffle`, each slice along the given axis is shuffled
independently of the others.
Parameters
----------
x : array_like, at least one-dimensional
Array to be shuffled.
axis : int, optional
Slices of `x` in this axis are shuffled. Each slice
is shuffled independently of the others. If `axis` is
None, the flattened array is shuffled.
out : ndarray, optional
If given, this is the destination of the shuffled array.
If `out` is None, a shuffled copy of the array is returned.
Returns
-------
ndarray
If `out` is None, a shuffled copy of `x` is returned.
Otherwise, the shuffled array is stored in `out`,
and `out` is returned
See Also
--------
shuffle
permutation
Notes
-----
An important distinction between methods ``shuffle`` and ``permuted`` is
how they both treat the ``axis`` parameter which can be found at
:ref:`generator-handling-axis-parameter`.
Examples
--------
Create a `numpy.random.Generator` instance:
>>> rng = np.random.default_rng()
Create a test array:
>>> x = np.arange(24).reshape(3, 8)
>>> x
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]])
Shuffle the rows of `x`:
>>> y = rng.permuted(x, axis=1)
>>> y
array([[ 4, 3, 6, 7, 1, 2, 5, 0], # random
[15, 10, 14, 9, 12, 11, 8, 13],
[17, 16, 20, 21, 18, 22, 23, 19]])
`x` has not been modified:
>>> x
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]])
To shuffle the rows of `x` in-place, pass `x` as the `out`
parameter:
>>> y = rng.permuted(x, axis=1, out=x)
>>> x
array([[ 3, 0, 4, 7, 1, 6, 2, 5], # random
[ 8, 14, 13, 9, 12, 11, 15, 10],
[17, 18, 16, 22, 19, 23, 20, 21]])
Note that when the ``out`` parameter is given, the return
value is ``out``:
>>> y is x
True
dirichlet(alpha, size=None)
Draw samples from the Dirichlet distribution.
Draw `size` samples of dimension k from a Dirichlet distribution. A
Dirichlet-distributed random variable can be seen as a multivariate
generalization of a Beta distribution. The Dirichlet distribution
is a conjugate prior of a multinomial distribution in Bayesian
inference.
Parameters
----------
alpha : sequence of floats, length k
Parameter of the distribution (length ``k`` for sample of
length ``k``).
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
vector of length ``k`` is returned.
Returns
-------
samples : ndarray,
The drawn samples, of shape ``(size, k)``.
Raises
------
ValueError
If any value in ``alpha`` is less than zero
Notes
-----
The Dirichlet distribution is a distribution over vectors
:math:`x` that fulfil the conditions :math:`x_i>0` and
:math:`\sum_{i=1}^k x_i = 1`.
The probability density function :math:`p` of a
Dirichlet-distributed random vector :math:`X` is
proportional to
.. math:: p(x) \propto \prod_{i=1}^{k}{x^{\alpha_i-1}_i},
where :math:`\alpha` is a vector containing the positive
concentration parameters.
The method uses the following property for computation: let :math:`Y`
be a random vector which has components that follow a standard gamma
distribution, then :math:`X = \frac{1}{\sum_{i=1}^k{Y_i}} Y`
is Dirichlet-distributed
References
----------
.. [1] David McKay, "Information Theory, Inference and Learning
Algorithms," chapter 23,
http://www.inference.org.uk/mackay/itila/
.. [2] Wikipedia, "Dirichlet distribution",
https://en.wikipedia.org/wiki/Dirichlet_distribution
Examples
--------
Taking an example cited in Wikipedia, this distribution can be used if
one wanted to cut strings (each of initial length 1.0) into K pieces
with different lengths, where each piece had, on average, a designated
average length, but allowing some variation in the relative sizes of
the pieces.
>>> s = np.random.default_rng().dirichlet((10, 5, 3), 20).transpose()
>>> import matplotlib.pyplot as plt
>>> plt.barh(range(20), s[0])
>>> plt.barh(range(20), s[1], left=s[0], color='g')
>>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')
>>> plt.title("Lengths of Strings")
multivariate_hypergeometric(colors, nsample, size=None,
method='marginals')
Generate variates from a multivariate hypergeometric distribution.
The multivariate hypergeometric distribution is a generalization
of the hypergeometric distribution.
Choose ``nsample`` items at random without replacement from a
collection with ``N`` distinct types. ``N`` is the length of
``colors``, and the values in ``colors`` are the number of occurrences
of that type in the collection. The total number of items in the
collection is ``sum(colors)``. Each random variate generated by this
function is a vector of length ``N`` holding the counts of the
different types that occurred in the ``nsample`` items.
The name ``colors`` comes from a common description of the
distribution: it is the probability distribution of the number of
marbles of each color selected without replacement from an urn
containing marbles of different colors; ``colors[i]`` is the number
of marbles in the urn with color ``i``.
Parameters
----------
colors : sequence of integers
The number of each type of item in the collection from which
a sample is drawn. The values in ``colors`` must be nonnegative.
To avoid loss of precision in the algorithm, ``sum(colors)``
must be less than ``10**9`` when `method` is "marginals".
nsample : int
The number of items selected. ``nsample`` must not be greater
than ``sum(colors)``.
size : int or tuple of ints, optional
The number of variates to generate, either an integer or a tuple
holding the shape of the array of variates. If the given size is,
e.g., ``(k, m)``, then ``k * m`` variates are drawn, where one
variate is a vector of length ``len(colors)``, and the return value
has shape ``(k, m, len(colors))``. If `size` is an integer, the
output has shape ``(size, len(colors))``. Default is None, in
which case a single variate is returned as an array with shape
``(len(colors),)``.
method : string, optional
Specify the algorithm that is used to generate the variates.
Must be 'count' or 'marginals' (the default). See the Notes
for a description of the methods.
Returns
-------
variates : ndarray
Array of variates drawn from the multivariate hypergeometric
distribution.
See Also
--------
hypergeometric : Draw samples from the (univariate) hypergeometric
distribution.
Notes
-----
The two methods do not return the same sequence of variates.
The "count" algorithm is roughly equivalent to the following numpy
code::
choices = np.repeat(np.arange(len(colors)), colors)
selection = np.random.choice(choices, nsample, replace=False)
variate = np.bincount(selection, minlength=len(colors))
The "count" algorithm uses a temporary array of integers with length
``sum(colors)``.
The "marginals" algorithm generates a variate by using repeated
calls to the univariate hypergeometric sampler. It is roughly
equivalent to::
variate = np.zeros(len(colors), dtype=np.int64)
# `remaining` is the cumulative sum of `colors` from the last
# element to the first; e.g. if `colors` is [3, 1, 5], then
# `remaining` is [9, 6, 5].
remaining = np.cumsum(colors[::-1])[::-1]
for i in range(len(colors)-1):
if nsample < 1:
break
variate[i] = hypergeometric(colors[i], remaining[i+1],
nsample)
nsample -= variate[i]
variate[-1] = nsample
The default method is "marginals". For some cases (e.g. when
`colors` contains relatively small integers), the "count" method
can be significantly faster than the "marginals" method. If
performance of the algorithm is important, test the two methods
with typical inputs to decide which works best.
.. versionadded:: 1.18.0
Examples
--------
>>> colors = [16, 8, 4]
>>> seed = 4861946401452
>>> gen = np.random.Generator(np.random.PCG64(seed))
>>> gen.multivariate_hypergeometric(colors, 6)
array([5, 0, 1])
>>> gen.multivariate_hypergeometric(colors, 6, size=3)
array([[5, 0, 1],
[2, 2, 2],
[3, 3, 0]])
>>> gen.multivariate_hypergeometric(colors, 6, size=(2, 2))
array([[[3, 2, 1],
[3, 2, 1]],
[[4, 1, 1],
[3, 2, 1]]])
multinomial(n, pvals, size=None)
Draw samples from a multinomial distribution.
The multinomial distribution is a multivariate generalization of the
binomial distribution. Take an experiment with one of ``p``
possible outcomes. An example of such an experiment is throwing a dice,
where the outcome can be 1 through 6. Each sample drawn from the
distribution represents `n` such experiments. Its values,
``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the
outcome was ``i``.
Parameters
----------
n : int or array-like of ints
Number of experiments.
pvals : array-like of floats
Probabilities of each of the ``p`` different outcomes with shape
``(k0, k1, ..., kn, p)``. Each element ``pvals[i,j,...,:]`` must
sum to 1 (however, the last element is always assumed to account
for the remaining probability, as long as
``sum(pvals[..., :-1], axis=-1) <= 1.0``. Must have at least 1
dimension where pvals.shape[-1] > 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn each with ``p`` elements. Default
is None where the output size is determined by the broadcast shape
of ``n`` and all by the final dimension of ``pvals``, which is
denoted as ``b=(b0, b1, ..., bq)``. If size is not None, then it
must be compatible with the broadcast shape ``b``. Specifically,
size must have ``q`` or more elements and size[-(q-j):] must equal
``bj``.
Returns
-------
out : ndarray
The drawn samples, of shape size, if provided. When size is
provided, the output shape is size + (p,) If not specified,
the shape is determined by the broadcast shape of ``n`` and
``pvals``, ``(b0, b1, ..., bq)`` augmented with the dimension of
the multinomial, ``p``, so that that output shape is
``(b0, b1, ..., bq, p)``.
Each entry ``out[i,j,...,:]`` is a ``p``-dimensional value drawn
from the distribution.
.. versionchanged:: 1.22.0
Added support for broadcasting `pvals` against `n`
Examples
--------
Throw a dice 20 times:
>>> rng = np.random.default_rng()
>>> rng.multinomial(20, [1/6.]*6, size=1)
array([[4, 1, 7, 5, 2, 1]]) # random
It landed 4 times on 1, once on 2, etc.
Now, throw the dice 20 times, and 20 times again:
>>> rng.multinomial(20, [1/6.]*6, size=2)
array([[3, 4, 3, 3, 4, 3],
[2, 4, 3, 4, 0, 7]]) # random
For the first run, we threw 3 times 1, 4 times 2, etc. For the second,
we threw 2 times 1, 4 times 2, etc.
Now, do one experiment throwing the dice 10 time, and 10 times again,
and another throwing the dice 20 times, and 20 times again:
>>> rng.multinomial([[10], [20]], [1/6.]*6, size=(2, 2))
array([[[2, 4, 0, 1, 2, 1],
[1, 3, 0, 3, 1, 2]],
[[1, 4, 4, 4, 4, 3],
[3, 3, 2, 5, 5, 2]]]) # random
The first array shows the outcomes of throwing the dice 10 times, and
the second shows the outcomes from throwing the dice 20 times.
A loaded die is more likely to land on number 6:
>>> rng.multinomial(100, [1/7.]*5 + [2/7.])
array([11, 16, 14, 17, 16, 26]) # random
Simulate 10 throws of a 4-sided die and 20 throws of a 6-sided die
>>> rng.multinomial([10, 20],[[1/4]*4 + [0]*2, [1/6]*6])
array([[2, 1, 4, 3, 0, 0],
[3, 3, 3, 6, 1, 4]], dtype=int64) # random
Generate categorical random variates from two categories where the
first has 3 outcomes and the second has 2.
>>> rng.multinomial(1, [[.1, .5, .4 ], [.3, .7, .0]])
array([[0, 0, 1],
[0, 1, 0]], dtype=int64) # random
``argmax(axis=-1)`` is then used to return the categories.
>>> pvals = [[.1, .5, .4 ], [.3, .7, .0]]
>>> rvs = rng.multinomial(1, pvals, size=(4,2))
>>> rvs.argmax(axis=-1)
array([[0, 1],
[2, 0],
[2, 1],
[2, 0]], dtype=int64) # random
The same output dimension can be produced using broadcasting.
>>> rvs = rng.multinomial([[1]] * 4, pvals)
>>> rvs.argmax(axis=-1)
array([[0, 1],
[2, 0],
[2, 1],
[2, 0]], dtype=int64) # random
The probability inputs should be normalized. As an implementation
detail, the value of the last entry is ignored and assumed to take
up any leftover probability mass, but this should not be relied on.
A biased coin which has twice as much weight on one side as on the
other should be sampled like so:
>>> rng.multinomial(100, [1.0 / 3, 2.0 / 3]) # RIGHT
array([38, 62]) # random
not like:
>>> rng.multinomial(100, [1.0, 2.0]) # WRONG
Traceback (most recent call last):
ValueError: pvals < 0, pvals > 1 or pvals contains NaNs
multivariate_normal(mean, cov, size=None, check_valid='warn',
tol=1e-8, *, method='svd')
Draw random samples from a multivariate normal distribution.
The multivariate normal, multinormal or Gaussian distribution is a
generalization of the one-dimensional normal distribution to higher
dimensions. Such a distribution is specified by its mean and
covariance matrix. These parameters are analogous to the mean
(average or "center") and variance (the squared standard deviation,
or "width") of the one-dimensional normal distribution.
Parameters
----------
mean : 1-D array_like, of length N
Mean of the N-dimensional distribution.
cov : 2-D array_like, of shape (N, N)
Covariance matrix of the distribution. It must be symmetric and
positive-semidefinite for proper sampling.
size : int or tuple of ints, optional
Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are
generated, and packed in an `m`-by-`n`-by-`k` arrangement. Because
each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.
If no shape is specified, a single (`N`-D) sample is returned.
check_valid : { 'warn', 'raise', 'ignore' }, optional
Behavior when the covariance matrix is not positive semidefinite.
tol : float, optional
Tolerance when checking the singular values in covariance matrix.
cov is cast to double before the check.
method : { 'svd', 'eigh', 'cholesky'}, optional
The cov input is used to compute a factor matrix A such that
``A @ A.T = cov``. This argument is used to select the method
used to compute the factor matrix A. The default method 'svd' is
the slowest, while 'cholesky' is the fastest but less robust than
the slowest method. The method `eigh` uses eigen decomposition to
compute A and is faster than svd but slower than cholesky.
.. versionadded:: 1.18.0
Returns
-------
out : ndarray
The drawn samples, of shape *size*, if that was provided. If not,
the shape is ``(N,)``.
In other words, each entry ``out[i,j,...,:]`` is an N-dimensional
value drawn from the distribution.
Notes
-----
The mean is a coordinate in N-dimensional space, which represents the
location where samples are most likely to be generated. This is
analogous to the peak of the bell curve for the one-dimensional or
univariate normal distribution.
Covariance indicates the level to which two variables vary together.
From the multivariate normal distribution, we draw N-dimensional
samples, :math:`X = [x_1, x_2, ... x_N]`. The covariance matrix
element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.
The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its
"spread").
Instead of specifying the full covariance matrix, popular
approximations include:
- Spherical covariance (`cov` is a multiple of the identity matrix)
- Diagonal covariance (`cov` has non-negative elements, and only on
the diagonal)
This geometrical property can be seen in two dimensions by plotting
generated data-points:
>>> mean = [0, 0]
>>> cov = [[1, 0], [0, 100]] # diagonal covariance
Diagonal covariance means that points are oriented along x or y-axis:
>>> import matplotlib.pyplot as plt
>>> x, y = np.random.default_rng().multivariate_normal(mean, cov, 5000).T
>>> plt.plot(x, y, 'x')
>>> plt.axis('equal')
>>> plt.show()
Note that the covariance matrix must be positive semidefinite (a.k.a.
nonnegative-definite). Otherwise, the behavior of this method is
undefined and backwards compatibility is not guaranteed.
This function internally uses linear algebra routines, and thus results
may not be identical (even up to precision) across architectures, OSes,
or even builds. For example, this is likely if ``cov`` has multiple equal
singular values and ``method`` is ``'svd'`` (default). In this case,
``method='cholesky'`` may be more robust.
References
----------
.. [1] Papoulis, A., "Probability, Random Variables, and Stochastic
Processes," 3rd ed., New York: McGraw-Hill, 1991.
.. [2] Duda, R. O., Hart, P. E., and Stork, D. G., "Pattern
Classification," 2nd ed., New York: Wiley, 2001.
Examples
--------
>>> mean = (1, 2)
>>> cov = [[1, 0], [0, 1]]
>>> rng = np.random.default_rng()
>>> x = rng.multivariate_normal(mean, cov, (3, 3))
>>> x.shape
(3, 3, 2)
We can use a different method other than the default to factorize cov:
>>> y = rng.multivariate_normal(mean, cov, (3, 3), method='cholesky')
>>> y.shape
(3, 3, 2)
Here we generate 800 samples from the bivariate normal distribution
with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]]. The
expected variances of the first and second components of the sample
are 6 and 3.5, respectively, and the expected correlation
coefficient is -3/sqrt(6*3.5) ≈ -0.65465.
>>> cov = np.array([[6, -3], [-3, 3.5]])
>>> pts = rng.multivariate_normal([0, 0], cov, size=800)
Check that the mean, covariance, and correlation coefficient of the
sample are close to the expected values:
>>> pts.mean(axis=0)
array([ 0.0326911 , -0.01280782]) # may vary
>>> np.cov(pts.T)
array([[ 5.96202397, -2.85602287],
[-2.85602287, 3.47613949]]) # may vary
>>> np.corrcoef(pts.T)[0, 1]
-0.6273591314603949 # may vary
We can visualize this data with a scatter plot. The orientation
of the point cloud illustrates the negative correlation of the
components of this sample.
>>> import matplotlib.pyplot as plt
>>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)
>>> plt.axis('equal')
>>> plt.grid()
>>> plt.show()
logseries(p, size=None)
Draw samples from a logarithmic series distribution.
Samples are drawn from a log series distribution with specified
shape parameter, 0 <= ``p`` < 1.
Parameters
----------
p : float or array_like of floats
Shape parameter for the distribution. Must be in the range [0, 1).
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``p`` is a scalar. Otherwise,
``np.array(p).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized logarithmic series distribution.
See Also
--------
scipy.stats.logser : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability mass function for the Log Series distribution is
.. math:: P(k) = \frac{-p^k}{k \ln(1-p)},
where p = probability.
The log series distribution is frequently used to represent species
richness and occurrence, first proposed by Fisher, Corbet, and
Williams in 1943 [2]. It may also be used to model the numbers of
occupants seen in cars [3].
References
----------
.. [1] Buzas, Martin A.; Culver, Stephen J., Understanding regional
species diversity through the log series distribution of
occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,
Volume 5, Number 5, September 1999 , pp. 187-195(9).
.. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The
relation between the number of species and the number of
individuals in a random sample of an animal population.
Journal of Animal Ecology, 12:42-58.
.. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small
Data Sets, CRC Press, 1994.
.. [4] Wikipedia, "Logarithmic distribution",
https://en.wikipedia.org/wiki/Logarithmic_distribution
Examples
--------
Draw samples from the distribution:
>>> a = .6
>>> s = np.random.default_rng().logseries(a, 10000)
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s)
# plot against distribution
>>> def logseries(k, p):
... return -p**k/(k*np.log(1-p))
>>> plt.plot(bins, logseries(bins, a) * count.max()/
... logseries(bins, a).max(), 'r')
>>> plt.show()
hypergeometric(ngood, nbad, nsample, size=None)
Draw samples from a Hypergeometric distribution.
Samples are drawn from a hypergeometric distribution with specified
parameters, `ngood` (ways to make a good selection), `nbad` (ways to make
a bad selection), and `nsample` (number of items sampled, which is less
than or equal to the sum ``ngood + nbad``).
Parameters
----------
ngood : int or array_like of ints
Number of ways to make a good selection. Must be nonnegative and
less than 10**9.
nbad : int or array_like of ints
Number of ways to make a bad selection. Must be nonnegative and
less than 10**9.
nsample : int or array_like of ints
Number of items sampled. Must be nonnegative and less than
``ngood + nbad``.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if `ngood`, `nbad`, and `nsample`
are all scalars. Otherwise, ``np.broadcast(ngood, nbad, nsample).size``
samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized hypergeometric distribution. Each
sample is the number of good items within a randomly selected subset of
size `nsample` taken from a set of `ngood` good items and `nbad` bad items.
See Also
--------
multivariate_hypergeometric : Draw samples from the multivariate
hypergeometric distribution.
scipy.stats.hypergeom : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Hypergeometric distribution is
.. math:: P(x) = \frac{\binom{g}{x}\binom{b}{n-x}}{\binom{g+b}{n}},
where :math:`0 \le x \le n` and :math:`n-b \le x \le g`
for P(x) the probability of ``x`` good results in the drawn sample,
g = `ngood`, b = `nbad`, and n = `nsample`.
Consider an urn with black and white marbles in it, `ngood` of them
are black and `nbad` are white. If you draw `nsample` balls without
replacement, then the hypergeometric distribution describes the
distribution of black balls in the drawn sample.
Note that this distribution is very similar to the binomial
distribution, except that in this case, samples are drawn without
replacement, whereas in the Binomial case samples are drawn with
replacement (or the sample space is infinite). As the sample space
becomes large, this distribution approaches the binomial.
The arguments `ngood` and `nbad` each must be less than `10**9`. For
extremely large arguments, the algorithm that is used to compute the
samples [4]_ breaks down because of loss of precision in floating point
calculations. For such large values, if `nsample` is not also large,
the distribution can be approximated with the binomial distribution,
`binomial(n=nsample, p=ngood/(ngood + nbad))`.
References
----------
.. [1] Lentner, Marvin, "Elementary Applied Statistics", Bogden
and Quigley, 1972.
.. [2] Weisstein, Eric W. "Hypergeometric Distribution." From
MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/HypergeometricDistribution.html
.. [3] Wikipedia, "Hypergeometric distribution",
https://en.wikipedia.org/wiki/Hypergeometric_distribution
.. [4] Stadlober, Ernst, "The ratio of uniforms approach for generating
discrete random variates", Journal of Computational and Applied
Mathematics, 31, pp. 181-189 (1990).
Examples
--------
Draw samples from the distribution:
>>> rng = np.random.default_rng()
>>> ngood, nbad, nsamp = 100, 2, 10
# number of good, number of bad, and number of samples
>>> s = rng.hypergeometric(ngood, nbad, nsamp, 1000)
>>> from matplotlib.pyplot import hist
>>> hist(s)
# note that it is very unlikely to grab both bad items
Suppose you have an urn with 15 white and 15 black marbles.
If you pull 15 marbles at random, how likely is it that
12 or more of them are one color?
>>> s = rng.hypergeometric(15, 15, 15, 100000)
>>> sum(s>=12)/100000. + sum(s<=3)/100000.
# answer = 0.003 ... pretty unlikely!
geometric(p, size=None)
Draw samples from the geometric distribution.
Bernoulli trials are experiments with one of two outcomes:
success or failure (an example of such an experiment is flipping
a coin). The geometric distribution models the number of trials
that must be run in order to achieve success. It is therefore
supported on the positive integers, ``k = 1, 2, ...``.
The probability mass function of the geometric distribution is
.. math:: f(k) = (1 - p)^{k - 1} p
where `p` is the probability of success of an individual trial.
Parameters
----------
p : float or array_like of floats
The probability of success of an individual trial.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``p`` is a scalar. Otherwise,
``np.array(p).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized geometric distribution.
Examples
--------
Draw ten thousand values from the geometric distribution,
with the probability of an individual success equal to 0.35:
>>> z = np.random.default_rng().geometric(p=0.35, size=10000)
How many trials succeeded after a single run?
>>> (z == 1).sum() / 10000.
0.34889999999999999 # random
zipf(a, size=None)
Draw samples from a Zipf distribution.
Samples are drawn from a Zipf distribution with specified parameter
`a` > 1.
The Zipf distribution (also known as the zeta distribution) is a
discrete probability distribution that satisfies Zipf's law: the
frequency of an item is inversely proportional to its rank in a
frequency table.
Parameters
----------
a : float or array_like of floats
Distribution parameter. Must be greater than 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``a`` is a scalar. Otherwise,
``np.array(a).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Zipf distribution.
See Also
--------
scipy.stats.zipf : probability density function, distribution, or
cumulative density function, etc.
Notes
-----
The probability density for the Zipf distribution is
.. math:: p(k) = \frac{k^{-a}}{\zeta(a)},
for integers :math:`k \geq 1`, where :math:`\zeta` is the Riemann Zeta
function.
It is named for the American linguist George Kingsley Zipf, who noted
that the frequency of any word in a sample of a language is inversely
proportional to its rank in the frequency table.
References
----------
.. [1] Zipf, G. K., "Selected Studies of the Principle of Relative
Frequency in Language," Cambridge, MA: Harvard Univ. Press,
1932.
Examples
--------
Draw samples from the distribution:
>>> a = 4.0
>>> n = 20000
>>> s = np.random.default_rng().zipf(a, size=n)
Display the histogram of the samples, along with
the expected histogram based on the probability
density function:
>>> import matplotlib.pyplot as plt
>>> from scipy.special import zeta # doctest: +SKIP
`bincount` provides a fast histogram for small integers.
>>> count = np.bincount(s)
>>> k = np.arange(1, s.max() + 1)
>>> plt.bar(k, count[1:], alpha=0.5, label='sample count')
>>> plt.plot(k, n*(k**-a)/zeta(a), 'k.-', alpha=0.5,
... label='expected count') # doctest: +SKIP
>>> plt.semilogy()
>>> plt.grid(alpha=0.4)
>>> plt.legend()
>>> plt.title(f'Zipf sample, a={a}, size={n}')
>>> plt.show()
poisson(lam=1.0, size=None)
Draw samples from a Poisson distribution.
The Poisson distribution is the limit of the binomial distribution
for large N.
Parameters
----------
lam : float or array_like of floats
Expected number of events occurring in a fixed-time interval,
must be >= 0. A sequence must be broadcastable over the requested
size.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``lam`` is a scalar. Otherwise,
``np.array(lam).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Poisson distribution.
Notes
-----
The Poisson distribution
.. math:: f(k; \lambda)=\frac{\lambda^k e^{-\lambda}}{k!}
For events with an expected separation :math:`\lambda` the Poisson
distribution :math:`f(k; \lambda)` describes the probability of
:math:`k` events occurring within the observed
interval :math:`\lambda`.
Because the output is limited to the range of the C int64 type, a
ValueError is raised when `lam` is within 10 sigma of the maximum
representable value.
References
----------
.. [1] Weisstein, Eric W. "Poisson Distribution."
From MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/PoissonDistribution.html
.. [2] Wikipedia, "Poisson distribution",
https://en.wikipedia.org/wiki/Poisson_distribution
Examples
--------
Draw samples from the distribution:
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> s = rng.poisson(5, 10000)
Display histogram of the sample:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 14, density=True)
>>> plt.show()
Draw each 100 values for lambda 100 and 500:
>>> s = rng.poisson(lam=(100., 500.), size=(100, 2))
negative_binomial(n, p, size=None)
Draw samples from a negative binomial distribution.
Samples are drawn from a negative binomial distribution with specified
parameters, `n` successes and `p` probability of success where `n`
is > 0 and `p` is in the interval (0, 1].
Parameters
----------
n : float or array_like of floats
Parameter of the distribution, > 0.
p : float or array_like of floats
Parameter of the distribution. Must satisfy 0 < p <= 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``n`` and ``p`` are both scalars.
Otherwise, ``np.broadcast(n, p).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized negative binomial distribution,
where each sample is equal to N, the number of failures that
occurred before a total of n successes was reached.
Notes
-----
The probability mass function of the negative binomial distribution is
.. math:: P(N;n,p) = \frac{\Gamma(N+n)}{N!\Gamma(n)}p^{n}(1-p)^{N},
where :math:`n` is the number of successes, :math:`p` is the
probability of success, :math:`N+n` is the number of trials, and
:math:`\Gamma` is the gamma function. When :math:`n` is an integer,
:math:`\frac{\Gamma(N+n)}{N!\Gamma(n)} = \binom{N+n-1}{N}`, which is
the more common form of this term in the pmf. The negative
binomial distribution gives the probability of N failures given n
successes, with a success on the last trial.
If one throws a die repeatedly until the third time a "1" appears,
then the probability distribution of the number of non-"1"s that
appear before the third "1" is a negative binomial distribution.
Because this method internally calls ``Generator.poisson`` with an
intermediate random value, a ValueError is raised when the choice of
:math:`n` and :math:`p` would result in the mean + 10 sigma of the sampled
intermediate distribution exceeding the max acceptable value of the
``Generator.poisson`` method. This happens when :math:`p` is too low
(a lot of failures happen for every success) and :math:`n` is too big (
a lot of successes are allowed).
Therefore, the :math:`n` and :math:`p` values must satisfy the constraint:
.. math:: n\frac{1-p}{p}+10n\sqrt{n}\frac{1-p}{p}<2^{63}-1-10\sqrt{2^{63}-1},
Where the left side of the equation is the derived mean + 10 sigma of
a sample from the gamma distribution internally used as the :math:`lam`
parameter of a poisson sample, and the right side of the equation is
the constraint for maximum value of :math:`lam` in ``Generator.poisson``.
References
----------
.. [1] Weisstein, Eric W. "Negative Binomial Distribution." From
MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/NegativeBinomialDistribution.html
.. [2] Wikipedia, "Negative binomial distribution",
https://en.wikipedia.org/wiki/Negative_binomial_distribution
Examples
--------
Draw samples from the distribution:
A real world example. A company drills wild-cat oil
exploration wells, each with an estimated probability of
success of 0.1. What is the probability of having one success
for each successive well, that is what is the probability of a
single success after drilling 5 wells, after 6 wells, etc.?
>>> s = np.random.default_rng().negative_binomial(1, 0.1, 100000)
>>> for i in range(1, 11): # doctest: +SKIP
... probability = sum(s>> rng = np.random.default_rng()
>>> n, p = 10, .5 # number of trials, probability of each trial
>>> s = rng.binomial(n, p, 1000)
# result of flipping a coin 10 times, tested 1000 times.
A real world example. A company drills 9 wild-cat oil exploration
wells, each with an estimated probability of success of 0.1. All nine
wells fail. What is the probability of that happening?
Let's do 20,000 trials of the model, and count the number that
generate zero positive results.
>>> sum(rng.binomial(9, 0.1, 20000) == 0)/20000.
# answer = 0.38885, or 39%.
triangular(left, mode, right, size=None)
Draw samples from the triangular distribution over the
interval ``[left, right]``.
The triangular distribution is a continuous probability
distribution with lower limit left, peak at mode, and upper
limit right. Unlike the other distributions, these parameters
directly define the shape of the pdf.
Parameters
----------
left : float or array_like of floats
Lower limit.
mode : float or array_like of floats
The value where the peak of the distribution occurs.
The value must fulfill the condition ``left <= mode <= right``.
right : float or array_like of floats
Upper limit, must be larger than `left`.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``left``, ``mode``, and ``right``
are all scalars. Otherwise, ``np.broadcast(left, mode, right).size``
samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized triangular distribution.
Notes
-----
The probability density function for the triangular distribution is
.. math:: P(x;l, m, r) = \begin{cases}
\frac{2(x-l)}{(r-l)(m-l)}& \text{for $l \leq x \leq m$},\\
\frac{2(r-x)}{(r-l)(r-m)}& \text{for $m \leq x \leq r$},\\
0& \text{otherwise}.
\end{cases}
The triangular distribution is often used in ill-defined
problems where the underlying distribution is not known, but
some knowledge of the limits and mode exists. Often it is used
in simulations.
References
----------
.. [1] Wikipedia, "Triangular distribution"
https://en.wikipedia.org/wiki/Triangular_distribution
Examples
--------
Draw values from the distribution and plot the histogram:
>>> import matplotlib.pyplot as plt
>>> h = plt.hist(np.random.default_rng().triangular(-3, 0, 8, 100000), bins=200,
... density=True)
>>> plt.show()
wald(mean, scale, size=None)
Draw samples from a Wald, or inverse Gaussian, distribution.
As the scale approaches infinity, the distribution becomes more like a
Gaussian. Some references claim that the Wald is an inverse Gaussian
with mean equal to 1, but this is by no means universal.
The inverse Gaussian distribution was first studied in relationship to
Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian
because there is an inverse relationship between the time to cover a
unit distance and distance covered in unit time.
Parameters
----------
mean : float or array_like of floats
Distribution mean, must be > 0.
scale : float or array_like of floats
Scale parameter, must be > 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``mean`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Wald distribution.
Notes
-----
The probability density function for the Wald distribution is
.. math:: P(x;mean,scale) = \sqrt{\frac{scale}{2\pi x^3}}e^
\frac{-scale(x-mean)^2}{2\cdotp mean^2x}
As noted above the inverse Gaussian distribution first arise
from attempts to model Brownian motion. It is also a
competitor to the Weibull for use in reliability modeling and
modeling stock returns and interest rate processes.
References
----------
.. [1] Brighton Webs Ltd., Wald Distribution,
https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp
.. [2] Chhikara, Raj S., and Folks, J. Leroy, "The Inverse Gaussian
Distribution: Theory : Methodology, and Applications", CRC Press,
1988.
.. [3] Wikipedia, "Inverse Gaussian distribution"
https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution
Examples
--------
Draw values from the distribution and plot the histogram:
>>> import matplotlib.pyplot as plt
>>> h = plt.hist(np.random.default_rng().wald(3, 2, 100000), bins=200, density=True)
>>> plt.show()
rayleigh(scale=1.0, size=None)
Draw samples from a Rayleigh distribution.
The :math:`\chi` and Weibull distributions are generalizations of the
Rayleigh.
Parameters
----------
scale : float or array_like of floats, optional
Scale, also equals the mode. Must be non-negative. Default is 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``scale`` is a scalar. Otherwise,
``np.array(scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Rayleigh distribution.
Notes
-----
The probability density function for the Rayleigh distribution is
.. math:: P(x;scale) = \frac{x}{scale^2}e^{\frac{-x^2}{2 \cdotp scale^2}}
The Rayleigh distribution would arise, for example, if the East
and North components of the wind velocity had identical zero-mean
Gaussian distributions. Then the wind speed would have a Rayleigh
distribution.
References
----------
.. [1] Brighton Webs Ltd., "Rayleigh Distribution,"
https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp
.. [2] Wikipedia, "Rayleigh distribution"
https://en.wikipedia.org/wiki/Rayleigh_distribution
Examples
--------
Draw values from the distribution and plot the histogram
>>> from matplotlib.pyplot import hist
>>> rng = np.random.default_rng()
>>> values = hist(rng.rayleigh(3, 100000), bins=200, density=True)
Wave heights tend to follow a Rayleigh distribution. If the mean wave
height is 1 meter, what fraction of waves are likely to be larger than 3
meters?
>>> meanvalue = 1
>>> modevalue = np.sqrt(2 / np.pi) * meanvalue
>>> s = rng.rayleigh(modevalue, 1000000)
The percentage of waves larger than 3 meters is:
>>> 100.*sum(s>3)/1000000.
0.087300000000000003 # random
lognormal(mean=0.0, sigma=1.0, size=None)
Draw samples from a log-normal distribution.
Draw samples from a log-normal distribution with specified mean,
standard deviation, and array shape. Note that the mean and standard
deviation are not the values for the distribution itself, but of the
underlying normal distribution it is derived from.
Parameters
----------
mean : float or array_like of floats, optional
Mean value of the underlying normal distribution. Default is 0.
sigma : float or array_like of floats, optional
Standard deviation of the underlying normal distribution. Must be
non-negative. Default is 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``mean`` and ``sigma`` are both scalars.
Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized log-normal distribution.
See Also
--------
scipy.stats.lognorm : probability density function, distribution,
cumulative density function, etc.
Notes
-----
A variable `x` has a log-normal distribution if `log(x)` is normally
distributed. The probability density function for the log-normal
distribution is:
.. math:: p(x) = \frac{1}{\sigma x \sqrt{2\pi}}
e^{(-\frac{(ln(x)-\mu)^2}{2\sigma^2})}
where :math:`\mu` is the mean and :math:`\sigma` is the standard
deviation of the normally distributed logarithm of the variable.
A log-normal distribution results if a random variable is the *product*
of a large number of independent, identically-distributed variables in
the same way that a normal distribution results if the variable is the
*sum* of a large number of independent, identically-distributed
variables.
References
----------
.. [1] Limpert, E., Stahel, W. A., and Abbt, M., "Log-normal
Distributions across the Sciences: Keys and Clues,"
BioScience, Vol. 51, No. 5, May, 2001.
https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf
.. [2] Reiss, R.D. and Thomas, M., "Statistical Analysis of Extreme
Values," Basel: Birkhauser Verlag, 2001, pp. 31-32.
Examples
--------
Draw samples from the distribution:
>>> rng = np.random.default_rng()
>>> mu, sigma = 3., 1. # mean and standard deviation
>>> s = rng.lognormal(mu, sigma, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')
>>> x = np.linspace(min(bins), max(bins), 10000)
>>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))
... / (x * sigma * np.sqrt(2 * np.pi)))
>>> plt.plot(x, pdf, linewidth=2, color='r')
>>> plt.axis('tight')
>>> plt.show()
Demonstrate that taking the products of random samples from a uniform
distribution can be fit well by a log-normal probability density
function.
>>> # Generate a thousand samples: each is the product of 100 random
>>> # values, drawn from a normal distribution.
>>> rng = rng
>>> b = []
>>> for i in range(1000):
... a = 10. + rng.standard_normal(100)
... b.append(np.prod(a))
>>> b = np.array(b) / np.min(b) # scale values to be positive
>>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')
>>> sigma = np.std(np.log(b))
>>> mu = np.mean(np.log(b))
>>> x = np.linspace(min(bins), max(bins), 10000)
>>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))
... / (x * sigma * np.sqrt(2 * np.pi)))
>>> plt.plot(x, pdf, color='r', linewidth=2)
>>> plt.show()
logistic(loc=0.0, scale=1.0, size=None)
Draw samples from a logistic distribution.
Samples are drawn from a logistic distribution with specified
parameters, loc (location or mean, also median), and scale (>0).
Parameters
----------
loc : float or array_like of floats, optional
Parameter of the distribution. Default is 0.
scale : float or array_like of floats, optional
Parameter of the distribution. Must be non-negative.
Default is 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``loc`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized logistic distribution.
See Also
--------
scipy.stats.logistic : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Logistic distribution is
.. math:: P(x) = P(x) = \frac{e^{-(x-\mu)/s}}{s(1+e^{-(x-\mu)/s})^2},
where :math:`\mu` = location and :math:`s` = scale.
The Logistic distribution is used in Extreme Value problems where it
can act as a mixture of Gumbel distributions, in Epidemiology, and by
the World Chess Federation (FIDE) where it is used in the Elo ranking
system, assuming the performance of each player is a logistically
distributed random variable.
References
----------
.. [1] Reiss, R.-D. and Thomas M. (2001), "Statistical Analysis of
Extreme Values, from Insurance, Finance, Hydrology and Other
Fields," Birkhauser Verlag, Basel, pp 132-133.
.. [2] Weisstein, Eric W. "Logistic Distribution." From
MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/LogisticDistribution.html
.. [3] Wikipedia, "Logistic-distribution",
https://en.wikipedia.org/wiki/Logistic_distribution
Examples
--------
Draw samples from the distribution:
>>> loc, scale = 10, 1
>>> s = np.random.default_rng().logistic(loc, scale, 10000)
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, bins=50)
# plot against distribution
>>> def logist(x, loc, scale):
... return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)
>>> lgst_val = logist(bins, loc, scale)
>>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())
>>> plt.show()
gumbel(loc=0.0, scale=1.0, size=None)
Draw samples from a Gumbel distribution.
Draw samples from a Gumbel distribution with specified location and
scale. For more information on the Gumbel distribution, see
Notes and References below.
Parameters
----------
loc : float or array_like of floats, optional
The location of the mode of the distribution. Default is 0.
scale : float or array_like of floats, optional
The scale parameter of the distribution. Default is 1. Must be non-
negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``loc`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Gumbel distribution.
See Also
--------
scipy.stats.gumbel_l
scipy.stats.gumbel_r
scipy.stats.genextreme
weibull
Notes
-----
The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme
Value Type I) distribution is one of a class of Generalized Extreme
Value (GEV) distributions used in modeling extreme value problems.
The Gumbel is a special case of the Extreme Value Type I distribution
for maximums from distributions with "exponential-like" tails.
The probability density for the Gumbel distribution is
.. math:: p(x) = \frac{e^{-(x - \mu)/ \beta}}{\beta} e^{ -e^{-(x - \mu)/
\beta}},
where :math:`\mu` is the mode, a location parameter, and
:math:`\beta` is the scale parameter.
The Gumbel (named for German mathematician Emil Julius Gumbel) was used
very early in the hydrology literature, for modeling the occurrence of
flood events. It is also used for modeling maximum wind speed and
rainfall rates. It is a "fat-tailed" distribution - the probability of
an event in the tail of the distribution is larger than if one used a
Gaussian, hence the surprisingly frequent occurrence of 100-year
floods. Floods were initially modeled as a Gaussian process, which
underestimated the frequency of extreme events.
It is one of a class of extreme value distributions, the Generalized
Extreme Value (GEV) distributions, which also includes the Weibull and
Frechet.
The function has a mean of :math:`\mu + 0.57721\beta` and a variance
of :math:`\frac{\pi^2}{6}\beta^2`.
References
----------
.. [1] Gumbel, E. J., "Statistics of Extremes,"
New York: Columbia University Press, 1958.
.. [2] Reiss, R.-D. and Thomas, M., "Statistical Analysis of Extreme
Values from Insurance, Finance, Hydrology and Other Fields,"
Basel: Birkhauser Verlag, 2001.
Examples
--------
Draw samples from the distribution:
>>> rng = np.random.default_rng()
>>> mu, beta = 0, 0.1 # location and scale
>>> s = rng.gumbel(mu, beta, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 30, density=True)
>>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)
... * np.exp( -np.exp( -(bins - mu) /beta) ),
... linewidth=2, color='r')
>>> plt.show()
Show how an extreme value distribution can arise from a Gaussian process
and compare to a Gaussian:
>>> means = []
>>> maxima = []
>>> for i in range(0,1000) :
... a = rng.normal(mu, beta, 1000)
... means.append(a.mean())
... maxima.append(a.max())
>>> count, bins, ignored = plt.hist(maxima, 30, density=True)
>>> beta = np.std(maxima) * np.sqrt(6) / np.pi
>>> mu = np.mean(maxima) - 0.57721*beta
>>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)
... * np.exp(-np.exp(-(bins - mu)/beta)),
... linewidth=2, color='r')
>>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))
... * np.exp(-(bins - mu)**2 / (2 * beta**2)),
... linewidth=2, color='g')
>>> plt.show()
laplace(loc=0.0, scale=1.0, size=None)
Draw samples from the Laplace or double exponential distribution with
specified location (or mean) and scale (decay).
The Laplace distribution is similar to the Gaussian/normal distribution,
but is sharper at the peak and has fatter tails. It represents the
difference between two independent, identically distributed exponential
random variables.
Parameters
----------
loc : float or array_like of floats, optional
The position, :math:`\mu`, of the distribution peak. Default is 0.
scale : float or array_like of floats, optional
:math:`\lambda`, the exponential decay. Default is 1. Must be non-
negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``loc`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Laplace distribution.
Notes
-----
It has the probability density function
.. math:: f(x; \mu, \lambda) = \frac{1}{2\lambda}
\exp\left(-\frac{|x - \mu|}{\lambda}\right).
The first law of Laplace, from 1774, states that the frequency
of an error can be expressed as an exponential function of the
absolute magnitude of the error, which leads to the Laplace
distribution. For many problems in economics and health
sciences, this distribution seems to model the data better
than the standard Gaussian distribution.
References
----------
.. [1] Abramowitz, M. and Stegun, I. A. (Eds.). "Handbook of
Mathematical Functions with Formulas, Graphs, and Mathematical
Tables, 9th printing," New York: Dover, 1972.
.. [2] Kotz, Samuel, et. al. "The Laplace Distribution and
Generalizations, " Birkhauser, 2001.
.. [3] Weisstein, Eric W. "Laplace Distribution."
From MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/LaplaceDistribution.html
.. [4] Wikipedia, "Laplace distribution",
https://en.wikipedia.org/wiki/Laplace_distribution
Examples
--------
Draw samples from the distribution
>>> loc, scale = 0., 1.
>>> s = np.random.default_rng().laplace(loc, scale, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 30, density=True)
>>> x = np.arange(-8., 8., .01)
>>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)
>>> plt.plot(x, pdf)
Plot Gaussian for comparison:
>>> g = (1/(scale * np.sqrt(2 * np.pi)) *
... np.exp(-(x - loc)**2 / (2 * scale**2)))
>>> plt.plot(x,g)
power(a, size=None)
Draws samples in [0, 1] from a power distribution with positive
exponent a - 1.
Also known as the power function distribution.
Parameters
----------
a : float or array_like of floats
Parameter of the distribution. Must be non-negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``a`` is a scalar. Otherwise,
``np.array(a).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized power distribution.
Raises
------
ValueError
If a <= 0.
Notes
-----
The probability density function is
.. math:: P(x; a) = ax^{a-1}, 0 \le x \le 1, a>0.
The power function distribution is just the inverse of the Pareto
distribution. It may also be seen as a special case of the Beta
distribution.
It is used, for example, in modeling the over-reporting of insurance
claims.
References
----------
.. [1] Christian Kleiber, Samuel Kotz, "Statistical size distributions
in economics and actuarial sciences", Wiley, 2003.
.. [2] Heckert, N. A. and Filliben, James J. "NIST Handbook 148:
Dataplot Reference Manual, Volume 2: Let Subcommands and Library
Functions", National Institute of Standards and Technology
Handbook Series, June 2003.
https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf
Examples
--------
Draw samples from the distribution:
>>> rng = np.random.default_rng()
>>> a = 5. # shape
>>> samples = 1000
>>> s = rng.power(a, samples)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, bins=30)
>>> x = np.linspace(0, 1, 100)
>>> y = a*x**(a-1.)
>>> normed_y = samples*np.diff(bins)[0]*y
>>> plt.plot(x, normed_y)
>>> plt.show()
Compare the power function distribution to the inverse of the Pareto.
>>> from scipy import stats # doctest: +SKIP
>>> rvs = rng.power(5, 1000000)
>>> rvsp = rng.pareto(5, 1000000)
>>> xx = np.linspace(0,1,100)
>>> powpdf = stats.powerlaw.pdf(xx,5) # doctest: +SKIP
>>> plt.figure()
>>> plt.hist(rvs, bins=50, density=True)
>>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP
>>> plt.title('power(5)')
>>> plt.figure()
>>> plt.hist(1./(1.+rvsp), bins=50, density=True)
>>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP
>>> plt.title('inverse of 1 + Generator.pareto(5)')
>>> plt.figure()
>>> plt.hist(1./(1.+rvsp), bins=50, density=True)
>>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP
>>> plt.title('inverse of stats.pareto(5)')
weibull(a, size=None)
Draw samples from a Weibull distribution.
Draw samples from a 1-parameter Weibull distribution with the given
shape parameter `a`.
.. math:: X = (-ln(U))^{1/a}
Here, U is drawn from the uniform distribution over (0,1].
The more common 2-parameter Weibull, including a scale parameter
:math:`\lambda` is just :math:`X = \lambda(-ln(U))^{1/a}`.
Parameters
----------
a : float or array_like of floats
Shape parameter of the distribution. Must be nonnegative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``a`` is a scalar. Otherwise,
``np.array(a).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Weibull distribution.
See Also
--------
scipy.stats.weibull_max
scipy.stats.weibull_min
scipy.stats.genextreme
gumbel
Notes
-----
The Weibull (or Type III asymptotic extreme value distribution
for smallest values, SEV Type III, or Rosin-Rammler
distribution) is one of a class of Generalized Extreme Value
(GEV) distributions used in modeling extreme value problems.
This class includes the Gumbel and Frechet distributions.
The probability density for the Weibull distribution is
.. math:: p(x) = \frac{a}
{\lambda}(\frac{x}{\lambda})^{a-1}e^{-(x/\lambda)^a},
where :math:`a` is the shape and :math:`\lambda` the scale.
The function has its peak (the mode) at
:math:`\lambda(\frac{a-1}{a})^{1/a}`.
When ``a = 1``, the Weibull distribution reduces to the exponential
distribution.
References
----------
.. [1] Waloddi Weibull, Royal Technical University, Stockholm,
1939 "A Statistical Theory Of The Strength Of Materials",
Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,
Generalstabens Litografiska Anstalts Forlag, Stockholm.
.. [2] Waloddi Weibull, "A Statistical Distribution Function of
Wide Applicability", Journal Of Applied Mechanics ASME Paper
1951.
.. [3] Wikipedia, "Weibull distribution",
https://en.wikipedia.org/wiki/Weibull_distribution
Examples
--------
Draw samples from the distribution:
>>> rng = np.random.default_rng()
>>> a = 5. # shape
>>> s = rng.weibull(a, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> x = np.arange(1,100.)/50.
>>> def weib(x,n,a):
... return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)
>>> count, bins, ignored = plt.hist(rng.weibull(5.,1000))
>>> x = np.arange(1,100.)/50.
>>> scale = count.max()/weib(x, 1., 5.).max()
>>> plt.plot(x, weib(x, 1., 5.)*scale)
>>> plt.show()
pareto(a, size=None)
Draw samples from a Pareto II or Lomax distribution with
specified shape.
The Lomax or Pareto II distribution is a shifted Pareto
distribution. The classical Pareto distribution can be
obtained from the Lomax distribution by adding 1 and
multiplying by the scale parameter ``m`` (see Notes). The
smallest value of the Lomax distribution is zero while for the
classical Pareto distribution it is ``mu``, where the standard
Pareto distribution has location ``mu = 1``. Lomax can also
be considered as a simplified version of the Generalized
Pareto distribution (available in SciPy), with the scale set
to one and the location set to zero.
The Pareto distribution must be greater than zero, and is
unbounded above. It is also known as the "80-20 rule". In
this distribution, 80 percent of the weights are in the lowest
20 percent of the range, while the other 20 percent fill the
remaining 80 percent of the range.
Parameters
----------
a : float or array_like of floats
Shape of the distribution. Must be positive.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``a`` is a scalar. Otherwise,
``np.array(a).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Pareto distribution.
See Also
--------
scipy.stats.lomax : probability density function, distribution or
cumulative density function, etc.
scipy.stats.genpareto : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Pareto distribution is
.. math:: p(x) = \frac{am^a}{x^{a+1}}
where :math:`a` is the shape and :math:`m` the scale.
The Pareto distribution, named after the Italian economist
Vilfredo Pareto, is a power law probability distribution
useful in many real world problems. Outside the field of
economics it is generally referred to as the Bradford
distribution. Pareto developed the distribution to describe
the distribution of wealth in an economy. It has also found
use in insurance, web page access statistics, oil field sizes,
and many other problems, including the download frequency for
projects in Sourceforge [1]_. It is one of the so-called
"fat-tailed" distributions.
References
----------
.. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of
Sourceforge projects.
.. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.
.. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme
Values, Birkhauser Verlag, Basel, pp 23-30.
.. [4] Wikipedia, "Pareto distribution",
https://en.wikipedia.org/wiki/Pareto_distribution
Examples
--------
Draw samples from the distribution:
>>> a, m = 3., 2. # shape and mode
>>> s = (np.random.default_rng().pareto(a, 1000) + 1) * m
Display the histogram of the samples, along with the probability
density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, _ = plt.hist(s, 100, density=True)
>>> fit = a*m**a / bins**(a+1)
>>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')
>>> plt.show()
vonmises(mu, kappa, size=None)
Draw samples from a von Mises distribution.
Samples are drawn from a von Mises distribution with specified mode
(mu) and dispersion (kappa), on the interval [-pi, pi].
The von Mises distribution (also known as the circular normal
distribution) is a continuous probability distribution on the unit
circle. It may be thought of as the circular analogue of the normal
distribution.
Parameters
----------
mu : float or array_like of floats
Mode ("center") of the distribution.
kappa : float or array_like of floats
Dispersion of the distribution, has to be >=0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``mu`` and ``kappa`` are both scalars.
Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized von Mises distribution.
See Also
--------
scipy.stats.vonmises : probability density function, distribution, or
cumulative density function, etc.
Notes
-----
The probability density for the von Mises distribution is
.. math:: p(x) = \frac{e^{\kappa cos(x-\mu)}}{2\pi I_0(\kappa)},
where :math:`\mu` is the mode and :math:`\kappa` the dispersion,
and :math:`I_0(\kappa)` is the modified Bessel function of order 0.
The von Mises is named for Richard Edler von Mises, who was born in
Austria-Hungary, in what is now the Ukraine. He fled to the United
States in 1939 and became a professor at Harvard. He worked in
probability theory, aerodynamics, fluid mechanics, and philosophy of
science.
References
----------
.. [1] Abramowitz, M. and Stegun, I. A. (Eds.). "Handbook of
Mathematical Functions with Formulas, Graphs, and Mathematical
Tables, 9th printing," New York: Dover, 1972.
.. [2] von Mises, R., "Mathematical Theory of Probability
and Statistics", New York: Academic Press, 1964.
Examples
--------
Draw samples from the distribution:
>>> mu, kappa = 0.0, 4.0 # mean and dispersion
>>> s = np.random.default_rng().vonmises(mu, kappa, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> from scipy.special import i0 # doctest: +SKIP
>>> plt.hist(s, 50, density=True)
>>> x = np.linspace(-np.pi, np.pi, num=51)
>>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa)) # doctest: +SKIP
>>> plt.plot(x, y, linewidth=2, color='r') # doctest: +SKIP
>>> plt.show()
standard_t(df, size=None)
Draw samples from a standard Student's t distribution with `df` degrees
of freedom.
A special case of the hyperbolic distribution. As `df` gets
large, the result resembles that of the standard normal
distribution (`standard_normal`).
Parameters
----------
df : float or array_like of floats
Degrees of freedom, must be > 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``df`` is a scalar. Otherwise,
``np.array(df).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized standard Student's t distribution.
Notes
-----
The probability density function for the t distribution is
.. math:: P(x, df) = \frac{\Gamma(\frac{df+1}{2})}{\sqrt{\pi df}
\Gamma(\frac{df}{2})}\Bigl( 1+\frac{x^2}{df} \Bigr)^{-(df+1)/2}
The t test is based on an assumption that the data come from a
Normal distribution. The t test provides a way to test whether
the sample mean (that is the mean calculated from the data) is
a good estimate of the true mean.
The derivation of the t-distribution was first published in
1908 by William Gosset while working for the Guinness Brewery
in Dublin. Due to proprietary issues, he had to publish under
a pseudonym, and so he used the name Student.
References
----------
.. [1] Dalgaard, Peter, "Introductory Statistics With R",
Springer, 2002.
.. [2] Wikipedia, "Student's t-distribution"
https://en.wikipedia.org/wiki/Student's_t-distribution
Examples
--------
From Dalgaard page 83 [1]_, suppose the daily energy intake for 11
women in kilojoules (kJ) is:
>>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \
... 7515, 8230, 8770])
Does their energy intake deviate systematically from the recommended
value of 7725 kJ? Our null hypothesis will be the absence of deviation,
and the alternate hypothesis will be the presence of an effect that could be
either positive or negative, hence making our test 2-tailed.
Because we are estimating the mean and we have N=11 values in our sample,
we have N-1=10 degrees of freedom. We set our significance level to 95% and
compute the t statistic using the empirical mean and empirical standard
deviation of our intake. We use a ddof of 1 to base the computation of our
empirical standard deviation on an unbiased estimate of the variance (note:
the final estimate is not unbiased due to the concave nature of the square
root).
>>> np.mean(intake)
6753.636363636364
>>> intake.std(ddof=1)
1142.1232221373727
>>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))
>>> t
-2.8207540608310198
We draw 1000000 samples from Student's t distribution with the adequate
degrees of freedom.
>>> import matplotlib.pyplot as plt
>>> s = np.random.default_rng().standard_t(10, size=1000000)
>>> h = plt.hist(s, bins=100, density=True)
Does our t statistic land in one of the two critical regions found at
both tails of the distribution?
>>> np.sum(np.abs(t) < np.abs(s)) / float(len(s))
0.018318 #random < 0.05, statistic is in critical region
The probability value for this 2-tailed test is about 1.83%, which is
lower than the 5% pre-determined significance threshold.
Therefore, the probability of observing values as extreme as our intake
conditionally on the null hypothesis being true is too low, and we reject
the null hypothesis of no deviation.
standard_cauchy(size=None)
Draw samples from a standard Cauchy distribution with mode = 0.
Also known as the Lorentz distribution.
Parameters
----------
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
Returns
-------
samples : ndarray or scalar
The drawn samples.
Notes
-----
The probability density function for the full Cauchy distribution is
.. math:: P(x; x_0, \gamma) = \frac{1}{\pi \gamma \bigl[ 1+
(\frac{x-x_0}{\gamma})^2 \bigr] }
and the Standard Cauchy distribution just sets :math:`x_0=0` and
:math:`\gamma=1`
The Cauchy distribution arises in the solution to the driven harmonic
oscillator problem, and also describes spectral line broadening. It
also describes the distribution of values at which a line tilted at
a random angle will cut the x axis.
When studying hypothesis tests that assume normality, seeing how the
tests perform on data from a Cauchy distribution is a good indicator of
their sensitivity to a heavy-tailed distribution, since the Cauchy looks
very much like a Gaussian distribution, but with heavier tails.
References
----------
.. [1] NIST/SEMATECH e-Handbook of Statistical Methods, "Cauchy
Distribution",
https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm
.. [2] Weisstein, Eric W. "Cauchy Distribution." From MathWorld--A
Wolfram Web Resource.
http://mathworld.wolfram.com/CauchyDistribution.html
.. [3] Wikipedia, "Cauchy distribution"
https://en.wikipedia.org/wiki/Cauchy_distribution
Examples
--------
Draw samples and plot the distribution:
>>> import matplotlib.pyplot as plt
>>> s = np.random.default_rng().standard_cauchy(1000000)
>>> s = s[(s>-25) & (s<25)] # truncate distribution so it plots well
>>> plt.hist(s, bins=100)
>>> plt.show()
noncentral_chisquare(df, nonc, size=None)
Draw samples from a noncentral chi-square distribution.
The noncentral :math:`\chi^2` distribution is a generalization of
the :math:`\chi^2` distribution.
Parameters
----------
df : float or array_like of floats
Degrees of freedom, must be > 0.
.. versionchanged:: 1.10.0
Earlier NumPy versions required dfnum > 1.
nonc : float or array_like of floats
Non-centrality, must be non-negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``df`` and ``nonc`` are both scalars.
Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized noncentral chi-square distribution.
Notes
-----
The probability density function for the noncentral Chi-square
distribution is
.. math:: P(x;df,nonc) = \sum^{\infty}_{i=0}
\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}
P_{Y_{df+2i}}(x),
where :math:`Y_{q}` is the Chi-square with q degrees of freedom.
References
----------
.. [1] Wikipedia, "Noncentral chi-squared distribution"
https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution
Examples
--------
Draw values from the distribution and plot the histogram
>>> rng = np.random.default_rng()
>>> import matplotlib.pyplot as plt
>>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),
... bins=200, density=True)
>>> plt.show()
Draw values from a noncentral chisquare with very small noncentrality,
and compare to a chisquare.
>>> plt.figure()
>>> values = plt.hist(rng.noncentral_chisquare(3, .0000001, 100000),
... bins=np.arange(0., 25, .1), density=True)
>>> values2 = plt.hist(rng.chisquare(3, 100000),
... bins=np.arange(0., 25, .1), density=True)
>>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')
>>> plt.show()
Demonstrate how large values of non-centrality lead to a more symmetric
distribution.
>>> plt.figure()
>>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),
... bins=200, density=True)
>>> plt.show()
chisquare(df, size=None)
Draw samples from a chi-square distribution.
When `df` independent random variables, each with standard normal
distributions (mean 0, variance 1), are squared and summed, the
resulting distribution is chi-square (see Notes). This distribution
is often used in hypothesis testing.
Parameters
----------
df : float or array_like of floats
Number of degrees of freedom, must be > 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``df`` is a scalar. Otherwise,
``np.array(df).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized chi-square distribution.
Raises
------
ValueError
When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)
is given.
Notes
-----
The variable obtained by summing the squares of `df` independent,
standard normally distributed random variables:
.. math:: Q = \sum_{i=0}^{\mathtt{df}} X^2_i
is chi-square distributed, denoted
.. math:: Q \sim \chi^2_k.
The probability density function of the chi-squared distribution is
.. math:: p(x) = \frac{(1/2)^{k/2}}{\Gamma(k/2)}
x^{k/2 - 1} e^{-x/2},
where :math:`\Gamma` is the gamma function,
.. math:: \Gamma(x) = \int_0^{-\infty} t^{x - 1} e^{-t} dt.
References
----------
.. [1] NIST "Engineering Statistics Handbook"
https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
Examples
--------
>>> np.random.default_rng().chisquare(2,4)
array([ 1.89920014, 9.00867716, 3.13710533, 5.62318272]) # random
noncentral_f(dfnum, dfden, nonc, size=None)
Draw samples from the noncentral F distribution.
Samples are drawn from an F distribution with specified parameters,
`dfnum` (degrees of freedom in numerator) and `dfden` (degrees of
freedom in denominator), where both parameters > 1.
`nonc` is the non-centrality parameter.
Parameters
----------
dfnum : float or array_like of floats
Numerator degrees of freedom, must be > 0.
.. versionchanged:: 1.14.0
Earlier NumPy versions required dfnum > 1.
dfden : float or array_like of floats
Denominator degrees of freedom, must be > 0.
nonc : float or array_like of floats
Non-centrality parameter, the sum of the squares of the numerator
means, must be >= 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``dfnum``, ``dfden``, and ``nonc``
are all scalars. Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``
samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized noncentral Fisher distribution.
Notes
-----
When calculating the power of an experiment (power = probability of
rejecting the null hypothesis when a specific alternative is true) the
non-central F statistic becomes important. When the null hypothesis is
true, the F statistic follows a central F distribution. When the null
hypothesis is not true, then it follows a non-central F statistic.
References
----------
.. [1] Weisstein, Eric W. "Noncentral F-Distribution."
From MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/NoncentralF-Distribution.html
.. [2] Wikipedia, "Noncentral F-distribution",
https://en.wikipedia.org/wiki/Noncentral_F-distribution
Examples
--------
In a study, testing for a specific alternative to the null hypothesis
requires use of the Noncentral F distribution. We need to calculate the
area in the tail of the distribution that exceeds the value of the F
distribution for the null hypothesis. We'll plot the two probability
distributions for comparison.
>>> rng = np.random.default_rng()
>>> dfnum = 3 # between group deg of freedom
>>> dfden = 20 # within groups degrees of freedom
>>> nonc = 3.0
>>> nc_vals = rng.noncentral_f(dfnum, dfden, nonc, 1000000)
>>> NF = np.histogram(nc_vals, bins=50, density=True)
>>> c_vals = rng.f(dfnum, dfden, 1000000)
>>> F = np.histogram(c_vals, bins=50, density=True)
>>> import matplotlib.pyplot as plt
>>> plt.plot(F[1][1:], F[0])
>>> plt.plot(NF[1][1:], NF[0])
>>> plt.show()
f(dfnum, dfden, size=None)
Draw samples from an F distribution.
Samples are drawn from an F distribution with specified parameters,
`dfnum` (degrees of freedom in numerator) and `dfden` (degrees of
freedom in denominator), where both parameters must be greater than
zero.
The random variate of the F distribution (also known as the
Fisher distribution) is a continuous probability distribution
that arises in ANOVA tests, and is the ratio of two chi-square
variates.
Parameters
----------
dfnum : float or array_like of floats
Degrees of freedom in numerator, must be > 0.
dfden : float or array_like of float
Degrees of freedom in denominator, must be > 0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``dfnum`` and ``dfden`` are both scalars.
Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized Fisher distribution.
See Also
--------
scipy.stats.f : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The F statistic is used to compare in-group variances to between-group
variances. Calculating the distribution depends on the sampling, and
so it is a function of the respective degrees of freedom in the
problem. The variable `dfnum` is the number of samples minus one, the
between-groups degrees of freedom, while `dfden` is the within-groups
degrees of freedom, the sum of the number of samples in each group
minus the number of groups.
References
----------
.. [1] Glantz, Stanton A. "Primer of Biostatistics.", McGraw-Hill,
Fifth Edition, 2002.
.. [2] Wikipedia, "F-distribution",
https://en.wikipedia.org/wiki/F-distribution
Examples
--------
An example from Glantz[1], pp 47-40:
Two groups, children of diabetics (25 people) and children from people
without diabetes (25 controls). Fasting blood glucose was measured,
case group had a mean value of 86.1, controls had a mean value of
82.2. Standard deviations were 2.09 and 2.49 respectively. Are these
data consistent with the null hypothesis that the parents diabetic
status does not affect their children's blood glucose levels?
Calculating the F statistic from the data gives a value of 36.01.
Draw samples from the distribution:
>>> dfnum = 1. # between group degrees of freedom
>>> dfden = 48. # within groups degrees of freedom
>>> s = np.random.default_rng().f(dfnum, dfden, 1000)
The lower bound for the top 1% of the samples is :
>>> np.sort(s)[-10]
7.61988120985 # random
So there is about a 1% chance that the F statistic will exceed 7.62,
the measured value is 36, so the null hypothesis is rejected at the 1%
level.
gamma(shape, scale=1.0, size=None)
Draw samples from a Gamma distribution.
Samples are drawn from a Gamma distribution with specified parameters,
`shape` (sometimes designated "k") and `scale` (sometimes designated
"theta"), where both parameters are > 0.
Parameters
----------
shape : float or array_like of floats
The shape of the gamma distribution. Must be non-negative.
scale : float or array_like of floats, optional
The scale of the gamma distribution. Must be non-negative.
Default is equal to 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``shape`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized gamma distribution.
See Also
--------
scipy.stats.gamma : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Gamma distribution is
.. math:: p(x) = x^{k-1}\frac{e^{-x/\theta}}{\theta^k\Gamma(k)},
where :math:`k` is the shape and :math:`\theta` the scale,
and :math:`\Gamma` is the Gamma function.
The Gamma distribution is often used to model the times to failure of
electronic components, and arises naturally in processes for which the
waiting times between Poisson distributed events are relevant.
References
----------
.. [1] Weisstein, Eric W. "Gamma Distribution." From MathWorld--A
Wolfram Web Resource.
http://mathworld.wolfram.com/GammaDistribution.html
.. [2] Wikipedia, "Gamma distribution",
https://en.wikipedia.org/wiki/Gamma_distribution
Examples
--------
Draw samples from the distribution:
>>> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)
>>> s = np.random.default_rng().gamma(shape, scale, 1000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> import scipy.special as sps # doctest: +SKIP
>>> count, bins, ignored = plt.hist(s, 50, density=True)
>>> y = bins**(shape-1)*(np.exp(-bins/scale) / # doctest: +SKIP
... (sps.gamma(shape)*scale**shape))
>>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP
>>> plt.show()
standard_gamma(shape, size=None, dtype=np.float64, out=None)
Draw samples from a standard Gamma distribution.
Samples are drawn from a Gamma distribution with specified parameters,
shape (sometimes designated "k") and scale=1.
Parameters
----------
shape : float or array_like of floats
Parameter, must be non-negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``shape`` is a scalar. Otherwise,
``np.array(shape).size`` samples are drawn.
dtype : dtype, optional
Desired dtype of the result, only `float64` and `float32` are supported.
Byteorder must be native. The default value is np.float64.
out : ndarray, optional
Alternative output array in which to place the result. If size is
not None, it must have the same shape as the provided size and
must match the type of the output values.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized standard gamma distribution.
See Also
--------
scipy.stats.gamma : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Gamma distribution is
.. math:: p(x) = x^{k-1}\frac{e^{-x/\theta}}{\theta^k\Gamma(k)},
where :math:`k` is the shape and :math:`\theta` the scale,
and :math:`\Gamma` is the Gamma function.
The Gamma distribution is often used to model the times to failure of
electronic components, and arises naturally in processes for which the
waiting times between Poisson distributed events are relevant.
References
----------
.. [1] Weisstein, Eric W. "Gamma Distribution." From MathWorld--A
Wolfram Web Resource.
http://mathworld.wolfram.com/GammaDistribution.html
.. [2] Wikipedia, "Gamma distribution",
https://en.wikipedia.org/wiki/Gamma_distribution
Examples
--------
Draw samples from the distribution:
>>> shape, scale = 2., 1. # mean and width
>>> s = np.random.default_rng().standard_gamma(shape, 1000000)
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> import scipy.special as sps # doctest: +SKIP
>>> count, bins, ignored = plt.hist(s, 50, density=True)
>>> y = bins**(shape-1) * ((np.exp(-bins/scale))/ # doctest: +SKIP
... (sps.gamma(shape) * scale**shape))
>>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP
>>> plt.show()
normal(loc=0.0, scale=1.0, size=None)
Draw random samples from a normal (Gaussian) distribution.
The probability density function of the normal distribution, first
derived by De Moivre and 200 years later by both Gauss and Laplace
independently [2]_, is often called the bell curve because of
its characteristic shape (see the example below).
The normal distributions occurs often in nature. For example, it
describes the commonly occurring distribution of samples influenced
by a large number of tiny, random disturbances, each with its own
unique distribution [2]_.
Parameters
----------
loc : float or array_like of floats
Mean ("centre") of the distribution.
scale : float or array_like of floats
Standard deviation (spread or "width") of the distribution. Must be
non-negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``loc`` and ``scale`` are both scalars.
Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized normal distribution.
See Also
--------
scipy.stats.norm : probability density function, distribution or
cumulative density function, etc.
Notes
-----
The probability density for the Gaussian distribution is
.. math:: p(x) = \frac{1}{\sqrt{ 2 \pi \sigma^2 }}
e^{ - \frac{ (x - \mu)^2 } {2 \sigma^2} },
where :math:`\mu` is the mean and :math:`\sigma` the standard
deviation. The square of the standard deviation, :math:`\sigma^2`,
is called the variance.
The function has its peak at the mean, and its "spread" increases with
the standard deviation (the function reaches 0.607 times its maximum at
:math:`x + \sigma` and :math:`x - \sigma` [2]_). This implies that
:meth:`normal` is more likely to return samples lying close to the
mean, rather than those far away.
References
----------
.. [1] Wikipedia, "Normal distribution",
https://en.wikipedia.org/wiki/Normal_distribution
.. [2] P. R. Peebles Jr., "Central Limit Theorem" in "Probability,
Random Variables and Random Signal Principles", 4th ed., 2001,
pp. 51, 51, 125.
Examples
--------
Draw samples from the distribution:
>>> mu, sigma = 0, 0.1 # mean and standard deviation
>>> s = np.random.default_rng().normal(mu, sigma, 1000)
Verify the mean and the variance:
>>> abs(mu - np.mean(s))
0.0 # may vary
>>> abs(sigma - np.std(s, ddof=1))
0.0 # may vary
Display the histogram of the samples, along with
the probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 30, density=True)
>>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *
... np.exp( - (bins - mu)**2 / (2 * sigma**2) ),
... linewidth=2, color='r')
>>> plt.show()
Two-by-four array of samples from the normal distribution with
mean 3 and standard deviation 2.5:
>>> np.random.default_rng().normal(3, 2.5, size=(2, 4))
array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random
[ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random
standard_normal(size=None, dtype=np.float64, out=None)
Draw samples from a standard Normal distribution (mean=0, stdev=1).
Parameters
----------
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
dtype : dtype, optional
Desired dtype of the result, only `float64` and `float32` are supported.
Byteorder must be native. The default value is np.float64.
out : ndarray, optional
Alternative output array in which to place the result. If size is not None,
it must have the same shape as the provided size and must match the type of
the output values.
Returns
-------
out : float or ndarray
A floating-point array of shape ``size`` of drawn samples, or a
single sample if ``size`` was not specified.
See Also
--------
normal :
Equivalent function with additional ``loc`` and ``scale`` arguments
for setting the mean and standard deviation.
Notes
-----
For random samples from the normal distribution with mean ``mu`` and
standard deviation ``sigma``, use one of::
mu + sigma * rng.standard_normal(size=...)
rng.normal(mu, sigma, size=...)
Examples
--------
>>> rng = np.random.default_rng()
>>> rng.standard_normal()
2.1923875335537315 # random
>>> s = rng.standard_normal(8000)
>>> s
array([ 0.6888893 , 0.78096262, -0.89086505, ..., 0.49876311, # random
-0.38672696, -0.4685006 ]) # random
>>> s.shape
(8000,)
>>> s = rng.standard_normal(size=(3, 4, 2))
>>> s.shape
(3, 4, 2)
Two-by-four array of samples from the normal distribution with
mean 3 and standard deviation 2.5:
>>> 3 + 2.5 * rng.standard_normal(size=(2, 4))
array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random
[ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random
uniform(low=0.0, high=1.0, size=None)
Draw samples from a uniform distribution.
Samples are uniformly distributed over the half-open interval
``[low, high)`` (includes low, but excludes high). In other words,
any value within the given interval is equally likely to be drawn
by `uniform`.
Parameters
----------
low : float or array_like of floats, optional
Lower boundary of the output interval. All values generated will be
greater than or equal to low. The default value is 0.
high : float or array_like of floats
Upper boundary of the output interval. All values generated will be
less than high. The high limit may be included in the returned array of
floats due to floating-point rounding in the equation
``low + (high-low) * random_sample()``. high - low must be
non-negative. The default value is 1.0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``low`` and ``high`` are both scalars.
Otherwise, ``np.broadcast(low, high).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized uniform distribution.
See Also
--------
integers : Discrete uniform distribution, yielding integers.
random : Floats uniformly distributed over ``[0, 1)``.
Notes
-----
The probability density function of the uniform distribution is
.. math:: p(x) = \frac{1}{b - a}
anywhere within the interval ``[a, b)``, and zero elsewhere.
When ``high`` == ``low``, values of ``low`` will be returned.
Examples
--------
Draw samples from the distribution:
>>> s = np.random.default_rng().uniform(-1,0,1000)
All values are within the given interval:
>>> np.all(s >= -1)
True
>>> np.all(s < 0)
True
Display the histogram of the samples, along with the
probability density function:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(s, 15, density=True)
>>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')
>>> plt.show()
choice(a, size=None, replace=True, p=None, axis=0, shuffle=True)
Generates a random sample from a given array
Parameters
----------
a : {array_like, int}
If an ndarray, a random sample is generated from its elements.
If an int, the random sample is generated from np.arange(a).
size : {int, tuple[int]}, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn from the 1-d `a`. If `a` has more
than one dimension, the `size` shape will be inserted into the
`axis` dimension, so the output ``ndim`` will be ``a.ndim - 1 +
len(size)``. Default is None, in which case a single value is
returned.
replace : bool, optional
Whether the sample is with or without replacement. Default is True,
meaning that a value of ``a`` can be selected multiple times.
p : 1-D array_like, optional
The probabilities associated with each entry in a.
If not given, the sample assumes a uniform distribution over all
entries in ``a``.
axis : int, optional
The axis along which the selection is performed. The default, 0,
selects by row.
shuffle : bool, optional
Whether the sample is shuffled when sampling without replacement.
Default is True, False provides a speedup.
Returns
-------
samples : single item or ndarray
The generated random samples
Raises
------
ValueError
If a is an int and less than zero, if p is not 1-dimensional, if
a is array-like with a size 0, if p is not a vector of
probabilities, if a and p have different lengths, or if
replace=False and the sample size is greater than the population
size.
See Also
--------
integers, shuffle, permutation
Notes
-----
Setting user-specified probabilities through ``p`` uses a more general but less
efficient sampler than the default. The general sampler produces a different sample
than the optimized sampler even if each element of ``p`` is 1 / len(a).
Examples
--------
Generate a uniform random sample from np.arange(5) of size 3:
>>> rng = np.random.default_rng()
>>> rng.choice(5, 3)
array([0, 3, 4]) # random
>>> #This is equivalent to rng.integers(0,5,3)
Generate a non-uniform random sample from np.arange(5) of size 3:
>>> rng.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])
array([3, 3, 0]) # random
Generate a uniform random sample from np.arange(5) of size 3 without
replacement:
>>> rng.choice(5, 3, replace=False)
array([3,1,0]) # random
>>> #This is equivalent to rng.permutation(np.arange(5))[:3]
Generate a uniform random sample from a 2-D array along the first
axis (the default), without replacement:
>>> rng.choice([[0, 1, 2], [3, 4, 5], [6, 7, 8]], 2, replace=False)
array([[3, 4, 5], # random
[0, 1, 2]])
Generate a non-uniform random sample from np.arange(5) of size
3 without replacement:
>>> rng.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])
array([2, 3, 0]) # random
Any of the above can be repeated with an arbitrary array-like
instead of just integers. For instance:
>>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']
>>> rng.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random
dtype='>> np.random.default_rng().bytes(10)
b'\xfeC\x9b\x86\x17\xf2\xa1\xafcp' # random
integers(low, high=None, size=None, dtype=np.int64, endpoint=False)
Return random integers from `low` (inclusive) to `high` (exclusive), or
if endpoint=True, `low` (inclusive) to `high` (inclusive). Replaces
`RandomState.randint` (with endpoint=False) and
`RandomState.random_integers` (with endpoint=True)
Return random integers from the "discrete uniform" distribution of
the specified dtype. If `high` is None (the default), then results are
from 0 to `low`.
Parameters
----------
low : int or array-like of ints
Lowest (signed) integers to be drawn from the distribution (unless
``high=None``, in which case this parameter is 0 and this value is
used for `high`).
high : int or array-like of ints, optional
If provided, one above the largest (signed) integer to be drawn
from the distribution (see above for behavior if ``high=None``).
If array-like, must contain integer values
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
dtype : dtype, optional
Desired dtype of the result. Byteorder must be native.
The default value is np.int64.
endpoint : bool, optional
If true, sample from the interval [low, high] instead of the
default [low, high)
Defaults to False
Returns
-------
out : int or ndarray of ints
`size`-shaped array of random integers from the appropriate
distribution, or a single such random int if `size` not provided.
Notes
-----
When using broadcasting with uint64 dtypes, the maximum value (2**64)
cannot be represented as a standard integer type. The high array (or
low if high is None) must have object dtype, e.g., array([2**64]).
Examples
--------
>>> rng = np.random.default_rng()
>>> rng.integers(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random
>>> rng.integers(1, size=10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
Generate a 2 x 4 array of ints between 0 and 4, inclusive:
>>> rng.integers(5, size=(2, 4))
array([[4, 0, 2, 1],
[3, 2, 2, 0]]) # random
Generate a 1 x 3 array with 3 different upper bounds
>>> rng.integers(1, [3, 5, 10])
array([2, 2, 9]) # random
Generate a 1 by 3 array with 3 different lower bounds
>>> rng.integers([1, 5, 7], 10)
array([9, 8, 7]) # random
Generate a 2 by 4 array using broadcasting with dtype of uint8
>>> rng.integers([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)
array([[ 8, 6, 9, 7],
[ 1, 16, 9, 12]], dtype=uint8) # random
References
----------
.. [1] Daniel Lemire., "Fast Random Integer Generation in an Interval",
ACM Transactions on Modeling and Computer Simulation 29 (1), 2019,
http://arxiv.org/abs/1805.10941.
standard_exponential(size=None, dtype=np.float64, method='zig', out=None)
Draw samples from the standard exponential distribution.
`standard_exponential` is identical to the exponential distribution
with a scale parameter of 1.
Parameters
----------
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
dtype : dtype, optional
Desired dtype of the result, only `float64` and `float32` are supported.
Byteorder must be native. The default value is np.float64.
method : str, optional
Either 'inv' or 'zig'. 'inv' uses the default inverse CDF method.
'zig' uses the much faster Ziggurat method of Marsaglia and Tsang.
out : ndarray, optional
Alternative output array in which to place the result. If size is not None,
it must have the same shape as the provided size and must match the type of
the output values.
Returns
-------
out : float or ndarray
Drawn samples.
Examples
--------
Output a 3x8000 array:
>>> n = np.random.default_rng().standard_exponential((3, 8000))
exponential(scale=1.0, size=None)
Draw samples from an exponential distribution.
Its probability density function is
.. math:: f(x; \frac{1}{\beta}) = \frac{1}{\beta} \exp(-\frac{x}{\beta}),
for ``x > 0`` and 0 elsewhere. :math:`\beta` is the scale parameter,
which is the inverse of the rate parameter :math:`\lambda = 1/\beta`.
The rate parameter is an alternative, widely used parameterization
of the exponential distribution [3]_.
The exponential distribution is a continuous analogue of the
geometric distribution. It describes many common situations, such as
the size of raindrops measured over many rainstorms [1]_, or the time
between page requests to Wikipedia [2]_.
Parameters
----------
scale : float or array_like of floats
The scale parameter, :math:`\beta = 1/\lambda`. Must be
non-negative.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``scale`` is a scalar. Otherwise,
``np.array(scale).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized exponential distribution.
Examples
--------
A real world example: Assume a company has 10000 customer support
agents and the average time between customer calls is 4 minutes.
>>> n = 10000
>>> time_between_calls = np.random.default_rng().exponential(scale=4, size=n)
What is the probability that a customer will call in the next
4 to 5 minutes?
>>> x = ((time_between_calls < 5).sum())/n
>>> y = ((time_between_calls < 4).sum())/n
>>> x-y
0.08 # may vary
References
----------
.. [1] Peyton Z. Peebles Jr., "Probability, Random Variables and
Random Signal Principles", 4th ed, 2001, p. 57.
.. [2] Wikipedia, "Poisson process",
https://en.wikipedia.org/wiki/Poisson_process
.. [3] Wikipedia, "Exponential distribution",
https://en.wikipedia.org/wiki/Exponential_distribution
beta(a, b, size=None)
Draw samples from a Beta distribution.
The Beta distribution is a special case of the Dirichlet distribution,
and is related to the Gamma distribution. It has the probability
distribution function
.. math:: f(x; a,b) = \frac{1}{B(\alpha, \beta)} x^{\alpha - 1}
(1 - x)^{\beta - 1},
where the normalization, B, is the beta function,
.. math:: B(\alpha, \beta) = \int_0^1 t^{\alpha - 1}
(1 - t)^{\beta - 1} dt.
It is often seen in Bayesian inference and order statistics.
Parameters
----------
a : float or array_like of floats
Alpha, positive (>0).
b : float or array_like of floats
Beta, positive (>0).
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a single value is returned if ``a`` and ``b`` are both scalars.
Otherwise, ``np.broadcast(a, b).size`` samples are drawn.
Returns
-------
out : ndarray or scalar
Drawn samples from the parameterized beta distribution.
random(size=None, dtype=np.float64, out=None)
Return random floats in the half-open interval [0.0, 1.0).
Results are from the "continuous uniform" distribution over the
stated interval. To sample :math:`Unif[a, b), b > a` use `uniform`
or multiply the output of `random` by ``(b - a)`` and add ``a``::
(b - a) * random() + a
Parameters
----------
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
dtype : dtype, optional
Desired dtype of the result, only `float64` and `float32` are supported.
Byteorder must be native. The default value is np.float64.
out : ndarray, optional
Alternative output array in which to place the result. If size is not None,
it must have the same shape as the provided size and must match the type of
the output values.
Returns
-------
out : float or ndarray of floats
Array of random floats of shape `size` (unless ``size=None``, in which
case a single float is returned).
See Also
--------
uniform : Draw samples from the parameterized uniform distribution.
Examples
--------
>>> rng = np.random.default_rng()
>>> rng.random()
0.47108547995356098 # random
>>> type(rng.random())
>>> rng.random((5,))
array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random
Three-by-two array of random numbers from [-5, 0):
>>> 5 * rng.random((3, 2)) - 5
array([[-3.99149989, -0.52338984], # random
[-2.99091858, -0.79479508],
[-1.23204345, -1.75224494]])
spawn(n_children)
Create new independent child generators.
See :ref:`seedsequence-spawn` for additional notes on spawning
children.
.. versionadded:: 1.25.0
Parameters
----------
n_children : int
Returns
-------
child_generators : list of Generators
Raises
------
TypeError
When the underlying SeedSequence does not implement spawning.
See Also
--------
random.BitGenerator.spawn, random.SeedSequence.spawn :
Equivalent method on the bit generator and seed sequence.
bit_generator :
The bit generator instance used by the generator.
Examples
--------
Starting from a seeded default generator:
>>> # High quality entropy created with: f"0x{secrets.randbits(128):x}"
>>> entropy = 0x3034c61a9ae04ff8cb62ab8ec2c4b501
>>> rng = np.random.default_rng(entropy)
Create two new generators for example for parallel executation:
>>> child_rng1, child_rng2 = rng.spawn(2)
Drawn numbers from each are independent but derived from the initial
seeding entropy:
>>> rng.uniform(), child_rng1.uniform(), child_rng2.uniform()
(0.19029263503854454, 0.9475673279178444, 0.4702687338396767)
It is safe to spawn additional children from the original ``rng`` or
the children:
>>> more_child_rngs = rng.spawn(20)
>>> nested_spawn = child_rng1.spawn(20)
P H
P P P H 0 x P H P 0
x 0 x P P H h P P H P P P P P P P P P P P h P h P h P ` P P P P x 0 P x 0 P P P 0 P P P 0 P
P
H x P @
P X P
H
` X h x h p a
0
_
ܶ
``
3 ` $ 7 & = @
x @ B p Q
h x
` # X ` & P @
H
@
8
0
(
! `
%
`
"
2
*
` (
+
#
`
_
"
x
p
`
h
@
`
`
X
`
P
H
& @
` * 8
% 0
& (
!
!
@
@
@
L
@ " [ ? ` 0
]
÷
[
x ) p
h @
` ֶ
X б
P H
@ Ȱ
8 h
0 Y
( 0
@ ! "
. ) (
_
7 ` F K
I
H
W
W
. 9 ) x
p
h X
`
X ж
P (
H
@
8 ʶ
0
(
^
U
U
P
0
` )
O
S
S
4 x
G
p
8
h
H
`
H
X
P
`
H
@
ݵ
8
T 0
@
(
ֵ
% @ 3 ϵ
E
E
@
$
ȵ
x p
p
h
`
X
P
H 8
@
8
0
(
.
R !
}
`
K (
6
)
x
p
h & ` X B
P
H д
@
8 w
0 q
( k
e
z
@ u
8
_
س
p
p
ȳ
Y
Y
k
x `
p f
h
`
X a
P P
H d @ 8
0
( X
N
N
# @ !
% ȴ
' 2 I
@
?
?
` `t I x Q
p Q
h B ` @
X
P 7
H 7
@ 2
8 d ' 0 $ (
S
S
@
3 -
-
`Y
M = @>
<
M
> ' ` " x
p
h
`
X
P G
H
@
8 = " 0 O
( O
`
(
. @
) "
P
#
p
#
:
:
] 0
x 0
p
h
`
X
P 4
H s
@ 8 .
0 (
( h
в
p
"
"
`
x
p ` h
`
X
P
H
@
8 @ 0
(
|
w
t @k
O
ط
k
!
P
\
p
Է
` N
x з
p з
h `
`
X
P
H ̷
@ ` Y 8 8
0 U
( N
G
P
& @
9
2
`
D
P
M
ȷ
y
hj ; D j = F
@, { p# { pd { c j P(
D 0 0
" " 0
" 0; { 0 { `# x { { | r | @r | P "s | @~ #| p{ /| P 4| { 0f { Pe A| * " D @# @.
P~ @% { { ^| p @^
@
F ` " " p+ || | 0t H { g { g j @, `\ pX D k " . @
% w 0# q | 08 + | pW | pV | h |
z `
v R
Fz 0P x
=z @s
z
`f
| d
{ P U
\z , L
y B
z pL 4
z (
z I
v pE
v A
v > v @; v 8 v @6 ` v 2 ` v 0 ` v P- ` |v * tv & mv # dv ` x Zv g Qv ] Lv ` S D{ 0C J z 3 < z + Dv " ?v 2{ p
-{ 5v
\{ { ` { z S{ <{ { f y @u y ` w U GCC: (GNU) 10.2.1 20210130 (Red Hat 10.2.1-11) " "
0 " I " E 0#
@# `#
p# ( # ; @% H M _ % P % & & & `' [ ( ' P P( l @ @ * q p+ e + Q @, R , G e @. ; y . w W ` / 0 0 k X - B I ? f < ~ ` @ 0 e `1 2 M g % 9 J b u M 1 @2
p 3 ` 3 p5 S 6 k Y 5 j
P + X 7 F r ( M ] x 0 : x J X v p h ` h X H
P
-
H =
S
@ c
x y
8
h
0
(
/ [ k )
U
e
6
F
l
|
P 0
@ @ e
u 8
0
* U
e x
` p
/ h
? k `
{ X
P
H
, @
< h 8
x 0
(
,
< L
\
l
0 (
# 5 K d
0
- (
P
` x u p h ` 7 ' ! 08
e @8 L | : 0; e ; @= t = u @> x % > 4 ? Q Z F z H pK Q V V W , @^ F C _ ( \ ` / r a c d h
i k k ( k " 7 0
L (
f P
@r L r L r & x q p{ { @~ P~ W X "
7 D Y x > ( ` 8
$ P 0 P J V P e 4 e p
\ - B V 0 o 0 u 7 9 R X
b K 7 I j @ E C # @ X p
X
4 D R ( ^ 0 P
p
,! 8! D!
Y! ! p ! !
! ! ` " " *" O" ^" n"
" "
" # X # ` /#
D# ` # ` # h #
# # #
# & 8$
M$ * $ `
$ P- $ @
$ 0 "%
7% 2 r% % % % %
% @6 % & & З
-& 8 J o&
& @; & & &
& > :' p
O' A ' ' ' ' ' @
( ' pE (
,( I j d( t(
( ( pL (
( 0P %)
8) R o)
{)
) `
) pV ) ) pW &* pX _* m* {* `\ % * * * * -- + !+ `
B 2+ x B+ h V+ ` i+ H v+ @ + 8 + + ( + 8 + + + X + (
, h %, A, @ Z, p, , , , , , - 8 $- h 7- N- c- |-
- - - - - P -
- ..
A. U.
r. . ` W . .
8 . `b b . / @
3/ ` p
[/ @
8 y/
/ / А d / / 0 80 S0 n0 0 0 @ 0 8 1 0 ?1 w1 1 x 1 p 2 h T2 ` 2 X 2 P 2 H /3 ( `3 3 3 3 4 N4 u4 4 4 X 4 5 8 5 H
05 @5 M5 l5 5 ` 5 5 8 5 5
5
6 6 "6
96
U6 `6
w6
6 6 6
6
6 6
7
7 p B7 `
v7 7 8 7 P
7 @ 7 h
!8 L8 v8 8 @
8 8
9
I9 @ m9 p
9 0 9 9
: 9: 0
e: :
: : 8
; 7; \; ; ; ;
; x
*< 8 S< ~<
< < H
= += (
U= =
= =
= $>
K> v> p
> >
> ? =? H h?
? @ ?
? ( @ `
7@ a@
@ @ @
@
A H -A 8 XA
A A x
A B $B OB xB ` B
B 8 B
#C NC
zC C
C C
'D QD ( zD D
D p D X
E JE
uE p E E X E E
@ E F @
GF c {F pd F Pe F 0f G g 3G g [G h V G G G 0t G @u : H ( H X 2H EH qH @
H H H H H @ D H W FI dI I I P I x I J P
/J H
KJ @
bJ 8
~J J J
J
J ( K K ,K 8 :K P LK ~K
K `
K X
K
K L @ L
bL P
yL H
L @
L 8
L L H L M
+M
dM P
yM H
M @
M 8
M M @
M z @N p
WN h
sN `
N X
N
( N N ` K N O
U
ZU
qU
U p U
U
U 8 U
U
V "V
9V
UV cV
zV
V X V V @ V X V
V . 0W
GW
cW sW
W
W
W
W
W x
X p
#X h
?X x MX _X H nX ~X P X X
X
( X
( Y
1Y
LY ( \Y
rY
Y
Y x
Y 8 Y
Y
Y 0 Z H "Z
0 6Z
LZ
gZ vZ
Z
Z Z
Z
Z
Z
[ 0 +[
A[
\[ l[
[
[
[ [ [ 3 2 &\ 0
=\ (
Y\ ` i\
\
\
\
\
\
]
]
.]
J]
a]
}] f % ] 0
] (
] @ ]
^
2^ ( D^ x V^
m^
^ ^
^
^ ^
^
_
-_
I_ X_
m_
|_
_
_ sX _ `
!`
8`
T`
k`
`
` x
` ` 8
` @
a 8
.a Aa 0
Xa (
ta
a
a
( a @
a `
a X
b b P
3b H
Ob {b b p
b h
b b *c ^ dc xc
c x
c h c p
c h
c
d
$d
;d
Wd `
nd X
d P
d H
d d d ` e 'e
>e
Ze
qe
e e ( e `
e 0C & f
f
;f
Rf
nf }f f
f
f
f
f
g
&g
=g x
Yg ( ig @
( ~g i /D g @
g 8
g 0
h (
h
0h ?h
Qh
hh
h
h
h
h h P h 0 h h 9i @
Ni i p i i h i `
i X
i P
j H
&j `
9j @
Pj 8
lj 0
j (
j
j
j H j
8 j k k
)k
Ek Vk x dk x {k P k P k
k
k h k
k
l #l 0 /l p >l h
Ql
hl
l
l
l
l
l l m
m
;m G : tm
m
m
m
m m
m
n %n
;n
Vn
ln
n
n
n n
n
n 0 o
o x
8o p
No h
io `
o X
o P
o H
o o @
o 8
p P !p 4p `p qp H p p p h p
p
p
p
q P
0q H
Kq 0
aq (
|q
q
q
q
q
q
r
'r
=r
Xr
sr
r
r
r r r H r ` s
s
1s @
Gs 8
bs 0
xs (
s
s
s
s x
s p
t h
&t 5t `
Kt X
ft
h t P i t t
8 t |i u .u =u
Tu
pu u u u
u
u
u
v
!v
=v
Tv
pv
v
v
v
v
v
w w
-w
Iw
`w x
|w p
w h
w w
w w
x p $x Ox ^x
h nx
a
xx
0
x
x
_
x
ܶ
x
``
3 x
` $ x
7 "y
& Ky
= ty
@
y
@ B y
Q
y
x
y
# !z
` & Jz
@
\z
z
z
z
z
{
! 7{
`
U{
w{
{
{
% {
|
1|
V|
||
|
`
" |
2 |
* }
` ( E}
+ n}
# }
}
`
}
_
" ~
*~
N~
`
p~
@
~
`
~
`
~
~
& %
` * N
% w
&
!
!
@
@
6
W
@
{
L ـ
@ "
[ >
? g
` 0
]
Ё
÷
8
[
B
) k
@
ֶ
б
Ȱ
h
+
Y
5
0
G
@ ! p
"
.
)
( ?
S
f
~
_
7
` F τ
K
ڄ
I
H
W
*
. S
9 |
)
X
΅
ж
(
ʶ
-
H
X
r
^
Ɔ
ӆ
U
݆
P
0
(
5
` ) ^
O
S
ć
4
G
8
=
H
N
\
`
w
ݵ
T Lj
@
ֵ
!
/
E
Q
% z
@ 3
ϵ
Ɖ
E
@
$ ?
K
ȵ
Z
h
p
8
Ί
܊
#
.
R K
!
s
}
ۋ
`
0
K X
(
i
6
) ʌ
܌
& #
K
B
V
e H w
д
@
w
q
Í
k
э
e
ߍ
z
@ %
u
2
8 Z
k
_
y
س
p
p
ȳ
̎
Y
1
k
>
P
`
c
f
p
|
a
P
d ď
X
-
? P
_
k
N
#
@ !
% /
ȴ
?
N
' w
2
I
@
?
ˑ
`
`t I C
Q
M
B v
@
7
2
d ' Ԓ
$
S
@
2
3 [
-
h
`Y
M =
@>
<
;
_
M
Ȕ
> '
` "
.
N
Z
G
Ε
= "
O
`
(
-
. U
@
c
) "
Ӗ
P
:
# c
p
#
:
Ɨ
]
0
2
0
E
W
h
4
s
ژ
.
(
h
-
>
T
в
f
v
p
"
̙
ܙ
`
&
7
O
]
m
`
ʚ
ؚ
@
|
G
w
t n
@k
՛
O
&
3
ط
?
Z
k
!
P
Ü
\
Ҝ
p
Է
` N
*
з
6
`
G
T
a
q
̷
}
` Y
8
U
N
Ν
G
ݝ
P
& :
b
@
q
9
2
`
D
ޞ
P
$
6
M
@
\
j
ȷ
v
0
`
P
P
?
]
v
`
P
נ
@
P @
L
x
`
@ + x
R j @s
t `f
d
' U
a L
B
ߣ 4
(
[
ɤ
= F
ѥ ` O ` K ` ` 4 ) n x d g ] # S D
[ J Y < ը + ' " U
K ʩ
I I ` Ϫ $ [ ҫ " ` h
C ! E " X P" n
z { " x{ ̬
֬
#
,
5
>
F X\ T g }
{ { 8 ` X 3 5 06 @
h=
@ ` x{ { { { } @
ʭ ߭ # 5 A _ 0 B n z ! Ǯ ܮ
, B U f s ֯ 03 2
- { 7 F Y l x _ ˰ h= Ѱ ` @ 3 & 2 G U e y I ű ձ 0
. / ` H a s C ̲ ( ; I _ ( س 0 G V q @ / ̴ y F T a 0 } a ϵ " $ 4 F [ q @ % ʶ + : G Y k C ÷ Ϸ p6 :
. < ] o ! θ ߸ & & D W h I 0+ p
ѹ p
( A O m @ & ` ̺ غ " 9 I 2 w b p $ ǻ ӻ ( P" Z N ) ; R a < n 0 V ͼ Y - > X m I ҽ p ` i 1 J V d z ` P I ž Ѿ ݾ 8 2 % 3 J Y s Ŀ 1 M a s S ' I & P p$ 3 > P ] - { R / ? U I x ~ P W __pyx_array___len__ __pyx_MemviewEnum___repr__ __pyx_memoryview___len__ __pyx_tp_traverse_5numpy_6random_10_generator_Generator __pyx_getprop_5numpy_6random_10_generator_9Generator_bit_generator __pyx_tp_traverse_Enum __pyx_getprop___pyx_memoryview_base __pyx_getprop___pyx_memoryviewslice_base __pyx_typeinfo_cmp __pyx_tp_new_Enum __pyx_empty_tuple __pyx_tp_new_5numpy_6random_10_generator_Generator __Pyx_PyObject_SetAttrStr __Pyx_PyObject_Call __Pyx_PyObject_GetAttrStr __Pyx_PyObject_LookupSpecial __pyx_f_5numpy_6random_10_generator__shuffle_int __Pyx_PyNumber_IntOrLongWrongResultType __pyx_tp_dealloc_memoryview __pyx_memoryview_thread_locks_used __pyx_memoryview_thread_locks __pyx_tp_dealloc_Enum __pyx_sq_item_array __pyx_setprop_5numpy_6random_10_generator_9Generator__bit_generator __pyx_tp_dealloc_5numpy_6random_10_generator_Generator __Pyx_GetException __pyx_tp_clear_Enum __pyx_tp_clear_5numpy_6random_10_generator_Generator __Pyx_setup_reduce_is_named __pyx_n_s_name __Pyx_Import __pyx_m __pyx_tp_clear_memoryview __Pyx_SetVtable __pyx_n_s_pyx_vtable __Pyx_ImportVoidPtr_0_29_36 __Pyx_ImportFunction_0_29_36 __Pyx_copy_spec_to_module __pyx_pymod_create main_interpreter_id.0 __pyx_tp_traverse_memoryview __Pyx_IterFinish.part.0 __Pyx_PyObject_GetAttrStrNoError __Pyx_setup_reduce __pyx_n_s_getstate __pyx_n_s_reduce_ex __pyx_n_s_reduce __pyx_n_s_reduce_cython __pyx_n_s_setstate __pyx_n_s_setstate_cython __Pyx_ImportType_0_29_36.constprop.0 __Pyx_BufFmt_TypeCharToAlignment.constprop.0 __pyx_fatalerror.constprop.0 __func__.308 __Pyx_ParseOptionalKeywords.constprop.0 __Pyx_PyObject_Call.constprop.0 __Pyx_Raise.constprop.0 __Pyx_PyCode_New.constprop.0 __Pyx_InitCachedConstants __pyx_kp_u_Invalid_bit_generator_The_bit_ge __pyx_tuple_ __pyx_kp_u_Providing_a_dtype_with_a_non_nat __pyx_tuple__8 __pyx_int_4294967296 __pyx_int_0 __pyx_tuple__9 __pyx_kp_u_a_must_be_a_positive_integer_unl __pyx_tuple__10 __pyx_kp_u_a_cannot_be_empty_unless_no_samp __pyx_tuple__11 __pyx_kp_u_p_must_be_1_dimensional __pyx_tuple__12 __pyx_kp_u_a_and_p_must_have_same_size __pyx_tuple__13 __pyx_kp_u_probabilities_contain_NaN __pyx_tuple__14 __pyx_kp_u_probabilities_are_not_non_negati __pyx_tuple__15 __pyx_kp_u_probabilities_do_not_sum_to_1 __pyx_tuple__16 __pyx_kp_u_Cannot_take_a_larger_sample_than __pyx_tuple__17 __pyx_kp_u_negative_dimensions_are_not_allo __pyx_tuple__18 __pyx_kp_u_Fewer_non_zero_entries_in_p_than __pyx_tuple__19 __pyx_tuple__20 __pyx_tuple__21 __pyx_kp_u_high_low_range_exceeds_valid_bou __pyx_tuple__22 __pyx_kp_u_Range_exceeds_valid_bounds __pyx_tuple__23 __pyx_kp_u_left_mode __pyx_tuple__26 __pyx_kp_u_mode_right __pyx_tuple__27 __pyx_kp_u_left_right __pyx_tuple__28 __pyx_kp_u_n_too_large_or_p_too_small_see_G __pyx_tuple__29 __pyx_kp_u_ngood_nbad_nsample __pyx_tuple__30 __pyx_kp_u_method_must_be_one_of_eigh_svd_c __pyx_tuple__31 __pyx_kp_u_mean_and_cov_must_not_be_complex __pyx_tuple__32 __pyx_kp_u_mean_must_be_1_dimensional __pyx_tuple__33 __pyx_kp_u_cov_must_be_2_dimensional_and_sq __pyx_tuple__34 __pyx_kp_u_mean_and_cov_must_have_same_leng __pyx_tuple__35 __pyx_slice__36 __pyx_kp_u_check_valid_must_equal_warn_rais __pyx_tuple__37 __pyx_builtin_RuntimeWarning __pyx_kp_u_covariance_is_not_symmetric_posi __pyx_tuple__38 __pyx_tuple__39 __pyx_kp_u_pvals_must_have_at_least_1_dimen __pyx_tuple__40 __pyx_kp_u_method_must_be_count_or_marginal __pyx_tuple__42 __pyx_kp_u_nsample_must_be_an_integer __pyx_tuple__43 __pyx_kp_u_nsample_must_be_nonnegative __pyx_tuple__44 __pyx_kp_u_When_method_is_marginals_sum_col __pyx_tuple__45 __pyx_kp_u_nsample_sum_colors __pyx_tuple__46 __pyx_kp_u_alpha_0 __pyx_tuple__47 __pyx_kp_u_out_must_be_a_numpy_array __pyx_tuple__48 __pyx_kp_u_out_must_have_the_same_shape_as __pyx_tuple__49 __pyx_kp_u_memory_allocation_failed_in_perm __pyx_tuple__50 __pyx_kp_u_array_is_read_only __pyx_tuple__51 __pyx_tuple__52 __pyx_kp_u_Axis_argument_is_only_supported __pyx_tuple__53 __pyx_kp_u_numpy_core_multiarray_failed_to __pyx_tuple__54 __pyx_kp_u_numpy_core_umath_failed_to_impor __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_tuple__56 __pyx_kp_s_itemsize_0_for_cython_array __pyx_tuple__57 __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_tuple__58 __pyx_kp_s_unable_to_allocate_array_data __pyx_tuple__59 __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_tuple__60 __pyx_kp_s_no_default___reduce___due_to_non __pyx_tuple__61 __pyx_tuple__62 __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_tuple__63 __pyx_kp_s_Unable_to_convert_item_to_object __pyx_tuple__64 __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_tuple__65 __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_tuple__66 __pyx_tuple__67 __pyx_int_neg_1 __pyx_tuple__68 __pyx_tuple__69 __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_tuple__70 __pyx_tuple__71 __pyx_tuple__72 __pyx_int_112105877 __pyx_int_136983863 __pyx_int_184977713 __pyx_tuple__73 __pyx_n_s_seed __pyx_empty_bytes __pyx_n_s_default_rng __pyx_kp_s_generator_pyx __pyx_kp_s_strided_and_direct_or_indirect __pyx_tuple__76 __pyx_kp_s_strided_and_direct __pyx_tuple__77 __pyx_kp_s_strided_and_indirect __pyx_tuple__78 __pyx_kp_s_contiguous_and_direct __pyx_tuple__79 __pyx_kp_s_contiguous_and_indirect __pyx_tuple__80 __pyx_n_s_pyx_result __pyx_n_s_pyx_PickleError __pyx_n_s_pyx_state __pyx_n_s_pyx_checksum __pyx_n_s_pyx_type __pyx_n_s_pyx_unpickle_Enum __pyx_kp_s_stringsource _copy_strided_to_strided.isra.0 __pyx_getprop_5numpy_6random_10_generator_9Generator__bit_generator __Pyx_PyUnicode_Equals __Pyx_IternextUnpackEndCheck __pyx_sq_item_memoryview __pyx_tp_dealloc__memoryviewslice __Pyx_GetBuiltinName __pyx_b __pyx_tp_traverse__memoryviewslice __Pyx_ImportFrom __Pyx_TypeTest __pyx_memoryview__slice_assign_scalar __pyx_tp_clear__memoryviewslice __Pyx_BufFmt_RaiseExpected __Pyx_BufFmt_ProcessTypeChunk __Pyx_BufFmt_CheckString __Pyx__PyObject_CallOneArg __Pyx_PyObject_CallOneArg __pyx_memoryview_refcount_objects_in_slice __pyx_tp_dealloc_array __Pyx_PyObject_Call2Args __Pyx_PyInt_As_size_t __Pyx_PyInt_As_long __Pyx_PyInt_As_int __Pyx_PyObject_GetIndex __Pyx_PyObject_CallNoArg __Pyx_PyInt_As_Py_intptr_t.part.0 __Pyx__GetModuleGlobalName __pyx_d __Pyx_AddTraceback __pyx_cython_runtime __pyx_dict_version.2 __pyx_dict_cached_value.1 __pyx_n_s_cline_in_traceback __pyx_code_cache __pyx_getprop___pyx_memoryview_itemsize __pyx_getprop___pyx_memoryview_ndim __pyx_memoryview_get_slice_from_memoryview __pyx_memoryviewslice_type __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig __pyx_memoryview_is_f_contig __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig __pyx_memoryview_is_c_contig __pyx_MemviewEnum___init__ __pyx_n_s_name_2 __pyx_pyargnames.307 __pyx_getprop___pyx_array_memview __pyx_unpickle_Enum__set_state __pyx_n_s_dict __pyx_n_s_update __pyx_memoryview_getbuffer __pyx_builtin_ValueError __pyx_array_getbuffer __pyx_n_u_c __pyx_n_u_fortran __pyx_getprop___pyx_memoryview_size __pyx_int_1 __pyx_getprop___pyx_memoryview_nbytes __pyx_n_s_size __pyx_getprop___pyx_memoryview_suboffsets __pyx_getprop___pyx_memoryview_strides __pyx_getprop___pyx_memoryview_shape __pyx_memoryview_fromslice __pyx_n_s_base __pyx_memoryview_copy_object_from_slice __pyx_memoryview_err __pyx_empty_unicode __pyx_memslice_transpose __pyx_getprop___pyx_memoryview_T __pyx_memoryview_new __pyx_memoryview_type __pyx_memoryview_err_dim __pyx_memoryview_copy_contents __pyx_kp_s_got_differing_extents_in_dimensi __pyx_builtin_MemoryError __pyx_memoryview___str__ __pyx_n_s_class __pyx_kp_s_MemoryView_of_r_object __pyx_memoryview___repr__ __pyx_builtin_id __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_memoryview_assign_item_from_object __pyx_n_s_struct __pyx_n_s_pack __pyx_memoryviewslice_assign_item_from_object __pyx_memoryview_setitem_indexed __pyx_memoryview_setitem_slice_assign_scalar __pyx_memoryview_is_slice __pyx_builtin_TypeError __pyx_pw___pyx_MemviewEnum_3__setstate_cython__ __pyx_tp_getattro_array __pyx_n_s_memview __pyx_mp_ass_subscript_array __pyx_array___getitem__ __pyx_array_get_memview __pyx_pw_5numpy_6random_10_generator_9Generator_1__init__ __pyx_n_s_capsule __pyx_n_s_lock __pyx_n_s_bit_generator __pyx_pyargnames.301 __pyx_pw_5numpy_6random_10_generator_9Generator_85logseries __pyx_float_0_0 __pyx_kp_u__5 __pyx_n_u_p __pyx_f_5numpy_6random_7_common_disc __pyx_n_s_p __pyx_pyargnames.181 __pyx_pw_5numpy_6random_10_generator_9Generator_81geometric __pyx_pyargnames.169 __pyx_pw_5numpy_6random_10_generator_9Generator_79zipf __pyx_n_u_a __pyx_n_s_a __pyx_pyargnames.168 __pyx_pw_5numpy_6random_10_generator_9Generator_77poisson __pyx_float_1_0 __pyx_n_u_lam __pyx_pyargnames.167 __pyx_n_s_lam __pyx_pw_5numpy_6random_10_generator_9Generator_69wald __pyx_n_u_scale __pyx_n_u_mean __pyx_f_5numpy_6random_7_common_cont __pyx_n_s_mean __pyx_n_s_scale __pyx_pyargnames.133 __pyx_pw_5numpy_6random_10_generator_9Generator_67rayleigh __pyx_pyargnames.132 __pyx_pw_5numpy_6random_10_generator_9Generator_65lognormal __pyx_n_u_sigma __pyx_n_s_sigma __pyx_pyargnames.131 __pyx_pw_5numpy_6random_10_generator_9Generator_63logistic __pyx_n_u_loc __pyx_n_s_loc __pyx_pyargnames.130 __pyx_pw_5numpy_6random_10_generator_9Generator_61gumbel __pyx_pyargnames.129 __pyx_pw_5numpy_6random_10_generator_9Generator_59laplace __pyx_pyargnames.128 __pyx_pw_5numpy_6random_10_generator_9Generator_57power __pyx_pyargnames.127 __pyx_pw_5numpy_6random_10_generator_9Generator_55weibull __pyx_pyargnames.126 __pyx_pw_5numpy_6random_10_generator_9Generator_53pareto __pyx_pyargnames.125 __pyx_pw_5numpy_6random_10_generator_9Generator_51vonmises __pyx_n_u_kappa __pyx_n_u_mu __pyx_n_s_mu __pyx_n_s_kappa __pyx_pyargnames.124 __pyx_pw_5numpy_6random_10_generator_9Generator_49standard_t __pyx_n_u_df __pyx_n_s_df __pyx_pyargnames.123 __pyx_pw_5numpy_6random_10_generator_9Generator_47standard_cauchy __pyx_pyargnames.122 __pyx_pw_5numpy_6random_10_generator_9Generator_45noncentral_chisquare __pyx_n_u_nonc __pyx_n_s_nonc __pyx_pyargnames.121 __pyx_pw_5numpy_6random_10_generator_9Generator_43chisquare __pyx_pyargnames.120 __pyx_pw_5numpy_6random_10_generator_9Generator_41noncentral_f __pyx_n_u_dfden __pyx_n_u_dfnum __pyx_n_s_dfnum __pyx_n_s_dfden __pyx_pyargnames.119 __pyx_pw_5numpy_6random_10_generator_9Generator_39f __pyx_pyargnames.118 __pyx_pw_5numpy_6random_10_generator_9Generator_37gamma __pyx_n_u_shape __pyx_pyargnames.117 __pyx_n_s_shape __pyx_pw_5numpy_6random_10_generator_9Generator_33normal __pyx_pyargnames.111 __pyx_pw_5numpy_6random_10_generator_9Generator_19exponential __pyx_pyargnames.9 __pyx_pw_5numpy_6random_10_generator_9Generator_17beta __pyx_n_u_b __pyx_n_s_b __pyx_pyargnames.8 __pyx_pw_5numpy_6random_10_generator_9Generator_9__setstate__ __pyx_n_s_state __pyx_pw_5numpy_6random_10_generator_9Generator_7__getstate__ __pyx_pw_5numpy_6random_10_generator_9Generator_5__str__ __pyx_kp_u__2 __pyx_kp_u__3 __pyx_pw_5numpy_6random_10_generator_9Generator_3__repr__ __pyx_n_s_str __pyx_kp_u_at_0x_X __pyx_n_s_format __pyx_pymod_exec__generator __pyx_assertions_enabled_flag __pyx_string_tab __pyx_float_0_1 __pyx_float_1eneg_8 __pyx_float_1_0001 __pyx_int_10 __pyx_int_20 __pyx_int_50 __pyx_int_1000000000 __pyx_n_s_main __pyx_n_s_range __pyx_n_s_reversed __pyx_n_s_ValueError __pyx_n_s_id __pyx_n_s_TypeError __pyx_n_s_OverflowError __pyx_builtin_OverflowError __pyx_n_s_RuntimeWarning __pyx_n_s_MemoryError __pyx_n_s_UserWarning __pyx_builtin_UserWarning __pyx_n_s_NotImplementedError __pyx_builtin_NotImplementedError __pyx_n_s_ImportError __pyx_builtin_ImportError __pyx_n_s_enumerate __pyx_n_s_Ellipsis __pyx_builtin_Ellipsis __pyx_n_s_IndexError __pyx_builtin_IndexError __pyx_type_5numpy_6random_10_generator_Generator generic strided indirect_contiguous __pyx_n_s_Generator __pyx_type___pyx_array __pyx_ptype_5numpy_6random_10_generator_Generator __pyx_vtable_array __pyx_vtabptr_array __pyx_type___pyx_MemviewEnum __pyx_array_type __pyx_memoryview_get_item_pointer __pyx_MemviewEnum_type __pyx_vtable_memoryview __pyx_memoryview_setitem_slice_assignment __pyx_vtabptr_memoryview __pyx_type___pyx_memoryview __pyx_memoryview_convert_item_to_object __pyx_vtable__memoryviewslice __pyx_type___pyx_memoryviewslice __pyx_vtabptr__memoryviewslice __pyx_memoryviewslice_convert_item_to_object __pyx_ptype_5numpy_dtype __pyx_ptype_5numpy_flatiter __pyx_ptype_5numpy_broadcast __pyx_ptype_5numpy_ndarray __pyx_ptype_5numpy_integer __pyx_ptype_5numpy_floating __pyx_ptype_5numpy_complexfloating __pyx_vp_5numpy_6random_7_common_POISSON_LAM_MAX __pyx_vp_5numpy_6random_7_common_LEGACY_POISSON_LAM_MAX __pyx_vp_5numpy_6random_7_common_MAXSIZE __pyx_f_5numpy_6random_17_bounded_integers__rand_uint64 __pyx_f_5numpy_6random_17_bounded_integers__rand_uint32 __pyx_f_5numpy_6random_17_bounded_integers__rand_uint16 __pyx_f_5numpy_6random_17_bounded_integers__rand_uint8 __pyx_f_5numpy_6random_17_bounded_integers__rand_bool __pyx_f_5numpy_6random_17_bounded_integers__rand_int64 __pyx_f_5numpy_6random_17_bounded_integers__rand_int32 __pyx_f_5numpy_6random_17_bounded_integers__rand_int16 __pyx_f_5numpy_6random_17_bounded_integers__rand_int8 __pyx_f_5numpy_6random_7_common_check_constraint __pyx_f_5numpy_6random_7_common_check_array_constraint __pyx_f_5numpy_6random_7_common_kahan_sum __pyx_f_5numpy_6random_7_common_double_fill __pyx_f_5numpy_6random_7_common_float_fill __pyx_f_5numpy_6random_7_common_validate_output_shape __pyx_f_5numpy_6random_7_common_cont_f __pyx_f_5numpy_6random_7_common_cont_broadcast_3 __pyx_f_5numpy_6random_7_common_discrete_broadcast_iii __pyx_n_s_operator __pyx_n_s_warnings __pyx_n_s_Sequence __pyx_n_s_collections_abc __pyx_n_s_numpy __pyx_n_s_np __pyx_n_s_normalize_axis_index __pyx_n_s_numpy_core_multiarray __pyx_n_s_PCG64 __pyx_n_s_pcg64 PyArray_API __pyx_n_s_poisson_lam_max __pyx_dict_version.324 __pyx_dict_cached_value.323 __pyx_n_s_float64 __pyx_k__4 __pyx_dict_version.322 __pyx_dict_cached_value.321 __pyx_k__6 __pyx_dict_version.320 __pyx_dict_cached_value.319 __pyx_n_s_int64 __pyx_k__7 __pyx_dict_version.318 __pyx_dict_cached_value.317 __pyx_k__24 __pyx_dict_version.316 __pyx_dict_cached_value.315 __pyx_n_s_numpy_random__generator __pyx_mdef_5numpy_6random_10_generator_1default_rng __pyx_k__25 __pyx_kp_u_spawn_n_children_Create_new_ind __pyx_kp_u_Generator_spawn_line_241 __pyx_kp_u_random_size_None_dtype_np_float __pyx_kp_u_Generator_random_line_299 __pyx_kp_u_exponential_scale_1_0_size_None __pyx_kp_u_Generator_exponential_line_405 __pyx_kp_u_standard_exponential_size_None __pyx_kp_u_Generator_standard_exponential_l __pyx_kp_u_integers_low_high_None_size_Non __pyx_kp_u_Generator_integers_line_526 __pyx_kp_u_bytes_length_Return_random_byte __pyx_kp_u_Generator_bytes_line_653 __pyx_kp_u_choice_a_size_None_replace_True __pyx_kp_u_Generator_choice_line_682 __pyx_kp_u_uniform_low_0_0_high_1_0_size_N __pyx_kp_u_Generator_uniform_line_945 __pyx_kp_u_standard_normal_size_None_dtype __pyx_kp_u_Generator_standard_normal_line_1 __pyx_kp_u_normal_loc_0_0_scale_1_0_size_N __pyx_kp_u_Generator_normal_line_1123 __pyx_kp_u_standard_gamma_shape_size_None __pyx_kp_u_Generator_standard_gamma_line_12 __pyx_kp_u_gamma_shape_scale_1_0_size_None __pyx_kp_u_Generator_gamma_line_1317 __pyx_kp_u_f_dfnum_dfden_size_None_Draw_sa __pyx_kp_u_Generator_f_line_1395 __pyx_kp_u_noncentral_f_dfnum_dfden_nonc_s __pyx_kp_u_Generator_noncentral_f_line_1483 __pyx_kp_u_chisquare_df_size_None_Draw_sam __pyx_kp_u_Generator_chisquare_line_1561 __pyx_kp_u_noncentral_chisquare_df_nonc_si __pyx_kp_u_Generator_noncentral_chisquare_l __pyx_kp_u_standard_cauchy_size_None_Draw __pyx_kp_u_Generator_standard_cauchy_line_1 __pyx_kp_u_standard_t_df_size_None_Draw_sa __pyx_kp_u_Generator_standard_t_line_1774 __pyx_kp_u_vonmises_mu_kappa_size_None_Dra __pyx_kp_u_Generator_vonmises_line_1880 __pyx_kp_u_pareto_a_size_None_Draw_samples __pyx_kp_u_Generator_pareto_line_1963 __pyx_kp_u_weibull_a_size_None_Draw_sample __pyx_kp_u_Generator_weibull_line_2061 __pyx_kp_u_power_a_size_None_Draws_samples __pyx_kp_u_Generator_power_line_2160 __pyx_kp_u_laplace_loc_0_0_scale_1_0_size __pyx_kp_u_Generator_laplace_line_2261 __pyx_kp_u_gumbel_loc_0_0_scale_1_0_size_N __pyx_kp_u_Generator_gumbel_line_2346 __pyx_kp_u_logistic_loc_0_0_scale_1_0_size __pyx_kp_u_Generator_logistic_line_2465 __pyx_kp_u_lognormal_mean_0_0_sigma_1_0_si __pyx_kp_u_Generator_lognormal_line_2545 __pyx_kp_u_rayleigh_scale_1_0_size_None_Dr __pyx_kp_u_Generator_rayleigh_line_2657 __pyx_kp_u_wald_mean_scale_size_None_Draw __pyx_kp_u_Generator_wald_line_2726 __pyx_kp_u_triangular_left_mode_right_size __pyx_kp_u_Generator_triangular_line_2794 __pyx_kp_u_binomial_n_p_size_None_Draw_sam __pyx_kp_u_Generator_binomial_line_2894 __pyx_kp_u_negative_binomial_n_p_size_None __pyx_kp_u_Generator_negative_binomial_line __pyx_kp_u_poisson_lam_1_0_size_None_Draw __pyx_kp_u_Generator_poisson_line_3162 __pyx_kp_u_zipf_a_size_None_Draw_samples_f __pyx_kp_u_Generator_zipf_line_3235 __pyx_kp_u_geometric_p_size_None_Draw_samp __pyx_kp_u_Generator_geometric_line_3323 __pyx_kp_u_hypergeometric_ngood_nbad_nsamp __pyx_kp_u_Generator_hypergeometric_line_33 __pyx_kp_u_logseries_p_size_None_Draw_samp __pyx_kp_u_Generator_logseries_line_3517 __pyx_kp_u_multivariate_normal_mean_cov_si __pyx_kp_u_Generator_multivariate_normal_li __pyx_kp_u_multinomial_n_pvals_size_None_D __pyx_kp_u_Generator_multinomial_line_3838 __pyx_kp_u_multivariate_hypergeometric_col __pyx_kp_u_Generator_multivariate_hypergeom __pyx_kp_u_dirichlet_alpha_size_None_Draw __pyx_kp_u_Generator_dirichlet_line_4300 __pyx_kp_u_permuted_x_axis_None_out_None_R __pyx_kp_u_Generator_permuted_line_4498 __pyx_kp_u_shuffle_x_axis_0_Modify_an_arra __pyx_kp_u_Generator_shuffle_line_4658 __pyx_kp_u_permutation_x_axis_0_Randomly_p __pyx_kp_u_Generator_permutation_line_4790 __pyx_kp_u_Construct_a_new_Generator_with_t __pyx_kp_u_default_rng_line_4863 __pyx_n_s_test __pyx_n_s_pyx_getbuffer __pyx_t_4.314 __pyx_n_s_View_MemoryView __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum __pyx_pw___pyx_memoryviewslice_3__setstate_cython__ __pyx_pw___pyx_memoryviewslice_1__reduce_cython__ __pyx_pw___pyx_memoryview_3__setstate_cython__ __pyx_pw___pyx_memoryview_1__reduce_cython__ __pyx_pw___pyx_array_3__setstate_cython__ __pyx_pw___pyx_array_1__reduce_cython__ __pyx_pw_5numpy_6random_10_generator_9Generator_11__reduce__ __pyx_n_s_generator_ctor __pyx_n_s_pickle __pyx_array___getattr__ __pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum __pyx_n_s_new __pyx_n_s_PickleError __pyx_n_s_pickle_2 __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_pyargnames.313 __Pyx_PyInt_As_Py_intptr_t __Pyx_PyInt_As_int64_t __pyx_n_s_unpack __pyx_n_s_error __pyx_memoryview_copy_new_contig __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran __pyx_memoryview_copy_fortran __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy __pyx_memoryview_copy __pyx_kp_s_Out_of_bounds_on_buffer_access_a __pyx_pw___pyx_MemviewEnum_1__reduce_cython__ __pyx_dict_version.306 __pyx_dict_cached_value.305 __pyx_dict_version.304 __pyx_dict_cached_value.303 __pyx_pw_5numpy_6random_10_generator_9Generator_25bytes __pyx_n_s_integers __pyx_dict_version.37 __pyx_dict_cached_value.36 __pyx_n_s_uint32 __pyx_n_s_dtype __pyx_n_s_astype __pyx_kp_u_u4 __pyx_n_s_tobytes __pyx_pw_5numpy_6random_10_generator_1default_rng __pyx_n_u_capsule __pyx_dict_version.311 __pyx_dict_cached_value.310 __pyx_pyargnames.312 __pyx_pw_5numpy_6random_10_generator_9Generator_13spawn __pyx_n_s_spawn __pyx_pw_5numpy_6random_10_generator_9Generator_31standard_normal __pyx_dict_version.109 __pyx_dict_cached_value.108 __pyx_dict_version.107 __pyx_dict_cached_value.106 __pyx_n_s_float32 __pyx_n_s_out __pyx_kp_u_Unsupported_dtype_r_for_standard_2 __pyx_pyargnames.110 __pyx_pw_5numpy_6random_10_generator_9Generator_15random __pyx_dict_version.6 __pyx_dict_cached_value.5 __pyx_dict_version.4 __pyx_dict_cached_value.3 __pyx_kp_u_Unsupported_dtype_r_for_random __pyx_pyargnames.7 __pyx_pw_5numpy_6random_10_generator_9Generator_35standard_gamma __pyx_dict_version.115 __pyx_dict_cached_value.114 __pyx_dict_version.113 __pyx_dict_cached_value.112 __pyx_pyargnames.116 __pyx_kp_u_Unsupported_dtype_r_for_standard_3 _unellipsify __pyx_kp_s_Cannot_index_with_type_s __pyx_mp_ass_subscript_memoryview __pyx_pw_5numpy_6random_10_generator_9Generator_21standard_exponential __pyx_n_u_zig __pyx_dict_version.13 __pyx_dict_cached_value.12 __pyx_dict_version.11 __pyx_dict_cached_value.10 __pyx_n_s_method __pyx_kp_u_Unsupported_dtype_r_for_standard __pyx_pyargnames.14 __pyx_tp_new_memoryview __pyx_n_s_flags __pyx_pyargnames.309 __pyx_n_s_dtype_is_object __pyx_n_s_obj __pyx_tp_new__memoryviewslice __pyx_pw_5numpy_6random_10_generator_9Generator_29uniform __pyx_dict_version.102 __pyx_dict_cached_value.101 __pyx_n_s_subtract __pyx_dict_version.104 __pyx_dict_cached_value.103 __pyx_n_s_isfinite __pyx_kp_u_high_low __pyx_n_s_high __pyx_dict_version.100 __pyx_dict_cached_value.99 __pyx_n_s_all __pyx_dict_version.98 __pyx_dict_cached_value.97 __pyx_n_s_low __pyx_pyargnames.105 __pyx_tp_new_array __pyx_n_s_c __pyx_n_s_encode __pyx_n_s_ASCII __pyx_kp_s_Invalid_shape_in_axis_d_d __pyx_n_s_fortran __pyx_n_b_O __pyx_n_s_itemsize __pyx_n_s_mode __pyx_n_s_allocate_buffer __pyx_pyargnames.302 __pyx_kp_s_Invalid_mode_expected_c_or_fortr __pyx_n_s_ndim __pyx_memview_slice __pyx_n_s_start __pyx_n_s_stop __pyx_n_s_step __pyx_memoryview___getitem__ __pyx_pw_5numpy_6random_10_generator_9Generator_75negative_binomial __pyx_n_u_n __pyx_n_s_n __pyx_dict_version.165 __pyx_dict_cached_value.164 __pyx_n_s_sqrt __pyx_dict_version.163 __pyx_dict_cached_value.162 __pyx_n_s_any __pyx_dict_version.161 __pyx_dict_cached_value.160 __pyx_n_s_greater __pyx_pyargnames.166 __pyx_pw_5numpy_6random_10_generator_9Generator_93dirichlet __pyx_dict_version.258 __pyx_dict_cached_value.257 __pyx_dict_version.256 __pyx_dict_cached_value.255 __pyx_n_s_less __pyx_dict_version.254 __pyx_dict_cached_value.253 __pyx_n_s_index __pyx_dict_version.252 __pyx_dict_cached_value.251 __pyx_n_s_zeros __pyx_dict_version.250 __pyx_dict_cached_value.249 __pyx_n_s_max __pyx_dict_version.248 __pyx_dict_cached_value.247 __pyx_n_s_empty_like __pyx_n_s_exit __pyx_n_s_enter __pyx_n_s_alpha __pyx_pyargnames.259 __pyx_pw_5numpy_6random_10_generator_9Generator_83hypergeometric __pyx_dict_version.179 __pyx_dict_cached_value.178 __pyx_n_s_ngood __pyx_dict_version.177 __pyx_dict_cached_value.176 __pyx_dict_version.175 __pyx_dict_cached_value.174 __pyx_dict_version.173 __pyx_dict_cached_value.172 __pyx_dict_version.171 __pyx_dict_cached_value.170 __pyx_n_s_add __pyx_n_u_nsample __pyx_n_u_nbad __pyx_n_u_ngood __pyx_n_s_nbad __pyx_n_s_nsample __pyx_kp_u_both_ngood_and_nbad_must_be_less __pyx_pyargnames.180 __pyx_pw_5numpy_6random_10_generator_9Generator_23integers __pyx_dict_version.34 __pyx_dict_cached_value.33 __pyx_n_s_int32 __pyx_dict_version.32 __pyx_dict_cached_value.31 __pyx_dict_version.16 __pyx_dict_cached_value.15 __pyx_n_s_array __pyx_dict_version.30 __pyx_dict_cached_value.29 __pyx_n_s_int16 __pyx_n_s_endpoint __pyx_pyargnames.35 __pyx_dict_version.28 __pyx_dict_cached_value.27 __pyx_n_s_int8 __pyx_dict_version.26 __pyx_dict_cached_value.25 __pyx_n_s_uint64 __pyx_dict_version.24 __pyx_dict_cached_value.23 __pyx_dict_version.22 __pyx_dict_cached_value.21 __pyx_n_s_uint16 __pyx_dict_version.20 __pyx_dict_cached_value.19 __pyx_n_s_uint8 __pyx_dict_version.18 __pyx_dict_cached_value.17 __pyx_n_s_bool __pyx_n_s_isnative __pyx_kp_u_Unsupported_dtype_r_for_integers __pyx_pw_5numpy_6random_10_generator_9Generator_73binomial __pyx_dict_version.158 __pyx_dict_cached_value.157 __pyx_n_s_empty __pyx_dict_version.156 __pyx_dict_cached_value.155 __pyx_dict_version.150 __pyx_dict_cached_value.149 __pyx_dict_version.148 __pyx_dict_cached_value.147 __pyx_pyargnames.159 __pyx_dict_version.154 __pyx_dict_cached_value.153 __pyx_dict_version.152 __pyx_dict_cached_value.151 __pyx_pw_5numpy_6random_10_generator_9Generator_99permutation __pyx_dict_version.299 __pyx_dict_cached_value.298 __pyx_n_s_arange __pyx_dict_version.297 __pyx_dict_cached_value.296 __pyx_n_s_asarray __pyx_n_s_shuffle __pyx_dict_version.295 __pyx_dict_cached_value.294 __pyx_n_s_x __pyx_dict_version.293 __pyx_dict_cached_value.292 __pyx_n_s_may_share_memory __pyx_dict_version.289 __pyx_dict_cached_value.288 __pyx_dict_version.287 __pyx_dict_cached_value.286 __pyx_n_s_intp __pyx_pyargnames.300 __pyx_n_s_axis __pyx_dict_version.291 __pyx_dict_cached_value.290 __pyx_pw_5numpy_6random_10_generator_9Generator_91multivariate_hypergeometric __pyx_n_u_marginals __pyx_n_u_count __pyx_dict_version.245 __pyx_dict_cached_value.244 __pyx_dict_version.243 __pyx_dict_cached_value.242 __pyx_dict_version.241 __pyx_dict_cached_value.240 __pyx_n_s_issubdtype __pyx_kp_u_colors_must_be_a_one_dimensional __pyx_dict_version.233 __pyx_dict_cached_value.232 __pyx_n_s_isscalar __pyx_dict_version.231 __pyx_dict_cached_value.230 __pyx_dict_version.229 __pyx_dict_cached_value.228 __pyx_pyargnames.246 __pyx_n_s_colors __pyx_dict_version.237 __pyx_dict_cached_value.236 __pyx_n_s_ascontiguousarray __pyx_dict_version.235 __pyx_dict_cached_value.234 __pyx_kp_u_sum_colors_must_not_exceed_the_m __pyx_kp_u_nsample_must_not_exceed_d __pyx_dict_version.239 __pyx_dict_cached_value.238 __pyx_kp_u_When_method_is_count_sum_colors __pyx_kp_u_Insufficient_memory_for_multivar __pyx_pw_5numpy_6random_10_generator_9Generator_97shuffle __pyx_n_s_writeable __pyx_dict_version.276 __pyx_dict_cached_value.275 __pyx_n_s_swapaxes __pyx_dict_version.274 __pyx_dict_cached_value.273 __pyx_dict_version.284 __pyx_dict_cached_value.283 __pyx_dict_version.282 __pyx_dict_cached_value.281 __pyx_dict_version.272 __pyx_dict_cached_value.271 __pyx_dict_version.270 __pyx_dict_cached_value.269 __pyx_n_s_warn __pyx_kp_u_you_are_shuffling_a __pyx_kp_u_object_which_is_not_a_subclass __pyx_n_s_strides __pyx_dict_version.280 __pyx_dict_cached_value.279 __pyx_dict_version.278 __pyx_dict_cached_value.277 __pyx_n_s_hasobject __pyx_n_s_stacklevel __pyx_pyargnames.285 __pyx_pw_5numpy_6random_10_generator_9Generator_71triangular __pyx_dict_version.145 __pyx_dict_cached_value.144 __pyx_dict_version.143 __pyx_dict_cached_value.142 __pyx_n_s_left __pyx_n_s_right __pyx_dict_version.141 __pyx_dict_cached_value.140 __pyx_dict_version.139 __pyx_dict_cached_value.138 __pyx_dict_version.137 __pyx_dict_cached_value.136 __pyx_dict_version.135 __pyx_dict_cached_value.134 __pyx_n_s_equal __pyx_pyargnames.146 __pyx_pf_5numpy_6random_10_generator_9Generator_94permuted __pyx_dict_version.267 __pyx_dict_cached_value.266 __pyx_dict_version.265 __pyx_dict_cached_value.264 __pyx_n_s_copyto __pyx_n_u_safe __pyx_n_s_casting __pyx_dict_version.263 __pyx_dict_cached_value.262 __pyx_dict_version.261 __pyx_dict_cached_value.260 __pyx_n_s_copy __pyx_n_u_K __pyx_n_s_order __pyx_n_s_ravel __pyx_n_u_A __pyx_pw_5numpy_6random_10_generator_9Generator_95permuted __pyx_pyargnames.268 __pyx_pw_5numpy_6random_10_generator_9Generator_87multivariate_normal __pyx_n_u_svd __pyx_n_u_warn __pyx_n_u_eigh __pyx_dict_version.203 __pyx_dict_cached_value.202 __pyx_dict_version.201 __pyx_dict_cached_value.200 __pyx_n_u_cholesky __pyx_dict_version.199 __pyx_dict_cached_value.198 __pyx_dict_version.197 __pyx_dict_cached_value.196 __pyx_n_s_cov __pyx_n_s_check_valid __pyx_n_s_tol __pyx_pyargnames.204 __pyx_n_s_standard_normal __pyx_n_s_reshape __pyx_dict_version.195 __pyx_dict_cached_value.194 __pyx_n_s_double __pyx_n_s_svd __pyx_n_s_numpy_linalg __pyx_n_u_ignore __pyx_n_u_raise __pyx_dict_version.193 __pyx_dict_cached_value.192 __pyx_n_s_allclose __pyx_dict_version.191 __pyx_dict_cached_value.190 __pyx_n_s_dot __pyx_n_s_T __pyx_n_s_eigh __pyx_n_s_cholesky __pyx_dict_version.185 __pyx_dict_cached_value.184 __pyx_dict_version.189 __pyx_dict_cached_value.188 __pyx_dict_version.183 __pyx_dict_cached_value.182 __pyx_n_s_rtol __pyx_n_s_atol __pyx_dict_version.187 __pyx_dict_cached_value.186 __pyx_pf_5numpy_6random_10_generator_9Generator_26choice __pyx_dict_version.95 __pyx_dict_cached_value.94 __pyx_dict_version.93 __pyx_dict_cached_value.92 __pyx_n_s_item __pyx_dict_version.89 __pyx_dict_cached_value.88 __pyx_n_s_prod __pyx_dict_version.91 __pyx_dict_cached_value.90 __pyx_dict_version.87 __pyx_dict_cached_value.86 __pyx_dict_version.85 __pyx_dict_cached_value.84 __pyx_n_s_finfo __pyx_dict_version.83 __pyx_dict_cached_value.82 __pyx_n_s_eps __pyx_dict_version.81 __pyx_dict_cached_value.80 __pyx_dict_version.79 __pyx_dict_cached_value.78 __pyx_dict_version.77 __pyx_dict_cached_value.76 __pyx_dict_version.75 __pyx_dict_cached_value.74 __pyx_n_s_isnan __pyx_dict_version.73 __pyx_dict_cached_value.72 __pyx_n_s_logical_or __pyx_n_s_reduce_2 __pyx_kp_u_a_must_be_a_sequence_or_an_integ __pyx_n_s_cumsum __pyx_n_s_random __pyx_n_s_searchsorted __pyx_n_u_right __pyx_n_s_side __pyx_dict_version.67 __pyx_dict_cached_value.66 __pyx_dict_version.65 __pyx_dict_cached_value.64 __pyx_dict_version.43 __pyx_dict_cached_value.42 __pyx_dict_version.71 __pyx_dict_cached_value.70 __pyx_dict_version.69 __pyx_dict_cached_value.68 __pyx_dict_version.61 __pyx_dict_cached_value.60 __pyx_n_s_count_nonzero __pyx_dict_version.59 __pyx_dict_cached_value.58 __pyx_dict_version.57 __pyx_dict_cached_value.56 __pyx_dict_cached_value.54 __pyx_dict_version.55 __pyx_dict_version.53 __pyx_dict_cached_value.52 __pyx_n_s_unique __pyx_n_s_return_index __pyx_n_s_sort __pyx_n_s_take __pyx_dict_version.63 __pyx_dict_cached_value.62 __pyx_dict_version.41 __pyx_dict_cached_value.40 __pyx_dict_version.39 __pyx_dict_cached_value.38 __pyx_dict_version.51 __pyx_dict_cached_value.50 __pyx_dict_version.49 __pyx_dict_cached_value.48 __pyx_dict_version.47 __pyx_dict_cached_value.46 __pyx_n_s_full __pyx_dict_version.45 __pyx_dict_cached_value.44 __Pyx_TypeInfo_nn_uint64_t __pyx_pw_5numpy_6random_10_generator_9Generator_27choice __pyx_n_s_replace __pyx_pyargnames.96 __pyx_pw_5numpy_6random_10_generator_9Generator_89multinomial __pyx_n_u_pvals __pyx_kp_u_1_2 __pyx_dict_version.226 __pyx_dict_cached_value.225 __pyx_kp_u_sum_pvals __pyx_kp_u_None __pyx_kp_u_1_0 __pyx_dict_version.224 __pyx_dict_cached_value.223 __pyx_dict_version.222 __pyx_dict_cached_value.221 __pyx_dict_version.220 __pyx_dict_cached_value.219 __pyx_dict_version.218 __pyx_dict_cached_value.217 __pyx_dict_version.216 __pyx_dict_cached_value.215 __pyx_dict_version.214 __pyx_dict_cached_value.213 __pyx_dict_version.212 __pyx_dict_cached_value.211 __pyx_kp_u_1 __pyx_dict_version.210 __pyx_dict_cached_value.209 __pyx_dict_version.208 __pyx_dict_cached_value.207 __pyx_dict_version.206 __pyx_dict_cached_value.205 __pyx_n_s_pvals __pyx_pyargnames.227 __pyx_n_s_sum __pyx_kp_u_astype_np_float64_1_0_The_pvals __pyx_kp_u_Output_size __pyx_kp_u_is_not_compatible_with_broadcas __pyx_kp_u__41 __pyx_moduledef __pyx_k_1 __pyx_k_1_0 __pyx_k_1_2 __pyx_k_A __pyx_k_ASCII __pyx_k_Axis_argument_is_only_supported __pyx_k_Buffer_view_does_not_expose_stri __pyx_k_Can_only_create_a_buffer_that_is __pyx_k_Cannot_assign_to_read_only_memor __pyx_k_Cannot_create_writable_memory_vi __pyx_k_Cannot_index_with_type_s __pyx_k_Cannot_take_a_larger_sample_than __pyx_k_Construct_a_new_Generator_with_t __pyx_k_Ellipsis __pyx_k_Empty_shape_tuple_for_cython_arr __pyx_k_Fewer_non_zero_entries_in_p_than __pyx_k_Generator __pyx_k_Generator_binomial_line_2894 __pyx_k_Generator_bytes_line_653 __pyx_k_Generator_chisquare_line_1561 __pyx_k_Generator_choice_line_682 __pyx_k_Generator_dirichlet_line_4300 __pyx_k_Generator_exponential_line_405 __pyx_k_Generator_f_line_1395 __pyx_k_Generator_gamma_line_1317 __pyx_k_Generator_geometric_line_3323 __pyx_k_Generator_gumbel_line_2346 __pyx_k_Generator_hypergeometric_line_33 __pyx_k_Generator_integers_line_526 __pyx_k_Generator_laplace_line_2261 __pyx_k_Generator_logistic_line_2465 __pyx_k_Generator_lognormal_line_2545 __pyx_k_Generator_logseries_line_3517 __pyx_k_Generator_multinomial_line_3838 __pyx_k_Generator_multivariate_hypergeom __pyx_k_Generator_multivariate_normal_li __pyx_k_Generator_negative_binomial_line __pyx_k_Generator_noncentral_chisquare_l __pyx_k_Generator_noncentral_f_line_1483 __pyx_k_Generator_normal_line_1123 __pyx_k_Generator_pareto_line_1963 __pyx_k_Generator_permutation_line_4790 __pyx_k_Generator_permuted_line_4498 __pyx_k_Generator_poisson_line_3162 __pyx_k_Generator_power_line_2160 __pyx_k_Generator_random_line_299 __pyx_k_Generator_rayleigh_line_2657 __pyx_k_Generator_shuffle_line_4658 __pyx_k_Generator_spawn_line_241 __pyx_k_Generator_standard_cauchy_line_1 __pyx_k_Generator_standard_exponential_l __pyx_k_Generator_standard_gamma_line_12 __pyx_k_Generator_standard_normal_line_1 __pyx_k_Generator_standard_t_line_1774 __pyx_k_Generator_triangular_line_2794 __pyx_k_Generator_uniform_line_945 __pyx_k_Generator_vonmises_line_1880 __pyx_k_Generator_wald_line_2726 __pyx_k_Generator_weibull_line_2061 __pyx_k_Generator_zipf_line_3235 __pyx_k_ImportError __pyx_k_Incompatible_checksums_0x_x_vs_0 __pyx_k_IndexError __pyx_k_Indirect_dimensions_not_supporte __pyx_k_Insufficient_memory_for_multivar __pyx_k_Invalid_bit_generator_The_bit_ge __pyx_k_Invalid_mode_expected_c_or_fortr __pyx_k_Invalid_shape_in_axis_d_d __pyx_k_K __pyx_k_MemoryError __pyx_k_MemoryView_of_r_at_0x_x __pyx_k_MemoryView_of_r_object __pyx_k_None __pyx_k_NotImplementedError __pyx_k_O __pyx_k_Out_of_bounds_on_buffer_access_a __pyx_k_Output_size __pyx_k_OverflowError __pyx_k_PCG64 __pyx_k_PickleError __pyx_k_Providing_a_dtype_with_a_non_nat __pyx_k_Range_exceeds_valid_bounds __pyx_k_RuntimeWarning __pyx_k_Sequence __pyx_k_T __pyx_k_TypeError __pyx_k_Unable_to_convert_item_to_object __pyx_k_Unsupported_dtype_r_for_integers __pyx_k_Unsupported_dtype_r_for_random __pyx_k_Unsupported_dtype_r_for_standard __pyx_k_Unsupported_dtype_r_for_standard_2 __pyx_k_Unsupported_dtype_r_for_standard_3 __pyx_k_UserWarning __pyx_k_ValueError __pyx_k_View_MemoryView __pyx_k_When_method_is_count_sum_colors __pyx_k_When_method_is_marginals_sum_col __pyx_k__2 __pyx_k__3 __pyx_k__41 __pyx_k__5 __pyx_k_a __pyx_k_a_and_p_must_have_same_size __pyx_k_a_cannot_be_empty_unless_no_samp __pyx_k_a_must_be_a_positive_integer_unl __pyx_k_a_must_be_a_sequence_or_an_integ __pyx_k_add __pyx_k_all __pyx_k_allclose __pyx_k_allocate_buffer __pyx_k_alpha __pyx_k_alpha_0 __pyx_k_any __pyx_k_arange __pyx_k_array __pyx_k_array_is_read_only __pyx_k_asarray __pyx_k_ascontiguousarray __pyx_k_astype __pyx_k_astype_np_float64_1_0_The_pvals __pyx_k_at_0x_X __pyx_k_atol __pyx_k_axis __pyx_k_b __pyx_k_base __pyx_k_binomial_n_p_size_None_Draw_sam __pyx_k_bit_generator __pyx_k_bool __pyx_k_both_ngood_and_nbad_must_be_less __pyx_k_bytes_length_Return_random_byte __pyx_k_c __pyx_k_capsule __pyx_k_casting __pyx_k_check_valid __pyx_k_check_valid_must_equal_warn_rais __pyx_k_chisquare_df_size_None_Draw_sam __pyx_k_choice_a_size_None_replace_True __pyx_k_cholesky __pyx_k_class __pyx_k_cline_in_traceback __pyx_k_collections_abc __pyx_k_colors __pyx_k_colors_must_be_a_one_dimensional __pyx_k_contiguous_and_direct __pyx_k_contiguous_and_indirect __pyx_k_copy __pyx_k_copyto __pyx_k_count __pyx_k_count_nonzero __pyx_k_cov __pyx_k_cov_must_be_2_dimensional_and_sq __pyx_k_covariance_is_not_symmetric_posi __pyx_k_cumsum __pyx_k_default_rng __pyx_k_default_rng_line_4863 __pyx_k_df __pyx_k_dfden __pyx_k_dfnum __pyx_k_dict __pyx_k_dirichlet_alpha_size_None_Draw __pyx_k_dot __pyx_k_double __pyx_k_dtype __pyx_k_dtype_is_object __pyx_k_eigh __pyx_k_empty __pyx_k_empty_like __pyx_k_encode __pyx_k_endpoint __pyx_k_enter __pyx_k_enumerate __pyx_k_eps __pyx_k_equal __pyx_k_error __pyx_k_exit __pyx_k_exponential_scale_1_0_size_None __pyx_k_f_dfnum_dfden_size_None_Draw_sa __pyx_k_finfo __pyx_k_flags __pyx_k_float32 __pyx_k_float64 __pyx_k_format __pyx_k_fortran __pyx_k_full __pyx_k_gamma_shape_scale_1_0_size_None __pyx_k_generator_ctor __pyx_k_generator_pyx __pyx_k_geometric_p_size_None_Draw_samp __pyx_k_getstate __pyx_k_got_differing_extents_in_dimensi __pyx_k_greater __pyx_k_gumbel_loc_0_0_scale_1_0_size_N __pyx_k_hasobject __pyx_k_high __pyx_k_high_low __pyx_k_high_low_range_exceeds_valid_bou __pyx_k_hypergeometric_ngood_nbad_nsamp __pyx_k_id __pyx_k_ignore __pyx_n_s_imatmul __pyx_k_imatmul __pyx_n_s_import __pyx_k_import __pyx_k_index __pyx_k_int16 __pyx_k_int32 __pyx_k_int64 __pyx_k_int8 __pyx_k_integers __pyx_k_integers_low_high_None_size_Non __pyx_k_intp __pyx_k_is_not_compatible_with_broadcas __pyx_k_isfinite __pyx_k_isnan __pyx_k_isnative __pyx_k_isscalar __pyx_k_issubdtype __pyx_k_item __pyx_k_itemsize __pyx_k_itemsize_0_for_cython_array __pyx_k_kappa __pyx_k_lam __pyx_k_laplace_loc_0_0_scale_1_0_size __pyx_k_left __pyx_k_left_mode __pyx_k_left_right __pyx_k_less __pyx_k_loc __pyx_k_lock __pyx_k_logical_or __pyx_k_logistic_loc_0_0_scale_1_0_size __pyx_k_lognormal_mean_0_0_sigma_1_0_si __pyx_k_logseries_p_size_None_Draw_samp __pyx_k_low __pyx_k_main __pyx_k_marginals __pyx_n_s_matmul __pyx_k_matmul __pyx_k_max __pyx_k_may_share_memory __pyx_k_mean __pyx_k_mean_and_cov_must_have_same_leng __pyx_k_mean_and_cov_must_not_be_complex __pyx_k_mean_must_be_1_dimensional __pyx_k_memory_allocation_failed_in_perm __pyx_k_memview __pyx_k_method __pyx_k_method_must_be_count_or_marginal __pyx_k_method_must_be_one_of_eigh_svd_c __pyx_k_mode __pyx_k_mode_right __pyx_k_mu __pyx_k_multinomial_n_pvals_size_None_D __pyx_k_multivariate_hypergeometric_col __pyx_k_multivariate_normal_mean_cov_si __pyx_k_n __pyx_k_n_too_large_or_p_too_small_see_G __pyx_k_name __pyx_k_name_2 __pyx_k_nbad __pyx_k_ndim __pyx_k_negative_binomial_n_p_size_None __pyx_k_negative_dimensions_are_not_allo __pyx_k_new __pyx_k_ngood __pyx_k_ngood_nbad_nsample __pyx_k_no_default___reduce___due_to_non __pyx_k_nonc __pyx_k_noncentral_chisquare_df_nonc_si __pyx_k_noncentral_f_dfnum_dfden_nonc_s __pyx_k_normal_loc_0_0_scale_1_0_size_N __pyx_k_normalize_axis_index __pyx_k_np __pyx_k_nsample __pyx_k_nsample_must_be_an_integer __pyx_k_nsample_must_be_nonnegative __pyx_k_nsample_must_not_exceed_d __pyx_k_nsample_sum_colors __pyx_k_numpy __pyx_k_numpy_core_multiarray __pyx_k_numpy_core_multiarray_failed_to __pyx_k_numpy_core_umath_failed_to_impor __pyx_k_numpy_linalg __pyx_k_numpy_random__generator __pyx_k_obj __pyx_k_object_which_is_not_a_subclass __pyx_k_operator __pyx_k_order __pyx_k_out __pyx_k_out_must_be_a_numpy_array __pyx_k_out_must_have_the_same_shape_as __pyx_k_p __pyx_k_p_must_be_1_dimensional __pyx_k_pack __pyx_k_pareto_a_size_None_Draw_samples __pyx_k_pcg64 __pyx_k_permutation_x_axis_0_Randomly_p __pyx_k_permuted_x_axis_None_out_None_R __pyx_k_pickle __pyx_k_pickle_2 __pyx_k_poisson_lam_1_0_size_None_Draw __pyx_k_poisson_lam_max __pyx_k_power_a_size_None_Draws_samples __pyx_k_probabilities_are_not_non_negati __pyx_k_probabilities_contain_NaN __pyx_k_probabilities_do_not_sum_to_1 __pyx_k_prod __pyx_k_pvals __pyx_k_pvals_must_have_at_least_1_dimen __pyx_k_pyx_PickleError __pyx_k_pyx_checksum __pyx_k_pyx_getbuffer __pyx_k_pyx_result __pyx_k_pyx_state __pyx_k_pyx_type __pyx_k_pyx_unpickle_Enum __pyx_k_pyx_vtable __pyx_k_raise __pyx_k_random __pyx_k_random_size_None_dtype_np_float __pyx_k_range __pyx_k_ravel __pyx_k_rayleigh_scale_1_0_size_None_Dr __pyx_k_reduce __pyx_k_reduce_2 __pyx_k_reduce_cython __pyx_k_reduce_ex __pyx_k_replace __pyx_k_reshape __pyx_k_return_index __pyx_k_reversed __pyx_k_right __pyx_n_s_rmatmul __pyx_k_rmatmul __pyx_k_rtol __pyx_k_safe __pyx_k_scale __pyx_k_searchsorted __pyx_k_seed __pyx_k_setstate __pyx_k_setstate_cython __pyx_k_shape __pyx_k_shuffle __pyx_k_shuffle_x_axis_0_Modify_an_arra __pyx_k_side __pyx_k_sigma __pyx_k_size __pyx_k_sort __pyx_k_spawn __pyx_k_spawn_n_children_Create_new_ind __pyx_k_sqrt __pyx_k_stacklevel __pyx_k_standard_cauchy_size_None_Draw __pyx_k_standard_exponential_size_None __pyx_k_standard_gamma_shape_size_None __pyx_k_standard_normal __pyx_k_standard_normal_size_None_dtype __pyx_k_standard_t_df_size_None_Draw_sa __pyx_k_start __pyx_k_state __pyx_k_step __pyx_k_stop __pyx_k_str __pyx_k_strided_and_direct __pyx_k_strided_and_direct_or_indirect __pyx_k_strided_and_indirect __pyx_k_strides __pyx_k_stringsource __pyx_k_struct __pyx_k_subtract __pyx_k_sum __pyx_k_sum_colors_must_not_exceed_the_m __pyx_k_sum_pvals __pyx_k_svd __pyx_k_swapaxes __pyx_k_take __pyx_k_test __pyx_k_tobytes __pyx_k_tol __pyx_k_triangular_left_mode_right_size __pyx_k_u4 __pyx_k_uint16 __pyx_k_uint32 __pyx_k_uint64 __pyx_k_uint8 __pyx_k_unable_to_allocate_array_data __pyx_k_unable_to_allocate_shape_and_str __pyx_k_uniform_low_0_0_high_1_0_size_N __pyx_k_unique __pyx_k_unpack __pyx_k_update __pyx_k_vonmises_mu_kappa_size_None_Dra __pyx_k_wald_mean_scale_size_None_Draw __pyx_k_warn __pyx_k_warnings __pyx_k_weibull_a_size_None_Draw_sample __pyx_k_writeable __pyx_k_x __pyx_k_you_are_shuffling_a __pyx_k_zeros __pyx_k_zig __pyx_k_zipf_a_size_None_Draw_samples_f __pyx_methods __pyx_moduledef_slots __pyx_methods__memoryviewslice __pyx_getsets__memoryviewslice __pyx_tp_as_sequence_memoryview __pyx_tp_as_mapping_memoryview __pyx_tp_as_buffer_memoryview __pyx_methods_memoryview __pyx_getsets_memoryview __pyx_methods_Enum __pyx_tp_as_sequence_array __pyx_tp_as_mapping_array __pyx_tp_as_buffer_array __pyx_methods_array __pyx_getsets_array __pyx_methods_5numpy_6random_10_generator_Generator __pyx_getsets_5numpy_6random_10_generator_Generator __pyx_doc_5numpy_6random_10_generator_9Generator_12spawn __pyx_doc_5numpy_6random_10_generator_9Generator_14random __pyx_doc_5numpy_6random_10_generator_9Generator_16beta __pyx_doc_5numpy_6random_10_generator_9Generator_18exponential __pyx_doc_5numpy_6random_10_generator_9Generator_20standard_exponential __pyx_doc_5numpy_6random_10_generator_9Generator_22integers __pyx_doc_5numpy_6random_10_generator_9Generator_24bytes __pyx_doc_5numpy_6random_10_generator_9Generator_26choice __pyx_doc_5numpy_6random_10_generator_9Generator_28uniform __pyx_doc_5numpy_6random_10_generator_9Generator_30standard_normal __pyx_doc_5numpy_6random_10_generator_9Generator_32normal __pyx_doc_5numpy_6random_10_generator_9Generator_34standard_gamma __pyx_doc_5numpy_6random_10_generator_9Generator_36gamma __pyx_doc_5numpy_6random_10_generator_9Generator_38f __pyx_doc_5numpy_6random_10_generator_9Generator_40noncentral_f __pyx_doc_5numpy_6random_10_generator_9Generator_42chisquare __pyx_doc_5numpy_6random_10_generator_9Generator_44noncentral_chisquare __pyx_doc_5numpy_6random_10_generator_9Generator_46standard_cauchy __pyx_doc_5numpy_6random_10_generator_9Generator_48standard_t __pyx_doc_5numpy_6random_10_generator_9Generator_50vonmises __pyx_doc_5numpy_6random_10_generator_9Generator_52pareto __pyx_doc_5numpy_6random_10_generator_9Generator_54weibull __pyx_doc_5numpy_6random_10_generator_9Generator_56power __pyx_doc_5numpy_6random_10_generator_9Generator_58laplace __pyx_doc_5numpy_6random_10_generator_9Generator_60gumbel __pyx_doc_5numpy_6random_10_generator_9Generator_62logistic __pyx_doc_5numpy_6random_10_generator_9Generator_64lognormal __pyx_doc_5numpy_6random_10_generator_9Generator_66rayleigh __pyx_doc_5numpy_6random_10_generator_9Generator_68wald __pyx_doc_5numpy_6random_10_generator_9Generator_70triangular __pyx_doc_5numpy_6random_10_generator_9Generator_72binomial __pyx_doc_5numpy_6random_10_generator_9Generator_74negative_binomial __pyx_doc_5numpy_6random_10_generator_9Generator_76poisson __pyx_doc_5numpy_6random_10_generator_9Generator_78zipf __pyx_doc_5numpy_6random_10_generator_9Generator_80geometric __pyx_doc_5numpy_6random_10_generator_9Generator_82hypergeometric __pyx_doc_5numpy_6random_10_generator_9Generator_84logseries __pyx_doc_5numpy_6random_10_generator_9Generator_86multivariate_normal __pyx_doc_5numpy_6random_10_generator_9Generator_88multinomial __pyx_doc_5numpy_6random_10_generator_9Generator_90multivariate_hypergeometric __pyx_doc_5numpy_6random_10_generator_9Generator_92dirichlet __pyx_doc_5numpy_6random_10_generator_9Generator_94permuted __pyx_doc_5numpy_6random_10_generator_9Generator_96shuffle __pyx_doc_5numpy_6random_10_generator_9Generator_98permutation __pyx_doc_5numpy_6random_10_generator_default_rng deregister_tm_clones __do_global_dtors_aux completed.0 __do_global_dtors_aux_fini_array_entry frame_dummy __frame_dummy_init_array_entry fe_double we_double ke_double fe_float we_float ke_float wi_double ki_double fi_double wi_float ki_float fi_float logfact __FRAME_END__ __GNU_EH_FRAME_HDR _GLOBAL_OFFSET_TABLE_ __TMC_END__ __dso_handle _DYNAMIC PyExc_ImportError PyInterpreterState_GetID PyDict_SetItemString exp@@GLIBC_2.2.5 PyUnicode_Compare PyExc_StopIteration random_buffered_bounded_uint32 PyFrame_New _PyUnicode_FastCopyCharacters random_weibull PyBool_Type PyModule_NewObject random_positive_int PyInit__generator memset@@GLIBC_2.2.5 PyException_SetCause _PyObject_GenericGetAttrWithDict __pyx_module_is_main_numpy__random___generator random_standard_gamma PyNumber_Remainder PyExc_ValueError PyType_Ready PyUnicode_DecodeASCII PyUnicode_Format PyExc_AssertionError PyList_AsTuple PyLong_FromUnsignedLong PyMem_Free random_multivariate_hypergeometric_count PyExc_SystemError random_bounded_uint16_fill __gmon_start__ log1p@@GLIBC_2.2.5 PyGILState_Release random_wald random_standard_normal random_geometric_search PyCapsule_Type PyUnicode_FromString _fini random_positive_int64 PyErr_NoMemory PyList_Type PyObject_GC_UnTrack random_rayleigh random_uint _PyObject_GetDictPtr random_loggam PyObject_IsTrue malloc@@GLIBC_2.2.5 random_standard_normal_fill PyExc_TypeError PyLong_FromSize_t PyMem_Realloc PyExc_Exception random_poisson PyObject_Not PyErr_GivenExceptionMatches PyIndex_Check PyThread_free_lock random_bounded_uint8_fill PyNumber_InPlaceMultiply PyNumber_Negative PyOS_snprintf PyUnicode_AsUTF8AndSize PyObject_GetItem random_power PyUnicode_FromFormat PyThread_allocate_lock PyNumber_Absolute log1pf@@GLIBC_2.2.5 _Py_FatalErrorFunc PyDict_Next PyImport_AddModule PyLong_AsLong Py_EnterRecursiveCall PyObject_CallFinalizerFromDealloc PyErr_Format _ITM_deregisterTMCloneTable PyFloat_FromDouble random_bounded_uint64_fill PyBaseObject_Type fmod@@GLIBC_2.2.5 _PyList_Extend PyNumber_InPlaceAdd PyObject_GetAttr PyErr_ExceptionMatches PyErr_Occurred PyNumber_InPlaceTrueDivide random_gamma_f random_exponential free@@GLIBC_2.2.5 random_standard_cauchy PyType_Modified PyExc_BufferError strlen@@GLIBC_2.2.5 PyObject_GetBuffer _ITM_registerTMCloneTable random_standard_exponential_inv_fill_f PyCapsule_New PyFloat_Type random_standard_exponential PyNumber_FloorDivide random_standard_exponential_inv_fill PyObject_GC_IsFinalized __cxa_finalize@@GLIBC_2.2.5 PyExc_ZeroDivisionError PyExc_IndexError _Py_FalseStruct PyErr_SetObject PyNumber_Multiply PyEval_RestoreThread PyErr_WriteUnraisable __isnan@@GLIBC_2.2.5 PyUnicode_InternFromString random_standard_uniform_f PyUnicode_Type PyExc_DeprecationWarning random_logseries PyObject_Size PyNumber_MatrixMultiply PyUnicode_Concat _Py_TrueStruct PyTuple_Pack PyLong_FromString PyEval_SaveThread PyExc_UnboundLocalError PyThreadState_Get PyTuple_Type PyErr_SetExcInfo random_vonmises PyDict_Size random_multivariate_hypergeometric_marginals pow@@GLIBC_2.2.5 PyModule_GetDict PyCode_NewEmpty PyErr_Restore PyImport_ImportModuleLevelObject PyCapsule_GetName PyObject_SetItem PyObject_GenericGetAttr PyLong_AsSsize_t PyObject_RichCompare random_interval PyObject_GetIter PyExc_RuntimeError PyType_IsSubtype Py_LeaveRecursiveCall PyBytes_Type random_buffered_bounded_uint8 PyBytes_FromString PyUnicode_Decode random_standard_normal_fill_f random_bounded_uint32_fill Py_GetVersion PyNumber_Add random_binomial_btpe PyGILState_Ensure PyDict_DelItem random_standard_uniform PyErr_WarnEx random_geometric PyErr_NormalizeException PyMethod_Type _PyInterpreterState_GetConfig PyObject_CallObject random_negative_binomial random_lognormal random_chisquare PyObject_Malloc PyErr_Fetch PyModule_GetName expf@@GLIBC_2.2.5 random_positive_int32 PyFloat_AsDouble vsnprintf@@GLIBC_2.2.5 PyObject_Format random_bounded_bool_fill PyObject_Hash PyNumber_Subtract PySlice_New PyObject_GetAttrString random_normal PyObject_IsInstance PyLong_Type random_uniform random_bounded_uint64 random_logistic _Py_EllipsisObject random_pareto powf@@GLIBC_2.2.5 PyObject_SetAttrString _Py_NoneStruct logfactorial PyExc_OverflowError PyList_Append PyObject_SetAttr random_zipf PyErr_SetNone random_triangular random_standard_uniform_fill_f acos@@GLIBC_2.2.5 PyBytes_FromStringAndSize PyDict_GetItemString PySequence_Tuple _PyDict_GetItem_KnownHash PyExc_AttributeError random_standard_normal_f random_standard_t PySlice_Type PyLong_FromLong random_standard_uniform_fill PyTraceBack_Here PyNumber_Or random_binomial PyExc_NameError random_gumbel memcmp@@GLIBC_2.2.5 PyException_SetTraceback _Py_Dealloc PyObject_Free PyImport_ImportModule random_beta _PyLong_Copy PyErr_GetExcInfo random_standard_exponential_fill PyErr_Clear PyTuple_New random_hypergeometric PyCFunction_Type PyCMethod_New random_multinomial PyUnicode_New PyImport_GetModuleDict random_laplace PyExc_NotImplementedError expm1@@GLIBC_2.2.5 random_standard_gamma_f random_gamma PyObject_RichCompareBool PyLong_FromSsize_t PyErr_WarnFormat PyErr_SetString PySequence_Contains PyNumber_TrueDivide PyModuleDef_Init PyUnicode_FromStringAndSize _PyDict_NewPresized PyCapsule_IsValid floor@@GLIBC_2.2.5 random_f PyBuffer_Release random_buffered_bounded_bool _PyType_Lookup _PyUnicode_Ready random_noncentral_chisquare random_geometric_inversion random_buffered_bounded_uint16 PyList_New sqrt@@GLIBC_2.2.5 PyMem_Malloc random_standard_exponential_f PyErr_PrintEx PyUnicode_AsUTF8 memcpy@@GLIBC_2.14 PyCapsule_GetPointer PyObject_GC_Track random_binomial_inversion PyNumber_Index log@@GLIBC_2.2.5 PyDict_SetItem logf@@GLIBC_2.2.5 PySequence_List PyLong_AsUnsignedLong random_standard_exponential_fill_f _init PyDict_New sqrtf@@GLIBC_2.2.5 random_noncentral_f .symtab .strtab .shstrtab .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .text .fini .rodata .eh_frame_hdr .eh_frame .init_array .fini_array .data.rel.ro .dynamic .got .got.plt .data .bss .comment 8 8 $ . o ` ` 8 p @ X X N H o 3 3 4 U o 5 5 P d 06 06 } n B @ @ x x s ` ~ ` h= h= @ @ < ` ` L x{ xk { k { k { k } m h p @ @ @v n
@ 0
/
P U h Z