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 ;
@ @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@.@ 4@x&? ?UUUUUU? a@ X@ `@ |@ @ MA .A-DT! C;, H 0d - * 0
0 - p @ P `L ` 0 D p h @ P l
!\ " %d `' ( (
)@
*d
+
+
,T . p/ @3 3T : >L @ Dh @H L O$ pR U$ W `[4 ^ ``< c fL j nx q @tx x Pz ` P ` h p < 8 $ h ` ! d! ! ! " # # $ $ D% % % <& /& =& 0JH' Z' {' 0( @) ) PT* @8,+ g+ @, `- `1t- P
- p. ,. @x. `. . . . @. / D/ d/ / @/ `/ / @/ p0 h0 p0 0 0 0 1 @ ,1 P @1 X1 l1 p!1 "1 "1 "1 #02 p#l2 $2 $2 &L3 `&3 &3 P'4 (P4 0)4 *4 @+5 -`5 05 05 05 15 16 2<6 3T6 03l6 `36 36 36 46 46 57 P587 p5P7 5h7 67 67 77 `77 7 8 7(8 p8L8 ;8 ;8 PF(9 Hd9 `I9 J9 J9 K : 0OL: 0Pp: P: PQ: pQ: R: S; T8; U; V; `XL< Z< PZ< p]@= `_= a@> @d> d> zR x $ @
FJ w ?;*3$" D X 4 X dE BDD d
GBI AAB |
xX D{
A \ BED D(D0|
(D ABBH Q
(D DBBC D
(A ABBE D 4 BFB B(A0A8DP8A0A(B BBB4 | Q ADD ^
CAE M
CAG A@
G h
H < AD A
AI G
AH V
AI G
AC t AT
K H ` < G BBB B(D0D8G`
8C0A(B BBBC K
8F0A(B BBBF 4 w AAG O
CAD I
CAC \ 4 BBE A(A0R
(D BBBI I
(D BBBE {(A EBB D 8 Ħ BEL E(A0A8E@8D0A(B BBBD y BEL E(A0A8E@8D0A(B BBB8 .~ BEH A(A0b(D BBB 8 p` BBE A(A0J(D BBB ( @ BAG U
DBK P l h BHE A(D0JHfA\0D(A BBB l BBB A(D0DPj
0D(A BBBL `
0D(A BBBE `
0D(D BBBB P 0 \ BBA s
EBI A
BBC D
BBH H
IBM d ` BBB B(D0D8Hh
8A0A(B BBBF
8F0A(B BBBA H BEE E(D0A8G8D0A(B BBB L 8 L BEA A(D@(
(A ABBE m
(A ABBE ( BD V
EG k
EH 0 t BEG e
EBF lEB ( dx BED ^
EBH yD F
AA D 8 BIA [
ABF L
ABA \
AEF D L BKD R
ABJ A
GBF Q
AEI \ ( BEI A(G0u
(D ABBJ [
(D ABBD \
(D DBBH @ (
BIA Y
BBG Q
EBH qBB ( l ` k BD d
EA I
EB P BBD G0Z
ABBB
DBBC `
ABBA 8 $ BEA G(G0s
(D ABBF d ( $ BBE E(D0A8F
8A0A(B BBBH d
8A0A(B BBBJ * 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 < 3 BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH <6 BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH d h9 BEA A(GPuXW`BhFpAxEFAEFQPW
(D ABBC l
(D ABBK AXW`RXFP_
(D ABBH | < BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG | x
> BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG |
@ BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG x $C BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | $F BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG THJ BBB A(A0G@eHIPYHF@_
0D(A BBBJ OHfPBXA`BhBpAxBBAQ@[
0D(A BBBG J BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | M BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG LO BFB B(D0A8G`NhapBxFAEFABFQ`hEpkhF`_
8D0A(B BBBI hWp_hA`NhVp`hG` R BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` | L Uj BBB B(A0D8G`hPpRhF`_
8D0A(B BBBE Rh[pBxFFBFABFQ` | X BBB B(A0D8GPHXi`BhApAxBADBFQP|XI`YXFP_
8D0A(B BBBG L Z BEA A(GPuXX`BhBpAxEFAEBWPW
(D ABBD l
(D ABBK AXW`RXFP_
(D ABBH | ]A BBA A(G@eHIPYHF@_
(D ABBF OHXPBXB`BhBpBxBBBQ@[
(D ABBD @ ` _ BBB B(D0GP
0D(B BBBE | eA BBA A(G@eHIPYHF@_
(D ABBF OHXPBXB`BhBpBxBBBQ@[
(D ABBD $ Xg BBB A(A0G@dHMP`HF@_
0D(A BBBH NHhPBXA`AhBpAxDBFQ@c
0D(A BBBH i BBB B(A0D8G`Uh[pBxFFBFABFQ`[
8D0A(B BBBD ^hWpRhF`hWp_hA` h < lv BBB A(G@
(D BBBC yHIPYHF@_
(D BBBF b
(D BBBD d o BBB A(A0G@eHIPYHF@_
0D(A BBBJ I
0D(A BBBD H LqF BEB B(A0A8D`Q
8D0A(B BBBA L \ P0 BBB D(D@
(A BBBK
(C BBBC \ 0 BBB A(D0
(D BBBE L
(D BBBB d
(D BBBB D Ђm BIA j
BBF l
BBH
BBJ H T % BBE B(A0A8D@'
8D0A(B BBBK ` ܌ BBA D(G@
(A ABBH \
(A ABBF R
(C ABBF \ BBB A(J DEFFBBAIbDEFFBBBIEFHFFBBAI{MHFFBBAI{MHFFBBAIM(A BBB @ BBB B(D0GP
0D(B BBBE @ < P BAD0v
ABH V
ABG j
CBI p BBD A(D0|
(D ABBF L
(D ABBC
(D ABBE
(D ABBH @ ؗ BBB B(A0GP
0D(B BBBB @ 8 T BBB B(A0GP
0D(B BBBB L | О PBB E(A0
(E BBBH r
(E BBBK BBB D(D0GPkXI`YXFP^
0A(A BBBB SXb`AhApBxADBFATPE
0A(A BBBH X BBB D(D0GPkXI`YXFP^
0A(A BBBB SXb`AhApBxADBFATPE
0A(A BBBH BBB D(D0GPkXI`YXFP^
0A(A BBBB SXb`AhApBxADBFATPE
0A(A BBBH | p BBA D(G@dHMP`HF@_
(D ABBA SHcPBXA`BhBpGxEFAQ@z
(D ABBD | BBB D(D0G`ehWpRhF`^
0A(A BBBA Wh[pFxFBFAEFAQ`A
0A(A BBBC
hWp_hA` BBB B(D0A8D`
8D0A(B BBBG yhIpYhF`\
8C0A(B BBBG j
8C0A(B BBBB H BBB B(A0D8DP
8D0A(B BBBE H d h BBB B(A0D8GPz
8D0A(B BBBE \ BBB B(A0A8G@IYF_
8D0A(B BBBK X l2 BBB B(A0D8DPRF_
8D0A(B BBBJ T l P +
BBB E(A0A8D`hIpYhF`b
8D0A(B BBBH T (
BBB B(A0A8DPkXI`YXFP_
8D0A(B BBBC X ! " BBB B(A0A8GpxIYxFp_
8D0A(B BBBC H x! $3 ! BBB B(D0D8D`
8D0A(B BBBE ! SI BBB B(A0A8DG
8D0A(B BBBF !IBKPBABBATWRFZoBAFBABBAR " |m3 BFB B(A0D8DEkF_
8D0A(B BBBA LVABFBBFBY9 bFBBFDBY<W_AFV`G \ X# Y" BBB B(A0A8JIYFb
8D0A(B BBBD l # ' BBB B(A0D8GmWRFb
8D0A(B BBBA `!W_A ($ $ BFB B(A0D8DXEkF_
8D0A(B BBBA USOEBBAABAT5eBDBBABYHW_AJV`G l %
A/ BBB B(A0D8G2WRFb
8D0A(B BBBD !V`G p% ;' BBB B(A0D8D_OAi_LBf
8D0A(B BBBG _LAPRFi _MB_MBGLABOAFEMBbGLA d p& bI BBB B(D0A8Dg
8A0A(B BBBF l
8A0A(B BBBB l & TX BFB B(A0D8G)WRFb
8D0A(B BBBA +W_F \ H' BBB B(A0D8GN
8D0A(B BBBA {"PRF ' ' ( ' ` AG0_
AH
AA ' T/ Dj H ( l AG@
AF t
AK 4
AK J
EA J
AE L( D U d( ' D b |( B \ ] ( ? D n ( @ DQ ( HH D |
A 4 ( | AO ~
EE L
AK J
AE ) dW AG AA 8) IO0
EA \) $ D _ t) DI ) AG _
AE ) ,& IX ) @/ AG ]A L ) P BAD D@
AAFG j
AAFN AAF <* S AG }A \* D U ( t* Ma
J n
J L
D A H * L BBB E(A0D8G[
8D0A(B BBBA * + + n \ L ,+ ` 4 @+ \ AGP
AG ^
AA L
AC x+ AG@
DD + % G] + 8 + I GED D(F0a(A ABBG8 , Y GED D(F0t(A ABBDH @, BEH H(KP
(E ABBK [(A AFB 8 , 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< - y GED D(G0O(A ABBH H - D BBE I(H0K8K`
8E0A(B BBBE 8 $. I GED D(F0b(A ABBFH `. BBE B(H0H8KP
8F0A(B BBBD 8 . I GED D(F0b(A ABBFH . $ AG@
AI t
AK 1
AF J
EI J
AE H 4/ x AG0
AC q
AF B
AE J
EA J
AE / GJ / GJ / GJ / 0 / vAD@O
EAH ` 0 $ D _ (0 D U @0 ( D c X0 D U p0 D U ( 0 AG0J
AM A 0 DQ 0 S AG }A 0 / AG ]A 1 D U $1 B \ ] <1 PC D z ( T1 AG V
AI XA $ 1 i BFG0IAK 1 4N AG DA 1 d DI 1 l3 D g
A 1 AG _
AE l 2 BFB A(A0Gpg
0D(A BBBK V
0D(A BBBG /
0D(A BBBA 2 & IX L 2
BFG E(D0A8J
8A0A(E BBBA 8 2
R BED A(G`k
(A ABBD 0 83 D ka
L nJHA
G L < l3 & AG
AL l
AK L
AC O
DE 3 W AG AA 3 IO0
EA , 3 C AGP#
AD _
AH 4 AG@
DD D4 _ D Z \4 D t4 ( 4 V BAG@CFB 4 L@
M r
E 0 4 MGG T
ABF h H 5 PZ BBB B(D0A8D@}
8D0A(B BBBE H X5 d BBB B(D0A8DPm
8D0A(B BBBE x 5 BDB B(A0A8DP
8A0A(B BBBD C
8A0A(B BBBC a
8A0A(B BBBE x 6 BDB B(A0A8DP
8A0A(B BBBC B
8A0A(B BBBD `
8A0A(B BBBF ( 6 0 I ACD g
AAG H 6 T BBB B(D0D8D`b
8A0A(B BBBH 7 ( BBB B(D0D8DP
8A0A(B BBBE
8A0A(B BBBC d
8A0A(B BBBB m
8A0A(B BBBA d 7 !{ BBB B(A0A8GP
8A0A(B BBBF I
8A0A(B BBBE x 8 #` BBE B(A0A8DPR
8K0A(B BBBI _
8A0A(B BBBG L
8A0A(B BBBJ , 8 |%w KHE }ABH \ 8 % BIB B(A0D8D`n
8A0A(B BBBA S8A0A(B BBB 0 0 k &
k k o `
G p H Ц 83 s o 2 o o 0 o k 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
This is an alias of `random_sample`. See `random_sample` for the complete
documentation.
This is an alias of `random_sample`. See `random_sample` for the complete
documentation.
Sets the singleton RandomState's bit generator
Parameters
----------
bitgen
A bit generator instance
Notes
-----
The singleton RandomState provides the random variate generators in the
``numpy.random``namespace. This function, and its counterpart get method,
provides a path to hot-swap the default MT19937 bit generator with a
user provided alternative. These function are intended to provide
a continuous path where a single underlying bit generator can be
used both with an instance of ``Generator`` and with the singleton
instance of RandomState.
See Also
--------
get_bit_generator
numpy.random.Generator
Returns the singleton RandomState's bit generator
Returns
-------
BitGenerator
The bit generator that underlies the singleton RandomState instance
Notes
-----
The singleton RandomState provides the random variate generators in the
``numpy.random`` namespace. This function, and its counterpart set method,
provides a path to hot-swap the default MT19937 bit generator with a
user provided alternative. These function are intended to provide
a continuous path where a single underlying bit generator can be
used both with an instance of ``Generator`` and with the singleton
instance of RandomState.
See Also
--------
set_bit_generator
numpy.random.Generator
seed(seed=None)
Reseed the singleton RandomState instance.
Notes
-----
This is a convenience, legacy function that exists to support
older code that uses the singleton RandomState. Best practice
is to use a dedicated ``Generator`` instance rather than
the random variate generation methods exposed directly in
the random module.
See Also
--------
numpy.random.Generator
permutation(x)
Randomly permute a sequence, or return a permuted range.
If `x` is a multi-dimensional array, it is only shuffled along its
first index.
.. note::
New code should use the
`~numpy.random.Generator.permutation`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
Returns
-------
out : ndarray
Permuted sequence or array range.
See Also
--------
random.Generator.permutation: which should be used for new code.
Examples
--------
>>> np.random.permutation(10)
array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random
>>> np.random.permutation([1, 4, 9, 12, 15])
array([15, 1, 9, 4, 12]) # random
>>> arr = np.arange(9).reshape((3, 3))
>>> np.random.permutation(arr)
array([[6, 7, 8], # random
[0, 1, 2],
[3, 4, 5]])
shuffle(x)
Modify a sequence in-place by shuffling its contents.
This function only shuffles the array along the first axis of a
multi-dimensional array. The order of sub-arrays is changed but
their contents remains the same.
.. note::
New code should use the `~numpy.random.Generator.shuffle`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
Parameters
----------
x : ndarray or MutableSequence
The array, list or mutable sequence to be shuffled.
Returns
-------
None
See Also
--------
random.Generator.shuffle: which should be used for new code.
Examples
--------
>>> arr = np.arange(10)
>>> np.random.shuffle(arr)
>>> arr
[1 7 5 2 9 4 3 6 0 8] # random
Multi-dimensional arrays are only shuffled along the first axis:
>>> arr = np.arange(9).reshape((3, 3))
>>> np.random.shuffle(arr)
>>> arr
array([[3, 4, 5], # random
[6, 7, 8],
[0, 1, 2]])
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.
.. note::
New code should use the `~numpy.random.Generator.dirichlet`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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 or equal to zero
See Also
--------
random.Generator.dirichlet: which should be used for new code.
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.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")
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``.
.. note::
New code should use the `~numpy.random.Generator.multinomial`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
Parameters
----------
n : int
Number of experiments.
pvals : sequence of floats, length p
Probabilities of each of the ``p`` different outcomes. These
must sum to 1 (however, the last element is always assumed to
account for the remaining probability, as long as
``sum(pvals[:-1]) <= 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. Default is None, in which case a
single value is returned.
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.
See Also
--------
random.Generator.multinomial: which should be used for new code.
Examples
--------
Throw a dice 20 times:
>>> np.random.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:
>>> np.random.multinomial(20, [1/6.]*6, size=2)
array([[3, 4, 3, 3, 4, 3], # random
[2, 4, 3, 4, 0, 7]])
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.
A loaded die is more likely to land on number 6:
>>> np.random.multinomial(100, [1/7.]*5 + [2/7.])
array([11, 16, 14, 17, 16, 26]) # 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:
>>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3]) # RIGHT
array([38, 62]) # random
not like:
>>> np.random.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)
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 (standard deviation, or "width,"
squared) of the one-dimensional normal distribution.
.. note::
New code should use the
`~numpy.random.Generator.multivariate_normal`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
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.
See Also
--------
random.Generator.multivariate_normal: which should be used for new code.
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.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.
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]]
>>> x = np.random.multivariate_normal(mean, cov, (3, 3))
>>> x.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 = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.logseries`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.logseries: which should be used for new code.
Notes
-----
The probability density 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.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``).
.. note::
New code should use the
`~numpy.random.Generator.hypergeometric`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
Parameters
----------
ngood : int or array_like of ints
Number of ways to make a good selection. Must be nonnegative.
nbad : int or array_like of ints
Number of ways to make a bad selection. Must be nonnegative.
nsample : int or array_like of ints
Number of items sampled. Must be at least 1 and at most
``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
--------
scipy.stats.hypergeom : probability density function, distribution or
cumulative density function, etc.
random.Generator.hypergeometric: which should be used for new code.
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.
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
Examples
--------
Draw samples from the distribution:
>>> ngood, nbad, nsamp = 100, 2, 10
# number of good, number of bad, and number of samples
>>> s = np.random.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 = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.geometric`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.geometric: which should be used for new code.
Examples
--------
Draw ten thousand values from the geometric distribution,
with the probability of an individual success equal to 0.35:
>>> z = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.zipf`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.zipf: which should be used for new code.
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.zipf(a, 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.
.. note::
New code should use the `~numpy.random.Generator.poisson`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.poisson: which should be used for new code.
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
>>> s = np.random.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 = np.random.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].
.. note::
New code should use the
`~numpy.random.Generator.negative_binomial`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
Parameters
----------
n : float or array_like of floats
Parameter of the distribution, > 0.
p : float or array_like of floats
Parameter of the distribution, >= 0 and <=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.
See Also
--------
random.Generator.negative_binomial: which should be used for new code.
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.
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.negative_binomial(1, 0.1, 100000)
>>> for i in range(1, 11): # doctest: +SKIP
... probability = sum(s>> n, p = 10, .5 # number of trials, probability of each trial
>>> s = np.random.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(np.random.binomial(9, 0.1, 20000) == 0)/20000.
# answer = 0.38885, or 38%.
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.
.. note::
New code should use the `~numpy.random.Generator.triangular`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.triangular: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.wald`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.wald: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.rayleigh`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.rayleigh: which should be used for new code.
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
>>> values = hist(np.random.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 = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.lognormal`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.lognormal: which should be used for new code.
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:
>>> mu, sigma = 3., 1. # mean and standard deviation
>>> s = np.random.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.
>>> b = []
>>> for i in range(1000):
... a = 10. + np.random.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).
.. note::
New code should use the `~numpy.random.Generator.logistic`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.logistic: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.gumbel`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
random.Generator.gumbel: which should be used for new code.
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:
>>> mu, beta = 0, 0.1 # location and scale
>>> s = np.random.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 = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.laplace`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.laplace: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.power`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.power: which should be used for new code.
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:
>>> a = 5. # shape
>>> samples = 1000
>>> s = np.random.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 = np.random.power(5, 1000000)
>>> rvsp = np.random.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('np.random.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 + np.random.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}`.
.. note::
New code should use the `~numpy.random.Generator.weibull`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
random.Generator.weibull: which should be used for new code.
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:
>>> a = 5. # shape
>>> s = np.random.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(np.random.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.
.. note::
New code should use the `~numpy.random.Generator.pareto`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.pareto: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.vonmises`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.vonmises: which should be used for new code.
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.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`).
.. note::
New code should use the `~numpy.random.Generator.standard_t`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.standard_t: which should be used for new code.
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.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.
.. note::
New code should use the
`~numpy.random.Generator.standard_cauchy`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.standard_cauchy: which should be used for new code.
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.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.
.. note::
New code should use the
`~numpy.random.Generator.noncentral_chisquare`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.noncentral_chisquare: which should be used for new code.
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
>>> import matplotlib.pyplot as plt
>>> values = plt.hist(np.random.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(np.random.noncentral_chisquare(3, .0000001, 100000),
... bins=np.arange(0., 25, .1), density=True)
>>> values2 = plt.hist(np.random.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(np.random.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.
.. note::
New code should use the `~numpy.random.Generator.chisquare`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.chisquare: which should be used for new code.
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.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.
.. note::
New code should use the
`~numpy.random.Generator.noncentral_f`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.noncentral_f: which should be used for new code.
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.
>>> dfnum = 3 # between group deg of freedom
>>> dfden = 20 # within groups degrees of freedom
>>> nonc = 3.0
>>> nc_vals = np.random.noncentral_f(dfnum, dfden, nonc, 1000000)
>>> NF = np.histogram(nc_vals, bins=50, density=True)
>>> c_vals = np.random.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.
.. note::
New code should use the `~numpy.random.Generator.f`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.f: which should be used for new code.
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.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.
.. note::
New code should use the `~numpy.random.Generator.gamma`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.gamma: which should be used for new code.
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.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)
Draw samples from a standard Gamma distribution.
Samples are drawn from a Gamma distribution with specified parameters,
shape (sometimes designated "k") and scale=1.
.. note::
New code should use the
`~numpy.random.Generator.standard_gamma`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
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.
random.Generator.standard_gamma: which should be used for new code.
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.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]_.
.. note::
New code should use the `~numpy.random.Generator.normal`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
random.Generator.normal: which should be used for new code.
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
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.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.1 # 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.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)
Draw samples from a standard Normal distribution (mean=0, stdev=1).
.. note::
New code should use the
`~numpy.random.Generator.standard_normal`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
-------
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.
random.Generator.standard_normal: which should be used for new code.
Notes
-----
For random samples from the normal distribution with mean ``mu`` and
standard deviation ``sigma``, use one of::
mu + sigma * np.random.standard_normal(size=...)
np.random.normal(mu, sigma, size=...)
Examples
--------
>>> np.random.standard_normal()
2.1923875335537315 #random
>>> s = np.random.standard_normal(8000)
>>> s
array([ 0.6888893 , 0.78096262, -0.89086505, ..., 0.49876311, # random
-0.38672696, -0.4685006 ]) # random
>>> s.shape
(8000,)
>>> s = np.random.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 * np.random.standard_normal(size=(2, 4))
array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random
[ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random
random_integers(low, high=None, size=None)
Random integers of type `np.int_` between `low` and `high`, inclusive.
Return random integers of type `np.int_` from the "discrete uniform"
distribution in the closed interval [`low`, `high`]. If `high` is
None (the default), then results are from [1, `low`]. The `np.int_`
type translates to the C long integer type and its precision
is platform dependent.
This function has been deprecated. Use randint instead.
.. deprecated:: 1.11.0
Parameters
----------
low : int
Lowest (signed) integer to be drawn from the distribution (unless
``high=None``, in which case this parameter is the *highest* such
integer).
high : int, optional
If provided, the largest (signed) integer to be drawn from the
distribution (see above for behavior if ``high=None``).
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
-------
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.
See Also
--------
randint : Similar to `random_integers`, only for the half-open
interval [`low`, `high`), and 0 is the lowest value if `high` is
omitted.
Notes
-----
To sample from N evenly spaced floating-point numbers between a and b,
use::
a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)
Examples
--------
>>> np.random.random_integers(5)
4 # random
>>> type(np.random.random_integers(5))
>>> np.random.random_integers(5, size=(3,2))
array([[5, 4], # random
[3, 3],
[4, 5]])
Choose five random numbers from the set of five evenly-spaced
numbers between 0 and 2.5, inclusive (*i.e.*, from the set
:math:`{0, 5/8, 10/8, 15/8, 20/8}`):
>>> 2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.
array([ 0.625, 1.25 , 0.625, 0.625, 2.5 ]) # random
Roll two six sided dice 1000 times and sum the results:
>>> d1 = np.random.random_integers(1, 6, 1000)
>>> d2 = np.random.random_integers(1, 6, 1000)
>>> dsums = d1 + d2
Display results as a histogram:
>>> import matplotlib.pyplot as plt
>>> count, bins, ignored = plt.hist(dsums, 11, density=True)
>>> plt.show()
randn(d0, d1, ..., dn)
Return a sample (or samples) from the "standard normal" distribution.
.. note::
This is a convenience function for users porting code from Matlab,
and wraps `standard_normal`. That function takes a
tuple to specify the size of the output, which is consistent with
other NumPy functions like `numpy.zeros` and `numpy.ones`.
.. note::
New code should use the
`~numpy.random.Generator.standard_normal`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
If positive int_like arguments are provided, `randn` generates an array
of shape ``(d0, d1, ..., dn)``, filled
with random floats sampled from a univariate "normal" (Gaussian)
distribution of mean 0 and variance 1. A single float randomly sampled
from the distribution is returned if no argument is provided.
Parameters
----------
d0, d1, ..., dn : int, optional
The dimensions of the returned array, must be non-negative.
If no argument is given a single Python float is returned.
Returns
-------
Z : ndarray or float
A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from
the standard normal distribution, or a single such float if
no parameters were supplied.
See Also
--------
standard_normal : Similar, but takes a tuple as its argument.
normal : Also accepts mu and sigma arguments.
random.Generator.standard_normal: which should be used for new code.
Notes
-----
For random samples from the normal distribution with mean ``mu`` and
standard deviation ``sigma``, use::
sigma * np.random.randn(...) + mu
Examples
--------
>>> np.random.randn()
2.1923875335537315 # random
Two-by-four array of samples from the normal distribution with
mean 3 and standard deviation 2.5:
>>> 3 + 2.5 * np.random.randn(2, 4)
array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random
[ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random
rand(d0, d1, ..., dn)
Random values in a given shape.
.. note::
This is a convenience function for users porting code from Matlab,
and wraps `random_sample`. That function takes a
tuple to specify the size of the output, which is consistent with
other NumPy functions like `numpy.zeros` and `numpy.ones`.
Create an array of the given shape and populate it with
random samples from a uniform distribution
over ``[0, 1)``.
Parameters
----------
d0, d1, ..., dn : int, optional
The dimensions of the returned array, must be non-negative.
If no argument is given a single Python float is returned.
Returns
-------
out : ndarray, shape ``(d0, d1, ..., dn)``
Random values.
See Also
--------
random
Examples
--------
>>> np.random.rand(3,2)
array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #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`.
.. note::
New code should use the `~numpy.random.Generator.uniform`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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 or equal to 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()``. 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
--------
randint : Discrete uniform distribution, yielding integers.
random_integers : Discrete uniform distribution over the closed
interval ``[low, high]``.
random_sample : Floats uniformly distributed over ``[0, 1)``.
random : Alias for `random_sample`.
rand : Convenience function that accepts dimensions as input, e.g.,
``rand(2,2)`` would generate a 2-by-2 array of floats,
uniformly distributed over ``[0, 1)``.
random.Generator.uniform: which should be used for new code.
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.
If ``high`` < ``low``, the results are officially undefined
and may eventually raise an error, i.e. do not rely on this
function to behave when passed arguments satisfying that
inequality condition. 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()``. For example:
>>> x = np.float32(5*0.99999999)
>>> x
5.0
Examples
--------
Draw samples from the distribution:
>>> s = np.random.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)
Generates a random sample from a given 1-D array
.. versionadded:: 1.7.0
.. note::
New code should use the `~numpy.random.Generator.choice`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
Parameters
----------
a : 1-D array-like or int
If an ndarray, a random sample is generated from its elements.
If an int, the random sample is generated as if it were ``np.arange(a)``
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.
replace : boolean, 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``.
Returns
-------
samples : single item or ndarray
The generated random samples
Raises
------
ValueError
If a is an int and less than zero, if a or p are not 1-dimensional,
if a is an array-like of 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
--------
randint, shuffle, permutation
random.Generator.choice: which should be used in new code
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).
Sampling random rows from a 2-D array is not possible with this function,
but is possible with `Generator.choice` through its ``axis`` keyword.
Examples
--------
Generate a uniform random sample from np.arange(5) of size 3:
>>> np.random.choice(5, 3)
array([0, 3, 4]) # random
>>> #This is equivalent to np.random.randint(0,5,3)
Generate a non-uniform random sample from np.arange(5) of size 3:
>>> np.random.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:
>>> np.random.choice(5, 3, replace=False)
array([3,1,0]) # random
>>> #This is equivalent to np.random.permutation(np.arange(5))[:3]
Generate a non-uniform random sample from np.arange(5) of size
3 without replacement:
>>> np.random.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']
>>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random
dtype='>> np.random.bytes(10)
b' eh\x85\x022SZ\xbf\xa4' #random
randint(low, high=None, size=None, dtype=int)
Return random integers from `low` (inclusive) to `high` (exclusive).
Return random integers from the "discrete uniform" distribution of
the specified dtype in the "half-open" interval [`low`, `high`). If
`high` is None (the default), then results are from [0, `low`).
.. note::
New code should use the `~numpy.random.Generator.integers`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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 one above the
*highest* such integer).
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 int.
.. versionadded:: 1.11.0
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.
See Also
--------
random_integers : similar to `randint`, only for the closed
interval [`low`, `high`], and 1 is the lowest value if `high` is
omitted.
random.Generator.integers: which should be used for new code.
Examples
--------
>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random
>>> np.random.randint(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:
>>> np.random.randint(5, size=(2, 4))
array([[4, 0, 2, 1], # random
[3, 2, 2, 0]])
Generate a 1 x 3 array with 3 different upper bounds
>>> np.random.randint(1, [3, 5, 10])
array([2, 2, 9]) # random
Generate a 1 by 3 array with 3 different lower bounds
>>> np.random.randint([1, 5, 7], 10)
array([9, 8, 7]) # random
Generate a 2 by 4 array using broadcasting with dtype of uint8
>>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)
array([[ 8, 6, 9, 7], # random
[ 1, 16, 9, 12]], dtype=uint8)
tomaxint(size=None)
Return a sample of uniformly distributed random integers in the interval
[0, ``np.iinfo(np.int_).max``]. The `np.int_` type translates to the C long
integer type and its precision is platform dependent.
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
-------
out : ndarray
Drawn samples, with shape `size`.
See Also
--------
randint : Uniform sampling over a given half-open interval of integers.
random_integers : Uniform sampling over a given closed interval of
integers.
Examples
--------
>>> rs = np.random.RandomState() # need a RandomState object
>>> rs.tomaxint((2,2,2))
array([[[1170048599, 1600360186], # random
[ 739731006, 1947757578]],
[[1871712945, 752307660],
[1601631370, 1479324245]]])
>>> rs.tomaxint((2,2,2)) < np.iinfo(np.int_).max
array([[[ True, True],
[ True, True]],
[[ True, True],
[ True, True]]])
standard_exponential(size=None)
Draw samples from the standard exponential distribution.
`standard_exponential` is identical to the exponential distribution
with a scale parameter of 1.
.. note::
New code should use the
`~numpy.random.Generator.standard_exponential`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
-------
out : float or ndarray
Drawn samples.
See Also
--------
random.Generator.standard_exponential: which should be used for new code.
Examples
--------
Output a 3x8000 array:
>>> n = np.random.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]_.
.. note::
New code should use the `~numpy.random.Generator.exponential`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
See Also
--------
random.Generator.exponential: which should be used for new code.
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.
.. note::
New code should use the `~numpy.random.Generator.beta`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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.
See Also
--------
random.Generator.beta: which should be used for new code.
random(size=None)
Return random floats in the half-open interval [0.0, 1.0). Alias for
`random_sample` to ease forward-porting to the new random API.
random_sample(size=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` multiply
the output of `random_sample` by `(b-a)` and add `a`::
(b - a) * random_sample() + a
.. note::
New code should use the `~numpy.random.Generator.random`
method of a `~numpy.random.Generator` instance instead;
please see the :ref:`random-quick-start`.
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
-------
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
--------
random.Generator.random: which should be used for new code.
Examples
--------
>>> np.random.random_sample()
0.47108547995356098 # random
>>> type(np.random.random_sample())
>>> np.random.random_sample((5,))
array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random
Three-by-two array of random numbers from [-5, 0):
>>> 5 * np.random.random_sample((3, 2)) - 5
array([[-3.99149989, -0.52338984], # random
[-2.99091858, -0.79479508],
[-1.23204345, -1.75224494]])
set_state(state)
Set the internal state of the generator from a tuple.
For use if one has reason to manually (re-)set the internal state of
the bit generator used by the RandomState instance. By default,
RandomState uses the "Mersenne Twister"[1]_ pseudo-random number
generating algorithm.
Parameters
----------
state : {tuple(str, ndarray of 624 uints, int, int, float), dict}
The `state` tuple has the following items:
1. the string 'MT19937', specifying the Mersenne Twister algorithm.
2. a 1-D array of 624 unsigned integers ``keys``.
3. an integer ``pos``.
4. an integer ``has_gauss``.
5. a float ``cached_gaussian``.
If state is a dictionary, it is directly set using the BitGenerators
`state` property.
Returns
-------
out : None
Returns 'None' on success.
See Also
--------
get_state
Notes
-----
`set_state` and `get_state` are not needed to work with any of the
random distributions in NumPy. If the internal state is manually altered,
the user should know exactly what he/she is doing.
For backwards compatibility, the form (str, array of 624 uints, int) is
also accepted although it is missing some information about the cached
Gaussian value: ``state = ('MT19937', keys, pos)``.
References
----------
.. [1] M. Matsumoto and T. Nishimura, "Mersenne Twister: A
623-dimensionally equidistributed uniform pseudorandom number
generator," *ACM Trans. on Modeling and Computer Simulation*,
Vol. 8, No. 1, pp. 3-30, Jan. 1998.
get_state(legacy=True)
Return a tuple representing the internal state of the generator.
For more details, see `set_state`.
Parameters
----------
legacy : bool, optional
Flag indicating to return a legacy tuple state when the BitGenerator
is MT19937, instead of a dict. Raises ValueError if the underlying
bit generator is not an instance of MT19937.
Returns
-------
out : {tuple(str, ndarray of 624 uints, int, int, float), dict}
If legacy is True, the returned tuple has the following items:
1. the string 'MT19937'.
2. a 1-D array of 624 unsigned integer keys.
3. an integer ``pos``.
4. an integer ``has_gauss``.
5. a float ``cached_gaussian``.
If `legacy` is False, or the BitGenerator is not MT19937, then
state is returned as a dictionary.
See Also
--------
set_state
Notes
-----
`set_state` and `get_state` are not needed to work with any of the
random distributions in NumPy. If the internal state is manually altered,
the user should know exactly what he/she is doing.
seed(seed=None)
Reseed a legacy MT19937 BitGenerator
Notes
-----
This is a convenience, legacy function.
The best practice is to **not** reseed a BitGenerator, rather to
recreate a new one. This method is here for legacy reasons.
This example demonstrates best practice.
>>> from numpy.random import MT19937
>>> from numpy.random import RandomState, SeedSequence
>>> rs = RandomState(MT19937(SeedSequence(123456789)))
# Later, you want to restart the stream
>>> rs = RandomState(MT19937(SeedSequence(987654321)))
0
H
H
`
H
H
`
H
`
H
`
H
H
H
p
`
H
`
H
H
H
H
`
x
0
0
A @ & ` 0 > $ P P ! @M " ` M " # x p @ h L " ` X L ' P H ! @ @L " 8 L " 0 ` $ ( K , * - % ` $ ` ( % ! ` ( ` , K ' ( # x p # h ` @ ! X P H @ 8 ` 0 ( ` > G L
@K ! @ p K 0 & J 5 l h P x F p h d ` c X & P @ H @ 8 \ 0 x ( ! p
;
U
:
:
9
(
h
h
`
0
@ 4 x
p
h
/ 6 `
N X
N P
!
H
0
@
8
0
(
`
%
3
G
~
~
$
$
a
\
@
X
x
p
h
`
@
X
P
H
@
8
0
X (
9
{
T
@
@
@ u
P
2
2
@ !
P
P x
n p
{ h
+ `
X
P
H
@
8
0
(
x
P
L
L
H
H
T x
@ p
h
`
H X
H P
H
@
h 8
h 0
@ p (
`
p
p
`
D
#
8
x
x
Q x
` p
` h
`
X
P
H
@
8
0
(
w
`k
] p
N
u
0
0
M ' x
` " p
h
@ `
X
P
X H
@
8
0
(
=
(
(
@
/
#
@
P
@
x
p
h
`
X
q P
H
@
@$ v 8
0
(
@ (
p
p
`
H
H
A
x
8 p
h
`
X
P
H
@
8
0
(
w
`
`
?
@{
|
|
P
~
x
p A
p
h
`
l 6 X
0 P
0 H
a @
8
0
Y z (
v
v
0
!
8
(
3
/
y
p
+
S
p
p
x
g p
q h
`
X
P
p H
@
8
0
(
b
b
M k
]
]
@
/
j
X
X
U
5 @ D 1 7
J 1 p1 `3 @ ̨ ٨
`d
0
o
h @
c y
W o
N j
ӧ e
Z
0 `W
K I
`;
W 6
\ -
ܧ 6 "
> 0
G p
/ 8 P - " Ѐ @ ~
z @x u r Po ڣ l z ԣ i l ̣ 0f ^ ţ pb K ^ ? Z @- @X # T E -
ʧ pR ` ` % ` 9 / p p u } `u 0 u `v y PW | GCC: (GNU) 10.2.1 20210130 (Red Hat 10.2.1-11) 1 ; 1 E p p1
1 X P h % 1 9 2 S 2 `3 Q 3 P4
5 > 6 G Q 7 w p8 ` ] Z ~ ` @u 9 ) 8 N : r ; < ` D @? L A 0B t x B x 1 0C E PD ` 0E z E ( G
0H k I pM N p 0 p
E h
_ @
| @ T
@
%
4 H
D @
Y
h @X
Z
5 ^ n X
| `
pb
0f #
8 i n z
l `
Po @
4 r m
}
u h
2
@x J r
z
~ 9
N Ѐ
`
( @
' P j ]
m
p
2
0 A r
A
- i
}
v
) g
F
3
D 0
@ @ m H
P
& 4 B % z
0 (
`
P
% X > 8
M \ e ` w X @
C x
p
`
X
P
p
% 9 P Q 8 j H
@ 8 0 9 x
L a ( z
@
0
*
V (
e
=
M
]
m
) T
d
8
,
<
a
q
" N
^ x
p
@ h
`
X
+
A P
Q
o H
@
8
0
-
=
i (
y
p
0 H N
^ (
! x
M _ 0
n
X X
!
Q
h 8 0 ( * E a + c ! ?! v! ! ! " K" u" " " x # p 8# P
K#
^# 0 q# 8
#
#
# #
# # #
$ H
$ `
#$
:$
V$ e$
|$ x
$
$ p
$ h
$
$ `
% X
!% x
5% P
L% H
h% `
y% @
% 8
%
% 0
% (
% p
&
&
<& X
H&
_&
{&
&
&
&
&
&
'
'
8'
I'
`'
|'
'
'
'
'
'
( @
(
7(
S( (
g(
~(
(
(
( x
(
( p
) h
*) x
H) `
_) X
{) 0
) P
) H
)
) @
* 8
*
3* 0
J* (
f*
w*
*
* 0
*
*
*
+
+
7+
I+
`+
|+
+
+
+ p
+
+
, P
,
*,
F, 8
V,
m,
,
,
,
,
,
,
-
1- x
M-
`- p
w- h
- `
- X
-
- P
- H
.
%. @
<. 8
X. p
w. 0
. (
. X
.
.
. @
/
'/
C/ (
X/
o/
/
/
/
/ H
/
/
0
+0
B0
^0
m0
0
0
0
0
0
0 h
1
:1
o1
1
1
1 2
2
(2 p
<2 X
M2
a2 h
w2 P
2
2
2
2
2
2
3
3 8
&3
:3
N3
d3 p
3 (
3
3
3
3 (
3
4
4
.4 h
=4 H
O4 0
_4
p4
4
4
4
4 P
4 (
4
5
5
&5
@5 h
_5 P
x5 8
5
5
5 @
5
5
5
6
6 '6 76
a6 6
6 6 `
7 37 `
]7 7
7 x 7 @
8 08
[8 8 P
8 8 8
8 h '9 X
Q9 w9 (
9 9
9 : 0
I: u:
: : H
: ;
H; p o; H
; x ;
; < h
?< j<
< < x
< =
B= n=
= ` =
= >
A> P j>
> >
> P ?
:? ` b? 0
? H ?
? @
@
8@ b@
@ X @
@ p A
4A ^A
A A
A B
3B H YB
B h B x
B X C
0C 8 [C h
C ( C
C 0 D
2D ]D
D D
D E
E KE ~E p
E h
E
E E
F x
1F 0 YF
pF
F F
F
F G
)G
EG
XG 8 iG (
zG
G G @
G H
G p
G -H
BH wH
H H
H
H
H 7I X
CI
XI `
dI I
I x
I x
I `
I 0 *J
@J x
[J `
lJ
|J p
J
J 0 J J
K
K
K
.K
i
j
j
$ Dj
Zj
j
P j
! j
j
@M " k
` -k
M " Uk
# ~k
k
@ k
L " k
l
L ' 7l
]l
! l
@L " l
L " l
` $ l
K , %m
* Nm
- wm
% m
m
m
` $ n
9n
]n
n
` n
n
( n
% o
! Bo
` do
o
( o
` , o
K ' p
( -p
# Vp
|p
# p
p
@ ! p
q
;q
^q
q
` q
q
` > q
q
G r
L 0r
Br
@K ! jr
@ ~r
r
p r
r
r
r
r
K 0 s
)s
& Rs
J 5 zs
l s
h s
P s
s
F s
s
d s
c s
& s
@ t
t
0t
\ ?t
x Ot
! \t
ft
st
p t
t
; t
t
t
U t
u
: u
9 |
Q|
h b|
@ p |
|
` |
p
|
` |
D
}
}
0}
=}
# f}
}
}
}
8 }
}
x }
}
Q ~
` /~
W~
a~
n~
{~
~
~
w
~
~
~
2
`k Z
o
] p
N
u
0
M '
` " H
]
@ y
X
ʀ
= !
5
\
k
( {
@ Ɓ
ԁ
/
# %
@ G
P m
z
@
ۂ
q
!
@$ v I
W
@ ( ~
̓
p
` #
0
>
L
H ]
A
ń
ڄ
8
#
8
E
w l
`
?
΅
ޅ
@{
|
P
2
?
L
~ Y
l
p A
Ȇ
l 6
0
a -
E
Y z l
v
0 ۇ
!
8
( 0
3 <
T
|
/
y
p
+
S
p
!
g .
q 9
H
W
f
p t
ʉ
ۉ
b
M k 7
] D
U
e
@
/ Ȋ
j
X
'
5
0 K
|
P
w
Y
@
Ќ y
u o
C j
6 e
S Í Z
v `W
3 I
k `;
6
q ڎ -
( "
R
z
ˏ B u @ p
6 4 A
u
# z
\ l
^
̒ K ! ? p > @- y #
k
% _ `
` ۔ { L n Ǖ
Q K a } `u h & u h O `v y | ݗ @0 ߗ p0 0 @
k ; 0 G k f
p
z
Ƙ
Ϙ
ؘ |Y 0 p @
k ( k 8 ` 0 2 83 Ц
`
0 ` k k k k m p @u @
1 C \ q `
ә p ' ) O B 8 D W K k @. pE ƚ ך ; ' y { B Q d p/ u e A `j _ ś J ۛ ( / Q 3 ' 0K 3 H @K V f C I R 0 ɜ ՜ | ` # 2 @ X O C e z P3 ʝ ؝ p8 # 0 L _ t z ў M - @M @ PO / W g p+ t A y ß П = @ a ) " E V f v ͠ < % `i . = J \ n , ? { f C ǡ ء ( : 2 M ^ o @2 S x n Ң p0 / r , 9 J E I h w U
- W ǣ < ߣ k ( ) U & B Q S N d p J ʤ + ' ؤ p~ w 4 M $ B @0 & [ 8 u `M ( n Z @Q N ʥ ݥ O # 7 E k V V m h @= Y Ȧ + ٦ `8 `C 7 Q I Y < I v b 8 n P i ѧ / M * ; > I \ h p, H x P, 2 b ~ ˨ ٨ @P H * M 7 J [ k 30 Ω + B N S 0t I ( 7 H c & d j p Ȫ ? -
` R 9 H 9 X i x @@ I ë Ϋ d W @/ $ __pyx_f_5numpy_6random_6mtrand_11RandomState__reset_gauss __pyx_tp_traverse_5numpy_6random_6mtrand_RandomState __pyx_getprop_5numpy_6random_6mtrand_11RandomState__bit_generator __pyx_tp_new_5numpy_6random_6mtrand_RandomState __pyx_vtabptr_5numpy_6random_6mtrand_RandomState __pyx_empty_tuple __Pyx_PyObject_Call __Pyx_PyObject_GetAttrStr __pyx_f_5numpy_6random_6mtrand_11RandomState__shuffle_raw __pyx_setprop_5numpy_6random_6mtrand_11RandomState__bit_generator __Pyx_PyNumber_IntOrLongWrongResultType __Pyx_PyInt_As_int __pyx_tp_dealloc_5numpy_6random_6mtrand_RandomState __Pyx_GetException __pyx_tp_clear_5numpy_6random_6mtrand_RandomState __Pyx_Import __pyx_m __Pyx_ImportVoidPtr_0_29_36 __Pyx_ImportFunction_0_29_36 __Pyx_copy_spec_to_module __pyx_pymod_create main_interpreter_id.0 __Pyx_PyDict_GetItem __Pyx_ImportType_0_29_36.constprop.0 __Pyx_PyObject_GetSlice.constprop.0 __Pyx_Raise.constprop.0 __Pyx_ParseOptionalKeywords.constprop.0 __Pyx_PyCode_New.constprop.0 __Pyx_PyUnicode_Equals __Pyx_IternextUnpackEndCheck __Pyx_GetBuiltinName __pyx_b __Pyx_ImportFrom __Pyx_PyInt_As_long __Pyx__PyObject_CallOneArg __Pyx_PyObject_CallOneArg __Pyx_PyObject_Call2Args __Pyx_PyObject_CallNoArg __Pyx_PyInt_As_Py_intptr_t.part.0 __Pyx_PyObject_GetItem __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_pw_5numpy_6random_6mtrand_11RandomState_83wald __pyx_kp_u__13 __pyx_float_0_0 __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.120 __pyx_n_s_size __pyx_pw_5numpy_6random_6mtrand_11RandomState_81rayleigh __pyx_float_1_0 __pyx_pyargnames.119 __pyx_pw_5numpy_6random_6mtrand_11RandomState_79lognormal __pyx_n_u_sigma __pyx_n_s_sigma __pyx_pyargnames.118 __pyx_pw_5numpy_6random_6mtrand_11RandomState_77logistic __pyx_n_u_loc __pyx_n_s_loc __pyx_pyargnames.117 __pyx_pw_5numpy_6random_6mtrand_11RandomState_75gumbel __pyx_pyargnames.116 __pyx_pw_5numpy_6random_6mtrand_11RandomState_73laplace __pyx_pyargnames.115 __pyx_pw_5numpy_6random_6mtrand_11RandomState_71power __pyx_n_u_a __pyx_n_s_a __pyx_pyargnames.114 __pyx_pw_5numpy_6random_6mtrand_11RandomState_69weibull __pyx_pyargnames.113 __pyx_pw_5numpy_6random_6mtrand_11RandomState_67pareto __pyx_pyargnames.112 __pyx_pw_5numpy_6random_6mtrand_11RandomState_65vonmises __pyx_n_u_kappa __pyx_n_u_mu __pyx_n_s_mu __pyx_n_s_kappa __pyx_pyargnames.111 __pyx_pw_5numpy_6random_6mtrand_11RandomState_63standard_t __pyx_int_0 __pyx_n_u_df __pyx_n_s_df __pyx_pyargnames.110 __pyx_pw_5numpy_6random_6mtrand_11RandomState_61standard_cauchy __pyx_pyargnames.109 __pyx_pw_5numpy_6random_6mtrand_11RandomState_59noncentral_chisquare __pyx_n_u_nonc __pyx_n_s_nonc __pyx_pyargnames.108 __pyx_pw_5numpy_6random_6mtrand_11RandomState_57chisquare __pyx_pyargnames.107 __pyx_pw_5numpy_6random_6mtrand_11RandomState_55noncentral_f __pyx_n_u_dfden __pyx_n_u_dfnum __pyx_n_s_dfnum __pyx_n_s_dfden __pyx_pyargnames.106 __pyx_pw_5numpy_6random_6mtrand_11RandomState_53f __pyx_pyargnames.105 __pyx_pw_5numpy_6random_6mtrand_11RandomState_51gamma __pyx_n_u_shape __pyx_pyargnames.104 __pyx_n_s_shape __pyx_pw_5numpy_6random_6mtrand_11RandomState_49standard_gamma __pyx_pyargnames.103 __pyx_pw_5numpy_6random_6mtrand_11RandomState_47normal __pyx_pyargnames.102 __pyx_pw_5numpy_6random_6mtrand_11RandomState_45standard_normal __pyx_pyargnames.101 __pyx_pw_5numpy_6random_6mtrand_11RandomState_39rand __pyx_n_s_random_sample __pyx_pw_5numpy_6random_6mtrand_11RandomState_27standard_exponential __pyx_pyargnames.15 __pyx_pw_5numpy_6random_6mtrand_11RandomState_25exponential __pyx_pyargnames.14 __pyx_pw_5numpy_6random_6mtrand_11RandomState_23beta __pyx_n_u_b __pyx_n_s_b __pyx_pyargnames.13 __pyx_pw_5numpy_6random_6mtrand_11RandomState_21random __pyx_pyargnames.12 __pyx_pw_5numpy_6random_6mtrand_11RandomState_19random_sample __pyx_f_5numpy_6random_7_common_double_fill __pyx_pyargnames.11 __pyx_pw_5numpy_6random_6mtrand_11RandomState_11__reduce__ __pyx_n_s_reduce __pyx_n_s_randomstate_ctor __pyx_n_s_pickle __pyx_n_s_get_state __pyx_n_s_legacy __pyx_pw_5numpy_6random_6mtrand_11RandomState_9__setstate__ __pyx_n_s_set_state __pyx_pw_5numpy_6random_6mtrand_11RandomState_7__getstate__ __pyx_pw_5numpy_6random_6mtrand_11RandomState_5__str__ __pyx_n_s_class __pyx_n_s_name __pyx_kp_u__2 __pyx_kp_u__3 __pyx_pw_5numpy_6random_6mtrand_11RandomState_3__repr__ __pyx_n_s_str __pyx_kp_u_at_0x_X __pyx_n_s_format __pyx_builtin_id __pyx_f_5numpy_6random_6mtrand_11RandomState__initialize_bit_generator __pyx_n_s_capsule __pyx_n_s_lock __pyx_builtin_ValueError __pyx_tuple__4 __pyx_pymod_exec_mtrand __pyx_empty_bytes __pyx_empty_unicode __pyx_string_tab __pyx_float_1eneg_8 __pyx_float_1_0001 __pyx_int_1 __pyx_int_4294967296 __pyx_int_neg_1 __pyx_n_s_id __pyx_n_s_main __pyx_n_s_ValueError __pyx_n_s_TypeError __pyx_builtin_TypeError __pyx_n_s_RuntimeWarning __pyx_builtin_RuntimeWarning __pyx_n_s_range __pyx_n_s_DeprecationWarning __pyx_builtin_DeprecationWarning __pyx_n_s_OverflowError __pyx_builtin_OverflowError __pyx_n_s_UserWarning __pyx_builtin_UserWarning __pyx_n_s_reversed __pyx_n_s_IndexError __pyx_builtin_IndexError __pyx_n_s_ImportError __pyx_builtin_ImportError __pyx_n_u_l __pyx_tuple_ __pyx_kp_u_Invalid_bit_generator_The_bit_ge __pyx_kp_u_can_only_re_seed_a_MT19937_BitGe __pyx_tuple__5 __pyx_kp_u_get_state_and_legacy_can_only_be __pyx_tuple__6 __pyx_kp_u_legacy_can_only_be_True_when_the __pyx_tuple__7 __pyx_kp_u_state_dictionary_is_not_valid __pyx_tuple__8 __pyx_kp_u_state_must_be_a_dict_or_a_tuple __pyx_tuple__9 __pyx_kp_u_set_state_can_only_be_used_with __pyx_tuple__10 __pyx_n_u_gauss __pyx_tuple__11 __pyx_n_u_has_gauss __pyx_tuple__12 __pyx_tuple__14 __pyx_kp_u_Providing_a_dtype_with_a_non_nat __pyx_tuple__16 __pyx_tuple__17 __pyx_kp_u_a_must_be_1_dimensional_or_an_in __pyx_tuple__18 __pyx_kp_u_a_must_be_greater_than_0_unless __pyx_tuple__19 __pyx_kp_u_a_must_be_1_dimensional __pyx_tuple__20 __pyx_kp_u_a_cannot_be_empty_unless_no_sam __pyx_tuple__21 __pyx_kp_u_p_must_be_1_dimensional __pyx_tuple__22 __pyx_kp_u_a_and_p_must_have_same_size __pyx_tuple__23 __pyx_kp_u_probabilities_contain_NaN __pyx_tuple__24 __pyx_kp_u_probabilities_are_not_non_negati __pyx_tuple__25 __pyx_kp_u_probabilities_do_not_sum_to_1 __pyx_tuple__26 __pyx_kp_u_Cannot_take_a_larger_sample_than __pyx_tuple__27 __pyx_kp_u_Negative_dimensions_are_not_allo __pyx_tuple__28 __pyx_kp_u_Fewer_non_zero_entries_in_p_than __pyx_tuple__29 __pyx_tuple__30 __pyx_kp_u_Range_exceeds_valid_bounds __pyx_tuple__31 __pyx_kp_u_left_mode __pyx_tuple__32 __pyx_kp_u_mode_right __pyx_tuple__33 __pyx_kp_u_left_right __pyx_tuple__34 __pyx_kp_u_ngood_nbad_nsample __pyx_tuple__35 __pyx_kp_u_mean_must_be_1_dimensional __pyx_tuple__36 __pyx_kp_u_cov_must_be_2_dimensional_and_sq __pyx_tuple__37 __pyx_kp_u_mean_and_cov_must_have_same_leng __pyx_tuple__38 __pyx_slice__39 __pyx_kp_u_check_valid_must_equal_warn_rais __pyx_tuple__40 __pyx_kp_u_covariance_is_not_symmetric_posi __pyx_tuple__41 __pyx_tuple__42 __pyx_tuple__43 __pyx_kp_u_pvals_must_be_a_1_d_sequence __pyx_tuple__44 __pyx_kp_u_alpha_0 __pyx_tuple__45 __pyx_kp_u_array_is_read_only __pyx_tuple__46 __pyx_kp_u_Shuffling_a_one_dimensional_arra __pyx_tuple__47 __pyx_tuple__48 __pyx_kp_u_x_must_be_an_integer_or_at_least __pyx_tuple__49 __pyx_kp_u_numpy_core_multiarray_failed_to __pyx_tuple__50 __pyx_kp_u_numpy_core_umath_failed_to_impor __pyx_n_s_bg_type __pyx_n_s_seed __pyx_kp_s_mtrand_pyx __pyx_n_s_get_bit_generator __pyx_n_s_singleton __pyx_n_s_bitgen __pyx_n_s_set_bit_generator __pyx_n_s_kwargs __pyx_n_s_args __pyx_n_s_sample __pyx_n_s_ranf __pyx_vtable_5numpy_6random_6mtrand_RandomState __pyx_type_5numpy_6random_6mtrand_RandomState __pyx_n_s_pyx_vtable __pyx_n_s_RandomState __pyx_ptype_5numpy_6random_6mtrand_RandomState __pyx_ptype_5numpy_dtype __pyx_ptype_5numpy_broadcast __pyx_ptype_5numpy_ndarray __pyx_ptype_5numpy_integer __pyx_ptype_5numpy_floating __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_validate_output_shape __pyx_f_5numpy_6random_7_common_disc __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_MT19937_2 __pyx_n_s_mt19937 __pyx_n_s_MT19937 PyArray_API __pyx_n_s_poisson_lam_max __pyx_k__15 __pyx_n_s_rand_2 __pyx_dict_version.339 __pyx_dict_cached_value.338 __pyx_n_s_beta __pyx_dict_version.337 __pyx_dict_cached_value.336 __pyx_n_s_binomial __pyx_dict_version.335 __pyx_dict_cached_value.334 __pyx_n_s_bytes __pyx_dict_version.333 __pyx_dict_cached_value.332 __pyx_n_s_chisquare __pyx_dict_version.331 __pyx_dict_cached_value.330 __pyx_n_s_choice __pyx_dict_version.329 __pyx_dict_cached_value.328 __pyx_n_s_dirichlet __pyx_dict_version.327 __pyx_dict_cached_value.326 __pyx_n_s_exponential __pyx_dict_version.325 __pyx_dict_cached_value.324 __pyx_n_s_f __pyx_dict_version.323 __pyx_dict_cached_value.322 __pyx_n_s_gamma __pyx_dict_version.321 __pyx_dict_cached_value.320 __pyx_dict_version.319 __pyx_dict_cached_value.318 __pyx_n_s_geometric __pyx_dict_version.317 __pyx_dict_cached_value.316 __pyx_n_s_gumbel __pyx_dict_version.315 __pyx_dict_cached_value.314 __pyx_n_s_hypergeometric __pyx_dict_version.313 __pyx_dict_cached_value.312 __pyx_n_s_laplace __pyx_dict_version.311 __pyx_dict_cached_value.310 __pyx_n_s_logistic __pyx_dict_version.309 __pyx_dict_cached_value.308 __pyx_n_s_lognormal __pyx_dict_version.307 __pyx_dict_cached_value.306 __pyx_n_s_logseries __pyx_dict_version.305 __pyx_dict_cached_value.304 __pyx_n_s_multinomial __pyx_dict_version.303 __pyx_dict_cached_value.302 __pyx_n_s_multivariate_normal __pyx_dict_version.301 __pyx_dict_cached_value.300 __pyx_n_s_negative_binomial __pyx_dict_version.299 __pyx_dict_cached_value.298 __pyx_n_s_noncentral_chisquare __pyx_dict_version.297 __pyx_dict_cached_value.296 __pyx_n_s_noncentral_f __pyx_dict_version.295 __pyx_dict_cached_value.294 __pyx_n_s_normal __pyx_dict_version.293 __pyx_dict_cached_value.292 __pyx_n_s_pareto __pyx_dict_version.291 __pyx_dict_cached_value.290 __pyx_n_s_permutation __pyx_dict_version.289 __pyx_dict_cached_value.288 __pyx_n_s_poisson __pyx_dict_version.287 __pyx_dict_cached_value.286 __pyx_n_s_power __pyx_dict_version.285 __pyx_dict_cached_value.284 __pyx_n_s_rand __pyx_dict_version.283 __pyx_dict_cached_value.282 __pyx_n_s_randint __pyx_dict_version.281 __pyx_dict_cached_value.280 __pyx_n_s_randn __pyx_dict_version.279 __pyx_dict_cached_value.278 __pyx_n_s_random __pyx_dict_version.277 __pyx_dict_cached_value.276 __pyx_n_s_random_integers __pyx_dict_version.275 __pyx_dict_cached_value.274 __pyx_dict_version.273 __pyx_dict_cached_value.272 __pyx_n_s_rayleigh __pyx_dict_version.271 __pyx_dict_cached_value.270 __pyx_dict_version.269 __pyx_dict_cached_value.268 __pyx_n_s_shuffle __pyx_dict_version.267 __pyx_dict_cached_value.266 __pyx_n_s_standard_cauchy __pyx_dict_version.265 __pyx_dict_cached_value.264 __pyx_n_s_standard_exponential __pyx_dict_version.263 __pyx_dict_cached_value.262 __pyx_n_s_standard_gamma __pyx_dict_version.261 __pyx_dict_cached_value.260 __pyx_n_s_standard_normal __pyx_dict_version.259 __pyx_dict_cached_value.258 __pyx_n_s_standard_t __pyx_dict_version.257 __pyx_dict_cached_value.256 __pyx_n_s_triangular __pyx_dict_version.255 __pyx_dict_cached_value.254 __pyx_n_s_uniform __pyx_dict_version.253 __pyx_dict_cached_value.252 __pyx_n_s_vonmises __pyx_dict_version.251 __pyx_dict_cached_value.250 __pyx_n_s_wald __pyx_dict_version.249 __pyx_dict_cached_value.248 __pyx_n_s_weibull __pyx_dict_version.247 __pyx_dict_cached_value.246 __pyx_n_s_zipf __pyx_n_s_numpy_random_mtrand __pyx_mdef_5numpy_6random_6mtrand_1seed __pyx_mdef_5numpy_6random_6mtrand_3get_bit_generator __pyx_mdef_5numpy_6random_6mtrand_5set_bit_generator __pyx_mdef_5numpy_6random_6mtrand_7sample __pyx_mdef_5numpy_6random_6mtrand_9ranf __pyx_n_u_beta __pyx_n_u_binomial __pyx_n_u_bytes __pyx_n_u_chisquare __pyx_n_u_choice __pyx_n_u_dirichlet __pyx_n_u_exponential __pyx_n_u_f __pyx_n_u_gamma __pyx_n_u_geometric __pyx_n_u_get_bit_generator __pyx_n_u_get_state __pyx_n_u_gumbel __pyx_n_u_hypergeometric __pyx_n_u_laplace __pyx_n_u_logistic __pyx_n_u_lognormal __pyx_n_u_logseries __pyx_n_u_multinomial __pyx_n_u_multivariate_normal __pyx_n_u_negative_binomial __pyx_n_u_noncentral_chisquare __pyx_n_u_noncentral_f __pyx_n_u_normal __pyx_n_u_pareto __pyx_n_u_permutation __pyx_n_u_poisson __pyx_n_u_power __pyx_n_u_rand __pyx_n_u_randint __pyx_n_u_randn __pyx_n_u_random __pyx_n_u_random_integers __pyx_n_u_random_sample __pyx_n_u_ranf __pyx_n_u_rayleigh __pyx_n_u_sample __pyx_n_u_seed __pyx_n_u_set_bit_generator __pyx_n_u_set_state __pyx_n_u_shuffle __pyx_n_u_standard_cauchy __pyx_n_u_standard_exponential __pyx_n_u_standard_gamma __pyx_n_u_standard_normal __pyx_n_u_standard_t __pyx_n_u_triangular __pyx_n_u_uniform __pyx_n_u_vonmises __pyx_n_u_wald __pyx_n_u_weibull __pyx_n_u_zipf __pyx_n_u_RandomState __pyx_n_s_all_2 __pyx_kp_u_seed_seed_None_Reseed_a_legacy __pyx_kp_u_RandomState_seed_line_228 __pyx_kp_u_random_sample_size_None_Return __pyx_kp_u_RandomState_random_sample_line_3 __pyx_kp_u_exponential_scale_1_0_size_None __pyx_kp_u_RandomState_exponential_line_499 __pyx_kp_u_standard_exponential_size_None __pyx_kp_u_RandomState_standard_exponential __pyx_kp_u_tomaxint_size_None_Return_a_sam __pyx_kp_u_RandomState_tomaxint_line_620 __pyx_kp_u_randint_low_high_None_size_None __pyx_kp_u_RandomState_randint_line_678 __pyx_kp_u_bytes_length_Return_random_byte __pyx_kp_u_RandomState_bytes_line_804 __pyx_kp_u_choice_a_size_None_replace_True __pyx_kp_u_RandomState_choice_line_841 __pyx_kp_u_uniform_low_0_0_high_1_0_size_N __pyx_kp_u_RandomState_uniform_line_1049 __pyx_kp_u_rand_d0_d1_dn_Random_values_in __pyx_kp_u_RandomState_rand_line_1176 __pyx_kp_u_randn_d0_d1_dn_Return_a_sample __pyx_kp_u_RandomState_randn_line_1220 __pyx_kp_u_random_integers_low_high_None_s __pyx_kp_u_RandomState_random_integers_line __pyx_kp_u_standard_normal_size_None_Draw __pyx_kp_u_RandomState_standard_normal_line __pyx_kp_u_normal_loc_0_0_scale_1_0_size_N __pyx_kp_u_RandomState_normal_line_1453 __pyx_kp_u_standard_gamma_shape_size_None __pyx_kp_u_RandomState_standard_gamma_line __pyx_kp_u_gamma_shape_scale_1_0_size_None __pyx_kp_u_RandomState_gamma_line_1644 __pyx_kp_u_f_dfnum_dfden_size_None_Draw_sa __pyx_kp_u_RandomState_f_line_1728 __pyx_kp_u_noncentral_f_dfnum_dfden_nonc_s __pyx_kp_u_RandomState_noncentral_f_line_18 __pyx_kp_u_chisquare_df_size_None_Draw_sam __pyx_kp_u_RandomState_chisquare_line_1909 __pyx_kp_u_noncentral_chisquare_df_nonc_si __pyx_kp_u_RandomState_noncentral_chisquare __pyx_kp_u_standard_cauchy_size_None_Draw __pyx_kp_u_RandomState_standard_cauchy_line __pyx_kp_u_standard_t_df_size_None_Draw_sa __pyx_kp_u_RandomState_standard_t_line_2149 __pyx_kp_u_vonmises_mu_kappa_size_None_Dra __pyx_kp_u_RandomState_vonmises_line_2264 __pyx_kp_u_pareto_a_size_None_Draw_samples __pyx_kp_u_RandomState_pareto_line_2353 __pyx_kp_u_weibull_a_size_None_Draw_sample __pyx_kp_u_RandomState_weibull_line_2456 __pyx_kp_u_power_a_size_None_Draws_samples __pyx_kp_u_RandomState_power_line_2560 __pyx_kp_u_laplace_loc_0_0_scale_1_0_size __pyx_kp_u_RandomState_laplace_line_2669 __pyx_kp_u_gumbel_loc_0_0_scale_1_0_size_N __pyx_kp_u_RandomState_gumbel_line_2763 __pyx_kp_u_logistic_loc_0_0_scale_1_0_size __pyx_kp_u_RandomState_logistic_line_2887 __pyx_kp_u_lognormal_mean_0_0_sigma_1_0_si __pyx_kp_u_RandomState_lognormal_line_2973 __pyx_kp_u_rayleigh_scale_1_0_size_None_Dr __pyx_kp_u_RandomState_rayleigh_line_3089 __pyx_kp_u_wald_mean_scale_size_None_Draw __pyx_kp_u_RandomState_wald_line_3166 __pyx_kp_u_triangular_left_mode_right_size __pyx_kp_u_RandomState_triangular_line_3243 __pyx_kp_u_binomial_n_p_size_None_Draw_sam __pyx_kp_u_RandomState_binomial_line_3352 __pyx_kp_u_negative_binomial_n_p_size_None __pyx_kp_u_RandomState_negative_binomial_li __pyx_kp_u_poisson_lam_1_0_size_None_Draw __pyx_kp_u_RandomState_poisson_line_3592 __pyx_kp_u_zipf_a_size_None_Draw_samples_f __pyx_kp_u_RandomState_zipf_line_3675 __pyx_kp_u_geometric_p_size_None_Draw_samp __pyx_kp_u_RandomState_geometric_line_3771 __pyx_kp_u_hypergeometric_ngood_nbad_nsamp __pyx_kp_u_RandomState_hypergeometric_line __pyx_kp_u_logseries_p_size_None_Draw_samp __pyx_kp_u_RandomState_logseries_line_3968 __pyx_kp_u_multivariate_normal_mean_cov_si __pyx_kp_u_RandomState_multivariate_normal __pyx_kp_u_multinomial_n_pvals_size_None_D __pyx_kp_u_RandomState_multinomial_line_425 __pyx_kp_u_dirichlet_alpha_size_None_Draw __pyx_kp_u_RandomState_dirichlet_line_4393 __pyx_kp_u_shuffle_x_Modify_a_sequence_in __pyx_kp_u_RandomState_shuffle_line_4542 __pyx_kp_u_permutation_x_Randomly_permute __pyx_kp_u_RandomState_permutation_line_466 __pyx_n_s_test __pyx_pw_5numpy_6random_6mtrand_11RandomState_41randn __pyx_pw_5numpy_6random_6mtrand_3get_bit_generator __pyx_dict_version.239 __pyx_dict_cached_value.238 __pyx_n_s_bit_generator_2 __pyx_pw_5numpy_6random_6mtrand_5set_bit_generator __pyx_dict_version.241 __pyx_dict_cached_value.240 __pyx_pw_5numpy_6random_6mtrand_7sample __pyx_dict_version.243 __pyx_dict_cached_value.242 __pyx_pw_5numpy_6random_6mtrand_9ranf __pyx_dict_version.245 __pyx_dict_cached_value.244 __pyx_f_5numpy_6random_6mtrand_int64_to_long __pyx_dict_version.159 __pyx_dict_cached_value.158 __pyx_n_s_isscalar __pyx_n_s_astype __pyx_n_u_unsafe __pyx_n_s_casting __pyx_pw_5numpy_6random_6mtrand_11RandomState_99logseries __pyx_n_u_p __pyx_n_s_p __pyx_pyargnames.160 __pyx_pw_5numpy_6random_6mtrand_11RandomState_95geometric __pyx_pyargnames.144 __pyx_pw_5numpy_6random_6mtrand_11RandomState_93zipf __pyx_pyargnames.143 __pyx_pw_5numpy_6random_6mtrand_11RandomState_91poisson __pyx_n_u_lam __pyx_pyargnames.142 __pyx_n_s_lam __pyx_pw_5numpy_6random_6mtrand_11RandomState_89negative_binomial __pyx_n_u_n __pyx_pyargnames.141 __pyx_n_s_n __pyx_pw_5numpy_6random_6mtrand_11RandomState_13seed __pyx_dict_version.4 __pyx_dict_cached_value.3 __pyx_n_s_legacy_seeding __pyx_pyargnames.5 __pyx_pw_5numpy_6random_6mtrand_11RandomState_33bytes __pyx_dict_version.45 __pyx_dict_cached_value.44 __pyx_n_s_uint32 __pyx_n_s_dtype __pyx_kp_u_u4 __pyx_n_s_tobytes __pyx_pw_5numpy_6random_6mtrand_11RandomState_17set_state __pyx_n_u_MT19937_2 __pyx_n_u_bit_generator __pyx_n_u_state __pyx_n_s_get __pyx_n_u_key __pyx_n_u_pos __pyx_n_s_state __pyx_pw_5numpy_6random_6mtrand_11RandomState_29tomaxint __pyx_dict_version.19 __pyx_dict_cached_value.18 __pyx_n_s_empty __pyx_dict_version.17 __pyx_dict_cached_value.16 __pyx_n_s_int64 __pyx_n_s_exit __pyx_n_s_enter __pyx_pyargnames.20 __pyx_pw_5numpy_6random_6mtrand_11RandomState_43random_integers __pyx_dict_version.97 __pyx_dict_cached_value.96 __pyx_n_s_warn __pyx_kp_u_This_function_is_deprecated_Plea_2 __pyx_n_s_low __pyx_n_s_high __pyx_dict_version.99 __pyx_dict_cached_value.98 __pyx_kp_u_This_function_is_deprecated_Plea __pyx_pyargnames.100 __pyx_pw_5numpy_6random_6mtrand_11RandomState_1__init__ __pyx_n_u_capsule __pyx_dict_version.225 __pyx_dict_cached_value.224 __pyx_dict_version.223 __pyx_dict_cached_value.222 __pyx_pyargnames.226 __pyx_pw_5numpy_6random_6mtrand_1seed __pyx_dict_version.236 __pyx_dict_cached_value.235 __pyx_dict_version.234 __pyx_dict_cached_value.233 __pyx_dict_version.232 __pyx_dict_cached_value.231 __pyx_dict_version.230 __pyx_dict_cached_value.229 __pyx_dict_version.228 __pyx_dict_cached_value.227 __pyx_pyargnames.237 __pyx_pw_5numpy_6random_6mtrand_11RandomState_15get_state __pyx_dict_version.9 __pyx_dict_cached_value.8 __pyx_dict_version.7 __pyx_dict_cached_value.6 __pyx_pyargnames.10 __pyx_pw_5numpy_6random_6mtrand_11RandomState_109permutation __pyx_dict_version.221 __pyx_dict_cached_value.220 __pyx_n_s_arange __pyx_dict_version.219 __pyx_dict_cached_value.218 __pyx_n_s_asarray __pyx_n_s_ndim __pyx_dict_version.217 __pyx_dict_cached_value.216 __pyx_n_s_may_share_memory __pyx_dict_version.213 __pyx_dict_cached_value.212 __pyx_dict_version.211 __pyx_dict_cached_value.210 __pyx_n_s_intp __pyx_dict_version.215 __pyx_dict_cached_value.214 __pyx_n_s_array __pyx_pw_5numpy_6random_6mtrand_11RandomState_37uniform __pyx_dict_version.92 __pyx_dict_cached_value.91 __pyx_n_s_subtract __pyx_dict_version.94 __pyx_dict_cached_value.93 __pyx_n_s_isfinite __pyx_dict_version.90 __pyx_dict_cached_value.89 __pyx_n_s_all __pyx_dict_version.88 __pyx_dict_cached_value.87 __pyx_pyargnames.95 __pyx_pw_5numpy_6random_6mtrand_11RandomState_97hypergeometric __pyx_dict_version.156 __pyx_dict_cached_value.155 __pyx_n_s_any __pyx_dict_version.154 __pyx_dict_cached_value.153 __pyx_n_s_less __pyx_dict_version.152 __pyx_dict_cached_value.151 __pyx_n_s_add __pyx_n_s_ngood __pyx_n_u_nsample __pyx_n_u_nbad __pyx_n_u_ngood __pyx_n_s_nbad __pyx_n_s_nsample __pyx_pyargnames.157 __pyx_dict_version.150 __pyx_dict_cached_value.149 __pyx_dict_version.148 __pyx_dict_cached_value.147 __pyx_dict_version.146 __pyx_dict_cached_value.145 __pyx_pw_5numpy_6random_6mtrand_11RandomState_105dirichlet __pyx_dict_version.194 __pyx_dict_cached_value.193 __pyx_dict_version.192 __pyx_dict_cached_value.191 __pyx_n_s_less_equal __pyx_dict_version.188 __pyx_dict_cached_value.187 __pyx_n_s_zeros __pyx_dict_version.186 __pyx_dict_cached_value.185 __pyx_n_s_float64 __pyx_dict_version.190 __pyx_dict_cached_value.189 __pyx_n_s_index __pyx_n_s_alpha __pyx_pyargnames.195 __pyx_pw_5numpy_6random_6mtrand_11RandomState_103multinomial __pyx_n_u_pvals __pyx_dict_version.181 __pyx_dict_cached_value.180 __pyx_dict_version.179 __pyx_dict_cached_value.178 __pyx_n_s_pvals __pyx_dict_version.183 __pyx_dict_cached_value.182 __pyx_n_s_issubdtype __pyx_kp_u_sum_pvals_1_1_0 __pyx_n_s_sum __pyx_kp_u_sum_pvals_1_astype_np_float64_1 __pyx_pyargnames.184 __pyx_pw_5numpy_6random_6mtrand_11RandomState_85triangular __pyx_dict_version.132 __pyx_dict_cached_value.131 __pyx_dict_version.130 __pyx_dict_cached_value.129 __pyx_n_s_greater __pyx_n_s_left __pyx_n_s_mode __pyx_n_s_right __pyx_dict_version.128 __pyx_dict_cached_value.127 __pyx_dict_version.126 __pyx_dict_cached_value.125 __pyx_dict_version.124 __pyx_dict_cached_value.123 __pyx_dict_version.122 __pyx_dict_cached_value.121 __pyx_n_s_equal __pyx_pyargnames.133 __pyx_pw_5numpy_6random_6mtrand_11RandomState_87binomial __pyx_dict_version.139 __pyx_dict_cached_value.138 __pyx_dict_version.135 __pyx_dict_cached_value.134 __pyx_pyargnames.140 __pyx_dict_version.137 __pyx_dict_cached_value.136 __pyx_pw_5numpy_6random_6mtrand_11RandomState_31randint __pyx_n_s_isnative __pyx_dict_version.42 __pyx_dict_cached_value.41 __pyx_n_s_newbyteorder __pyx_dict_version.40 __pyx_dict_cached_value.39 __pyx_n_s_int32 __pyx_dict_version.38 __pyx_dict_cached_value.37 __pyx_dict_version.36 __pyx_dict_cached_value.35 __pyx_n_s_int16 __pyx_pyargnames.43 __pyx_dict_version.22 __pyx_dict_cached_value.21 __pyx_dict_version.34 __pyx_dict_cached_value.33 __pyx_n_s_int8 __pyx_dict_version.32 __pyx_dict_cached_value.31 __pyx_n_s_uint64 __pyx_dict_version.30 __pyx_dict_cached_value.29 __pyx_dict_version.28 __pyx_dict_cached_value.27 __pyx_n_s_uint16 __pyx_dict_version.26 __pyx_dict_cached_value.25 __pyx_n_s_uint8 __pyx_dict_version.24 __pyx_dict_cached_value.23 __pyx_n_s_bool __pyx_kp_u_Unsupported_dtype_r_for_randint __pyx_pw_5numpy_6random_6mtrand_11RandomState_107shuffle __pyx_n_s_flags __pyx_n_s_writeable __pyx_n_s_type __pyx_dict_version.205 __pyx_dict_cached_value.204 __pyx_n_s_object __pyx_dict_version.203 __pyx_dict_cached_value.202 __pyx_n_s_stacklevel __pyx_dict_version.201 __pyx_dict_cached_value.200 __pyx_n_s_empty_like __pyx_dict_version.199 __pyx_dict_cached_value.198 __pyx_dict_version.197 __pyx_dict_cached_value.196 __pyx_kp_u_you_are_shuffling_a __pyx_kp_u_object_which_is_not_a_subclass __pyx_n_s_strides __pyx_n_s_itemsize __pyx_dict_version.209 __pyx_dict_cached_value.208 __pyx_dict_version.207 __pyx_dict_cached_value.206 __pyx_pw_5numpy_6random_6mtrand_11RandomState_101multivariate_normal __pyx_n_u_warn __pyx_n_s_svd __pyx_n_s_numpy_linalg __pyx_dict_version.176 __pyx_dict_cached_value.175 __pyx_dict_version.174 __pyx_dict_cached_value.173 __pyx_n_s_reshape __pyx_dict_version.172 __pyx_dict_cached_value.171 __pyx_n_s_double __pyx_n_u_ignore __pyx_dict_version.164 __pyx_dict_cached_value.163 __pyx_n_s_dot __pyx_dict_version.162 __pyx_dict_cached_value.161 __pyx_n_s_sqrt __pyx_n_s_cov __pyx_n_s_check_valid __pyx_n_s_tol __pyx_pyargnames.177 __pyx_n_u_raise __pyx_dict_version.170 __pyx_dict_cached_value.169 __pyx_n_s_allclose __pyx_dict_version.168 __pyx_dict_cached_value.167 __pyx_n_s_T __pyx_n_s_rtol __pyx_n_s_atol __pyx_dict_version.166 __pyx_dict_cached_value.165 __pyx_pw_5numpy_6random_6mtrand_11RandomState_35choice __pyx_dict_version.85 __pyx_dict_cached_value.84 __pyx_n_s_copy __pyx_dict_version.83 __pyx_dict_cached_value.82 __pyx_n_s_item __pyx_dict_version.77 __pyx_dict_cached_value.76 __pyx_dict_version.75 __pyx_dict_cached_value.74 __pyx_n_s_finfo __pyx_dict_version.73 __pyx_dict_cached_value.72 __pyx_n_s_eps __pyx_dict_version.71 __pyx_dict_cached_value.70 __pyx_dict_version.69 __pyx_dict_cached_value.68 __pyx_dict_version.67 __pyx_dict_cached_value.66 __pyx_dict_version.65 __pyx_dict_cached_value.64 __pyx_n_s_isnan __pyx_dict_version.63 __pyx_dict_cached_value.62 __pyx_n_s_logical_or __pyx_n_s_reduce_2 __pyx_n_s_cumsum __pyx_n_s_searchsorted __pyx_n_u_right __pyx_n_s_side __pyx_dict_version.57 __pyx_dict_cached_value.56 __pyx_dict_version.47 __pyx_dict_cached_value.46 __pyx_pyargnames.86 __pyx_dict_version.81 __pyx_dict_cached_value.80 __pyx_n_s_prod __pyx_n_s_replace __pyx_dict_version.79 __pyx_dict_cached_value.78 __pyx_dict_version.61 __pyx_dict_cached_value.60 __pyx_dict_version.59 __pyx_dict_cached_value.58 __pyx_dict_version.55 __pyx_dict_cached_value.54 __pyx_n_s_count_nonzero __pyx_dict_version.53 __pyx_dict_cached_value.52 __pyx_n_s_ravel __pyx_dict_version.51 __pyx_dict_cached_value.50 __pyx_dict_version.49 __pyx_dict_cached_value.48 __pyx_n_s_unique __pyx_n_s_return_index __pyx_n_s_sort __pyx_n_s_take __pyx_moduledef __pyx_k_Cannot_take_a_larger_sample_than __pyx_k_DeprecationWarning __pyx_k_Fewer_non_zero_entries_in_p_than __pyx_k_ImportError __pyx_k_IndexError __pyx_k_Invalid_bit_generator_The_bit_ge __pyx_k_MT19937 __pyx_k_MT19937_2 __pyx_k_Negative_dimensions_are_not_allo __pyx_k_OverflowError __pyx_k_Providing_a_dtype_with_a_non_nat __pyx_k_RandomState __pyx_k_RandomState_binomial_line_3352 __pyx_k_RandomState_bytes_line_804 __pyx_k_RandomState_chisquare_line_1909 __pyx_k_RandomState_choice_line_841 __pyx_k_RandomState_dirichlet_line_4393 __pyx_k_RandomState_exponential_line_499 __pyx_k_RandomState_f_line_1728 __pyx_k_RandomState_gamma_line_1644 __pyx_k_RandomState_geometric_line_3771 __pyx_k_RandomState_gumbel_line_2763 __pyx_k_RandomState_hypergeometric_line __pyx_k_RandomState_laplace_line_2669 __pyx_k_RandomState_logistic_line_2887 __pyx_k_RandomState_lognormal_line_2973 __pyx_k_RandomState_logseries_line_3968 __pyx_k_RandomState_multinomial_line_425 __pyx_k_RandomState_multivariate_normal __pyx_k_RandomState_negative_binomial_li __pyx_k_RandomState_noncentral_chisquare __pyx_k_RandomState_noncentral_f_line_18 __pyx_k_RandomState_normal_line_1453 __pyx_k_RandomState_pareto_line_2353 __pyx_k_RandomState_permutation_line_466 __pyx_k_RandomState_poisson_line_3592 __pyx_k_RandomState_power_line_2560 __pyx_k_RandomState_rand_line_1176 __pyx_k_RandomState_randint_line_678 __pyx_k_RandomState_randn_line_1220 __pyx_k_RandomState_random_integers_line __pyx_k_RandomState_random_sample_line_3 __pyx_k_RandomState_rayleigh_line_3089 __pyx_k_RandomState_seed_line_228 __pyx_k_RandomState_shuffle_line_4542 __pyx_k_RandomState_standard_cauchy_line __pyx_k_RandomState_standard_exponential __pyx_k_RandomState_standard_gamma_line __pyx_k_RandomState_standard_normal_line __pyx_k_RandomState_standard_t_line_2149 __pyx_k_RandomState_tomaxint_line_620 __pyx_k_RandomState_triangular_line_3243 __pyx_k_RandomState_uniform_line_1049 __pyx_k_RandomState_vonmises_line_2264 __pyx_k_RandomState_wald_line_3166 __pyx_k_RandomState_weibull_line_2456 __pyx_k_RandomState_zipf_line_3675 __pyx_k_Range_exceeds_valid_bounds __pyx_k_RuntimeWarning __pyx_k_Sequence __pyx_k_Shuffling_a_one_dimensional_arra __pyx_k_T __pyx_k_This_function_is_deprecated_Plea __pyx_k_This_function_is_deprecated_Plea_2 __pyx_k_TypeError __pyx_k_Unsupported_dtype_r_for_randint __pyx_k_UserWarning __pyx_k_ValueError __pyx_k__13 __pyx_k__2 __pyx_k__3 __pyx_k_a __pyx_k_a_and_p_must_have_same_size __pyx_k_a_cannot_be_empty_unless_no_sam __pyx_k_a_must_be_1_dimensional __pyx_k_a_must_be_1_dimensional_or_an_in __pyx_k_a_must_be_greater_than_0_unless __pyx_k_add __pyx_k_all __pyx_k_all_2 __pyx_k_allclose __pyx_k_alpha __pyx_k_alpha_0 __pyx_k_any __pyx_k_arange __pyx_k_args __pyx_k_array __pyx_k_array_is_read_only __pyx_k_asarray __pyx_k_astype __pyx_k_at_0x_X __pyx_k_atol __pyx_k_b __pyx_k_beta __pyx_k_bg_type __pyx_k_binomial __pyx_k_binomial_n_p_size_None_Draw_sam __pyx_k_bit_generator __pyx_k_bit_generator_2 __pyx_k_bitgen __pyx_k_bool __pyx_k_bytes __pyx_k_bytes_length_Return_random_byte __pyx_k_can_only_re_seed_a_MT19937_BitGe __pyx_k_capsule __pyx_k_casting __pyx_k_check_valid __pyx_k_check_valid_must_equal_warn_rais __pyx_k_chisquare __pyx_k_chisquare_df_size_None_Draw_sam __pyx_k_choice __pyx_k_choice_a_size_None_replace_True __pyx_k_class __pyx_k_cline_in_traceback __pyx_k_collections_abc __pyx_k_copy __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_df __pyx_k_dfden __pyx_k_dfnum __pyx_k_dirichlet __pyx_k_dirichlet_alpha_size_None_Draw __pyx_k_dot __pyx_k_double __pyx_k_dtype __pyx_k_empty __pyx_k_empty_like __pyx_k_enter __pyx_k_eps __pyx_k_equal __pyx_k_exit __pyx_k_exponential __pyx_k_exponential_scale_1_0_size_None __pyx_k_f __pyx_k_f_dfnum_dfden_size_None_Draw_sa __pyx_k_finfo __pyx_k_flags __pyx_k_float64 __pyx_k_format __pyx_k_gamma __pyx_k_gamma_shape_scale_1_0_size_None __pyx_k_gauss __pyx_k_geometric __pyx_k_geometric_p_size_None_Draw_samp __pyx_k_get __pyx_k_get_bit_generator __pyx_k_get_state __pyx_k_get_state_and_legacy_can_only_be __pyx_k_greater __pyx_k_gumbel __pyx_k_gumbel_loc_0_0_scale_1_0_size_N __pyx_k_has_gauss __pyx_k_high __pyx_k_hypergeometric __pyx_k_hypergeometric_ngood_nbad_nsamp __pyx_k_id __pyx_k_ignore __pyx_n_s_import __pyx_k_import __pyx_k_index __pyx_k_int16 __pyx_k_int32 __pyx_k_int64 __pyx_k_int8 __pyx_k_intp __pyx_k_isfinite __pyx_k_isnan __pyx_k_isnative __pyx_k_isscalar __pyx_k_issubdtype __pyx_k_item __pyx_k_itemsize __pyx_k_kappa __pyx_k_key __pyx_k_kwargs __pyx_k_l __pyx_k_lam __pyx_k_laplace __pyx_k_laplace_loc_0_0_scale_1_0_size __pyx_k_left __pyx_k_left_mode __pyx_k_left_right __pyx_k_legacy __pyx_k_legacy_can_only_be_True_when_the __pyx_k_legacy_seeding __pyx_k_less __pyx_k_less_equal __pyx_k_loc __pyx_k_lock __pyx_k_logical_or __pyx_k_logistic __pyx_k_logistic_loc_0_0_scale_1_0_size __pyx_k_lognormal __pyx_k_lognormal_mean_0_0_sigma_1_0_si __pyx_k_logseries __pyx_k_logseries_p_size_None_Draw_samp __pyx_k_low __pyx_k_main __pyx_k_may_share_memory __pyx_k_mean __pyx_k_mean_and_cov_must_have_same_leng __pyx_k_mean_must_be_1_dimensional __pyx_k_mode __pyx_k_mode_right __pyx_k_mt19937 __pyx_k_mtrand_pyx __pyx_k_mu __pyx_k_multinomial __pyx_k_multinomial_n_pvals_size_None_D __pyx_k_multivariate_normal __pyx_k_multivariate_normal_mean_cov_si __pyx_k_n __pyx_k_name __pyx_k_nbad __pyx_k_ndim __pyx_k_negative_binomial __pyx_k_negative_binomial_n_p_size_None __pyx_k_newbyteorder __pyx_k_ngood __pyx_k_ngood_nbad_nsample __pyx_k_nonc __pyx_k_noncentral_chisquare __pyx_k_noncentral_chisquare_df_nonc_si __pyx_k_noncentral_f __pyx_k_noncentral_f_dfnum_dfden_nonc_s __pyx_k_normal __pyx_k_normal_loc_0_0_scale_1_0_size_N __pyx_k_np __pyx_k_nsample __pyx_k_numpy __pyx_k_numpy_core_multiarray_failed_to __pyx_k_numpy_core_umath_failed_to_impor __pyx_k_numpy_linalg __pyx_k_numpy_random_mtrand __pyx_k_object __pyx_k_object_which_is_not_a_subclass __pyx_k_operator __pyx_k_p __pyx_k_p_must_be_1_dimensional __pyx_k_pareto __pyx_k_pareto_a_size_None_Draw_samples __pyx_k_permutation __pyx_k_permutation_x_Randomly_permute __pyx_k_pickle __pyx_k_poisson __pyx_k_poisson_lam_1_0_size_None_Draw __pyx_k_poisson_lam_max __pyx_k_pos __pyx_k_power __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_be_a_1_d_sequence __pyx_k_pyx_vtable __pyx_k_raise __pyx_k_rand __pyx_k_rand_2 __pyx_k_rand_d0_d1_dn_Random_values_in __pyx_k_randint __pyx_k_randint_low_high_None_size_None __pyx_k_randn __pyx_k_randn_d0_d1_dn_Return_a_sample __pyx_k_random __pyx_k_random_integers __pyx_k_random_integers_low_high_None_s __pyx_k_random_sample __pyx_k_random_sample_size_None_Return __pyx_k_randomstate_ctor __pyx_k_ranf __pyx_k_range __pyx_k_ravel __pyx_k_rayleigh __pyx_k_rayleigh_scale_1_0_size_None_Dr __pyx_k_reduce __pyx_k_reduce_2 __pyx_k_replace __pyx_k_reshape __pyx_k_return_index __pyx_k_reversed __pyx_k_right __pyx_k_rtol __pyx_k_sample __pyx_k_scale __pyx_k_searchsorted __pyx_k_seed __pyx_k_seed_seed_None_Reseed_a_legacy __pyx_k_set_bit_generator __pyx_k_set_state __pyx_k_set_state_can_only_be_used_with __pyx_k_shape __pyx_k_shuffle __pyx_k_shuffle_x_Modify_a_sequence_in __pyx_k_side __pyx_k_sigma __pyx_k_singleton __pyx_k_size __pyx_k_sort __pyx_k_sqrt __pyx_k_stacklevel __pyx_k_standard_cauchy __pyx_k_standard_cauchy_size_None_Draw __pyx_k_standard_exponential __pyx_k_standard_exponential_size_None __pyx_k_standard_gamma __pyx_k_standard_gamma_shape_size_None __pyx_k_standard_normal __pyx_k_standard_normal_size_None_Draw __pyx_k_standard_t __pyx_k_standard_t_df_size_None_Draw_sa __pyx_k_state __pyx_k_state_dictionary_is_not_valid __pyx_k_state_must_be_a_dict_or_a_tuple __pyx_k_str __pyx_k_strides __pyx_k_subtract __pyx_k_sum __pyx_k_sum_pvals_1_1_0 __pyx_k_sum_pvals_1_astype_np_float64_1 __pyx_k_svd __pyx_k_take __pyx_k_test __pyx_k_tobytes __pyx_k_tol __pyx_k_tomaxint_size_None_Return_a_sam __pyx_k_triangular __pyx_k_triangular_left_mode_right_size __pyx_k_type __pyx_k_u4 __pyx_k_uint16 __pyx_k_uint32 __pyx_k_uint64 __pyx_k_uint8 __pyx_k_uniform __pyx_k_uniform_low_0_0_high_1_0_size_N __pyx_k_unique __pyx_k_unsafe __pyx_k_vonmises __pyx_k_vonmises_mu_kappa_size_None_Dra __pyx_k_wald __pyx_k_wald_mean_scale_size_None_Draw __pyx_k_warn __pyx_k_warnings __pyx_k_weibull __pyx_k_weibull_a_size_None_Draw_sample __pyx_k_writeable __pyx_k_x_must_be_an_integer_or_at_least __pyx_k_you_are_shuffling_a __pyx_k_zeros __pyx_k_zipf __pyx_k_zipf_a_size_None_Draw_samples_f __pyx_methods __pyx_moduledef_slots __pyx_methods_5numpy_6random_6mtrand_RandomState __pyx_getsets_5numpy_6random_6mtrand_RandomState __pyx_doc_5numpy_6random_6mtrand_11RandomState_12seed __pyx_doc_5numpy_6random_6mtrand_11RandomState_14get_state __pyx_doc_5numpy_6random_6mtrand_11RandomState_16set_state __pyx_doc_5numpy_6random_6mtrand_11RandomState_18random_sample __pyx_doc_5numpy_6random_6mtrand_11RandomState_20random __pyx_doc_5numpy_6random_6mtrand_11RandomState_22beta __pyx_doc_5numpy_6random_6mtrand_11RandomState_24exponential __pyx_doc_5numpy_6random_6mtrand_11RandomState_26standard_exponential __pyx_doc_5numpy_6random_6mtrand_11RandomState_28tomaxint __pyx_doc_5numpy_6random_6mtrand_11RandomState_30randint __pyx_doc_5numpy_6random_6mtrand_11RandomState_32bytes __pyx_doc_5numpy_6random_6mtrand_11RandomState_34choice __pyx_doc_5numpy_6random_6mtrand_11RandomState_36uniform __pyx_doc_5numpy_6random_6mtrand_11RandomState_38rand __pyx_doc_5numpy_6random_6mtrand_11RandomState_40randn __pyx_doc_5numpy_6random_6mtrand_11RandomState_42random_integers __pyx_doc_5numpy_6random_6mtrand_11RandomState_44standard_normal __pyx_doc_5numpy_6random_6mtrand_11RandomState_46normal __pyx_doc_5numpy_6random_6mtrand_11RandomState_48standard_gamma __pyx_doc_5numpy_6random_6mtrand_11RandomState_50gamma __pyx_doc_5numpy_6random_6mtrand_11RandomState_52f __pyx_doc_5numpy_6random_6mtrand_11RandomState_54noncentral_f __pyx_doc_5numpy_6random_6mtrand_11RandomState_56chisquare __pyx_doc_5numpy_6random_6mtrand_11RandomState_58noncentral_chisquare __pyx_doc_5numpy_6random_6mtrand_11RandomState_60standard_cauchy __pyx_doc_5numpy_6random_6mtrand_11RandomState_62standard_t __pyx_doc_5numpy_6random_6mtrand_11RandomState_64vonmises __pyx_doc_5numpy_6random_6mtrand_11RandomState_66pareto __pyx_doc_5numpy_6random_6mtrand_11RandomState_68weibull __pyx_doc_5numpy_6random_6mtrand_11RandomState_70power __pyx_doc_5numpy_6random_6mtrand_11RandomState_72laplace __pyx_doc_5numpy_6random_6mtrand_11RandomState_74gumbel __pyx_doc_5numpy_6random_6mtrand_11RandomState_76logistic __pyx_doc_5numpy_6random_6mtrand_11RandomState_78lognormal __pyx_doc_5numpy_6random_6mtrand_11RandomState_80rayleigh __pyx_doc_5numpy_6random_6mtrand_11RandomState_82wald __pyx_doc_5numpy_6random_6mtrand_11RandomState_84triangular __pyx_doc_5numpy_6random_6mtrand_11RandomState_86binomial __pyx_doc_5numpy_6random_6mtrand_11RandomState_88negative_binomial __pyx_doc_5numpy_6random_6mtrand_11RandomState_90poisson __pyx_doc_5numpy_6random_6mtrand_11RandomState_92zipf __pyx_doc_5numpy_6random_6mtrand_11RandomState_94geometric __pyx_doc_5numpy_6random_6mtrand_11RandomState_96hypergeometric __pyx_doc_5numpy_6random_6mtrand_11RandomState_98logseries __pyx_doc_5numpy_6random_6mtrand_11RandomState_100multivariate_normal __pyx_doc_5numpy_6random_6mtrand_11RandomState_102multinomial __pyx_doc_5numpy_6random_6mtrand_11RandomState_104dirichlet __pyx_doc_5numpy_6random_6mtrand_11RandomState_106shuffle __pyx_doc_5numpy_6random_6mtrand_11RandomState_108permutation __pyx_doc_5numpy_6random_6mtrand_8ranf __pyx_doc_5numpy_6random_6mtrand_6sample __pyx_doc_5numpy_6random_6mtrand_4set_bit_generator __pyx_doc_5numpy_6random_6mtrand_2get_bit_generator __pyx_doc_5numpy_6random_6mtrand_seed 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 __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 __pyx_module_is_main_numpy__random__mtrand PyExc_StopIteration random_buffered_bounded_uint32 legacy_gauss PyFrame_New _PyUnicode_FastCopyCharacters random_weibull PyBool_Type PyModule_NewObject random_positive_int memset@@GLIBC_2.2.5 legacy_wald random_standard_gamma PyNumber_Remainder ceil@@GLIBC_2.2.5 PyExc_ValueError PyType_Ready PyUnicode_Format legacy_logseries PyList_AsTuple PyExc_SystemError random_bounded_uint16_fill __gmon_start__ log1p@@GLIBC_2.2.5 legacy_lognormal random_wald random_standard_normal random_geometric_search PyCapsule_Type _fini random_positive_int64 legacy_standard_exponential PyList_Type PyObject_GC_UnTrack random_rayleigh random_uint _PyObject_GetDictPtr random_loggam PyObject_IsTrue random_standard_normal_fill PyExc_TypeError PyMem_Realloc PyExc_Exception legacy_beta PyObject_Not PyDict_Type PyErr_GivenExceptionMatches PyDict_GetItemWithError random_bounded_uint8_fill PyExc_KeyError PyOS_snprintf PyUnicode_AsUTF8AndSize random_power PyUnicode_FromFormat legacy_random_hypergeometric log1pf@@GLIBC_2.2.5 PyDict_Next PyImport_AddModule PyLong_AsLong Py_EnterRecursiveCall PyObject_CallFinalizerFromDealloc legacy_random_zipf PyErr_Format _ITM_deregisterTMCloneTable PyFloat_FromDouble random_bounded_uint64_fill PyBaseObject_Type fmod@@GLIBC_2.2.5 PyNumber_Long PyNumber_InPlaceAdd PyObject_GetAttr PyErr_ExceptionMatches PyErr_Occurred PyDict_Copy PyNumber_InPlaceTrueDivide random_gamma_f random_exponential random_standard_cauchy PyType_Modified legacy_gamma _ITM_registerTMCloneTable random_standard_exponential_inv_fill_f PyCapsule_New PyFloat_Type random_standard_exponential random_standard_exponential_inv_fill PyObject_GC_IsFinalized __cxa_finalize@@GLIBC_2.2.5 PyExc_IndexError _Py_FalseStruct PyErr_SetObject PyNumber_Multiply PyEval_RestoreThread __isnan@@GLIBC_2.2.5 PyUnicode_InternFromString random_standard_uniform_f PyUnicode_Type PyExc_DeprecationWarning random_logseries PyObject_Size _Py_TrueStruct PyTuple_Pack PyLong_FromString PyEval_SaveThread legacy_power PyThreadState_Get PyTuple_Type PyErr_SetExcInfo random_vonmises PyDict_Size pow@@GLIBC_2.2.5 PyModule_GetDict PyCode_NewEmpty PyErr_Restore PyImport_ImportModuleLevelObject PyCapsule_GetName legacy_exponential PyObject_SetItem PyLong_AsSsize_t legacy_f PyObject_RichCompare random_interval PyObject_GetIter PyExc_RuntimeError PyType_IsSubtype Py_LeaveRecursiveCall legacy_standard_cauchy random_buffered_bounded_uint8 legacy_noncentral_chisquare PyUnicode_Decode random_standard_normal_fill_f random_bounded_uint32_fill Py_GetVersion PyNumber_Add random_binomial_btpe legacy_noncentral_f random_standard_uniform PyErr_WarnEx PyErr_NormalizeException PyMethod_Type legacy_standard_gamma random_negative_binomial random_lognormal random_chisquare PyErr_Fetch PyModule_GetName expf@@GLIBC_2.2.5 random_positive_int32 PyFloat_AsDouble PyObject_Format legacy_pareto random_bounded_bool_fill PyObject_Hash PyNumber_Subtract PySlice_New PyObject_GetAttrString random_normal legacy_negative_binomial legacy_random_multinomial PyObject_IsInstance PyLong_Type random_uniform random_bounded_uint64 random_logistic _Py_EllipsisObject random_pareto powf@@GLIBC_2.2.5 PyObject_SetAttrString _Py_NoneStruct PyExc_OverflowError PyList_Append PyObject_SetAttr random_triangular random_standard_uniform_fill_f acos@@GLIBC_2.2.5 PyBytes_FromStringAndSize PyDict_GetItemString PySequence_Tuple legacy_random_poisson _PyDict_GetItem_KnownHash PyExc_AttributeError random_standard_normal_f random_standard_t PyLong_FromLong random_standard_uniform_fill PyTraceBack_Here PyExc_NameError legacy_random_geometric random_gumbel memcmp@@GLIBC_2.2.5 PyException_SetTraceback _Py_Dealloc legacy_standard_t PyImport_ImportModule random_beta PyErr_GetExcInfo random_standard_exponential_fill PyErr_Clear legacy_rayleigh legacy_chisquare legacy_random_binomial PyTuple_New PyCFunction_Type PyCMethod_New PyUnicode_New PyImport_GetModuleDict random_laplace expm1@@GLIBC_2.2.5 random_standard_gamma_f random_gamma PyLong_FromSsize_t PyErr_WarnFormat PyErr_SetString PySequence_Contains PyModuleDef_Init PyInit_mtrand PyUnicode_FromStringAndSize _PyDict_NewPresized PyCapsule_IsValid floor@@GLIBC_2.2.5 legacy_weibull random_f 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 PyUnicode_AsUTF8 memcpy@@GLIBC_2.14 PyCapsule_GetPointer random_binomial_inversion PyNumber_Index legacy_vonmises log@@GLIBC_2.2.5 PyDict_SetItem logf@@GLIBC_2.2.5 PySequence_List random_standard_exponential_fill_f _init PyDict_New sqrtf@@GLIBC_2.2.5 random_noncentral_f legacy_normal .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 @ G H o 0 0 U o 2 2 P d 83 83 s n B Ц Ц H x s @
~ ` ` ? 0 0 0 , ` ` 9 k [ k [ k [ k [ m ] p ` 0 @u @e u @
@
X 0 @
/ p
8 z &