From b00e58e883366da17aff70f7d6961ccd99f95cac Mon Sep 17 00:00:00 2001 From: HighDiceRoller <98680644+HighDiceRoller@users.noreply.github.com> Date: Fri, 17 Nov 2023 03:57:29 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20HighDice?= =?UTF-8?q?Roller/icepool@4fb1923205027c56ea2f2870d0ac7f97a66aed1a=20?= =?UTF-8?q?=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- apidoc/v1.1.1/favicon.ico | Bin 0 -> 17227 bytes apidoc/v1.1.1/favicon.png | Bin 0 -> 5971 bytes apidoc/v1.1.1/icepool.html | 15973 +++++++++++++++++++++++++ apidoc/v1.1.1/icepool/evaluator.html | 4813 ++++++++ apidoc/v1.1.1/icepool/function.html | 1930 +++ apidoc/v1.1.1/icepool/typing.html | 828 ++ apidoc/v1.1.1/index.html | 7 + apidoc/v1.1.1/search.js | 46 + 8 files changed, 23597 insertions(+) create mode 100644 apidoc/v1.1.1/favicon.ico create mode 100644 apidoc/v1.1.1/favicon.png create mode 100644 apidoc/v1.1.1/icepool.html create mode 100644 apidoc/v1.1.1/icepool/evaluator.html create mode 100644 apidoc/v1.1.1/icepool/function.html create mode 100644 apidoc/v1.1.1/icepool/typing.html create mode 100644 apidoc/v1.1.1/index.html create mode 100644 apidoc/v1.1.1/search.js diff --git a/apidoc/v1.1.1/favicon.ico b/apidoc/v1.1.1/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..9bc02024aec7361ff64679769829cb86a65c5430 GIT binary patch literal 17227 zcmbWeWmud+vo<&k?(XjHkl+wPa0|iRB?NbOcXtWy65J)YJHZ`-yW0-rJ?A@n?Oyxs zE8!Uh9uU1jwXRXy)LE{y?ihJud7BK8~^x5Fj2OQ>2Q2YH`F(+voN*2P4H;_S|jz za{qDG)5&=^Xrq{Qx^F}CQ9@y`S6JoEL&$a@drbZyx26K7{`X_8hZw^{NQ-o z%*gx|+Psg}DXVcYxx>PX8Nydp{uFaZ^%w@^Kl(%4#O;3lOv#8tltH6+)K6M4qm5N% zFB7VCnHXkl^O=CbXh^ZnP-7xGe)6%3O5{MdWJ_wog)y^KyA&d{hfh%t2LBVu(a=Q6 ztf#+m-E3g30z;2S<`pxD;Ey+xW=UE?#aCZ-(BxwG<@_e#_v`h~&3TbCjBq+r)3bQ+ zV?TU8NEu=b`S`P!{PDqpt*R5+)n}GkU=pg$8h}Ck*=FXV>?NV(RkvMuN7>Z*?A~N> zq8YQDPmzO9gTMMNHf-RmqHC|KL=~y zkxGFoZ$UWkdx<;YywL%3f*G?TLIt}@K_k;Q!3M)kR7u+Jua9TT@V?Ww-<3soUT3(| z6^$SEKbp~*e47H}_5(Q$K;nz6NQJPj@BfW!y*V?^yKAjG@!tUe5a0f}R(_&XxZ)R( zYkhM#J>GZW8oMIVgAfU(l16|4!qTn#)peP2prV6oEDUrLwax zGyek7Nl(*8>K#+1Z8ly^XLBUNz1J#esCWghA)7hPQRh1#jAVzKhZkOJz3#K5mfU_P z2j8Cpl@>q%fjTvlYI{+3{vx&D*<5~LcZ#~j$EU=qh_|sMYQ?WuBXatv~Dc8w)b@K0u7!n|u?6S3Hd%09(v&kbu@KyR6 zYBqkJm?25Uj;_A=oxNMP5Wz{6SHw<480|E?lCbY^kX`^O+L_mm-mnnDsI-}} zq!$L4nOmZ6%e*RUr-J$|t1?2iP*%WcNu)8-vrTe2L8OXb=nMTzY-sl1V7%0n1fszR zf_fx)=89?(>zsqe+VJfYwGGSI(`YkxXbOzQ*90>!h=n%8#ZlXSzwV6))Z7qj<39F# zF`C*yKfgnAZ4GQg*CVU`hFR^OZO^Jb>;{3Z1=89!Pi*t_wc;?4zv>yJEoE>d0mxCv zUqpbXvL>y3mM&go>XNT*A;C@3+}aKVD+G3?pEpKf7BGKS+$S3U2wu|&= ze3YRGk(*R*%Gs`P_12QR%>L#b^Q}KW(S085Y*z|grYFSy0ll?ex({R%g`IC)fX!a; z%^MKn4~SH;Ecn@F=F@?>p-fGoAeAt1pvM$|T(Nzn zv2kb~x$h#!jYN2P>oTq~PXMlbcNS{Eg!n-MVr}g#z0?JYk*m^mKJMPWmqi)Pv)t`P z^TklKszG09{V3eTW+ASro#BXpbB1TA$<_3DV=z48N80!F>d((^%TGC>IA)DGHVY*4 zmU6ZjY*ekp%C1%Re6{c+(2PZ{b;t;z8m5^^<%JsfWvp4HRcRdTbIW@sVJeg%ZJqa; z&s|<%KG#CM`stFOwPZm6V@^k!}=1+vi?-p zZ+E)C$%Ewh-OV>58bz!*4A%5)5@!8i%eRVJL3m zhi6Ci2RpgMQt0`(;^N0${=^0$2+ZgcBp64wX>)^-=vv=KjN!Bf!zS0W%7XozIt?O< zuRfoVWr#l-!=_8PBI95iVEGoLs86ms`Z7AU^P%cCc*~gtjE~WiomCMzw;GI4oYPbJ zd{QjW@H>E1D?Wil`5KaD>7IOcO&K&ju#Epyt9EvoXfoC{468fVocldxP|{&7a_D+c zZDXDu)Ati^PegH_t@b1PUM05Au-%X!D~k&8&Qp!~%Aq_DrMauYb*nyEEjU+5DPgC` zovpSR##wK-bMmZ9{!aN)`r>r`=Ri5p&yso%pGiN+Cc+$Ednd=xVPL7ykr+Q|Bd6P) z^(QA^@A)vG9w`C4HiP+ASv~(Su=tF?rl8B;+0^Lf>MsBpIpIJ z?dh2*-?NnGaCWK^s}IZ^9g^PitWrNL4NC)&0Qqj1my`qZ-7;i}hRBO*NSLM#{cHlyunSD_gkX^ybl5Zp!olDYf^QBHJvc~ z1@~?rS5h)oMyW;@aWIyqloiT!Rfr*ec0m-^7a#mc+K~FXyxoHfSg(ObWg_Hl$Ca4wu9u89zodc}leb z0s>3-c;!d^IRbf>(2A$E)z=ih=JnoW1={BkP3YxGM!Uj~jg3dZFBH9Gp}`%~jwd1| zc)f0?zo0PM;(UqO6NMQ&!GujE>hoy3{JoDB5D)D$H<#`N zTru?3dGOvkH|u}I>lT)CvG~L-NIWpKI+p2G(R%| zd~H3&)^~q)6*$iu*=->f1E|?q>qE09<5Okm&id0rcHAtkqrbZ(__pdk#@_&$5T01b}bWtbQ=Q8ycM>;^@Ub)yXX zAe0jPW$&)`cSwGJ5OqKhm4AFaeX(yG8Xp%aK^g|nJfM)j8sS za&z#k)6?We7^zZITnK0DJ4*0I0bXq>ch{{6BHoVv*p*n~E`TrvssuJ|23KY+Mpatm zmu-~hdMJ}6B$)b6yCgVmW^7A{0pDjUsK&-3_d|tG3{pml$wTW;5k0r7G&C&jWl!c% z!JW6v*iXg+tV)R!pB!e5Oc;^4d@O5=_#I|0?`pSJp<0*x=CRQBcFA3S%`AkLNO8Lx zO5W)sqPuQm!$9iLX`4uG|Sa>~VJ#Vs?uIn)oDt;+?+v`}>AwXn}*h$a3GdrMf0(LATT zdZM~B=-3(h$zG|p6udzSNh$%HsNIg?Y=PX9G3RvWYzaSxxJ|7pe%>MR_qR26mI*S| zLHygZxD==;A`FglvB@yfvmMHvlqRC#0G~A)_aew&KG?L#Ck@0%e6I3;w-1dJst#q5 zqNHKR1qn?1Gf>?~R@}6*OW1Df{Hddy6@Kw0G4iF<7@vfYXF~S{%nCSo$S<~l>r-C7 z*yypblbeG<2g6daIqPcvoxS4xJt3|DbFz$LHjY%JKI&CkUba0~HA^U)57D&jjL(*O zKD|l^NJV;?{W`W5+=xii978R4BYxlVDpFCG!0Lsq^b?NT>(01qhcZ7Q;rLTX4w0#m z^-iMgE-_>|>Sm`nfqdBz!_L`=W|WR*6oc46t3%>2tfveA#cUYA8A4YI$D#2%e z>>68USvl3J{$i|^VXK=%=Gg@FgO7rq8ja}Y^jT91)uIaI~R7-147mNdQR`#Z(<#G!EG$1 zih51aDjOD3gf;zXzZBhKKSeym41)V*MJdm~b*_G^`|MbBs#-J$YqJ8cj}mkJf#+LM zNlsUzfcdZo1^a9g^$oHoDRNfH2@4rI85>$G7mTe5!(+WX^Bk^HMM}0?1nfieF|!4N zP21t1)Rr3KT#(og@lD-FDSY1qa;PiaqF%aSweKiPIFyrDKPT(cB`|!%P|&|SQ2P6c zZV<`n@7L~?3-Nd6^Ed~@(0H^KSX{H1NK<13iiyln`v$hGD2QcXHlqC=Bi#tFNTmLN zU!SPJ{Hhg1%na36$Zukj5P?W;37r{89o@DzR)0K2aMWZG_|b_skQ|KCW9s&kE|v0X z+C_Tu4T2a-?H|6&jl|Tank57=;_wMT9R$L}G6Nn7z=*!}(fhOaxtW(8H&%=Zt9k_h z>;TRw!M~E|&|tzBS$FZMG+P&8hL6vyVC=qR%4&+afQ7IATGABvKBDs)0?DEwo;;Wr zVeTjk0w;XE_c*act|LMCymo)d79Jwtm!C%(LWxD|jJ~{*vwMwRWA(Pb{(0?DL*pm$ z@tGKy`gkFG%P0rm=$n-(XngXn!(~(@h)fZUN?)Y0cuZq6HtYoW!5WkXE+H^#Yfj~t za=#CWQws7^?bruHJ0jJwq9-|LjUPNs@gYpmxI9=%Vu=`~NI4RB<*>n3;%5HloY$tC zwODD$cmhE`(ps)1LM<&(pGj%0~sFE99kFld$wFEvQ=;**L&=R#GMV2atW$gt~tCre*jNkW38XYHEKZ2 z7)1M90C|t6k_flRum($vj~{UB6Q>Zb<+QjxSmjf0q_w_@@@%hs+1g(Oi-w9W3Bm{a zz=dPu3!@pCkOJ|5i0~)hQoHw^N`)$_Fja83jwcrX-6_U}b^Ix8?7OqFf!q>K70yt4 zSIqKay(Wic#Ye%9_j8MxmQx3bewBu+mkH^4s561NSC_UJKg*7MjLN)c$uuabdF=_o zmHqhQ)61eC;Rd7z2jS>L!B&LDqe=+V%x{Knl4Wdy{1 zq>pd#Qt@pD(!e*6uqG2<7g}yLJ(&|=bX#m3=G+KabUEm$Tnnj8rYpo#J=H3q9r_K5 zzKT{dYA`|CGykTO%{Mz*#$w#P{T`XY3aGX)odAAObgULZ7N5XB(Thc+ZXq`}q);hp zT0DrIUtg#~UaOv|9U*Ui_1z!qqhbCw=m|GmgVKigQ<)jN{B1&f?ys3r)bD$}IkPt) zD%)<#skcAV3#UTfVy3jY|BbuK^KVtR%0364XDji6c2Uz6XGJAV5ttWdaM!7Lvahw5 zybNW7W^+4tMmSm+L|^>&Ptn13hI0iKo%%jeefg6ukt4p>F}`vmkBIgq+m*kQe0L-c zyu+{6c$g9u8+Uen($cnk38AC}ua(Q>N7H!G!Ny?WgBNEmW*z#Ylun;YX(h_St7g-W z-Y*sgUB_@XF^xZe^)5&a?%-F-9ueQ!*XGQHM}-iV7iGA+p4FgGKXSkl)7nOI-rKlF zWEXY2AZ~0m?%v7};M^J3DpYS7Y`#L9W>L&~uQqY~Z=$?6i0=I!<$nw44FdoOtpADf z89L#FN`(C#9d^biD{U=Kukyu;!M@pyj2QLNG++EwKZjI9$TXu}_oASp>v*sTFH%L{ z>2AWazC>LJH|`YU{3Azj#Ge&Lola${ana#LgLzi* zID`+Ju+@W=%9uhTBKjV12K(^Fqq>RYxoGMcJEDgg{WtM+^cp~*H~7dVN=zn?`Vw_u z5K>KL=%P6t8R>ijL?VaooFrF;{~?W%xyNz-l4Qc)z``Os>t`LjrF`p5{c>vinqmnU zxA{F7zmKkw^abK&k&`+exPsSTTq2{wu9*6!cPsCQA7e_l z%3;9u^f=m^_;o_aL_!4LaC`qL=ZDmvAnA8fCQgNRD#`pa;0hyh=I(9U@Oy+f=)yZb z%?n7rjd!8WKC@AJ?lPb?tIrv#Y>5kW$?2P{xz zVt|7qcNg3N)4gFEfP{F`t-)`h3nc_eJ*vi!8p^i?W`JZpOy!gI5%vcodOZfL5v;eb z?>HxJ4SaY<=9KeBcpok@j)O1oFkaH^+CHctvnbz|OF~EnQug@*%cq6O&e|abrIzWZ zLoWN*J8)n!tA-JQK=IihiGTtmxRM7&qw6bCI;d!j#)nkaZsdBNMjHhH!X1w_J=h+< z5f?)ZVBLSrYd^dXyhb2$oSkZUJD}Fpwa^M&94PD7d7K7Gw7j9aOj-M6$IHDEoM{0G zU34G*sB>v!C~Ls>iL^Y^nd|wfnnHIK{KgXN?pzj|$vctwNdRdw!1P{70>#t59KQ4S zmK{&xbb00-h37Ro#EiSHTgusQLM8$LBVmU%eGCRinC`mIF;hVwWC_1EODQ#O2!aqy zDy0|zx`CUf#e3dlBM~AXfPuU7rv*}=(b>?<{)DpJ1*dul0tt-jnNOv=$mWAYN|D;3 ze_nP|i);GXtP~|y>)5zdY2oclkBfTTQ_Ogm+tEC8obIkqILWs&DE}6wxW*!YGhwEk zvYZKjMz94yqB941nTzx+Jwm{eB zjHD1H*I>;Z)qwz5=gM=qFY*K26sfPGApv@_DnrUX(85SqqTXwz`i&;a0FL4t7tYg} zNCvjt?`FunM-ITdvyPER3KCS&RxT~9$>f;LmOam`xVW@vW$!M`2gf86_lxL2)Hlq#$!mZV(p;s*~I^CKG zWP{q~xARHI6XvH6_R9*fHyZ#LWr`_UIIVTLv=<9>xdn?Id+P7ZzY+_fon6uLpJ`VJ zO@s<~lw6vo&c?advepaqc8T;{nsBU^u;xiSg(&z#kx*Le$DEJQ224RJcm2~X<`W^D zawDIuun)~WjUsij-|e!P99`=ga2W}!;oUG~;HFSRNN?__vWp2vTk#d#*8r2^tWT|v zoEk$kV+>^4xYh&-LxAY|MIaQ?%kTai;t`L+$r&@KJU}WQ7sp}l0rcL1y=f`+{gUyf zfF#HE{S@C;`#hhwukg*5JtmecTzA(zKcAC&?s9HRd8Xmjtb`JRbYo`>cf@Jik=|E> z;-;|NklzNF1lhfvw>sC>cNuqwD`lB?dCd&&^NpPzOB5A^$VvRA*$tA7XTMB<>w&|W zI)bI=>t)?Fg^%>CPNDX{}fv^Pu0=LxK7XcU{V~aDq;~x*rVG`L(X{EWGo< z4O|%0H?1G-oT)y2io=P}s=RjmQEHOX?g-^TcF@F>VY=Tm_j38k;JVgC7fN*$PkSk| z$`#1=i)?_6X08m9C1Tc&x}Xlmyf=`wb4WG`7WY#@6)A$Q2vyY2?L`2U@kMf9XCK%c z{x^0PY4Ri}7Vfxy4%=Hi9HWb)6^64ke9dJp+KCG=W&-619=Ayu;%AXuE0HcI4FT&F z5$kY|B$)J@sg*4&xTXVeL(;dk(?CPYx2GOJ*pUsy6B}wkfhx*uyBnZ3w9OhZf=^O)-*i!#TVADq-e_GJIYCVLiR7BNzi@{kgZ%P64Ibd?)pusf+!U&+i=t7nM7&jP9 zdU(6ql}Wk;iiI(*|6pIX#O9ppjn)=(AQ;X9GTXs^Mmr*k(ZzDR+IkluQlFOauwX;n zbj05UWoz%$@y1t9VzJ%W(M~n~^S`CYy6RL>v*=kp;Gfw4V5Ou&bn@d^dcFRwF{LWfwqSC^SksMVhlH>%C*7kGL z@aGzU_xD#xYVk3cpUkZ>4PuD-s}bM%PU{$dWdLUx83Jtx6!rq{7y&773*ROe{Zs5; zV0jnv!WM>xJM$)l+Qs-Q8Th+pD6EXoaJ}`EL3@aMvS7C%?tPzt>*1gv^Jb^bxPxD3 zT3cjw(wQ8IdK&yI5)KBz5^w5T<>8?kyzPCOu=&MQ3BBCX`+@wZl8(&I2HzR*t{C@!<(t~D{&ET4Wm0CsUn1Kc$m_^8H)4oIXrP(D{Fd*_jF zw!OALQqW(Q;1B`rh6usJK)uiceN@wXtGV&kXJ{M!hg=5$^4CuajeR|_COGOyygmL| zBdadgzMWuLg{CJB&5N$uk>QfY<#QUjMl38fwvv?nl`hPs%IAArox-~PdajRi^mu5E zL3P?Fk@U%R9vIt*bE$b4sSX*nPUCC03W(5PKKo{M9o-lA8e#noxh@}@B9UZtHGI=M z%P=Lxf`xtT+iXs&HN=cTXwp}lxx+Osb26u& z8d8*`vC_PZ!|6GHZ%}SCl(H6Lp34up;vB3rH`V>U<&dwmfq{_8UAmC<86sPH zyG0eIrmBtTxv^?(MQP>C1Z&^ionJ$TpcgG@VLPhYE+l_8?!?`qOgF%~BNAXAJ?gI2 zFvAxJL&P!-H~@CQI}cOuv0u~dyj=BD4^)-zI|FVol<3f=r{MsO0#7HwcD+HC268K1 z!pkCyEd=44o$v-Bh<+Lr%MBsUqEfD{FI@|QAe){80kx&>fIC5=ehIHQO~vv5=Sl+% zL{S1=GJoh>{SAxpUk`R%-is4*L=Ef=O6z3 zGTxsQkU!-3^*IRcdMM! zrz)Byj`@Bamc zFdB(xz|*I6X!^%hDtDLKX{{Xuk56S70ZW;gjRHlAnb!GJkM5;0$J(HIqC-kE{nRk{ zPKB60!&u&gujU809I+j73Pv>^fN?u)5udG5OcL)C1OTuy$e;csAe-6niJ+X)Ci9aov zrzo2Hw{gDMtIBC_)~c@KB~l82ozb#3d+2z9KW)MRXLJ2PCwANw*5TO>edePhU0&I9 zgt{kc;ath;F~BWf&?ef^aa$krZ2c8E8||ROrmh*J{T2PG&8)gs^y8wAEx_w+tsjg2 zftj67lw00>@=JkDcqt+yy_hX^Ei>56Gy67w z5Co3FL&R&HH%@`Uns<*RHSSZ03Ib#mn!=j-10Mlx!g+%o zU$PnG5wj1nIi|l?(;*^{;;5%`RG`Bczg)2oQ?Kam<;I6PU$_Ox$9-=t1EvKMYKZ#F z{O(?CW>Loq1g9Afw}8Ve(C1oFi2M-$Ic}&FeW*)fNAcUa(3e=zW9URVp5Z;q0L4Nm82?aRr`0X0gCHQuZmmAlD!c8Roc;-dxnd8VHRXjmF z+@EOOd(DuYOUnQnK(+8+z2DK+^9SC%$~<$(qj`MO9%)NYiv^i}CP@_2A#|=5&o)q@$x8JDu?4!_eyXa26aUIbP;TEcQr7fhzbUJ?aIE48tW8Y4`tEe*$@2!FZxBion@&m$N z&H17}GJQ$6N_`@3x&2Edo2r0{{yl^AIJ{8aSwKYo<@^s9Y_~?s>a)&WHp#t8R>my* z#PRN{S^x+Ca{aQ+cr!r9yU+ZRb-8-TX1>JR82WbUO$>wPIGj)!i+bSW$3&RC+XQPS z`(5H&3j|da>>Q+{)}6Sqi$PJ)l)rHsDf0|Nw+>4?J#h5jyG=eq5H5HPQ)leNMPy=l zi^oB;pJ-{&U1?GrY>dr_g2-L0T=dVz|O31zxPjlx5aKKY87sSxGh6u<41a5 zoKb-ds2sff<5UKh-8tJL!+)f?q53UJT43(|OcxGZ!C*L3!u7PGkhsjX^=j#sTStth zB0zTr#Q9*5veRPN?j`z4bCl0feTYWpKRhj`=ry%`j-~RMo2@KLte^G!Qy04hrv9-! z{0YLhMG4O1a#ulH&jzRReaGNSC%b(>pKmfor_Nq01E@YKV=j@> z%uk4x_nIJUwN)TPCSd zJ4W0~7uf%La{yecjwO5q2-y!C#pvzKP-J0#S_Z5^g$W8!R^snUm1l~m+Mea+vZ6CK z^ZX?>2iEF4Ux}xiMZYOU&D%x`00vPd5EF;R099)*JhBql{jhR>g(tS9O>$+f-F}hD+ z6?;JFAnJr5B+(xGn~zcdnInb;lMcJl^{jWXU^#yK_X6m1jzYwTVp}_zQIQ6691C@U z%cQVIIwst$=ia1T!*nO6n}ZCXPY4dtAL5HC-2BB}kALAODQ?BP#1DJi`D6{-=2uFk zC;~xx$hs7B5Z}k$;_LP1cg;uSBK0K;zId7~UpDcRR?5Lji zfWqLvm}dxrQB7&a)jN8%WbQ6@oy3)rRFbDRIUzm(B*%=ar`fLH+=wUpC5E?vbhPse zAT*^5=dQ2R>46WfJO^=Y?>>t`iu=={xtQP^|Y#ynnK-*Hr$MjqSoMhw*e|+kIsB<0#?&E2ElI=@Z9EcGi-dG?dpZdsI)*`47-+1yBO z^+`^@mdxuf;6zX>Rm~bq)&B*T_`$Q!`@?->O}C^K!yo!7u`>(1vz}*LQtX^fc4d#L zF^#JXco5GUG{nrsyqi#p)JTF}u2oc3!|bv7`ufTysH^%1Ok(HE`d9uDp-LwIj?2bz za-0lJlm3WM7X^E#CyH5%j_JWq_M@k~Ew$&o`Jr?7Y%Anxp=XZA<+ z67UoTWB`X-<1oE_&7D=11LZ1_?`9UgOG~C=%qo}QwWMp;&kb0k2qL*x2VQIEsWLzl zzppK~{4Web{gS_Uxkj9!(Ecpi6W9NIj~`gzTn509|EpI7k=0S(({>0<7dmQbK|UV# z%OVQ9Uo=N8{B4+^{f%MH5OVses-DT+L?cD;xh=)vwAuaQ^VIYikw7)oddo-UKYR=v zZdJs_dLVw{)4w0FVb|KKMkG80R4RBYoV03=gko0It<9c?uCc7vx4pQ>v0Z-XpJVD8#z(X^H60M-tm_DYM|h*XMfQHJDzuU+#SfD@AK zh08T+^fCw$3cXHKG+^PSAf=lcL&l*8aAQ6gI-hceU3jc`aaVVTrk*Vzej>f~ zl2-*A_z8j*ZXjqO4DWtX6vV3n{R0=Z8%QiB2-4?sOi+soZ=!OX99ZZO{fw0L_+s`% z|KxZXU^{$%+vSB<8FB);gLC%x7-l4=Lv<9S9Y~ci|5WMS>IykooJtmTOiS(EBQ}yC z(25C*;m0G=$CUm=sT<2-Li1RHb2t?h-A9G}uoJH|I?awh)dj}Hu)7hU&4zHKblQDU zdN?RZQBlNzW%Wc3!KY^ zQgt-)@UcyZM^EF(AhRi;{ao&!A9(h3|6&N)nG9wONg}qH(kt+w)IqF+3OZ3(u+(a{ zg+lhf@2H@$LzEjETv1OM|1#J~h9jG`_x;)An#(ZKRA>u{W_RaHdlidCIL$#;l z56X%lEk!W3(~hRuMb@t+>h`;A`{0BkxqMWpYbU0?wGz91V56=KZ0JGJg&PfqAYHLf zeNn|=H>0x&1xfm9-sT$oosj;W&aMCPP&6B+)ppFza1l;u6?C$=O3pWmSsqw4Rfq9~ zvxN;GLq|ZT^WWLtQ-jB+hVc*Qu7zY3!7r-86rpuP^h}At_sla@24e;k>S)k z_Wc@EUun7TCMT0aumXrU$c5+w#iDv{M2Bh3lL+Ww2~rh3-5EsTmW7$T3uSwbcuV8q z-3gvYQYj0EkUXuqcK;}{oYYS@i{+^j`74d89a-{f&l|2uW{?8xsHfGPevAcZ&jAvZ&xl$CUXFn5(fGj30-aMt_!MK@FBPs7a z2S-4VsYt|wgZiyCb2yu}Q{#ITB+x|I+1e{P9C5%V3=+6S%I8e7ZTh?Ut~V!>hPayfbLtah`L=xCoD zlvCu(P#(5Lw6xIcBVjbe2+{%rW;yjFa1Uh1qkPXk1=E{=L)bZ}RGYF;_d4 zdaw4yon|l(q~+e?uuU-)wKb!+E8ufiKmZSUK(T5{WL&QVS(g2?Uy7jP>TRWfR`_CV zo!n-<_{I;It)H142&T6WM!U`JhQxb_2=oB(0*@Sg@DC^h$v(#aF6#Sj{eSl|=QIwi zCAR*$lY!ha5YU0l2I>H0?|i!huA2}!U8iy=sKrv&l^{v7mt&Pqoef^8m8XaqWVAj? zG`8b30%k88MZWA#F5gyjn(( zqr+Z~Hw>i~cq{nahAz98SgF(GZF@5g$KD`vs|G2YkXvXe;^%IyQt%VieN{n@xC`l9 z3jt`ZhQrHL7Uh&()Wwto$lrH*f{q{PE^>_Fn} z7lOs-$*>#qo3$VRKI>-jO~C(Mf1vp0=~k>T-l_xjeA~wBB~UI?^&glt0)yd4NLas| zPi%D3@iJB?1 zpM$RE{UtalG__mDQQaHfOi9x`mi?bedii&spW%`Xf(AA`@|x;y0cE7YaV&-;kXukU&|||G&yCSt~g2|K#zO z#xFaV2b7H_7Sa1Q?}v6|-v)4&$?R`8Py#?!tXdrC?ZNe@HXB}4zvKNu<#~9aqCrE1 zLs$DwwM)2MrHx%9rZ~&=x5F7!mSY05)X2OH%G>+CTRp8HYW7}K9@#s@X>T0B{m`NF znDj9J761bKb2C^sG5=U-PMFe?m0*PZf&=K>gENl*P2llv8CE!(e(q{hu{h-m#sF>Ro*nV_hXB^6+s&6q%V1OAJpDR$P{>7HiPFE7%r@-9B&9lJ>)T&y8icO0n}#){#dSfg~JM5 zEE_S9t=#|JRRH?<#SN)S*|lh1xO4f~krE`U{;_$l!H|Bmq~XIu$Z{sMZ9O}Xi$Q2} z?{TxWoqcQsMTEDOgaC>-W+wlvN!AX`5zmg9k+sXej?L^fP~P_JX(~HByn3w-<7I&MbjJXii+%$uKjzE9aIK8 z5xOx+Zd35-pQ~II0AT(LL1^}B0pv1*7o3!7O`HkdTL`~B{*D^|JX(hiGKiGHyi^~9 zO*f-kb7Malup)gw`bp2L@4tO0J`;Cbi$W;0%7L)UZ>zpm)`b-FkM9#AG99x^!1!F2 zFMFzSu&-?8cBx?2o8mG-5JvHTT|#w$e;)nS>^zw^cPRv9Vop){694_bTaU7i;3Y`fd|ORkIz5BN?Rc#J17pnj9e#MzoL!JRlr{zHKHp}1 z@5Ue06N2DYh4=uo{_)$8hnvQe{>Zmey{-3?ZHhY{m)^BZ?M)1t3_aT!1@mg9OQC67 z3ZsGoa{Y0bx>SKCkNj{kZSmgKt4SIL0wnxs&q9>I-Wri==rhyjO5gkq{pa=zEPKHy1(Un+=gy2$VBnDVczX`71e8fF+1X?n*8`qU6klBpsW@Vh5pb!(Ok;q%2bEK+3MO!m;A27?rPt$bA%)Z8pO2u9c z@=h1a5j$sfn~54|cC4X)iSQ?!kOl~dQ2YgfkHg?9hn{LPRaGtY#Q2{l+fNYi)l`?| zSrM`4Ta|Kj&{TYn)bR}k33DUkbeo?kPkY~3Xp$^trA(1kHY{t)N^qKas{^h9fxhtY zjG}Pgs@Vvs!=yw6_M0Kuz2N>>*1RX23D%fnjw^4#A8G~p;|j@6?g2S?e0v$xk(6*0QDGj7exPp*1 zOf+gUo!nkb&uLMg*Ax!YiRWUia~BA&pA; zPl1;u9WVR+u)Pk)^N&3-p0gkEI_l&g!uOfc;?G9=mST`!FE%SXasfw=e+ML5J!xHz z2BDyErr{S6(2;F(;uwD{6PPx z-tw~M)<%+wbb1@nXQ@(0rYjvIksoR$+rd=reuCYwjHdPQx>f^tdf1YZLl4NBE4ogM zKQ72-{X&rsCo*YvdM)SVWq9}3&12js3w-rCrnfTtJgX>5P8F4 z3is3Su!qip2!MHo?djG(q9r6Zw?ci`lR1JlB~B7^rh~AdTkiOAV5)Gs{Wg@{=cwId z5dN$AMJ`@|o2JEp03i!izorFD&K>9ZB;ljLFPiJ^AT=hW=F{9^?Zle$C6Chcj}@Aq zfcVt9(wXA&-Aac&<$dTj1S=Pt<-cD|lq=H?0|gq*AI5<;uM$HEb?vi&HR8Asyl>*0 z*0Xp5KO#`YyqX@J(IL>B|9 literal 0 HcmV?d00001 diff --git a/apidoc/v1.1.1/favicon.png b/apidoc/v1.1.1/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..fccb2823c33ec755974d7b0ebbdfd54a4dc94df7 GIT binary patch literal 5971 zcma)=WmH^EwuT!B?gz0)#Zd32wpN-96CI@L_?*-Q9yW794^* zx4-%1&a9cc?)*6C)T*iOgsX97-Gj0D!Nk@J18)ZTABfJ3e_UEe$G7VW#ciOs5{pF{VE%$2r~XnE#->@* zu<=1lxzgyQZT;P)5gAFgbV3+=FFC8p>>_;)T`k#{q@)U=_pQlH0v!G0y}EiR^JZ+M z^RZ_Fys2Y@O`bPmH;6%%Zd2FI^NfRe@zkFn{(!Nj?>Dz2O%D#htdsPgSmMW#@-L%wm&+JpN zc=0(qkaT5fjx9U%NtIes4ZUjhI+CkVAYo8MTh>=kcUKXaGo*I&c9wfP12}Xsz)bT( zOi=b^!Ry9O_t7C65pMKfA$-3qMRgF6xxIE@i-)P+D}Kq!>98Bxv^kmdTZjbP8Vd8n3J+z1HldRxx&}9JqHEPEKzy3Clc&%5EipPsDSzc{>*6<`-2G z{twHw)enQBSG&$)BK)<-H8T|1V<~sl4JJ230-J)|f*$TDGYell8A4ksj+c{yq>!n( z3x?bXzci{6?=}m;5=y$_^L&VL|8h%`=myXk3r6FnsGw`HyUGm>i&c0daZ|3t@RqN2 zi4N@X{mq!<#eTpi+>cM0*5O9`svAkzsXP@MN$N}(Y`U0CB zJ=v6{6`R4MTxZdE=RAQEQ!5^iKvqHFH|1^fM?JIp-$vA@mP2*wD`8cVO0#Yi+9Jkw zGU@?l?5GnuXxhZaLS!)YXr4FYOq*YmI3QHlfYj%Pqp_0U{Q9h(ZsH9iNzrNl2)a@2Z| zOeJ4ZJjnElaOQwW!cNsdAs`iI&!#`4A8+n68RWWl0}K5`4Ef1>dF0YrW@;@1hHmc= z%5LjNjpIE-y)dMi2;cc_Ldtix4XuIU@r-+l3doyPX~r$y#AmXjGx}&L1E#CU+!&N5 zM|~qtV@bI23Vdgl2Z!g7pt-Cp{R+-!F6(=&6l``i3R_}MQ3ZL=eS=xEE&$%k#IJld z<({+}QV)37?GIM%JM%Gvm*jxJi<)&PB9zh}2H20}e&OWd8y{AT_Gw5==-@Z)>?CTs z`80J96bm^zt3Eo%Z!oy=Q2_;`AhQv*%;}<5Wz1^LR67^z{{U^UiEhCq5^q zYpzmn@PemCp)gpv;Uzjc@H?WTUdZG;2&s@e9hb7RCkYKqGooPm5~^Pd_y zY)n0yTuX!9S89M4)k9GpV+Iw9VUD;OMCgn?Koak{ctIW1A?TNR_G$Xa+{l?DmMZ(aoY`Dta^w4@`h<2S9j3?4}erTnVm^^)OX zDuhas6hIbl;+?l&b{r)niQImY3t`{WXTW6HjDOLROj;Rj0`D*Q2!?2s3@RA02aHfF z3opZ%AKV#V&ikVEh@`WBEE#c3kf(r8=Q?HyQj592cHOFvpDS%ipv2~M5whjnSh+H3 z(45c_Guv_Fy&fOqrxCO3KIzM2)1tW^Z<6DFr0%&>A5WLb&azm$%^vBs1t;;O+U94t z+}0cEVVS>m(+$bB&)h=~rWf+ka6MAEO0a|r$h9~%A?|gkWB8_tXd9VVFM1eEKzlKw z?-4dY^V^LuiX#0V-xq;}9CSLn`rPuQLF;Ce_trEH9#+ns?s5iLj^nr66&V$`bA6U0 zGiv_DyexO#!MxyIEf%o4pQ$Dlfiv5v>6wZ1dR>OlaBUg(Q6uKIB?XNy zi&TK_%tZ;HO;WW>`<;qV>_S|DAXqd`BkYt08{g zLo!M@R|G}t?D)SACf#UO>}9c`MI5H)Zv+-euFZTYvI#G{qEX6?Hyoeg{5nT2Ye(%D)s$kKm zFz>-rC;Ch%YEtLzJm?9M<;yeqPEh#2PN8q3PNExuK6-p~zTZA`&V2jpAlSDnu^~87 z7JDYtNAhwg*k%u6dq-fLGkkR`NNnzdUm4vt#1JWe&ZL4TTFHqQ5Gv=(>9@Q@9Dd%M z5gAZ=d1J*t2%yT|Fn;*9rhFLwyOEsb=nRX6|78*u;%yi_Xr~H0h#&jyfB3`6njyW` z)9@AC8I}bh#)9;W8l9JDr#_%r+K!*+jGmAyP#jx0hQS8=C9>;akVC8e1EHJ*eRt=(>NRgOAgGKxL@A65{W zvbn&D(@8)(OA}M)7H`RGjM4jg$Jj){RF0H-xTVfPjO()(cdWrGP>L~N96x@_YwjSRP-hrG`nr(f5hRwB` zBUOprug6ka@_R*RAcpYRb-N5<-1lx^=!N zQ~3(PrdEY9@;r@#w-v)u?r5SaGfJ)Y>a6s!?8aax7Lly&ZSL_3@y##t0E%otDghE6 z>BQ5ImmhdI{Dh zCXz&rud3oEGRw2Dv@(VX`Z!2!@ga4D+wEek2%yr4ez76 zE>vn{tVWy-hg^2jE!s>88<>nRSg`{(-qftA8k@YG72I>V`C>fd^YUrSeg5Sf9G=9O|S)Pn%eXA?xyIh3m*wOobVdY{JTamYoDSwQY~BM}*x3v>dn z3)64Hf!s%Ur(pzyb z1usM8Rne#_$n#qQ%B@MS&rF5A2vLB`O#%<^i3DTG5TCX+{h8V$2z&<$wMSze)l;dj zuOg15&v^R9K#(<@5KBfe_&er*mRgO`=+-nzTQNT{}fvm%CxiX2R&A`gijX%;n}EY)#7`>i2FsJ z3oz+ecmIS*$iEnX`O;h@>sU#7Vf;$LU1td{2U1JdGMVY_&mK^$lkWOOzhMkh-Enbd&q(#sZ5JwS>cQKkSp~RLpKX=_9yL69r%cwU1Zv6 zKq6#Hbwz)ILjlz@@SYr9^K+RWliO%qoMV?@vD32;W5>!AR}jA)gku_}pVPwJsWmAH1Pi4Xa@t z0u&RTbR$m!QB`>`E-v9m7$v_TvMDfGlM1_6kB6NhchK8DOz{kTTyyA_&6e6*@m(Yi z*=OC72Vk#~94!j?L;NQVChhIavI>zu{tixnZ2{*O)cB&wm` z70oB63%DTGEpJ=0UNhZ{+sp7IM;oP#SjDfSdG&-7WPhY`F)N$ zDnPI+>n+7IEf+7?J?V9O`X){lGN^Gsm^Ir10NCC(>=e$SCxm!44kA1DL=-|P-KM6v3KYmz+*!m^%4bG3v7lMYuKc^j zJ%WFCQ;Y-zs;&f?Cv}uH?89xm6VHVqFW4^s_>-^$jc(ZhB8&UpU*XlvWuZjU-gLra z#yLH&QegKQ{>X-F=d}*(}FyRh|6mD&p3IlLXpz~_Xq>5 z?CVJfHc2rZApG-$4)xur6Wg`GIOJbFL2M59Pfv(B=9qB&9PYL2)^P_FqPHx4F6N@z zc^D<%37chbZfsvpAG{nO=LObO+caeSB^c}keFOjE4O{tF6UP7K4Hm%b2O^6J3qj`Uth^X zWQl}1Fu=1T^1BWB7kn(gU%P6wSwkz@%C5%1l=O2IAV>KiN9NJSq%r9e6>=*AZ~~PP zQ%WF{>l9H|Rn`Nw|Kjp&K zZt9s9mT9kf1iPKM3dqx`YgH($*JiQ}0JT&1q|-w!gkl6|FO3N4ypI)mBS|4gM@;V9 zi_OwLaR$V7A^2>b9Cetdm#dVI$`lb8qygr?M;b9xUQ% zUB{*u1MYz%tBZNDd?nn8#;52>d_?6@lI}mxy&VA(u@9^BW%iHDpURaH@$E`c-?6++ zuNSfZNvam(BdZE&_;VeakK z#9<ryt-A4tiCV;)u&uN&SMzpo?bUhl^Y(1T>O65$YptLqjRT6ML>~8s)(UJ zMKL~2N7L+n^UyfyzU0{d^GMt;D)i7ps_K-&xl6z*qIH%pcqMgyl=H?ZvG#rg;U0M3 zlh))kBs?PH{MlPX>7BC~Zdp0PV3Sgn_p65KBTKwz!-)AZo9_HW_sz_ltn#}M?)vSX z6X#-w2MvEwCg5mw#I@C$nLs!`J-2i$MyiwgVV3stRajpG=7TdRYsjexZRdRHH`}CV zbg%2*rSG-NuJBH}kBVefnHmTL`@49NbICcG7ZJM}1lSPlwwkIfuz|DO=T2PASLGdA zh=uDrI>5OLj|}j=I=dC*`o6V?KM~GZB@j*MQKXEL^lZ45c|m^j5NW!=4LSCBguE;V ND9Qrgz@&}7{tr3E!TSIJ literal 0 HcmV?d00001 diff --git a/apidoc/v1.1.1/icepool.html b/apidoc/v1.1.1/icepool.html new file mode 100644 index 00000000..6b43b3ea --- /dev/null +++ b/apidoc/v1.1.1/icepool.html @@ -0,0 +1,15973 @@ + + + + + + + icepool API documentation + + + + + + + + + + +
+
+

+icepool

+ +

Package for computing dice and card probabilities.

+ +

Starting with v0.25.1, you can replace latest in the URL with an old version +number to get the documentation for that version.

+ +

See this JupyterLite distribution +for examples.

+ +

Visit the project page.

+ +

General conventions:

+ +
    +
  • Instances are immutable (apart from internal caching). Anything that looks +like it mutates an instance actually returns a separate instance with the +change.
    • +
  • Unless explictly specified otherwise, elements with zero quantity, rolls, etc. +are considered.
    • +
+
+ + + + + + 
  1"""Package for computing dice and card probabilities.
+  2
+  3Starting with `v0.25.1`, you can replace `latest` in the URL with an old version
+  4number to get the documentation for that version.
+  5
+  6See [this JupyterLite distribution](https://highdiceroller.github.io/icepool/notebooks/lab/index.html)
+  7for examples.
+  8
+  9[Visit the project page.](https://github.com/HighDiceRoller/icepool)
+ 10
+ 11General conventions:
+ 12
+ 13* Instances are immutable (apart from internal caching). Anything that looks
+ 14    like it mutates an instance actually returns a separate instance with the
+ 15    change.
+ 16* Unless explictly specified otherwise, elements with zero quantity, rolls, etc.
+ 17    are considered.
+ 18"""
+ 19
+ 20__docformat__ = 'google'
+ 21
+ 22__version__ = '1.1.1'
+ 23
+ 24from typing import Final
+ 25
+ 26from icepool.typing import Outcome, Order, RerollType
+ 27
+ 28Reroll: Final = RerollType.Reroll
+ 29"""Indicates that an outcome should be rerolled (with unlimited depth).
+ 30
+ 31This can be used in place of outcomes in many places. See individual function
+ 32and method descriptions for details.
+ 33
+ 34This effectively removes the outcome from the probability space, along with its
+ 35contribution to the denominator.
+ 36
+ 37This can be used for conditional probability by removing all outcomes not
+ 38consistent with the given observations.
+ 39
+ 40Operation in specific cases:
+ 41
+ 42* When used with `Again`, only that stage is rerolled, not the entire `Again`
+ 43    tree.
+ 44* To reroll with limited depth, use `Die.reroll()`, or `Again` with no
+ 45    modification.
+ 46* When used with `MultisetEvaluator`, the entire evaluation is rerolled.
+ 47"""
+ 48
+ 49# Expose certain names at top-level.
+ 50
+ 51from icepool.function import (d, __getattr__, coin, one_hot,
+ 52                              iter_cartesian_product, from_cumulative, from_rv,
+ 53                              min_outcome, max_outcome, align, align_range,
+ 54                              commonize_denominator, reduce, accumulate, map,
+ 55                              map_function, map_and_time)
+ 56
+ 57from icepool.population.base import Population
+ 58from icepool.population.die import implicit_convert_to_die, Die
+ 59from icepool.collection.vector import tupleize, vectorize, Vector
+ 60from icepool.population.again import AgainExpression
+ 61
+ 62Again: Final = AgainExpression()
+ 63"""A symbol indicating that the die should be rolled again, usually with some operation applied.
+ 64
+ 65This is designed to be used with the `Die()` constructor.
+ 66`AgainExpression`s should not be fed to functions or methods other than
+ 67`Die()`, but it can be used with operators. Examples:
+ 68
+ 69* `Again + 6`: Roll again and add 6.
+ 70* `Again + Again`: Roll again twice and sum.
+ 71
+ 72The `again_depth` and `again_end` arguments to `Die()` affect how these
+ 73arguments are processed.
+ 74
+ 75If you want something more complex, use e.g. `Die.map()` instead.
+ 76"""
+ 77
+ 78from icepool.population.die_with_truth import DieWithTruth
+ 79
+ 80from icepool.collection.counts import CountsKeysView, CountsValuesView, CountsItemsView
+ 81
+ 82from icepool.population.keep import lowest, highest, middle
+ 83
+ 84from icepool.generator.pool import Pool, standard_pool
+ 85
+ 86from icepool.generator.multiset_generator import MultisetGenerator, NextMultisetGenerator
+ 87from icepool.generator.alignment import Alignment
+ 88from icepool.evaluator.multiset_evaluator import MultisetEvaluator
+ 89
+ 90from icepool.population.deck import Deck
+ 91from icepool.generator.deal import Deal
+ 92
+ 93from icepool.expression.multiset_expression import MultisetExpression, implicit_convert_to_expression
+ 94from icepool.expression.multiset_function import multiset_function
+ 95
+ 96import icepool.expression as expression
+ 97import icepool.generator as generator
+ 98import icepool.evaluator as evaluator
+ 99
+100import icepool.typing as typing
+101
+102__all__ = [
+103    'd', 'coin', 'one_hot', 'Outcome', 'Die', 'Population', 'tupleize',
+104    'vectorize', 'Vector', 'Again', 'CountsKeysView', 'CountsValuesView',
+105    'CountsItemsView', 'from_cumulative', 'from_rv', 'lowest', 'highest',
+106    'middle', 'min_outcome', 'max_outcome', 'align', 'align_range',
+107    'commonize_denominator', 'reduce', 'accumulate', 'map', 'map_function',
+108    'map_and_time', 'Reroll', 'RerollType', 'Pool', 'standard_pool',
+109    'MultisetGenerator', 'Alignment', 'MultisetExpression',
+110    'MultisetEvaluator', 'Order', 'Deck', 'Deal', 'multiset_function',
+111    'function', 'typing', 'evaluator'
+112]
+
+ + +
+
+ +
+
@cache
+ + def + d(sides: int, /) -> Die[int]: + + + +
+ + 
18@cache
+19def d(sides: int, /) -> 'icepool.Die[int]':
+20    """A standard die.
+21
+22    Specifically, the outcomes are `int`s from `1` to `sides` inclusive,
+23    with quantity 1 each.
+24
+25    Don't confuse this with `icepool.Die()`:
+26
+27    * `icepool.Die([6])`: A `Die` that always rolls the integer 6.
+28    * `icepool.d(6)`: A d6.
+29
+30    You can also import individual standard dice from the `icepool` module, e.g.
+31    `from icepool import d6`.
+32    """
+33    if not isinstance(sides, int):
+34        raise TypeError('Argument to standard() must be an int.')
+35    elif sides < 1:
+36        raise ValueError('Standard die must have at least one side.')
+37    return icepool.Die(range(1, sides + 1))
+
+ + +

A standard die.

+ +

Specifically, the outcomes are ints from 1 to sides inclusive, +with quantity 1 each.

+ +

Don't confuse this with icepool.Die():

+ + + +

You can also import individual standard dice from the icepool module, e.g. +from icepool import d6.

+
+ + +
+
+ +
+ + def + coin(n: int, d: int, /) -> Die[bool]: + + + +
+ + 
56def coin(n: int, d: int, /) -> 'icepool.Die[bool]':
+57    """A `Die` that rolls `True` with probability `n / d`, and `False` otherwise.
+58
+59    If `n == 0` or `n == d` the result will have only one outcome.
+60    """
+61    data = {}
+62    if n != d:
+63        data[False] = d - n
+64    if n != 0:
+65        data[True] = n
+66    return icepool.Die(data)
+
+ + +

A Die that rolls True with probability n / d, and False otherwise.

+ +

If n == 0 or n == d the result will have only one outcome.

+
+ + +
+
+ +
+ + def + one_hot(sides: int, /) -> Die[tuple[bool, ...]]: + + + +
+ + 
69def one_hot(sides: int, /) -> 'icepool.Die[tuple[bool, ...]]':
+70    """A `Die` with `Vector` outcomes with one element set to `True` uniformly at random and the rest `False`.
+71
+72    This is an easy (if somewhat expensive) way of representing how many dice
+73    in a pool rolled each number. For example, the outcomes of `10 @ one_hot(6)`
+74    are the `(ones, twos, threes, fours, fives, sixes)` rolled in 10d6.
+75    """
+76    data = []
+77    for i in range(sides):
+78        outcome = [False] * sides
+79        outcome[i] = True
+80        data.append(icepool.Vector(outcome))
+81    return icepool.Die(data)
+
+ + +

A Die with Vector outcomes with one element set to True uniformly at random and the rest False.

+ +

This is an easy (if somewhat expensive) way of representing how many dice +in a pool rolled each number. For example, the outcomes of 10 @ one_hot(6) +are the (ones, twos, threes, fours, fives, sixes) rolled in 10d6.

+
+ + +
+
+ +
+ + class + Outcome(typing.Hashable, typing.Protocol[-T_contra]): + + + +
+ + 
67class Outcome(Hashable, Protocol[T_contra]):
+68    """Protocol to attempt to verify that outcome types are hashable and sortable.
+69
+70    Far from foolproof, e.g. it cannot enforce total ordering.
+71    """
+72
+73    def __lt__(self, other: T_contra) -> bool:
+74        ...
+
+ + +

Protocol to attempt to verify that outcome types are hashable and sortable.

+ +

Far from foolproof, e.g. it cannot enforce total ordering.

+
+ + +
+
+ +
+ + class + Die(icepool.Population[+T_co]): + + + +
+ + 
  41class Die(Population[T_co]):
+  42    """Sampling with replacement. Quantities represent weights.
+  43
+  44    Dice are immutable. Methods do not modify the `Die` in-place;
+  45    rather they return a `Die` representing the result.
+  46
+  47    It *is* (mostly) well-defined to have a `Die` with zero-quantity outcomes.
+  48    These can be useful in a few cases, such as:
+  49
+  50    * `MultisetEvaluator` will iterate through zero-quantity outcomes,
+  51        rather than possibly skipping that outcome. (Though in most cases it's
+  52        better to use `MultisetEvaluator.alignment()`.)
+  53    * `icepool.align()` and the like are convenient for making dice share the
+  54        same set of outcomes.
+  55
+  56    However, zero-quantity outcomes have a computational cost like any other
+  57    outcome. Unless you have a specific use case in mind, it's best to leave
+  58    them out.
+  59
+  60    Most operators and methods will not introduce zero-quantity outcomes if
+  61    their arguments do not have any; nor remove zero-quantity outcomes.
+  62
+  63    It's also possible to have "empty" dice with no outcomes at all,
+  64    though these have little use other than being sentinel values.
+  65    """
+  66
+  67    _data: Counts[T_co]
+  68
+  69    @property
+  70    def _new_type(self) -> type:
+  71        return Die
+  72
+  73    def __new__(
+  74        cls,
+  75        outcomes: Sequence | Mapping[Any, int],
+  76        times: Sequence[int] | int = 1,
+  77        *,
+  78        again_depth: int = 1,
+  79        again_end: 'Outcome | Die | icepool.RerollType | None' = None
+  80    ) -> 'Die[T_co]':
+  81        """Constructor for a `Die`.
+  82
+  83        Don't confuse this with `d()`:
+  84
+  85        * `Die([6])`: A `Die` that always rolls the `int` 6.
+  86        * `d(6)`: A d6.
+  87
+  88        Also, don't confuse this with `Pool()`:
+  89
+  90        * `Die([1, 2, 3, 4, 5, 6])`: A d6.
+  91        * `Pool([1, 2, 3, 4, 5, 6])`: A `Pool` of six dice that always rolls one
+  92            of each number.
+  93
+  94        Here are some different ways of constructing a d6:
+  95
+  96        * Just import it: `from icepool import d6`
+  97        * Use the `d()` function: `icepool.d(6)`
+  98        * Use a d6 that you already have: `Die(d6)` or `Die([d6])`
+  99        * Mix a d3 and a d3+3: `Die([d3, d3+3])`
+ 100        * Use a dict: `Die({1:1, 2:1, 3:1, 4:1, 5:1, 6:1})`
+ 101        * Give the faces as a sequence: `Die([1, 2, 3, 4, 5, 6])`
+ 102
+ 103        All quantities must be non-negative, though they can be zero.
+ 104
+ 105        Several methods and functions foward **kwargs to this constructor.
+ 106        However, these only affect the construction of the returned or yielded
+ 107        dice. Any other implicit conversions of arguments or operands to dice
+ 108        will be done with the default keyword arguments.
+ 109
+ 110        EXPERIMENTAL: Use `icepool.Again` to roll the dice again, usually with
+ 111        some modification. For example,
+ 112
+ 113        ```
+ 114        Die([1, 2, 3, 4, 5, 6 + Again])
+ 115        ```
+ 116
+ 117        would be an exploding d6. Use the `again_depth` parameter to control
+ 118        the maximum depth. `again_depth` does not apply to `Reroll`.
+ 119
+ 120        If the roll reaches the maximum depth, the `again_end` is used instead
+ 121        of rolling again. Options for `again_end` include:
+ 122
+ 123        * No value (`None`), which will attempt to determine a zero value from
+ 124            the outcomes that don't involve `Again`.
+ 125        * A single outcome, or a `Die`.
+ 126        * `Reroll`, which will reroll any end roll involving `Again`.
+ 127        * You could also consider some sort of placeholder value such as
+ 128            `math.inf`.
+ 129
+ 130        Denominator: For a flat set of outcomes, the denominator is just the
+ 131        sum of the corresponding quantities. If the outcomes themselves have
+ 132        secondary denominators, then the overall denominator is the primary
+ 133        denominator times the LCM of the outcome denominators.
+ 134
+ 135        For example, `Die([d3, d4, d6])` has a final denominator of 36: 3 for
+ 136        the primary selection between the three secondary dice, times 12 for
+ 137        the LCM of 3, 4, and 6.
+ 138
+ 139        Args:
+ 140            outcomes: The faces of the `Die`. This can be one of the following:
+ 141                * A `Sequence` of outcomes. Duplicates will contribute
+ 142                    quantity for each appearance.
+ 143                * A `Mapping` from outcomes to quantities.
+ 144
+ 145                Individual outcomes can each be one of the following:
+ 146
+ 147                * An outcome, which must be hashable and totally orderable.
+ 148                * A `Die`, which will be flattened into the result.
+ 149                    The quantity assigned to a `Die` is shared among its
+ 150                    outcomes. The total denominator will be scaled up if
+ 151                    necessary.
+ 152                * `icepool.Reroll`, which will drop itself from consideration.
+ 153                * EXPERIMENTAL: `icepool.Again`. See the main text for
+ 154                    explanation.
+ 155            times: Multiplies the quantity of each element of `outcomes`.
+ 156                `times` can either be a sequence of the same length as
+ 157                `outcomes` or a single `int` to apply to all elements of
+ 158                `outcomes`.
+ 159        Raises:
+ 160            ValueError: `None` is not a valid outcome for a `Die`.
+ 161        """
+ 162        if again_depth < 0:
+ 163            raise ValueError('again_depth cannot be negative.')
+ 164
+ 165        # Check for Again.
+ 166        if icepool.population.again.contains_again(outcomes):
+ 167            if again_end is None:
+ 168                # Create a test die with `Again`s removed,
+ 169                # then find the zero.
+ 170                test: Die[T_co] = Die(outcomes,
+ 171                                      again_depth=0,
+ 172                                      again_end=icepool.Reroll)
+ 173                if len(test) == 0:
+ 174                    raise ValueError(
+ 175                        'If all outcomes contain Again, an explicit again_end must be provided.'
+ 176                    )
+ 177                again_end = test.zero().simplify()
+ 178            else:
+ 179                again_end = implicit_convert_to_die(again_end)
+ 180                if icepool.population.again.contains_again(again_end):
+ 181                    raise ValueError('again_end cannot itself contain Again.')
+ 182
+ 183            if again_depth == 0:
+ 184                # Base case.
+ 185                outcomes = icepool.population.again.replace_agains(
+ 186                    outcomes, again_end)
+ 187            else:
+ 188                tail: Die[T_co] = Die(outcomes,
+ 189                                      times,
+ 190                                      again_depth=0,
+ 191                                      again_end=again_end)
+ 192                for _ in range(again_depth):
+ 193                    tail = Die(outcomes, times, again_depth=0, again_end=tail)
+ 194                return tail
+ 195
+ 196        outcomes, times = icepool.creation_args.itemize(outcomes, times)
+ 197        # Agains have been replaced by this point.
+ 198        outcomes = cast(Sequence[T_co | Die[T_co] | icepool.RerollType],
+ 199                        outcomes)
+ 200
+ 201        if len(outcomes) == 1 and times[0] == 1 and isinstance(
+ 202                outcomes[0], Die):
+ 203            return outcomes[0]
+ 204
+ 205        counts: Counts[T_co] = icepool.creation_args.expand_args_for_die(
+ 206            outcomes, times)
+ 207
+ 208        return Die._new_raw(counts)
+ 209
+ 210    @classmethod
+ 211    def _new_raw(cls, data: Counts[T_co]) -> 'Die[T_co]':
+ 212        """Creates a new `Die` using already-processed arguments.
+ 213
+ 214        Args:
+ 215            data: At this point, this is a Counts.
+ 216        """
+ 217        self = super(Population, cls).__new__(cls)
+ 218        self._data = data
+ 219        return self
+ 220
+ 221    # Defined separately from the superclass to help typing.
+ 222    def unary_operator(self: 'icepool.Die[T_co]', op: Callable[..., U], *args,
+ 223                       **kwargs) -> 'icepool.Die[U]':
+ 224        """Performs the unary operation on the outcomes.
+ 225
+ 226        This is used for the standard unary operators
+ 227        `-, +, abs, ~, round, trunc, floor, ceil`
+ 228        as well as the additional methods
+ 229        `zero, bool`.
+ 230
+ 231        This is NOT used for the `[]` operator; when used directly, this is
+ 232        interpreted as a `Mapping` operation and returns the count corresponding
+ 233        to a given outcome. See `marginals()` for applying the `[]` operator to
+ 234        outcomes.
+ 235
+ 236        Returns:
+ 237            A `Die` representing the result.
+ 238
+ 239        Raises:
+ 240            ValueError: If tuples are of mismatched length.
+ 241        """
+ 242        return self._unary_operator(op, *args, **kwargs)
+ 243
+ 244    def binary_operator(self, other: 'Die', op: Callable[..., U], *args,
+ 245                        **kwargs) -> 'Die[U]':
+ 246        """Performs the operation on pairs of outcomes.
+ 247
+ 248        By the time this is called, the other operand has already been
+ 249        converted to a `Die`.
+ 250
+ 251        If one side of a binary operator is a tuple and the other is not, the
+ 252        binary operator is applied to each element of the tuple with the
+ 253        non-tuple side. For example, the following are equivalent:
+ 254
+ 255        ```
+ 256        cartesian_product(d6, d8) * 2
+ 257        cartesian_product(d6 * 2, d8 * 2)
+ 258        ```
+ 259
+ 260        This is used for the standard binary operators
+ 261        `+, -, *, /, //, %, **, <<, >>, &, |, ^`
+ 262        and the standard binary comparators
+ 263        `<, <=, >=, >, ==, !=, cmp`.
+ 264
+ 265        `==` and `!=` additionally set the truth value of the `Die` according to
+ 266        whether the dice themselves are the same or not.
+ 267
+ 268        The `@` operator does NOT use this method directly.
+ 269        It rolls the left `Die`, which must have integer outcomes,
+ 270        then rolls the right `Die` that many times and sums the outcomes.
+ 271
+ 272        Returns:
+ 273            A `Die` representing the result.
+ 274
+ 275        Raises:
+ 276            ValueError: If tuples are of mismatched length within one of the
+ 277                dice or between the dice.
+ 278        """
+ 279        data: MutableMapping[Any, int] = defaultdict(int)
+ 280        for (outcome_self,
+ 281             quantity_self), (outcome_other,
+ 282                              quantity_other) in itertools.product(
+ 283                                  self.items(), other.items()):
+ 284            new_outcome = op(outcome_self, outcome_other, *args, **kwargs)
+ 285            data[new_outcome] += quantity_self * quantity_other
+ 286        return self._new_type(data)
+ 287
+ 288    # Basic access.
+ 289
+ 290    def keys(self) -> CountsKeysView[T_co]:
+ 291        return self._data.keys()
+ 292
+ 293    def values(self) -> CountsValuesView:
+ 294        return self._data.values()
+ 295
+ 296    def items(self) -> CountsItemsView[T_co]:
+ 297        return self._data.items()
+ 298
+ 299    def __getitem__(self, outcome, /) -> int:
+ 300        return self._data[outcome]
+ 301
+ 302    def __iter__(self) -> Iterator[T_co]:
+ 303        return iter(self.keys())
+ 304
+ 305    def __len__(self) -> int:
+ 306        """The number of outcomes. """
+ 307        return len(self._data)
+ 308
+ 309    def __contains__(self, outcome) -> bool:
+ 310        return outcome in self._data
+ 311
+ 312    # Quantity management.
+ 313
+ 314    def simplify(self) -> 'Die[T_co]':
+ 315        """Divides all quantities by their greatest common denominator. """
+ 316        return icepool.Die(self._data.simplify())
+ 317
+ 318    # Rerolls and other outcome management.
+ 319
+ 320    def reroll(self,
+ 321               which: Callable[..., bool] | Collection[T_co] | None = None,
+ 322               /,
+ 323               *,
+ 324               star: bool | None = None,
+ 325               depth: int | None = None) -> 'Die[T_co]':
+ 326        """Rerolls the given outcomes.
+ 327
+ 328        Args:
+ 329            which: Selects which outcomes to reroll. Options:
+ 330                * A single outcome to reroll.
+ 331                * A collection of outcomes to reroll.
+ 332                * A callable that takes an outcome and returns `True` if it
+ 333                    should be rerolled.
+ 334                * If not provided, the min outcome will be rerolled.
+ 335            star: Whether outcomes should be unpacked into separate arguments
+ 336                before sending them to a callable `which`.
+ 337                If not provided, this will be guessed based on the function
+ 338                signature.
+ 339            depth: The maximum number of times to reroll.
+ 340                If omitted, rerolls an unlimited number of times.
+ 341
+ 342        Returns:
+ 343            A `Die` representing the reroll.
+ 344            If the reroll would never terminate, the result has no outcomes.
+ 345        """
+ 346
+ 347        if which is None:
+ 348            outcome_set = {self.min_outcome()}
+ 349        elif callable(which):
+ 350            if star is None:
+ 351                star = guess_star(which)
+ 352            if star:
+ 353
+ 354                # Need TypeVarTuple to check this.
+ 355                outcome_set = {
+ 356                    outcome for outcome in self.outcomes()
+ 357                    if which(*outcome)  # type: ignore
+ 358                }
+ 359            else:
+ 360                outcome_set = {
+ 361                    outcome for outcome in self.outcomes() if which(outcome)
+ 362                }
+ 363        else:
+ 364            # Collection.
+ 365            outcome_set = set(which)
+ 366
+ 367        if depth is None:
+ 368            data = {
+ 369                outcome: quantity
+ 370                for outcome, quantity in self.items()
+ 371                if outcome not in outcome_set
+ 372            }
+ 373        elif depth < 0:
+ 374            raise ValueError('reroll depth cannot be negative.')
+ 375        else:
+ 376            total_reroll_quantity = sum(
+ 377                quantity for outcome, quantity in self.items()
+ 378                if outcome in outcome_set)
+ 379            total_stop_quantity = self.denominator() - total_reroll_quantity
+ 380            rerollable_factor = total_reroll_quantity**depth
+ 381            stop_factor = (self.denominator()**(depth + 1) - rerollable_factor *
+ 382                           total_reroll_quantity) // total_stop_quantity
+ 383            data = {
+ 384                outcome: (rerollable_factor *
+ 385                          quantity if outcome in outcome_set else stop_factor *
+ 386                          quantity) for outcome, quantity in self.items()
+ 387            }
+ 388        return icepool.Die(data)
+ 389
+ 390    def filter(self,
+ 391               which: Callable[..., bool] | Collection[T_co],
+ 392               /,
+ 393               *,
+ 394               star: bool | None = None,
+ 395               depth: int | None = None) -> 'Die[T_co]':
+ 396        """Rerolls until getting one of the given outcomes.
+ 397
+ 398        Essentially the complement of `reroll()`.
+ 399
+ 400        Args:
+ 401            which: Selects which outcomes to reroll until. Options:
+ 402                * A callable that takes an outcome and returns `True` if it
+ 403                    should be accepted.
+ 404                * A collection of outcomes to reroll until.
+ 405            star: Whether outcomes should be unpacked into separate arguments
+ 406                before sending them to a callable `which`.
+ 407                If not provided, this will be guessed based on the function
+ 408                signature.
+ 409            depth: The maximum number of times to reroll.
+ 410                If omitted, rerolls an unlimited number of times.
+ 411
+ 412        Returns:
+ 413            A `Die` representing the reroll.
+ 414            If the reroll would never terminate, the result has no outcomes.
+ 415        """
+ 416
+ 417        if callable(which):
+ 418            if star is None:
+ 419                star = guess_star(which)
+ 420            if star:
+ 421
+ 422                not_outcomes = {
+ 423                    outcome for outcome in self.outcomes()
+ 424                    if not which(*outcome)  # type: ignore
+ 425                }
+ 426            else:
+ 427                not_outcomes = {
+ 428                    outcome for outcome in self.outcomes() if not which(outcome)
+ 429                }
+ 430        else:
+ 431            not_outcomes = {
+ 432                not_outcome for not_outcome in self.outcomes()
+ 433                if not_outcome not in which
+ 434            }
+ 435        return self.reroll(not_outcomes, depth=depth)
+ 436
+ 437    def truncate(self, min_outcome=None, max_outcome=None) -> 'Die[T_co]':
+ 438        """Truncates the outcomes of this `Die` to the given range.
+ 439
+ 440        The endpoints are included in the result if applicable.
+ 441        If one of the arguments is not provided, that side will not be truncated.
+ 442
+ 443        This effectively rerolls outcomes outside the given range.
+ 444        If instead you want to replace those outcomes with the nearest endpoint,
+ 445        use `clip()`.
+ 446
+ 447        Not to be confused with `trunc(die)`, which performs integer truncation
+ 448        on each outcome.
+ 449        """
+ 450        if min_outcome is not None:
+ 451            start = bisect.bisect_left(self.outcomes(), min_outcome)
+ 452        else:
+ 453            start = None
+ 454        if max_outcome is not None:
+ 455            stop = bisect.bisect_right(self.outcomes(), max_outcome)
+ 456        else:
+ 457            stop = None
+ 458        data = {k: v for k, v in self.items()[start:stop]}
+ 459        return icepool.Die(data)
+ 460
+ 461    def clip(self, min_outcome=None, max_outcome=None) -> 'Die[T_co]':
+ 462        """Clips the outcomes of this `Die` to the given values.
+ 463
+ 464        The endpoints are included in the result if applicable.
+ 465        If one of the arguments is not provided, that side will not be clipped.
+ 466
+ 467        This is not the same as rerolling outcomes beyond this range;
+ 468        the outcome is simply adjusted to fit within the range.
+ 469        This will typically cause some quantity to bunch up at the endpoint.
+ 470        If you want to reroll outcomes beyond this range, use `truncate()`.
+ 471        """
+ 472        data: MutableMapping[Any, int] = defaultdict(int)
+ 473        for outcome, quantity in self.items():
+ 474            if min_outcome is not None and outcome <= min_outcome:
+ 475                data[min_outcome] += quantity
+ 476            elif max_outcome is not None and outcome >= max_outcome:
+ 477                data[max_outcome] += quantity
+ 478            else:
+ 479                data[outcome] += quantity
+ 480        return icepool.Die(data)
+ 481
+ 482    def set_range(self: 'Die[int]',
+ 483                  min_outcome: int | None = None,
+ 484                  max_outcome: int | None = None) -> 'Die[int]':
+ 485        """Sets the outcomes of this `Die` to the given `int` range (inclusive).
+ 486
+ 487        This may remove outcomes (if they are not within the range)
+ 488        and/or add zero-quantity outcomes (if they are in range but not present
+ 489        in this `Die`).
+ 490
+ 491        Args:
+ 492            min_outcome: The min outcome of the result.
+ 493                If omitted, the min outcome of this `Die` will be used.
+ 494            max_outcome: The max outcome of the result.
+ 495                If omitted, the max outcome of this `Die` will be used.
+ 496        """
+ 497        if min_outcome is None:
+ 498            min_outcome = self.min_outcome()
+ 499        if max_outcome is None:
+ 500            max_outcome = self.max_outcome()
+ 501
+ 502        return self.set_outcomes(range(min_outcome, max_outcome + 1))
+ 503
+ 504    def set_outcomes(self, outcomes: Iterable[T_co]) -> 'Die[T_co]':
+ 505        """Sets the set of outcomes to the argument.
+ 506
+ 507        This may remove outcomes (if they are not present in the argument)
+ 508        and/or add zero-quantity outcomes (if they are not present in this `Die`).
+ 509        """
+ 510        data = {x: self.quantity(x) for x in outcomes}
+ 511        return icepool.Die(data)
+ 512
+ 513    def trim(self) -> 'Die[T_co]':
+ 514        """Removes all zero-quantity outcomes. """
+ 515        data = {k: v for k, v in self.items() if v > 0}
+ 516        return icepool.Die(data)
+ 517
+ 518    @cached_property
+ 519    def _popped_min(self) -> tuple['Die[T_co]', int]:
+ 520        die = Die._new_raw(self._data.remove_min())
+ 521        return die, self.quantities()[0]
+ 522
+ 523    def _pop_min(self) -> tuple['Die[T_co]', int]:
+ 524        """A `Die` with the min outcome removed, and the quantity of the removed outcome.
+ 525
+ 526        Raises:
+ 527            IndexError: If this `Die` has no outcome to pop.
+ 528        """
+ 529        return self._popped_min
+ 530
+ 531    @cached_property
+ 532    def _popped_max(self) -> tuple['Die[T_co]', int]:
+ 533        die = Die._new_raw(self._data.remove_max())
+ 534        return die, self.quantities()[-1]
+ 535
+ 536    def _pop_max(self) -> tuple['Die[T_co]', int]:
+ 537        """A `Die` with the max outcome removed, and the quantity of the removed outcome.
+ 538
+ 539        Raises:
+ 540            IndexError: If this `Die` has no outcome to pop.
+ 541        """
+ 542        return self._popped_max
+ 543
+ 544    # Mixtures.
+ 545
+ 546    def map(
+ 547            self,
+ 548            repl:
+ 549        'Callable[..., U | Die[U] | icepool.RerollType | icepool.AgainExpression] | Mapping[T_co, U | Die[U] | icepool.RerollType | icepool.AgainExpression]',
+ 550            /,
+ 551            *extra_args,
+ 552            star: bool | None = None,
+ 553            repeat: int | None = 1,
+ 554            again_depth: int = 1,
+ 555            again_end: 'U | Die[U] | icepool.RerollType | None' = None
+ 556    ) -> 'Die[U]':
+ 557        """Maps outcomes of the `Die` to other outcomes.
+ 558
+ 559        This is also useful for representing processes.
+ 560
+ 561        As `icepool.map(repl, self, ...)`.
+ 562        """
+ 563        return icepool.map(repl,
+ 564                           self,
+ 565                           *extra_args,
+ 566                           star=star,
+ 567                           repeat=repeat,
+ 568                           again_depth=again_depth,
+ 569                           again_end=again_end)
+ 570
+ 571    def map_and_time(
+ 572            self,
+ 573            repl:
+ 574        'Callable[..., T_co | Die[T_co] | icepool.RerollType] | Mapping[T_co, T_co | Die[T_co] | icepool.RerollType]',
+ 575            /,
+ 576            *extra_args,
+ 577            star: bool | None = None,
+ 578            repeat: int) -> 'Die[tuple[T_co, int]]':
+ 579        """Repeatedly map outcomes of the state to other outcomes, while also
+ 580        counting timesteps.
+ 581
+ 582        This is useful for representing processes.
+ 583
+ 584        As `map_and_time(repl, self, ...)`.
+ 585        """
+ 586        return icepool.map_and_time(repl,
+ 587                                    self,
+ 588                                    *extra_args,
+ 589                                    star=star,
+ 590                                    repeat=repeat)
+ 591
+ 592    def explode(self,
+ 593                which: Collection[T_co] | Callable[..., bool] | None = None,
+ 594                *,
+ 595                star: bool | None = None,
+ 596                depth: int = 9,
+ 597                end=None) -> 'Die[T_co]':
+ 598        """Causes outcomes to be rolled again and added to the total.
+ 599
+ 600        Args:
+ 601            which: Which outcomes to explode. Options:
+ 602                * A single outcome to explode.
+ 603                * An collection of outcomes to explode.
+ 604                * A callable that takes an outcome and returns `True` if it
+ 605                    should be exploded.
+ 606                * If not supplied, the max outcome will explode.
+ 607            star: Whether outcomes should be unpacked into separate arguments
+ 608                before sending them to a callable `which`.
+ 609                If not provided, this will be guessed based on the function
+ 610                signature.
+ 611            depth: The maximum number of additional dice to roll.
+ 612                If not supplied, a default value will be used.
+ 613            end: Once depth is reached, further explosions will be treated
+ 614                as this value. By default, a zero value will be used.
+ 615        """
+ 616
+ 617        if which is None:
+ 618            outcome_set = {self.max_outcome()}
+ 619        elif callable(which):
+ 620            if star is None:
+ 621                star = guess_star(which)
+ 622            if star:
+ 623                # Need TypeVarTuple to type-check this.
+ 624                outcome_set = {
+ 625                    outcome for outcome in self.outcomes()
+ 626                    if which(*outcome)  # type: ignore
+ 627                }
+ 628            else:
+ 629                outcome_set = {
+ 630                    outcome for outcome in self.outcomes() if which(outcome)
+ 631                }
+ 632        else:
+ 633            if not which:
+ 634                return self
+ 635            outcome_set = set(which)
+ 636
+ 637        if depth < 0:
+ 638            raise ValueError('depth cannot be negative.')
+ 639        elif depth == 0:
+ 640            return self
+ 641
+ 642        def map_final(outcome):
+ 643            if outcome in outcome_set:
+ 644                return outcome + icepool.Again
+ 645            else:
+ 646                return outcome
+ 647
+ 648        return self.map(map_final, again_depth=depth, again_end=end)
+ 649
+ 650    def if_else(
+ 651            self,
+ 652            outcome_if_true: U | 'Die[U]',
+ 653            outcome_if_false: U | 'Die[U]',
+ 654            *,
+ 655            again_depth: int = 1,
+ 656            again_end: 'U | Die[U] | icepool.RerollType | None' = None
+ 657    ) -> 'Die[U]':
+ 658        """Ternary conditional operator.
+ 659
+ 660        This replaces truthy outcomes with the first argument and falsy outcomes
+ 661        with the second argument.
+ 662
+ 663        Args:
+ 664            again_depth: Forwarded to the final die constructor.
+ 665            again_end: Forwarded to the final die constructor.
+ 666        """
+ 667        return self.map(lambda x: bool(x)).map(
+ 668            {
+ 669                True: outcome_if_true,
+ 670                False: outcome_if_false
+ 671            },
+ 672            again_depth=again_depth,
+ 673            again_end=again_end)
+ 674
+ 675    def is_in(self, target: Container[T_co], /) -> 'Die[bool]':
+ 676        """A die that returns True iff the roll of the die is contained in the target."""
+ 677        return self.map(lambda x: x in target)
+ 678
+ 679    def count(self, rolls: int, target: Container[T_co], /) -> 'Die[int]':
+ 680        """Roll this dice a number of times and count how many are in the target."""
+ 681        return rolls @ self.is_in(target)
+ 682
+ 683    # Pools and sums.
+ 684
+ 685    @cached_property
+ 686    def _sum_cache(self) -> MutableMapping[int, 'Die']:
+ 687        return {}
+ 688
+ 689    def _sum_all(self, rolls: int, /) -> 'Die':
+ 690        """Roll this `Die` `rolls` times and sum the results.
+ 691
+ 692        If `rolls` is negative, roll the `Die` `abs(rolls)` times and negate
+ 693        the result.
+ 694
+ 695        If you instead want to replace tuple (or other sequence) outcomes with
+ 696        their sum, use `die.map(sum)`.
+ 697        """
+ 698        if rolls in self._sum_cache:
+ 699            return self._sum_cache[rolls]
+ 700
+ 701        if rolls < 0:
+ 702            result = -self._sum_all(-rolls)
+ 703        elif rolls == 0:
+ 704            result = self.zero().simplify()
+ 705        elif rolls == 1:
+ 706            result = self
+ 707        else:
+ 708            # Binary split seems to perform much worse.
+ 709            result = self + self._sum_all(rolls - 1)
+ 710
+ 711        self._sum_cache[rolls] = result
+ 712        return result
+ 713
+ 714    def __matmul__(self: 'Die[int]', other) -> 'Die':
+ 715        """Roll the left `Die`, then roll the right `Die` that many times and sum the outcomes."""
+ 716        other = implicit_convert_to_die(other)
+ 717
+ 718        data: MutableMapping[int, Any] = defaultdict(int)
+ 719
+ 720        max_abs_die_count = max(abs(self.min_outcome()),
+ 721                                abs(self.max_outcome()))
+ 722        for die_count, die_count_quantity in self.items():
+ 723            factor = other.denominator()**(max_abs_die_count - abs(die_count))
+ 724            subresult = other._sum_all(die_count)
+ 725            for outcome, subresult_quantity in subresult.items():
+ 726                data[
+ 727                    outcome] += subresult_quantity * die_count_quantity * factor
+ 728
+ 729        return icepool.Die(data)
+ 730
+ 731    def __rmatmul__(self, other: 'int | Die[int]') -> 'Die':
+ 732        """Roll the left `Die`, then roll the right `Die` that many times and sum the outcomes."""
+ 733        other = implicit_convert_to_die(other)
+ 734        return other.__matmul__(self)
+ 735
+ 736    def pool(self, rolls: int | Sequence[int] = 1, /) -> 'icepool.Pool[T_co]':
+ 737        """Creates a `Pool` from this `Die`.
+ 738
+ 739        You might subscript the pool immediately afterwards, e.g.
+ 740        `d6.pool(5)[-1, ..., 1]` takes the difference between the highest and
+ 741        lowest of 5d6.
+ 742
+ 743        Args:
+ 744            rolls: The number of copies of this `Die` to put in the pool.
+ 745                Or, a sequence of one `int` per die acting as
+ 746                `keep_tuple`. Note that `...` cannot be used in the
+ 747                argument to this method, as the argument determines the size of
+ 748                the pool.
+ 749        """
+ 750        if isinstance(rolls, int):
+ 751            return icepool.Pool({self: rolls})
+ 752        else:
+ 753            pool_size = len(rolls)
+ 754            return icepool.Pool({self: pool_size})[rolls]
+ 755
+ 756    def lowest(self, rolls: int, /, keep: int = 1, drop: int = 0) -> 'Die':
+ 757        """Roll several of this `Die` and return the lowest result, or the sum of some of the lowest.
+ 758
+ 759        The outcomes should support addition and multiplication if `keep != 1`.
+ 760
+ 761        Args:
+ 762            rolls: The number of dice to roll. All dice will have the same
+ 763                outcomes as `self`.
+ 764            keep: The number of dice to keep.
+ 765            drop: If provided, this many lowest dice will be dropped before
+ 766                keeping.
+ 767
+ 768        Returns:
+ 769            A `Die` representing the probability distribution of the sum.
+ 770        """
+ 771        if keep == 1 and drop == 0:
+ 772            return self._lowest_single(rolls)
+ 773
+ 774        start = drop if drop > 0 else None
+ 775        stop = keep + (drop or 0)
+ 776        index = slice(start, stop)
+ 777        # Expression evaluators are difficult to type.
+ 778        return self.pool(rolls)[index].sum()  # type: ignore
+ 779
+ 780    def _lowest_single(self, rolls: int, /) -> 'Die':
+ 781        """Roll this die several times and keep the lowest."""
+ 782        if rolls == 0:
+ 783            return self.zero().simplify()
+ 784        return icepool.from_cumulative(self.outcomes(),
+ 785                                       [x**rolls for x in self.quantities_ge()],
+ 786                                       reverse=True)
+ 787
+ 788    def highest(self,
+ 789                rolls: int,
+ 790                /,
+ 791                keep: int = 1,
+ 792                drop: int = 0) -> 'Die[T_co]':
+ 793        """Roll several of this `Die` and return the highest result, or the sum of some of the highest.
+ 794
+ 795        The outcomes should support addition and multiplication if `keep != 1`.
+ 796
+ 797        Args:
+ 798            rolls: The number of dice to roll.
+ 799            keep: The number of dice to keep.
+ 800            drop: If provided, this many highest dice will be dropped before
+ 801                keeping.
+ 802
+ 803        Returns:
+ 804            A `Die` representing the probability distribution of the sum.
+ 805        """
+ 806        if keep == 1 and drop == 0:
+ 807            return self._highest_single(rolls)
+ 808        start = -(keep + (drop or 0))
+ 809        stop = -drop if drop > 0 else None
+ 810        index = slice(start, stop)
+ 811        # Expression evaluators are difficult to type.
+ 812        return self.pool(rolls)[index].sum()  # type: ignore
+ 813
+ 814    def _highest_single(self, rolls: int, /) -> 'Die[T_co]':
+ 815        """Roll this die several times and keep the highest."""
+ 816        if rolls == 0:
+ 817            return self.zero().simplify()
+ 818        return icepool.from_cumulative(self.outcomes(),
+ 819                                       [x**rolls for x in self.quantities_le()])
+ 820
+ 821    def middle(self,
+ 822               rolls: int,
+ 823               /,
+ 824               keep: int = 1,
+ 825               *,
+ 826               tie: Literal['error', 'high', 'low'] = 'error') -> 'icepool.Die':
+ 827        """Roll several of this `Die` and sum the sorted results in the middle.
+ 828
+ 829        The outcomes should support addition and multiplication if `keep != 1`.
+ 830
+ 831        Args:
+ 832            rolls: The number of dice to roll.
+ 833            keep: The number of outcomes to sum. If this is greater than the
+ 834                current keep_size, all are kept.
+ 835            tie: What to do if `keep` is odd but the current keep_size
+ 836                is even, or vice versa.
+ 837                * 'error' (default): Raises `IndexError`.
+ 838                * 'high': The higher outcome is taken.
+ 839                * 'low': The lower outcome is taken.
+ 840        """
+ 841        # Expression evaluators are difficult to type.
+ 842        return self.pool(rolls).middle(keep, tie=tie).sum()  # type: ignore
+ 843
+ 844    # Unary operators.
+ 845
+ 846    def __neg__(self) -> 'Die[T_co]':
+ 847        return self.unary_operator(operator.neg)
+ 848
+ 849    def __pos__(self) -> 'Die[T_co]':
+ 850        return self.unary_operator(operator.pos)
+ 851
+ 852    def __invert__(self) -> 'Die[T_co]':
+ 853        return self.unary_operator(operator.invert)
+ 854
+ 855    def abs(self) -> 'Die[T_co]':
+ 856        return self.unary_operator(operator.abs)
+ 857
+ 858    __abs__ = abs
+ 859
+ 860    def round(self, ndigits: int | None = None) -> 'Die':
+ 861        return self.unary_operator(round, ndigits)
+ 862
+ 863    __round__ = round
+ 864
+ 865    def trunc(self) -> 'Die':
+ 866        return self.unary_operator(math.trunc)
+ 867
+ 868    __trunc__ = trunc
+ 869
+ 870    def floor(self) -> 'Die':
+ 871        return self.unary_operator(math.floor)
+ 872
+ 873    __floor__ = floor
+ 874
+ 875    def ceil(self) -> 'Die':
+ 876        return self.unary_operator(math.ceil)
+ 877
+ 878    __ceil__ = ceil
+ 879
+ 880    @staticmethod
+ 881    def _zero(x):
+ 882        return x * 0
+ 883
+ 884    def zero(self) -> 'Die[T_co]':
+ 885        """Zeros all outcomes of this die.
+ 886
+ 887        This is done by multiplying all outcomes by `0`.
+ 888
+ 889        The result will have the same denominator as this die.
+ 890
+ 891        Raises:
+ 892            ValueError: If the zeros did not resolve to a single outcome.
+ 893        """
+ 894        result = self.unary_operator(Die._zero)
+ 895        if len(result) != 1:
+ 896            raise ValueError('zero() did not resolve to a single outcome.')
+ 897        return result
+ 898
+ 899    def zero_outcome(self) -> T_co:
+ 900        """A zero-outcome for this die.
+ 901
+ 902        E.g. `0` for a `Die` whose outcomes are `int`s.
+ 903        """
+ 904        return self.zero().outcomes()[0]
+ 905
+ 906    # Binary operators.
+ 907
+ 908    def __add__(self, other) -> 'Die':
+ 909        if isinstance(other, icepool.AgainExpression):
+ 910            return NotImplemented
+ 911        other = implicit_convert_to_die(other)
+ 912        return self.binary_operator(other, operator.add)
+ 913
+ 914    def __radd__(self, other) -> 'Die':
+ 915        if isinstance(other, icepool.AgainExpression):
+ 916            return NotImplemented
+ 917        other = implicit_convert_to_die(other)
+ 918        return other.binary_operator(self, operator.add)
+ 919
+ 920    def __sub__(self, other) -> 'Die':
+ 921        if isinstance(other, icepool.AgainExpression):
+ 922            return NotImplemented
+ 923        other = implicit_convert_to_die(other)
+ 924        return self.binary_operator(other, operator.sub)
+ 925
+ 926    def __rsub__(self, other) -> 'Die':
+ 927        if isinstance(other, icepool.AgainExpression):
+ 928            return NotImplemented
+ 929        other = implicit_convert_to_die(other)
+ 930        return other.binary_operator(self, operator.sub)
+ 931
+ 932    def __mul__(self, other) -> 'Die':
+ 933        if isinstance(other, icepool.AgainExpression):
+ 934            return NotImplemented
+ 935        other = implicit_convert_to_die(other)
+ 936        return self.binary_operator(other, operator.mul)
+ 937
+ 938    def __rmul__(self, other) -> 'Die':
+ 939        if isinstance(other, icepool.AgainExpression):
+ 940            return NotImplemented
+ 941        other = implicit_convert_to_die(other)
+ 942        return other.binary_operator(self, operator.mul)
+ 943
+ 944    def __truediv__(self, other) -> 'Die':
+ 945        if isinstance(other, icepool.AgainExpression):
+ 946            return NotImplemented
+ 947        other = implicit_convert_to_die(other)
+ 948        return self.binary_operator(other, operator.truediv)
+ 949
+ 950    def __rtruediv__(self, other) -> 'Die':
+ 951        if isinstance(other, icepool.AgainExpression):
+ 952            return NotImplemented
+ 953        other = implicit_convert_to_die(other)
+ 954        return other.binary_operator(self, operator.truediv)
+ 955
+ 956    def __floordiv__(self, other) -> 'Die':
+ 957        if isinstance(other, icepool.AgainExpression):
+ 958            return NotImplemented
+ 959        other = implicit_convert_to_die(other)
+ 960        return self.binary_operator(other, operator.floordiv)
+ 961
+ 962    def __rfloordiv__(self, other) -> 'Die':
+ 963        if isinstance(other, icepool.AgainExpression):
+ 964            return NotImplemented
+ 965        other = implicit_convert_to_die(other)
+ 966        return other.binary_operator(self, operator.floordiv)
+ 967
+ 968    def __pow__(self, other) -> 'Die':
+ 969        if isinstance(other, icepool.AgainExpression):
+ 970            return NotImplemented
+ 971        other = implicit_convert_to_die(other)
+ 972        return self.binary_operator(other, operator.pow)
+ 973
+ 974    def __rpow__(self, other) -> 'Die':
+ 975        if isinstance(other, icepool.AgainExpression):
+ 976            return NotImplemented
+ 977        other = implicit_convert_to_die(other)
+ 978        return other.binary_operator(self, operator.pow)
+ 979
+ 980    def __mod__(self, other) -> 'Die':
+ 981        if isinstance(other, icepool.AgainExpression):
+ 982            return NotImplemented
+ 983        other = implicit_convert_to_die(other)
+ 984        return self.binary_operator(other, operator.mod)
+ 985
+ 986    def __rmod__(self, other) -> 'Die':
+ 987        if isinstance(other, icepool.AgainExpression):
+ 988            return NotImplemented
+ 989        other = implicit_convert_to_die(other)
+ 990        return other.binary_operator(self, operator.mod)
+ 991
+ 992    def __lshift__(self, other) -> 'Die':
+ 993        if isinstance(other, icepool.AgainExpression):
+ 994            return NotImplemented
+ 995        other = implicit_convert_to_die(other)
+ 996        return self.binary_operator(other, operator.lshift)
+ 997
+ 998    def __rlshift__(self, other) -> 'Die':
+ 999        if isinstance(other, icepool.AgainExpression):
+1000            return NotImplemented
+1001        other = implicit_convert_to_die(other)
+1002        return other.binary_operator(self, operator.lshift)
+1003
+1004    def __rshift__(self, other) -> 'Die':
+1005        if isinstance(other, icepool.AgainExpression):
+1006            return NotImplemented
+1007        other = implicit_convert_to_die(other)
+1008        return self.binary_operator(other, operator.rshift)
+1009
+1010    def __rrshift__(self, other) -> 'Die':
+1011        if isinstance(other, icepool.AgainExpression):
+1012            return NotImplemented
+1013        other = implicit_convert_to_die(other)
+1014        return other.binary_operator(self, operator.rshift)
+1015
+1016    def __and__(self, other) -> 'Die':
+1017        if isinstance(other, icepool.AgainExpression):
+1018            return NotImplemented
+1019        other = implicit_convert_to_die(other)
+1020        return self.binary_operator(other, operator.and_)
+1021
+1022    def __rand__(self, other) -> 'Die':
+1023        if isinstance(other, icepool.AgainExpression):
+1024            return NotImplemented
+1025        other = implicit_convert_to_die(other)
+1026        return other.binary_operator(self, operator.and_)
+1027
+1028    def __or__(self, other) -> 'Die':
+1029        if isinstance(other, icepool.AgainExpression):
+1030            return NotImplemented
+1031        other = implicit_convert_to_die(other)
+1032        return self.binary_operator(other, operator.or_)
+1033
+1034    def __ror__(self, other) -> 'Die':
+1035        if isinstance(other, icepool.AgainExpression):
+1036            return NotImplemented
+1037        other = implicit_convert_to_die(other)
+1038        return other.binary_operator(self, operator.or_)
+1039
+1040    def __xor__(self, other) -> 'Die':
+1041        if isinstance(other, icepool.AgainExpression):
+1042            return NotImplemented
+1043        other = implicit_convert_to_die(other)
+1044        return self.binary_operator(other, operator.xor)
+1045
+1046    def __rxor__(self, other) -> 'Die':
+1047        if isinstance(other, icepool.AgainExpression):
+1048            return NotImplemented
+1049        other = implicit_convert_to_die(other)
+1050        return other.binary_operator(self, operator.xor)
+1051
+1052    # Comparators.
+1053
+1054    def __lt__(self, other) -> 'Die[bool]':
+1055        other = implicit_convert_to_die(other)
+1056        return self.binary_operator(other, operator.lt)
+1057
+1058    def __le__(self, other) -> 'Die[bool]':
+1059        other = implicit_convert_to_die(other)
+1060        return self.binary_operator(other, operator.le)
+1061
+1062    def __ge__(self, other) -> 'Die[bool]':
+1063        other = implicit_convert_to_die(other)
+1064        return self.binary_operator(other, operator.ge)
+1065
+1066    def __gt__(self, other) -> 'Die[bool]':
+1067        other = implicit_convert_to_die(other)
+1068        return self.binary_operator(other, operator.gt)
+1069
+1070    # Equality operators. These produce a `DieWithTruth`.
+1071
+1072    # The result has a truth value, but is not a bool.
+1073    def __eq__(self, other) -> 'icepool.DieWithTruth[bool]':  # type: ignore
+1074        other_die: Die = implicit_convert_to_die(other)
+1075
+1076        def data_callback() -> Counts[bool]:
+1077            return self.binary_operator(other_die, operator.eq)._data
+1078
+1079        def truth_value_callback() -> bool:
+1080            return self.equals(other)
+1081
+1082        return icepool.DieWithTruth(data_callback, truth_value_callback)
+1083
+1084    # The result has a truth value, but is not a bool.
+1085    def __ne__(self, other) -> 'icepool.DieWithTruth[bool]':  # type: ignore
+1086        other_die: Die = implicit_convert_to_die(other)
+1087
+1088        def data_callback() -> Counts[bool]:
+1089            return self.binary_operator(other_die, operator.ne)._data
+1090
+1091        def truth_value_callback() -> bool:
+1092            return not self.equals(other)
+1093
+1094        return icepool.DieWithTruth(data_callback, truth_value_callback)
+1095
+1096    def cmp(self, other) -> 'Die[int]':
+1097        """A `Die` with outcomes 1, -1, and 0.
+1098
+1099        The quantities are equal to the positive outcome of `self > other`,
+1100        `self < other`, and the remainder respectively.
+1101
+1102        This will include all three outcomes even if they have zero quantity.
+1103        """
+1104        other = implicit_convert_to_die(other)
+1105
+1106        data = {}
+1107
+1108        lt = self < other
+1109        if True in lt:
+1110            data[-1] = lt[True]
+1111        eq = self == other
+1112        if True in eq:
+1113            data[0] = eq[True]
+1114        gt = self > other
+1115        if True in gt:
+1116            data[1] = gt[True]
+1117
+1118        return Die(data)
+1119
+1120    @staticmethod
+1121    def _sign(x) -> int:
+1122        z = Die._zero(x)
+1123        if x > z:
+1124            return 1
+1125        elif x < z:
+1126            return -1
+1127        else:
+1128            return 0
+1129
+1130    def sign(self) -> 'Die[int]':
+1131        """Outcomes become 1 if greater than `zero()`, -1 if less than `zero()`, and 0 otherwise.
+1132
+1133        Note that for `float`s, +0.0, -0.0, and nan all become 0.
+1134        """
+1135        return self.unary_operator(Die._sign)
+1136
+1137    # Equality and hashing.
+1138
+1139    def __bool__(self) -> bool:
+1140        raise TypeError(
+1141            'A `Die` only has a truth value if it is the result of == or !=.\n'
+1142            'This could result from trying to use a die in an if-statement,\n'
+1143            'in which case you should use `die.if_else()` instead.\n'
+1144            'Or it could result from trying to use a `Die` inside a tuple or vector outcome,\n'
+1145            'in which case you should use `tupleize()` or `vectorize().')
+1146
+1147    @cached_property
+1148    def _hash_key(self) -> tuple:
+1149        """A tuple that uniquely (as `equals()`) identifies this die.
+1150
+1151        Apart from being hashable and totally orderable, this is not guaranteed
+1152        to be in any particular format or have any other properties.
+1153        """
+1154        return tuple(self.items())
+1155
+1156    @cached_property
+1157    def _hash(self) -> int:
+1158        return hash(self._hash_key)
+1159
+1160    def __hash__(self) -> int:
+1161        return self._hash
+1162
+1163    def equals(self, other, *, simplify: bool = False) -> bool:
+1164        """`True` iff both dice have the same outcomes and quantities.
+1165
+1166        This is `False` if `other` is not a `Die`, even if it would convert
+1167        to an equal `Die`.
+1168
+1169        Truth value does NOT matter.
+1170
+1171        If one `Die` has a zero-quantity outcome and the other `Die` does not
+1172        contain that outcome, they are treated as unequal by this function.
+1173
+1174        The `==` and `!=` operators have a dual purpose; they return a `Die`
+1175        with a truth value determined by this method.
+1176        Only dice returned by these methods have a truth value. The data of
+1177        these dice is lazily evaluated since the caller may only be interested
+1178        in the `Die` value or the truth value.
+1179
+1180        Args:
+1181            simplify: If `True`, the dice will be simplified before comparing.
+1182                Otherwise, e.g. a 2:2 coin is not `equals()` to a 1:1 coin.
+1183        """
+1184        if not isinstance(other, Die):
+1185            return False
+1186
+1187        if simplify:
+1188            return self.simplify()._hash_key == other.simplify()._hash_key
+1189        else:
+1190            return self._hash_key == other._hash_key
+1191
+1192    # Strings.
+1193
+1194    def __repr__(self) -> str:
+1195        inner = ', '.join(
+1196            f'{outcome}: {weight}' for outcome, weight in self.items())
+1197        return type(self).__qualname__ + '({' + inner + '})'
+
+ + +

Sampling with replacement. Quantities represent weights.

+ +

Dice are immutable. Methods do not modify the Die in-place; +rather they return a Die representing the result.

+ +

It is (mostly) well-defined to have a Die with zero-quantity outcomes. +These can be useful in a few cases, such as:

+ + + +

However, zero-quantity outcomes have a computational cost like any other +outcome. Unless you have a specific use case in mind, it's best to leave +them out.

+ +

Most operators and methods will not introduce zero-quantity outcomes if +their arguments do not have any; nor remove zero-quantity outcomes.

+ +

It's also possible to have "empty" dice with no outcomes at all, +though these have little use other than being sentinel values.

+
+ + +
+ +
+ + Die( outcomes: Union[Sequence, Mapping[Any, int]], times: Union[Sequence[int], int] = 1, *, again_depth: int = 1, again_end: Outcome | Die | RerollType | None = None) + + + +
+ + 
 73    def __new__(
+ 74        cls,
+ 75        outcomes: Sequence | Mapping[Any, int],
+ 76        times: Sequence[int] | int = 1,
+ 77        *,
+ 78        again_depth: int = 1,
+ 79        again_end: 'Outcome | Die | icepool.RerollType | None' = None
+ 80    ) -> 'Die[T_co]':
+ 81        """Constructor for a `Die`.
+ 82
+ 83        Don't confuse this with `d()`:
+ 84
+ 85        * `Die([6])`: A `Die` that always rolls the `int` 6.
+ 86        * `d(6)`: A d6.
+ 87
+ 88        Also, don't confuse this with `Pool()`:
+ 89
+ 90        * `Die([1, 2, 3, 4, 5, 6])`: A d6.
+ 91        * `Pool([1, 2, 3, 4, 5, 6])`: A `Pool` of six dice that always rolls one
+ 92            of each number.
+ 93
+ 94        Here are some different ways of constructing a d6:
+ 95
+ 96        * Just import it: `from icepool import d6`
+ 97        * Use the `d()` function: `icepool.d(6)`
+ 98        * Use a d6 that you already have: `Die(d6)` or `Die([d6])`
+ 99        * Mix a d3 and a d3+3: `Die([d3, d3+3])`
+100        * Use a dict: `Die({1:1, 2:1, 3:1, 4:1, 5:1, 6:1})`
+101        * Give the faces as a sequence: `Die([1, 2, 3, 4, 5, 6])`
+102
+103        All quantities must be non-negative, though they can be zero.
+104
+105        Several methods and functions foward **kwargs to this constructor.
+106        However, these only affect the construction of the returned or yielded
+107        dice. Any other implicit conversions of arguments or operands to dice
+108        will be done with the default keyword arguments.
+109
+110        EXPERIMENTAL: Use `icepool.Again` to roll the dice again, usually with
+111        some modification. For example,
+112
+113        ```
+114        Die([1, 2, 3, 4, 5, 6 + Again])
+115        ```
+116
+117        would be an exploding d6. Use the `again_depth` parameter to control
+118        the maximum depth. `again_depth` does not apply to `Reroll`.
+119
+120        If the roll reaches the maximum depth, the `again_end` is used instead
+121        of rolling again. Options for `again_end` include:
+122
+123        * No value (`None`), which will attempt to determine a zero value from
+124            the outcomes that don't involve `Again`.
+125        * A single outcome, or a `Die`.
+126        * `Reroll`, which will reroll any end roll involving `Again`.
+127        * You could also consider some sort of placeholder value such as
+128            `math.inf`.
+129
+130        Denominator: For a flat set of outcomes, the denominator is just the
+131        sum of the corresponding quantities. If the outcomes themselves have
+132        secondary denominators, then the overall denominator is the primary
+133        denominator times the LCM of the outcome denominators.
+134
+135        For example, `Die([d3, d4, d6])` has a final denominator of 36: 3 for
+136        the primary selection between the three secondary dice, times 12 for
+137        the LCM of 3, 4, and 6.
+138
+139        Args:
+140            outcomes: The faces of the `Die`. This can be one of the following:
+141                * A `Sequence` of outcomes. Duplicates will contribute
+142                    quantity for each appearance.
+143                * A `Mapping` from outcomes to quantities.
+144
+145                Individual outcomes can each be one of the following:
+146
+147                * An outcome, which must be hashable and totally orderable.
+148                * A `Die`, which will be flattened into the result.
+149                    The quantity assigned to a `Die` is shared among its
+150                    outcomes. The total denominator will be scaled up if
+151                    necessary.
+152                * `icepool.Reroll`, which will drop itself from consideration.
+153                * EXPERIMENTAL: `icepool.Again`. See the main text for
+154                    explanation.
+155            times: Multiplies the quantity of each element of `outcomes`.
+156                `times` can either be a sequence of the same length as
+157                `outcomes` or a single `int` to apply to all elements of
+158                `outcomes`.
+159        Raises:
+160            ValueError: `None` is not a valid outcome for a `Die`.
+161        """
+162        if again_depth < 0:
+163            raise ValueError('again_depth cannot be negative.')
+164
+165        # Check for Again.
+166        if icepool.population.again.contains_again(outcomes):
+167            if again_end is None:
+168                # Create a test die with `Again`s removed,
+169                # then find the zero.
+170                test: Die[T_co] = Die(outcomes,
+171                                      again_depth=0,
+172                                      again_end=icepool.Reroll)
+173                if len(test) == 0:
+174                    raise ValueError(
+175                        'If all outcomes contain Again, an explicit again_end must be provided.'
+176                    )
+177                again_end = test.zero().simplify()
+178            else:
+179                again_end = implicit_convert_to_die(again_end)
+180                if icepool.population.again.contains_again(again_end):
+181                    raise ValueError('again_end cannot itself contain Again.')
+182
+183            if again_depth == 0:
+184                # Base case.
+185                outcomes = icepool.population.again.replace_agains(
+186                    outcomes, again_end)
+187            else:
+188                tail: Die[T_co] = Die(outcomes,
+189                                      times,
+190                                      again_depth=0,
+191                                      again_end=again_end)
+192                for _ in range(again_depth):
+193                    tail = Die(outcomes, times, again_depth=0, again_end=tail)
+194                return tail
+195
+196        outcomes, times = icepool.creation_args.itemize(outcomes, times)
+197        # Agains have been replaced by this point.
+198        outcomes = cast(Sequence[T_co | Die[T_co] | icepool.RerollType],
+199                        outcomes)
+200
+201        if len(outcomes) == 1 and times[0] == 1 and isinstance(
+202                outcomes[0], Die):
+203            return outcomes[0]
+204
+205        counts: Counts[T_co] = icepool.creation_args.expand_args_for_die(
+206            outcomes, times)
+207
+208        return Die._new_raw(counts)
+
+ + +

Constructor for a Die.

+ +

Don't confuse this with d():

+ +
    +
  • Die([6]): A Die that always rolls the int 6.
    • +
  • d(6): A d6.
    • +
+ +

Also, don't confuse this with Pool():

+ +
    +
  • Die([1, 2, 3, 4, 5, 6]): A d6.
    • +
  • Pool([1, 2, 3, 4, 5, 6]): A Pool of six dice that always rolls one +of each number.
    • +
+ +

Here are some different ways of constructing a d6:

+ +
    +
  • Just import it: from icepool import d6
    • +
  • Use the d() function: icepool.d(6)
    • +
  • Use a d6 that you already have: Die(d6) or Die([d6])
    • +
  • Mix a d3 and a d3+3: Die([d3, d3+3])
    • +
  • Use a dict: Die({1:1, 2:1, 3:1, 4:1, 5:1, 6:1})
    • +
  • Give the faces as a sequence: Die([1, 2, 3, 4, 5, 6])
    • +
+ +

All quantities must be non-negative, though they can be zero.

+ +

Several methods and functions foward **kwargs to this constructor. +However, these only affect the construction of the returned or yielded +dice. Any other implicit conversions of arguments or operands to dice +will be done with the default keyword arguments.

+ +

EXPERIMENTAL: Use icepool.Again to roll the dice again, usually with +some modification. For example,

+ +
Die([1, 2, 3, 4, 5, 6 + Again])
+
+ +

would be an exploding d6. Use the again_depth parameter to control +the maximum depth. again_depth does not apply to Reroll.

+ +

If the roll reaches the maximum depth, the again_end is used instead +of rolling again. Options for again_end include:

+ +
    +
  • No value (None), which will attempt to determine a zero value from +the outcomes that don't involve Again.
    • +
  • A single outcome, or a Die.
    • +
  • Reroll, which will reroll any end roll involving Again.
    • +
  • You could also consider some sort of placeholder value such as +math.inf.
    • +
+ +

Denominator: For a flat set of outcomes, the denominator is just the +sum of the corresponding quantities. If the outcomes themselves have +secondary denominators, then the overall denominator is the primary +denominator times the LCM of the outcome denominators.

+ +

For example, Die([d3, d4, d6]) has a final denominator of 36: 3 for +the primary selection between the three secondary dice, times 12 for +the LCM of 3, 4, and 6.

+ +
Arguments:
+ +
    +

  • outcomes: The faces of the Die. This can be one of the following:

    + +
      +
    • A Sequence of outcomes. Duplicates will contribute +quantity for each appearance.
      • +
    • A Mapping from outcomes to quantities.
      • +
    + +

    Individual outcomes can each be one of the following:

    + +
      +
    • An outcome, which must be hashable and totally orderable.
      • +
    • A Die, which will be flattened into the result. +The quantity assigned to a Die is shared among its +outcomes. The total denominator will be scaled up if +necessary.
      • +
    • icepool.Reroll, which will drop itself from consideration.
      • +
    • EXPERIMENTAL: icepool.Again. See the main text for +explanation.
      • +
    • +
  • times: Multiplies the quantity of each element of outcomes. +times can either be a sequence of the same length as +outcomes or a single int to apply to all elements of +outcomes.
    • +
+ +
Raises:
+ +
    +
  • ValueError: None is not a valid outcome for a Die.
    • +
+
+ + +
+
+ +
+ + def + unary_operator( self: Die[+T_co], op: Callable[..., ~U], *args, **kwargs) -> Die[~U]: + + + +
+ + 
222    def unary_operator(self: 'icepool.Die[T_co]', op: Callable[..., U], *args,
+223                       **kwargs) -> 'icepool.Die[U]':
+224        """Performs the unary operation on the outcomes.
+225
+226        This is used for the standard unary operators
+227        `-, +, abs, ~, round, trunc, floor, ceil`
+228        as well as the additional methods
+229        `zero, bool`.
+230
+231        This is NOT used for the `[]` operator; when used directly, this is
+232        interpreted as a `Mapping` operation and returns the count corresponding
+233        to a given outcome. See `marginals()` for applying the `[]` operator to
+234        outcomes.
+235
+236        Returns:
+237            A `Die` representing the result.
+238
+239        Raises:
+240            ValueError: If tuples are of mismatched length.
+241        """
+242        return self._unary_operator(op, *args, **kwargs)
+
+ + +

Performs the unary operation on the outcomes.

+ +

This is used for the standard unary operators +-, +, abs, ~, round, trunc, floor, ceil +as well as the additional methods +zero, bool.

+ +

This is NOT used for the [] operator; when used directly, this is +interpreted as a Mapping operation and returns the count corresponding +to a given outcome. See marginals() for applying the [] operator to +outcomes.

+ +
Returns:
+ +
+

A Die representing the result.

+
+ +
Raises:
+ +
    +
  • ValueError: If tuples are of mismatched length.
    • +
+
+ + +
+
+ +
+ + def + binary_operator( self, other: Die, op: Callable[..., ~U], *args, **kwargs) -> Die[~U]: + + + +
+ + 
244    def binary_operator(self, other: 'Die', op: Callable[..., U], *args,
+245                        **kwargs) -> 'Die[U]':
+246        """Performs the operation on pairs of outcomes.
+247
+248        By the time this is called, the other operand has already been
+249        converted to a `Die`.
+250
+251        If one side of a binary operator is a tuple and the other is not, the
+252        binary operator is applied to each element of the tuple with the
+253        non-tuple side. For example, the following are equivalent:
+254
+255        ```
+256        cartesian_product(d6, d8) * 2
+257        cartesian_product(d6 * 2, d8 * 2)
+258        ```
+259
+260        This is used for the standard binary operators
+261        `+, -, *, /, //, %, **, <<, >>, &, |, ^`
+262        and the standard binary comparators
+263        `<, <=, >=, >, ==, !=, cmp`.
+264
+265        `==` and `!=` additionally set the truth value of the `Die` according to
+266        whether the dice themselves are the same or not.
+267
+268        The `@` operator does NOT use this method directly.
+269        It rolls the left `Die`, which must have integer outcomes,
+270        then rolls the right `Die` that many times and sums the outcomes.
+271
+272        Returns:
+273            A `Die` representing the result.
+274
+275        Raises:
+276            ValueError: If tuples are of mismatched length within one of the
+277                dice or between the dice.
+278        """
+279        data: MutableMapping[Any, int] = defaultdict(int)
+280        for (outcome_self,
+281             quantity_self), (outcome_other,
+282                              quantity_other) in itertools.product(
+283                                  self.items(), other.items()):
+284            new_outcome = op(outcome_self, outcome_other, *args, **kwargs)
+285            data[new_outcome] += quantity_self * quantity_other
+286        return self._new_type(data)
+
+ + +

Performs the operation on pairs of outcomes.

+ +

By the time this is called, the other operand has already been +converted to a Die.

+ +

If one side of a binary operator is a tuple and the other is not, the +binary operator is applied to each element of the tuple with the +non-tuple side. For example, the following are equivalent:

+ +
cartesian_product(d6, d8) * 2
+cartesian_product(d6 * 2, d8 * 2)
+
+ +

This is used for the standard binary operators ++, -, *, /, //, %, **, <<, >>, &, |, ^ +and the standard binary comparators +<, <=, >=, >, ==, !=, cmp.

+ +

== and != additionally set the truth value of the Die according to +whether the dice themselves are the same or not.

+ +

The @ operator does NOT use this method directly. +It rolls the left Die, which must have integer outcomes, +then rolls the right Die that many times and sums the outcomes.

+ +
Returns:
+ +
+

A Die representing the result.

+
+ +
Raises:
+ +
    +
  • ValueError: If tuples are of mismatched length within one of the +dice or between the dice.
    • +
+
+ + +
+
+ +
+ + def + keys(self) -> CountsKeysView[+T_co]: + + + +
+ + 
290    def keys(self) -> CountsKeysView[T_co]:
+291        return self._data.keys()
+
+ + +

The outcomes within the population in sorted order.

+
+ + +
+
+ +
+ + def + values(self) -> CountsValuesView: + + + +
+ + 
293    def values(self) -> CountsValuesView:
+294        return self._data.values()
+
+ + +

The quantities within the population in outcome order.

+
+ + +
+
+ +
+ + def + items(self) -> CountsItemsView[+T_co]: + + + +
+ + 
296    def items(self) -> CountsItemsView[T_co]:
+297        return self._data.items()
+
+ + +

The (outcome, quantity)s of the population in sorted order.

+
+ + +
+
+ +
+ + def + simplify(self) -> Die[+T_co]: + + + +
+ + 
314    def simplify(self) -> 'Die[T_co]':
+315        """Divides all quantities by their greatest common denominator. """
+316        return icepool.Die(self._data.simplify())
+
+ + +

Divides all quantities by their greatest common denominator.

+
+ + +
+
+ +
+ + def + reroll( self, which: Union[Callable[..., bool], Collection[+T_co], NoneType] = None, /, *, star: bool | None = None, depth: int | None = None) -> Die[+T_co]: + + + +
+ + 
320    def reroll(self,
+321               which: Callable[..., bool] | Collection[T_co] | None = None,
+322               /,
+323               *,
+324               star: bool | None = None,
+325               depth: int | None = None) -> 'Die[T_co]':
+326        """Rerolls the given outcomes.
+327
+328        Args:
+329            which: Selects which outcomes to reroll. Options:
+330                * A single outcome to reroll.
+331                * A collection of outcomes to reroll.
+332                * A callable that takes an outcome and returns `True` if it
+333                    should be rerolled.
+334                * If not provided, the min outcome will be rerolled.
+335            star: Whether outcomes should be unpacked into separate arguments
+336                before sending them to a callable `which`.
+337                If not provided, this will be guessed based on the function
+338                signature.
+339            depth: The maximum number of times to reroll.
+340                If omitted, rerolls an unlimited number of times.
+341
+342        Returns:
+343            A `Die` representing the reroll.
+344            If the reroll would never terminate, the result has no outcomes.
+345        """
+346
+347        if which is None:
+348            outcome_set = {self.min_outcome()}
+349        elif callable(which):
+350            if star is None:
+351                star = guess_star(which)
+352            if star:
+353
+354                # Need TypeVarTuple to check this.
+355                outcome_set = {
+356                    outcome for outcome in self.outcomes()
+357                    if which(*outcome)  # type: ignore
+358                }
+359            else:
+360                outcome_set = {
+361                    outcome for outcome in self.outcomes() if which(outcome)
+362                }
+363        else:
+364            # Collection.
+365            outcome_set = set(which)
+366
+367        if depth is None:
+368            data = {
+369                outcome: quantity
+370                for outcome, quantity in self.items()
+371                if outcome not in outcome_set
+372            }
+373        elif depth < 0:
+374            raise ValueError('reroll depth cannot be negative.')
+375        else:
+376            total_reroll_quantity = sum(
+377                quantity for outcome, quantity in self.items()
+378                if outcome in outcome_set)
+379            total_stop_quantity = self.denominator() - total_reroll_quantity
+380            rerollable_factor = total_reroll_quantity**depth
+381            stop_factor = (self.denominator()**(depth + 1) - rerollable_factor *
+382                           total_reroll_quantity) // total_stop_quantity
+383            data = {
+384                outcome: (rerollable_factor *
+385                          quantity if outcome in outcome_set else stop_factor *
+386                          quantity) for outcome, quantity in self.items()
+387            }
+388        return icepool.Die(data)
+
+ + +

Rerolls the given outcomes.

+ +
Arguments:
+ +
    +
  • which: Selects which outcomes to reroll. Options: +
      +
    • A single outcome to reroll.
      • +
    • A collection of outcomes to reroll.
      • +
    • A callable that takes an outcome and returns True if it +should be rerolled.
      • +
    • If not provided, the min outcome will be rerolled.
      • +
    • +
  • star: Whether outcomes should be unpacked into separate arguments +before sending them to a callable which. +If not provided, this will be guessed based on the function +signature.
    • +
  • depth: The maximum number of times to reroll. +If omitted, rerolls an unlimited number of times.
    • +
+ +
Returns:
+ +
+

A Die representing the reroll. + If the reroll would never terminate, the result has no outcomes.

+
+
+ + +
+
+ +
+ + def + filter( self, which: Union[Callable[..., bool], Collection[+T_co]], /, *, star: bool | None = None, depth: int | None = None) -> Die[+T_co]: + + + +
+ + 
390    def filter(self,
+391               which: Callable[..., bool] | Collection[T_co],
+392               /,
+393               *,
+394               star: bool | None = None,
+395               depth: int | None = None) -> 'Die[T_co]':
+396        """Rerolls until getting one of the given outcomes.
+397
+398        Essentially the complement of `reroll()`.
+399
+400        Args:
+401            which: Selects which outcomes to reroll until. Options:
+402                * A callable that takes an outcome and returns `True` if it
+403                    should be accepted.
+404                * A collection of outcomes to reroll until.
+405            star: Whether outcomes should be unpacked into separate arguments
+406                before sending them to a callable `which`.
+407                If not provided, this will be guessed based on the function
+408                signature.
+409            depth: The maximum number of times to reroll.
+410                If omitted, rerolls an unlimited number of times.
+411
+412        Returns:
+413            A `Die` representing the reroll.
+414            If the reroll would never terminate, the result has no outcomes.
+415        """
+416
+417        if callable(which):
+418            if star is None:
+419                star = guess_star(which)
+420            if star:
+421
+422                not_outcomes = {
+423                    outcome for outcome in self.outcomes()
+424                    if not which(*outcome)  # type: ignore
+425                }
+426            else:
+427                not_outcomes = {
+428                    outcome for outcome in self.outcomes() if not which(outcome)
+429                }
+430        else:
+431            not_outcomes = {
+432                not_outcome for not_outcome in self.outcomes()
+433                if not_outcome not in which
+434            }
+435        return self.reroll(not_outcomes, depth=depth)
+
+ + +

Rerolls until getting one of the given outcomes.

+ +

Essentially the complement of reroll().

+ +
Arguments:
+ +
    +
  • which: Selects which outcomes to reroll until. Options: +
      +
    • A callable that takes an outcome and returns True if it +should be accepted.
      • +
    • A collection of outcomes to reroll until.
      • +
    • +
  • star: Whether outcomes should be unpacked into separate arguments +before sending them to a callable which. +If not provided, this will be guessed based on the function +signature.
    • +
  • depth: The maximum number of times to reroll. +If omitted, rerolls an unlimited number of times.
    • +
+ +
Returns:
+ +
+

A Die representing the reroll. + If the reroll would never terminate, the result has no outcomes.

+
+
+ + +
+
+ +
+ + def + truncate( self, min_outcome=None, max_outcome=None) -> Die[+T_co]: + + + +
+ + 
437    def truncate(self, min_outcome=None, max_outcome=None) -> 'Die[T_co]':
+438        """Truncates the outcomes of this `Die` to the given range.
+439
+440        The endpoints are included in the result if applicable.
+441        If one of the arguments is not provided, that side will not be truncated.
+442
+443        This effectively rerolls outcomes outside the given range.
+444        If instead you want to replace those outcomes with the nearest endpoint,
+445        use `clip()`.
+446
+447        Not to be confused with `trunc(die)`, which performs integer truncation
+448        on each outcome.
+449        """
+450        if min_outcome is not None:
+451            start = bisect.bisect_left(self.outcomes(), min_outcome)
+452        else:
+453            start = None
+454        if max_outcome is not None:
+455            stop = bisect.bisect_right(self.outcomes(), max_outcome)
+456        else:
+457            stop = None
+458        data = {k: v for k, v in self.items()[start:stop]}
+459        return icepool.Die(data)
+
+ + +

Truncates the outcomes of this Die to the given range.

+ +

The endpoints are included in the result if applicable. +If one of the arguments is not provided, that side will not be truncated.

+ +

This effectively rerolls outcomes outside the given range. +If instead you want to replace those outcomes with the nearest endpoint, +use clip().

+ +

Not to be confused with trunc(die), which performs integer truncation +on each outcome.

+
+ + +
+
+ +
+ + def + clip( self, min_outcome=None, max_outcome=None) -> Die[+T_co]: + + + +
+ + 
461    def clip(self, min_outcome=None, max_outcome=None) -> 'Die[T_co]':
+462        """Clips the outcomes of this `Die` to the given values.
+463
+464        The endpoints are included in the result if applicable.
+465        If one of the arguments is not provided, that side will not be clipped.
+466
+467        This is not the same as rerolling outcomes beyond this range;
+468        the outcome is simply adjusted to fit within the range.
+469        This will typically cause some quantity to bunch up at the endpoint.
+470        If you want to reroll outcomes beyond this range, use `truncate()`.
+471        """
+472        data: MutableMapping[Any, int] = defaultdict(int)
+473        for outcome, quantity in self.items():
+474            if min_outcome is not None and outcome <= min_outcome:
+475                data[min_outcome] += quantity
+476            elif max_outcome is not None and outcome >= max_outcome:
+477                data[max_outcome] += quantity
+478            else:
+479                data[outcome] += quantity
+480        return icepool.Die(data)
+
+ + +

Clips the outcomes of this Die to the given values.

+ +

The endpoints are included in the result if applicable. +If one of the arguments is not provided, that side will not be clipped.

+ +

This is not the same as rerolling outcomes beyond this range; +the outcome is simply adjusted to fit within the range. +This will typically cause some quantity to bunch up at the endpoint. +If you want to reroll outcomes beyond this range, use truncate().

+
+ + +
+
+ +
+ + def + set_range( self: Die[int], min_outcome: int | None = None, max_outcome: int | None = None) -> Die[int]: + + + +
+ + 
482    def set_range(self: 'Die[int]',
+483                  min_outcome: int | None = None,
+484                  max_outcome: int | None = None) -> 'Die[int]':
+485        """Sets the outcomes of this `Die` to the given `int` range (inclusive).
+486
+487        This may remove outcomes (if they are not within the range)
+488        and/or add zero-quantity outcomes (if they are in range but not present
+489        in this `Die`).
+490
+491        Args:
+492            min_outcome: The min outcome of the result.
+493                If omitted, the min outcome of this `Die` will be used.
+494            max_outcome: The max outcome of the result.
+495                If omitted, the max outcome of this `Die` will be used.
+496        """
+497        if min_outcome is None:
+498            min_outcome = self.min_outcome()
+499        if max_outcome is None:
+500            max_outcome = self.max_outcome()
+501
+502        return self.set_outcomes(range(min_outcome, max_outcome + 1))
+
+ + +

Sets the outcomes of this Die to the given int range (inclusive).

+ +

This may remove outcomes (if they are not within the range) +and/or add zero-quantity outcomes (if they are in range but not present +in this Die).

+ +
Arguments:
+ +
    +
  • min_outcome: The min outcome of the result. +If omitted, the min outcome of this Die will be used.
    • +
  • max_outcome: The max outcome of the result. +If omitted, the max outcome of this Die will be used.
    • +
+
+ + +
+
+ +
+ + def + set_outcomes(self, outcomes: Iterable[+T_co]) -> Die[+T_co]: + + + +
+ + 
504    def set_outcomes(self, outcomes: Iterable[T_co]) -> 'Die[T_co]':
+505        """Sets the set of outcomes to the argument.
+506
+507        This may remove outcomes (if they are not present in the argument)
+508        and/or add zero-quantity outcomes (if they are not present in this `Die`).
+509        """
+510        data = {x: self.quantity(x) for x in outcomes}
+511        return icepool.Die(data)
+
+ + +

Sets the set of outcomes to the argument.

+ +

This may remove outcomes (if they are not present in the argument) +and/or add zero-quantity outcomes (if they are not present in this Die).

+
+ + +
+
+ +
+ + def + trim(self) -> Die[+T_co]: + + + +
+ + 
513    def trim(self) -> 'Die[T_co]':
+514        """Removes all zero-quantity outcomes. """
+515        data = {k: v for k, v in self.items() if v > 0}
+516        return icepool.Die(data)
+
+ + +

Removes all zero-quantity outcomes.

+
+ + +
+
+ +
+ + def + map( self, repl: Union[Callable[..., Union[~U, Die[~U], RerollType, icepool.population.again.AgainExpression]], Mapping[+T_co, Union[~U, Die[~U], RerollType, icepool.population.again.AgainExpression]]], /, *extra_args, star: bool | None = None, repeat: int | None = 1, again_depth: int = 1, again_end: Union[~U, Die[~U], RerollType, NoneType] = None) -> Die[~U]: + + + +
+ + 
546    def map(
+547            self,
+548            repl:
+549        'Callable[..., U | Die[U] | icepool.RerollType | icepool.AgainExpression] | Mapping[T_co, U | Die[U] | icepool.RerollType | icepool.AgainExpression]',
+550            /,
+551            *extra_args,
+552            star: bool | None = None,
+553            repeat: int | None = 1,
+554            again_depth: int = 1,
+555            again_end: 'U | Die[U] | icepool.RerollType | None' = None
+556    ) -> 'Die[U]':
+557        """Maps outcomes of the `Die` to other outcomes.
+558
+559        This is also useful for representing processes.
+560
+561        As `icepool.map(repl, self, ...)`.
+562        """
+563        return icepool.map(repl,
+564                           self,
+565                           *extra_args,
+566                           star=star,
+567                           repeat=repeat,
+568                           again_depth=again_depth,
+569                           again_end=again_end)
+
+ + +

Maps outcomes of the Die to other outcomes.

+ +

This is also useful for representing processes.

+ +

As icepool.map(repl, self, ...).

+
+ + +
+
+ +
+ + def + map_and_time( self, repl: Union[Callable[..., Union[+T_co, Die[+T_co], RerollType]], Mapping[+T_co, Union[+T_co, Die[+T_co], RerollType]]], /, *extra_args, star: bool | None = None, repeat: int) -> Die[tuple[+T_co, int]]: + + + +
+ + 
571    def map_and_time(
+572            self,
+573            repl:
+574        'Callable[..., T_co | Die[T_co] | icepool.RerollType] | Mapping[T_co, T_co | Die[T_co] | icepool.RerollType]',
+575            /,
+576            *extra_args,
+577            star: bool | None = None,
+578            repeat: int) -> 'Die[tuple[T_co, int]]':
+579        """Repeatedly map outcomes of the state to other outcomes, while also
+580        counting timesteps.
+581
+582        This is useful for representing processes.
+583
+584        As `map_and_time(repl, self, ...)`.
+585        """
+586        return icepool.map_and_time(repl,
+587                                    self,
+588                                    *extra_args,
+589                                    star=star,
+590                                    repeat=repeat)
+
+ + +

Repeatedly map outcomes of the state to other outcomes, while also +counting timesteps.

+ +

This is useful for representing processes.

+ +

As map_and_time(repl, self, ...).

+
+ + +
+
+ +
+ + def + explode( self, which: Union[Callable[..., bool], Collection[+T_co], NoneType] = None, *, star: bool | None = None, depth: int = 9, end=None) -> Die[+T_co]: + + + +
+ + 
592    def explode(self,
+593                which: Collection[T_co] | Callable[..., bool] | None = None,
+594                *,
+595                star: bool | None = None,
+596                depth: int = 9,
+597                end=None) -> 'Die[T_co]':
+598        """Causes outcomes to be rolled again and added to the total.
+599
+600        Args:
+601            which: Which outcomes to explode. Options:
+602                * A single outcome to explode.
+603                * An collection of outcomes to explode.
+604                * A callable that takes an outcome and returns `True` if it
+605                    should be exploded.
+606                * If not supplied, the max outcome will explode.
+607            star: Whether outcomes should be unpacked into separate arguments
+608                before sending them to a callable `which`.
+609                If not provided, this will be guessed based on the function
+610                signature.
+611            depth: The maximum number of additional dice to roll.
+612                If not supplied, a default value will be used.
+613            end: Once depth is reached, further explosions will be treated
+614                as this value. By default, a zero value will be used.
+615        """
+616
+617        if which is None:
+618            outcome_set = {self.max_outcome()}
+619        elif callable(which):
+620            if star is None:
+621                star = guess_star(which)
+622            if star:
+623                # Need TypeVarTuple to type-check this.
+624                outcome_set = {
+625                    outcome for outcome in self.outcomes()
+626                    if which(*outcome)  # type: ignore
+627                }
+628            else:
+629                outcome_set = {
+630                    outcome for outcome in self.outcomes() if which(outcome)
+631                }
+632        else:
+633            if not which:
+634                return self
+635            outcome_set = set(which)
+636
+637        if depth < 0:
+638            raise ValueError('depth cannot be negative.')
+639        elif depth == 0:
+640            return self
+641
+642        def map_final(outcome):
+643            if outcome in outcome_set:
+644                return outcome + icepool.Again
+645            else:
+646                return outcome
+647
+648        return self.map(map_final, again_depth=depth, again_end=end)
+
+ + +

Causes outcomes to be rolled again and added to the total.

+ +
Arguments:
+ +
    +
  • which: Which outcomes to explode. Options: +
      +
    • A single outcome to explode.
      • +
    • An collection of outcomes to explode.
      • +
    • A callable that takes an outcome and returns True if it +should be exploded.
      • +
    • If not supplied, the max outcome will explode.
      • +
    • +
  • star: Whether outcomes should be unpacked into separate arguments +before sending them to a callable which. +If not provided, this will be guessed based on the function +signature.
    • +
  • depth: The maximum number of additional dice to roll. +If not supplied, a default value will be used.
    • +
  • end: Once depth is reached, further explosions will be treated +as this value. By default, a zero value will be used.
    • +
+
+ + +
+
+ +
+ + def + if_else( self, outcome_if_true: Union[~U, Die[~U]], outcome_if_false: Union[~U, Die[~U]], *, again_depth: int = 1, again_end: Union[~U, Die[~U], RerollType, NoneType] = None) -> Die[~U]: + + + +
+ + 
650    def if_else(
+651            self,
+652            outcome_if_true: U | 'Die[U]',
+653            outcome_if_false: U | 'Die[U]',
+654            *,
+655            again_depth: int = 1,
+656            again_end: 'U | Die[U] | icepool.RerollType | None' = None
+657    ) -> 'Die[U]':
+658        """Ternary conditional operator.
+659
+660        This replaces truthy outcomes with the first argument and falsy outcomes
+661        with the second argument.
+662
+663        Args:
+664            again_depth: Forwarded to the final die constructor.
+665            again_end: Forwarded to the final die constructor.
+666        """
+667        return self.map(lambda x: bool(x)).map(
+668            {
+669                True: outcome_if_true,
+670                False: outcome_if_false
+671            },
+672            again_depth=again_depth,
+673            again_end=again_end)
+
+ + +

Ternary conditional operator.

+ +

This replaces truthy outcomes with the first argument and falsy outcomes +with the second argument.

+ +
Arguments:
+ +
    +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + is_in(self, target: Container[+T_co], /) -> Die[bool]: + + + +
+ + 
675    def is_in(self, target: Container[T_co], /) -> 'Die[bool]':
+676        """A die that returns True iff the roll of the die is contained in the target."""
+677        return self.map(lambda x: x in target)
+
+ + +

A die that returns True iff the roll of the die is contained in the target.

+
+ + +
+
+ +
+ + def + count( self, rolls: int, target: Container[+T_co], /) -> Die[int]: + + + +
+ + 
679    def count(self, rolls: int, target: Container[T_co], /) -> 'Die[int]':
+680        """Roll this dice a number of times and count how many are in the target."""
+681        return rolls @ self.is_in(target)
+
+ + +

Roll this dice a number of times and count how many are in the target.

+
+ + +
+
+ +
+ + def + pool( self, rolls: Union[int, Sequence[int]] = 1, /) -> Pool[+T_co]: + + + +
+ + 
736    def pool(self, rolls: int | Sequence[int] = 1, /) -> 'icepool.Pool[T_co]':
+737        """Creates a `Pool` from this `Die`.
+738
+739        You might subscript the pool immediately afterwards, e.g.
+740        `d6.pool(5)[-1, ..., 1]` takes the difference between the highest and
+741        lowest of 5d6.
+742
+743        Args:
+744            rolls: The number of copies of this `Die` to put in the pool.
+745                Or, a sequence of one `int` per die acting as
+746                `keep_tuple`. Note that `...` cannot be used in the
+747                argument to this method, as the argument determines the size of
+748                the pool.
+749        """
+750        if isinstance(rolls, int):
+751            return icepool.Pool({self: rolls})
+752        else:
+753            pool_size = len(rolls)
+754            return icepool.Pool({self: pool_size})[rolls]
+
+ + +

Creates a Pool from this Die.

+ +

You might subscript the pool immediately afterwards, e.g. +d6.pool(5)[-1, ..., 1] takes the difference between the highest and +lowest of 5d6.

+ +
Arguments:
+ +
    +
  • rolls: The number of copies of this Die to put in the pool. +Or, a sequence of one int per die acting as +keep_tuple. Note that ... cannot be used in the +argument to this method, as the argument determines the size of +the pool.
    • +
+
+ + +
+
+ +
+ + def + lowest( self, rolls: int, /, keep: int = 1, drop: int = 0) -> Die: + + + +
+ + 
756    def lowest(self, rolls: int, /, keep: int = 1, drop: int = 0) -> 'Die':
+757        """Roll several of this `Die` and return the lowest result, or the sum of some of the lowest.
+758
+759        The outcomes should support addition and multiplication if `keep != 1`.
+760
+761        Args:
+762            rolls: The number of dice to roll. All dice will have the same
+763                outcomes as `self`.
+764            keep: The number of dice to keep.
+765            drop: If provided, this many lowest dice will be dropped before
+766                keeping.
+767
+768        Returns:
+769            A `Die` representing the probability distribution of the sum.
+770        """
+771        if keep == 1 and drop == 0:
+772            return self._lowest_single(rolls)
+773
+774        start = drop if drop > 0 else None
+775        stop = keep + (drop or 0)
+776        index = slice(start, stop)
+777        # Expression evaluators are difficult to type.
+778        return self.pool(rolls)[index].sum()  # type: ignore
+
+ + +

Roll several of this Die and return the lowest result, or the sum of some of the lowest.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • rolls: The number of dice to roll. All dice will have the same +outcomes as self.
    • +
  • keep: The number of dice to keep.
    • +
  • drop: If provided, this many lowest dice will be dropped before +keeping.
    • +
+ +
Returns:
+ +
+

A Die representing the probability distribution of the sum.

+
+
+ + +
+
+ +
+ + def + highest( self, rolls: int, /, keep: int = 1, drop: int = 0) -> Die[+T_co]: + + + +
+ + 
788    def highest(self,
+789                rolls: int,
+790                /,
+791                keep: int = 1,
+792                drop: int = 0) -> 'Die[T_co]':
+793        """Roll several of this `Die` and return the highest result, or the sum of some of the highest.
+794
+795        The outcomes should support addition and multiplication if `keep != 1`.
+796
+797        Args:
+798            rolls: The number of dice to roll.
+799            keep: The number of dice to keep.
+800            drop: If provided, this many highest dice will be dropped before
+801                keeping.
+802
+803        Returns:
+804            A `Die` representing the probability distribution of the sum.
+805        """
+806        if keep == 1 and drop == 0:
+807            return self._highest_single(rolls)
+808        start = -(keep + (drop or 0))
+809        stop = -drop if drop > 0 else None
+810        index = slice(start, stop)
+811        # Expression evaluators are difficult to type.
+812        return self.pool(rolls)[index].sum()  # type: ignore
+
+ + +

Roll several of this Die and return the highest result, or the sum of some of the highest.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • rolls: The number of dice to roll.
    • +
  • keep: The number of dice to keep.
    • +
  • drop: If provided, this many highest dice will be dropped before +keeping.
    • +
+ +
Returns:
+ +
+

A Die representing the probability distribution of the sum.

+
+
+ + +
+
+ +
+ + def + middle( self, rolls: int, /, keep: int = 1, *, tie: Literal['error', 'high', 'low'] = 'error') -> Die: + + + +
+ + 
821    def middle(self,
+822               rolls: int,
+823               /,
+824               keep: int = 1,
+825               *,
+826               tie: Literal['error', 'high', 'low'] = 'error') -> 'icepool.Die':
+827        """Roll several of this `Die` and sum the sorted results in the middle.
+828
+829        The outcomes should support addition and multiplication if `keep != 1`.
+830
+831        Args:
+832            rolls: The number of dice to roll.
+833            keep: The number of outcomes to sum. If this is greater than the
+834                current keep_size, all are kept.
+835            tie: What to do if `keep` is odd but the current keep_size
+836                is even, or vice versa.
+837                * 'error' (default): Raises `IndexError`.
+838                * 'high': The higher outcome is taken.
+839                * 'low': The lower outcome is taken.
+840        """
+841        # Expression evaluators are difficult to type.
+842        return self.pool(rolls).middle(keep, tie=tie).sum()  # type: ignore
+
+ + +

Roll several of this Die and sum the sorted results in the middle.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • rolls: The number of dice to roll.
    • +
  • keep: The number of outcomes to sum. If this is greater than the +current keep_size, all are kept.
    • +
  • tie: What to do if keep is odd but the current keep_size +is even, or vice versa. +
      +
    • 'error' (default): Raises IndexError.
      • +
    • 'high': The higher outcome is taken.
      • +
    • 'low': The lower outcome is taken.
      • +
    • +
+
+ + +
+
+ +
+ + def + abs(self) -> Die[+T_co]: + + + +
+ + 
855    def abs(self) -> 'Die[T_co]':
+856        return self.unary_operator(operator.abs)
+
+ + + + +
+
+ +
+ + def + round(self, ndigits: int | None = None) -> Die: + + + +
+ + 
860    def round(self, ndigits: int | None = None) -> 'Die':
+861        return self.unary_operator(round, ndigits)
+
+ + + + +
+
+ +
+ + def + trunc(self) -> Die: + + + +
+ + 
865    def trunc(self) -> 'Die':
+866        return self.unary_operator(math.trunc)
+
+ + + + +
+
+ +
+ + def + floor(self) -> Die: + + + +
+ + 
870    def floor(self) -> 'Die':
+871        return self.unary_operator(math.floor)
+
+ + + + +
+
+ +
+ + def + ceil(self) -> Die: + + + +
+ + 
875    def ceil(self) -> 'Die':
+876        return self.unary_operator(math.ceil)
+
+ + + + +
+
+ +
+ + def + zero(self) -> Die[+T_co]: + + + +
+ + 
884    def zero(self) -> 'Die[T_co]':
+885        """Zeros all outcomes of this die.
+886
+887        This is done by multiplying all outcomes by `0`.
+888
+889        The result will have the same denominator as this die.
+890
+891        Raises:
+892            ValueError: If the zeros did not resolve to a single outcome.
+893        """
+894        result = self.unary_operator(Die._zero)
+895        if len(result) != 1:
+896            raise ValueError('zero() did not resolve to a single outcome.')
+897        return result
+
+ + +

Zeros all outcomes of this die.

+ +

This is done by multiplying all outcomes by 0.

+ +

The result will have the same denominator as this die.

+ +
Raises:
+ +
    +
  • ValueError: If the zeros did not resolve to a single outcome.
    • +
+
+ + +
+
+ +
+ + def + zero_outcome(self) -> +T_co: + + + +
+ + 
899    def zero_outcome(self) -> T_co:
+900        """A zero-outcome for this die.
+901
+902        E.g. `0` for a `Die` whose outcomes are `int`s.
+903        """
+904        return self.zero().outcomes()[0]
+
+ + +

A zero-outcome for this die.

+ +

E.g. 0 for a Die whose outcomes are ints.

+
+ + +
+
+ +
+ + def + cmp(self, other) -> Die[int]: + + + +
+ + 
1096    def cmp(self, other) -> 'Die[int]':
+1097        """A `Die` with outcomes 1, -1, and 0.
+1098
+1099        The quantities are equal to the positive outcome of `self > other`,
+1100        `self < other`, and the remainder respectively.
+1101
+1102        This will include all three outcomes even if they have zero quantity.
+1103        """
+1104        other = implicit_convert_to_die(other)
+1105
+1106        data = {}
+1107
+1108        lt = self < other
+1109        if True in lt:
+1110            data[-1] = lt[True]
+1111        eq = self == other
+1112        if True in eq:
+1113            data[0] = eq[True]
+1114        gt = self > other
+1115        if True in gt:
+1116            data[1] = gt[True]
+1117
+1118        return Die(data)
+
+ + +

A Die with outcomes 1, -1, and 0.

+ +

The quantities are equal to the positive outcome of self > other, +self < other, and the remainder respectively.

+ +

This will include all three outcomes even if they have zero quantity.

+
+ + +
+
+ +
+ + def + sign(self) -> Die[int]: + + + +
+ + 
1130    def sign(self) -> 'Die[int]':
+1131        """Outcomes become 1 if greater than `zero()`, -1 if less than `zero()`, and 0 otherwise.
+1132
+1133        Note that for `float`s, +0.0, -0.0, and nan all become 0.
+1134        """
+1135        return self.unary_operator(Die._sign)
+
+ + +

Outcomes become 1 if greater than zero(), -1 if less than zero(), and 0 otherwise.

+ +

Note that for floats, +0.0, -0.0, and nan all become 0.

+
+ + +
+
+ +
+ + def + equals(self, other, *, simplify: bool = False) -> bool: + + + +
+ + 
1163    def equals(self, other, *, simplify: bool = False) -> bool:
+1164        """`True` iff both dice have the same outcomes and quantities.
+1165
+1166        This is `False` if `other` is not a `Die`, even if it would convert
+1167        to an equal `Die`.
+1168
+1169        Truth value does NOT matter.
+1170
+1171        If one `Die` has a zero-quantity outcome and the other `Die` does not
+1172        contain that outcome, they are treated as unequal by this function.
+1173
+1174        The `==` and `!=` operators have a dual purpose; they return a `Die`
+1175        with a truth value determined by this method.
+1176        Only dice returned by these methods have a truth value. The data of
+1177        these dice is lazily evaluated since the caller may only be interested
+1178        in the `Die` value or the truth value.
+1179
+1180        Args:
+1181            simplify: If `True`, the dice will be simplified before comparing.
+1182                Otherwise, e.g. a 2:2 coin is not `equals()` to a 1:1 coin.
+1183        """
+1184        if not isinstance(other, Die):
+1185            return False
+1186
+1187        if simplify:
+1188            return self.simplify()._hash_key == other.simplify()._hash_key
+1189        else:
+1190            return self._hash_key == other._hash_key
+
+ + +

True iff both dice have the same outcomes and quantities.

+ +

This is False if other is not a Die, even if it would convert +to an equal Die.

+ +

Truth value does NOT matter.

+ +

If one Die has a zero-quantity outcome and the other Die does not +contain that outcome, they are treated as unequal by this function.

+ +

The == and != operators have a dual purpose; they return a Die +with a truth value determined by this method. +Only dice returned by these methods have a truth value. The data of +these dice is lazily evaluated since the caller may only be interested +in the Die value or the truth value.

+ +
Arguments:
+ +
    +
  • simplify: If True, the dice will be simplified before comparing. +Otherwise, e.g. a 2:2 coin is not equals() to a 1:1 coin.
    • +
+
+ + +
+
+
Inherited Members
+
+
Population
+
outcomes
+
common_outcome_length
+
is_empty
+
min_outcome
+
max_outcome
+
nearest_le
+
nearest_lt
+
nearest_ge
+
nearest_gt
+
quantity
+
quantities
+
denominator
+
scale_quantities
+
has_zero_quantities
+
quantity_ne
+
quantity_le
+
quantity_lt
+
quantity_ge
+
quantity_gt
+
quantities_le
+
quantities_ge
+
quantities_lt
+
quantities_gt
+
probability
+
probability_le
+
probability_lt
+
probability_ge
+
probability_gt
+
probabilities
+
probabilities_le
+
probabilities_ge
+
probabilities_lt
+
probabilities_gt
+
mode
+
modal_quantity
+
kolmogorov_smirnov
+
cramer_von_mises
+
median
+
median_low
+
median_high
+
quantile
+
quantile_low
+
quantile_high
+
mean
+
variance
+
standard_deviation
+
sd
+
standardized_moment
+
skewness
+
excess_kurtosis
+
entropy
+
marginals
+
covariance
+
correlation
+
sample
+
format
+ +
+
collections.abc.Mapping
+
get
+ +
+
+
+
+
+ +
+ + class + Population(abc.ABC, typing.Generic[+T_co], typing.Mapping[typing.Any, int]): + + + +
+ + 
 27class Population(ABC, Generic[T_co], Mapping[Any, int]):
+ 28    """A mapping from outcomes to `int` quantities.
+ 29
+ 30    Outcomes with each instance must be hashable and totally orderable.
+ 31
+ 32    Subclasses include `Die` and `Deck`.
+ 33    """
+ 34
+ 35    # Abstract methods.
+ 36
+ 37    @property
+ 38    @abstractmethod
+ 39    def _new_type(self) -> type:
+ 40        """The type to use when constructing a new instance."""
+ 41
+ 42    @abstractmethod
+ 43    def keys(self) -> CountsKeysView[T_co]:
+ 44        """The outcomes within the population in sorted order."""
+ 45
+ 46    @abstractmethod
+ 47    def values(self) -> CountsValuesView:
+ 48        """The quantities within the population in outcome order."""
+ 49
+ 50    @abstractmethod
+ 51    def items(self) -> CountsItemsView[T_co]:
+ 52        """The (outcome, quantity)s of the population in sorted order."""
+ 53
+ 54    def _unary_operator(self, op: Callable[..., U], *args, **kwargs):
+ 55        data: MutableMapping[Any, int] = defaultdict(int)
+ 56        for outcome, quantity in self.items():
+ 57            new_outcome = op(outcome, *args, **kwargs)
+ 58            data[new_outcome] += quantity
+ 59        return self._new_type(data)
+ 60
+ 61    # Outcomes.
+ 62
+ 63    def outcomes(self) -> CountsKeysView[T_co]:
+ 64        """The outcomes of the mapping in ascending order.
+ 65
+ 66        These are also the `keys` of the mapping.
+ 67        Prefer to use the name `outcomes`.
+ 68        """
+ 69        return self.keys()
+ 70
+ 71    @cached_property
+ 72    def _common_outcome_length(self) -> int | None:
+ 73        result = None
+ 74        for outcome in self.outcomes():
+ 75            if isinstance(outcome, Sized):
+ 76                if result is None:
+ 77                    result = len(outcome)
+ 78                elif len(outcome) != result:
+ 79                    return None
+ 80        return result
+ 81
+ 82    def common_outcome_length(self) -> int | None:
+ 83        """The common length of all outcomes.
+ 84
+ 85        If outcomes have no lengths or different lengths, the result is `None`.
+ 86        """
+ 87        return self._common_outcome_length
+ 88
+ 89    def is_empty(self) -> bool:
+ 90        """`True` iff this population has no outcomes. """
+ 91        return len(self) == 0
+ 92
+ 93    def min_outcome(self) -> T_co:
+ 94        """The least outcome."""
+ 95        return self.outcomes()[0]
+ 96
+ 97    def max_outcome(self) -> T_co:
+ 98        """The greatest outcome."""
+ 99        return self.outcomes()[-1]
+100
+101    def nearest_le(self, outcome) -> T_co | None:
+102        """The nearest outcome that is <= the argument.
+103
+104        Returns `None` if there is no such outcome.
+105        """
+106        if outcome in self:
+107            return outcome
+108        index = bisect.bisect_right(self.outcomes(), outcome) - 1
+109        if index < 0:
+110            return None
+111        return self.outcomes()[index]
+112
+113    def nearest_lt(self, outcome) -> T_co | None:
+114        """The nearest outcome that is < the argument.
+115
+116        Returns `None` if there is no such outcome.
+117        """
+118        index = bisect.bisect_left(self.outcomes(), outcome) - 1
+119        if index < 0:
+120            return None
+121        return self.outcomes()[index]
+122
+123    def nearest_ge(self, outcome) -> T_co | None:
+124        """The nearest outcome that is >= the argument.
+125
+126        Returns `None` if there is no such outcome.
+127        """
+128        if outcome in self:
+129            return outcome
+130        index = bisect.bisect_left(self.outcomes(), outcome)
+131        if index >= len(self):
+132            return None
+133        return self.outcomes()[index]
+134
+135    def nearest_gt(self, outcome) -> T_co | None:
+136        """The nearest outcome that is > the argument.
+137
+138        Returns `None` if there is no such outcome.
+139        """
+140        index = bisect.bisect_right(self.outcomes(), outcome)
+141        if index >= len(self):
+142            return None
+143        return self.outcomes()[index]
+144
+145    # Quantities.
+146
+147    def quantity(self, outcome: Hashable) -> int:
+148        """The quantity of a single outcome, or 0 if not present."""
+149        return self.get(outcome, 0)
+150
+151    @overload
+152    def quantities(self) -> CountsValuesView:
+153        ...
+154
+155    @overload
+156    def quantities(self, outcomes: Sequence) -> Sequence[int]:
+157        ...
+158
+159    def quantities(
+160            self,
+161            outcomes: Sequence | None = None
+162    ) -> CountsValuesView | Sequence[int]:
+163        """The quantities of the mapping in sorted order.
+164
+165        These are also the `values` of the mapping.
+166        Prefer to use the name `quantities`.
+167
+168        Args:
+169            outcomes: If provided, the quantities corresponding to these
+170                outcomes will be returned (or 0 if not present).
+171        """
+172        if outcomes is None:
+173            return self.values()
+174        else:
+175            return tuple(self.quantity(outcome) for outcome in outcomes)
+176
+177    @cached_property
+178    def _denominator(self) -> int:
+179        return sum(self.values())
+180
+181    def denominator(self) -> int:
+182        """The sum of all quantities (e.g. weights or duplicates).
+183
+184        For the number of unique outcomes, including those with zero quantity,
+185        use `len()`.
+186        """
+187        return self._denominator
+188
+189    # Quantities.
+190
+191    def scale_quantities(self: C, scale: int) -> C:
+192        """Scales all quantities by an integer."""
+193        if scale == 1:
+194            return self
+195        data = {outcome: quantity * scale for outcome, quantity in self.items()}
+196        return self._new_type(data)
+197
+198    def has_zero_quantities(self) -> bool:
+199        """`True` iff `self` contains at least one outcome with zero quantity. """
+200        return 0 in self.values()
+201
+202    def quantity_ne(self, outcome) -> int:
+203        """The quantity != a single outcome. """
+204        return self.denominator() - self.quantity(outcome)
+205
+206    @cached_property
+207    def _cumulative_quantities(self) -> Mapping[T_co, int]:
+208        result = {}
+209        cdf = 0
+210        for outcome, quantity in self.items():
+211            cdf += quantity
+212            result[outcome] = cdf
+213        return result
+214
+215    def quantity_le(self, outcome) -> int:
+216        """The quantity <= a single outcome."""
+217        outcome = self.nearest_le(outcome)
+218        if outcome is None:
+219            return 0
+220        else:
+221            return self._cumulative_quantities[outcome]
+222
+223    def quantity_lt(self, outcome) -> int:
+224        """The quantity < a single outcome."""
+225        outcome = self.nearest_lt(outcome)
+226        if outcome is None:
+227            return 0
+228        else:
+229            return self._cumulative_quantities[outcome]
+230
+231    def quantity_ge(self, outcome) -> int:
+232        """The quantity >= a single outcome."""
+233        return self.denominator() - self.quantity_lt(outcome)
+234
+235    def quantity_gt(self, outcome) -> int:
+236        """The quantity > a single outcome."""
+237        return self.denominator() - self.quantity_le(outcome)
+238
+239    @cached_property
+240    def _quantities_le(self) -> Sequence[int]:
+241        return tuple(itertools.accumulate(self.values()))
+242
+243    def quantities_le(self, outcomes: Sequence | None = None) -> Sequence[int]:
+244        """The quantity <= each outcome in order.
+245
+246        Args:
+247            outcomes: If provided, the quantities corresponding to these
+248                outcomes will be returned (or 0 if not present).
+249        """
+250        if outcomes is None:
+251            return self._quantities_le
+252        else:
+253            return tuple(self.quantity_le(x) for x in outcomes)
+254
+255    @cached_property
+256    def _quantities_ge(self) -> Sequence[int]:
+257        return tuple(
+258            itertools.accumulate(self.values()[:-1],
+259                                 operator.sub,
+260                                 initial=self.denominator()))
+261
+262    def quantities_ge(self, outcomes: Sequence | None = None) -> Sequence[int]:
+263        """The quantity >= each outcome in order.
+264
+265        Args:
+266            outcomes: If provided, the quantities corresponding to these
+267                outcomes will be returned (or 0 if not present).
+268        """
+269        if outcomes is None:
+270            return self._quantities_ge
+271        else:
+272            return tuple(self.quantity_ge(x) for x in outcomes)
+273
+274    def quantities_lt(self, outcomes: Sequence | None = None) -> Sequence[int]:
+275        """The quantity < each outcome in order.
+276
+277        Args:
+278            outcomes: If provided, the quantities corresponding to these
+279                outcomes will be returned (or 0 if not present).
+280        """
+281        return tuple(
+282            self.denominator() - x for x in self.quantities_ge(outcomes))
+283
+284    def quantities_gt(self, outcomes: Sequence | None = None) -> Sequence[int]:
+285        """The quantity > each outcome in order.
+286
+287        Args:
+288            outcomes: If provided, the quantities corresponding to these
+289                outcomes will be returned (or 0 if not present).
+290        """
+291        return tuple(
+292            self.denominator() - x for x in self.quantities_le(outcomes))
+293
+294    # Probabilities.
+295
+296    def probability(self, outcome: Hashable) -> Fraction:
+297        """The probability of a single outcome, or 0.0 if not present. """
+298        return Fraction(self.quantity(outcome), self.denominator())
+299
+300    def probability_le(self, outcome: Hashable) -> Fraction:
+301        """The probability <= a single outcome. """
+302        return Fraction(self.quantity_le(outcome), self.denominator())
+303
+304    def probability_lt(self, outcome: Hashable) -> Fraction:
+305        """The probability < a single outcome. """
+306        return Fraction(self.quantity_lt(outcome), self.denominator())
+307
+308    def probability_ge(self, outcome: Hashable) -> Fraction:
+309        """The probability >= a single outcome. """
+310        return Fraction(self.quantity_ge(outcome), self.denominator())
+311
+312    def probability_gt(self, outcome: Hashable) -> Fraction:
+313        """The probability > a single outcome. """
+314        return Fraction(self.quantity_gt(outcome), self.denominator())
+315
+316    @cached_property
+317    def _probabilities(self) -> Sequence[Fraction]:
+318        return tuple(Fraction(v, self.denominator()) for v in self.values())
+319
+320    @overload
+321    def probabilities(self,
+322                      outcomes: Sequence | None = None,
+323                      *,
+324                      percent: Literal[False]) -> Sequence[Fraction]:
+325        ...
+326
+327    @overload
+328    def probabilities(self,
+329                      outcomes: Sequence | None = None,
+330                      *,
+331                      percent: Literal[True]) -> Sequence[float]:
+332        ...
+333
+334    @overload
+335    def probabilities(self,
+336                      outcomes: Sequence | None = None) -> Sequence[Fraction]:
+337        ...
+338
+339    def probabilities(
+340            self,
+341            outcomes: Sequence | None = None,
+342            *,
+343            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+344        """The probability of each outcome in order.
+345
+346        Also known as the probability mass function (PMF).
+347
+348        Args:
+349            outcomes: If provided, the probabilities corresponding to these
+350                outcomes will be returned (or 0 if not present).
+351            percent: If set, the results will be in percent 
+352                (i.e. total of 100.0) and the values are `float`s.
+353                Otherwise, the total will be 1 and the values are `Fraction`s.
+354        """
+355        if outcomes is None:
+356            result = self._probabilities
+357        else:
+358            result = tuple(self.probability(x) for x in outcomes)
+359
+360        if percent:
+361            return tuple(100.0 * x for x in result)
+362        else:
+363            return result
+364
+365    @cached_property
+366    def _probabilities_le(self) -> Sequence[Fraction]:
+367        return tuple(
+368            Fraction(quantity, self.denominator())
+369            for quantity in self.quantities_le())
+370
+371    @overload
+372    def probabilities_le(self,
+373                         outcomes: Sequence | None = None,
+374                         *,
+375                         percent: Literal[False]) -> Sequence[Fraction]:
+376        ...
+377
+378    @overload
+379    def probabilities_le(self,
+380                         outcomes: Sequence | None = None,
+381                         *,
+382                         percent: Literal[True]) -> Sequence[float]:
+383        ...
+384
+385    @overload
+386    def probabilities_le(self,
+387                         outcomes: Sequence |
+388                         None = None) -> Sequence[Fraction]:
+389        ...
+390
+391    def probabilities_le(
+392            self,
+393            outcomes: Sequence | None = None,
+394            *,
+395            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+396        """The probability of rolling <= each outcome in order.
+397
+398        Also known as the cumulative distribution function (CDF),
+399        though this term is ambigiuous whether it is < or <=.
+400
+401        Args:
+402            outcomes: If provided, the probabilities corresponding to these
+403                outcomes will be returned (or 0 if not present).
+404            percent: If set, the results will be in percent 
+405                (i.e. total of 100.0) and the values are `float`s.
+406                Otherwise, the total will be 1 and the values are `Fraction`s.
+407        """
+408        if outcomes is None:
+409            result = self._probabilities_le
+410        else:
+411            result = tuple(self.probability_le(x) for x in outcomes)
+412
+413        if percent:
+414            return tuple(100.0 * x for x in result)
+415        else:
+416            return result
+417
+418    @cached_property
+419    def _probabilities_ge(self) -> Sequence[Fraction]:
+420        return tuple(
+421            Fraction(quantity, self.denominator())
+422            for quantity in self.quantities_ge())
+423
+424    @overload
+425    def probabilities_ge(self,
+426                         outcomes: Sequence | None = None,
+427                         *,
+428                         percent: Literal[False]) -> Sequence[Fraction]:
+429        ...
+430
+431    @overload
+432    def probabilities_ge(self,
+433                         outcomes: Sequence | None = None,
+434                         *,
+435                         percent: Literal[True]) -> Sequence[float]:
+436        ...
+437
+438    @overload
+439    def probabilities_ge(self,
+440                         outcomes: Sequence |
+441                         None = None) -> Sequence[Fraction]:
+442        ...
+443
+444    def probabilities_ge(
+445            self,
+446            outcomes: Sequence | None = None,
+447            *,
+448            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+449        """The probability of rolling >= each outcome in order.
+450
+451        Also known as the survival function (SF) or
+452        complementary cumulative distribution function (CCDF),
+453        though these term are ambigiuous whether they are is > or >=.
+454
+455        Args:
+456            outcomes: If provided, the probabilities corresponding to these
+457                outcomes will be returned (or 0 if not present).
+458            percent: If set, the results will be in percent 
+459                (i.e. total of 100.0) and the values are `float`s.
+460                Otherwise, the total will be 1 and the values are `Fraction`s.
+461        """
+462        if outcomes is None:
+463            result = self._probabilities_ge
+464        else:
+465            result = tuple(self.probability_ge(x) for x in outcomes)
+466
+467        if percent:
+468            return tuple(100.0 * x for x in result)
+469        else:
+470            return result
+471
+472    @overload
+473    def probabilities_lt(self,
+474                         outcomes: Sequence | None = None,
+475                         *,
+476                         percent: Literal[False]) -> Sequence[Fraction]:
+477        ...
+478
+479    @overload
+480    def probabilities_lt(self,
+481                         outcomes: Sequence | None = None,
+482                         *,
+483                         percent: Literal[True]) -> Sequence[float]:
+484        ...
+485
+486    @overload
+487    def probabilities_lt(self,
+488                         outcomes: Sequence |
+489                         None = None) -> Sequence[Fraction]:
+490        ...
+491
+492    def probabilities_lt(
+493            self,
+494            outcomes: Sequence | None = None,
+495            *,
+496            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+497        """The probability of rolling < each outcome in order.
+498
+499        Args:
+500            outcomes: If provided, the probabilities corresponding to these
+501                outcomes will be returned (or 0 if not present).
+502            percent: If set, the results will be in percent 
+503                (i.e. total of 100.0) and the values are `float`s.
+504                Otherwise, the total will be 1 and the values are `Fraction`s.
+505        """
+506        if outcomes is None:
+507            result = tuple(1 - x for x in self._probabilities_ge)
+508        else:
+509            result = tuple(1 - self.probability_ge(x) for x in outcomes)
+510
+511        if percent:
+512            return tuple(100.0 * x for x in result)
+513        else:
+514            return result
+515
+516    @overload
+517    def probabilities_gt(self,
+518                         outcomes: Sequence | None = None,
+519                         *,
+520                         percent: Literal[False]) -> Sequence[Fraction]:
+521        ...
+522
+523    @overload
+524    def probabilities_gt(self,
+525                         outcomes: Sequence | None = None,
+526                         *,
+527                         percent: Literal[True]) -> Sequence[float]:
+528        ...
+529
+530    @overload
+531    def probabilities_gt(self,
+532                         outcomes: Sequence |
+533                         None = None) -> Sequence[Fraction]:
+534        ...
+535
+536    def probabilities_gt(
+537            self,
+538            outcomes: Sequence | None = None,
+539            *,
+540            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+541        """The probability of rolling > each outcome in order.
+542
+543        Args:
+544            outcomes: If provided, the probabilities corresponding to these
+545                outcomes will be returned (or 0 if not present).
+546            percent: If set, the results will be in percent 
+547                (i.e. total of 100.0) and the values are `float`s.
+548                Otherwise, the total will be 1 and the values are `Fraction`s.
+549        """
+550        if outcomes is None:
+551            result = tuple(1 - x for x in self._probabilities_le)
+552        else:
+553            result = tuple(1 - self.probability_le(x) for x in outcomes)
+554
+555        if percent:
+556            return tuple(100.0 * x for x in result)
+557        else:
+558            return result
+559
+560    # Scalar statistics.
+561
+562    def mode(self) -> tuple:
+563        """A tuple containing the most common outcome(s) of the population.
+564
+565        These are sorted from lowest to highest.
+566        """
+567        return tuple(outcome for outcome, quantity in self.items()
+568                     if quantity == self.modal_quantity())
+569
+570    def modal_quantity(self) -> int:
+571        """The highest quantity of any single outcome. """
+572        return max(self.quantities())
+573
+574    def kolmogorov_smirnov(self, other) -> Fraction:
+575        """Kolmogorov–Smirnov statistic. The maximum absolute difference between CDFs. """
+576        a, b = icepool.align(self, other)
+577        return max(
+578            abs(a - b)
+579            for a, b in zip(a.probabilities_le(), b.probabilities_le()))
+580
+581    def cramer_von_mises(self, other) -> Fraction:
+582        """Cramér-von Mises statistic. The sum-of-squares difference between CDFs. """
+583        a, b = icepool.align(self, other)
+584        return sum(
+585            ((a - b)**2
+586             for a, b in zip(a.probabilities_le(), b.probabilities_le())),
+587            start=Fraction(0, 1))
+588
+589    def median(self):
+590        """The median, taking the mean in case of a tie.
+591
+592        This will fail if the outcomes do not support division;
+593        in this case, use `median_low` or `median_high` instead.
+594        """
+595        return self.quantile(1, 2)
+596
+597    def median_low(self) -> T_co:
+598        """The median, taking the lower in case of a tie."""
+599        return self.quantile_low(1, 2)
+600
+601    def median_high(self) -> T_co:
+602        """The median, taking the higher in case of a tie."""
+603        return self.quantile_high(1, 2)
+604
+605    def quantile(self, n: int, d: int = 100):
+606        """The outcome `n / d` of the way through the CDF, taking the mean in case of a tie.
+607
+608        This will fail if the outcomes do not support addition and division;
+609        in this case, use `quantile_low` or `quantile_high` instead.
+610        """
+611        # Should support addition and division.
+612        return (self.quantile_low(n, d) +
+613                self.quantile_high(n, d)) / 2  # type: ignore
+614
+615    def quantile_low(self, n: int, d: int = 100) -> T_co:
+616        """The outcome `n / d` of the way through the CDF, taking the lesser in case of a tie."""
+617        index = bisect.bisect_left(self.quantities_le(),
+618                                   (n * self.denominator() + d - 1) // d)
+619        if index >= len(self):
+620            return self.max_outcome()
+621        return self.outcomes()[index]
+622
+623    def quantile_high(self, n: int, d: int = 100) -> T_co:
+624        """The outcome `n / d` of the way through the CDF, taking the greater in case of a tie."""
+625        index = bisect.bisect_right(self.quantities_le(),
+626                                    n * self.denominator() // d)
+627        if index >= len(self):
+628            return self.max_outcome()
+629        return self.outcomes()[index]
+630
+631    @overload
+632    def mean(self: 'Population[numbers.Rational]') -> Fraction:
+633        ...
+634
+635    @overload
+636    def mean(self: 'Population[float]') -> float:
+637        ...
+638
+639    def mean(
+640        self: 'Population[numbers.Rational] | Population[float]'
+641    ) -> Fraction | float:
+642        return try_fraction(
+643            sum(outcome * quantity for outcome, quantity in self.items()),
+644            self.denominator())
+645
+646    @overload
+647    def variance(self: 'Population[numbers.Rational]') -> Fraction:
+648        ...
+649
+650    @overload
+651    def variance(self: 'Population[float]') -> float:
+652        ...
+653
+654    def variance(
+655        self: 'Population[numbers.Rational] | Population[float]'
+656    ) -> Fraction | float:
+657        """This is the population variance, not the sample variance."""
+658        mean = self.mean()
+659        mean_of_squares = try_fraction(
+660            sum(quantity * outcome**2 for outcome, quantity in self.items()),
+661            self.denominator())
+662        return mean_of_squares - mean * mean
+663
+664    def standard_deviation(
+665            self: 'Population[numbers.Rational] | Population[float]') -> float:
+666        return math.sqrt(self.variance())
+667
+668    sd = standard_deviation
+669
+670    def standardized_moment(
+671            self: 'Population[numbers.Rational] | Population[float]',
+672            k: int) -> float:
+673        sd = self.standard_deviation()
+674        mean = self.mean()
+675        ev = sum(p * (outcome - mean)**k  # type: ignore 
+676                 for outcome, p in zip(self.outcomes(), self.probabilities()))
+677        return ev / (sd**k)
+678
+679    def skewness(
+680            self: 'Population[numbers.Rational] | Population[float]') -> float:
+681        return self.standardized_moment(3)
+682
+683    def excess_kurtosis(
+684            self: 'Population[numbers.Rational] | Population[float]') -> float:
+685        return self.standardized_moment(4) - 3.0
+686
+687    def entropy(self, base: float = 2.0) -> float:
+688        """The entropy of a random sample from this population.
+689        
+690        Args:
+691            base: The logarithm base to use. Default is 2.0, which gives the 
+692                entropy in bits.
+693        """
+694        return -sum(
+695            p * math.log(p, base) for p in self.probabilities() if p > 0.0)
+696
+697    # Joint statistics.
+698
+699    class _Marginals(Sequence):
+700        """Helper class for implementing `marginals()`."""
+701
+702        def __init__(self, population, /):
+703            self._population = population
+704
+705        def __len__(self) -> int:
+706            """The minimum len() of all outcomes."""
+707            return min(len(x) for x in self._population.outcomes())
+708
+709        def __getitem__(self, dims: int | slice, /):
+710            """Marginalizes the given dimensions."""
+711            return self._population._unary_operator(operator.getitem, dims)
+712
+713    @property
+714    def marginals(self):
+715        """A property that applies the `[]` operator to outcomes.
+716
+717        For example, `population.marginals[:2]` will marginalize the first two
+718        elements of the outcomes.
+719        """
+720        return Population._Marginals(self)
+721
+722    @overload
+723    def covariance(self: 'Population[tuple[numbers.Rational, ...]]', i: int,
+724                   j: int) -> Fraction:
+725        ...
+726
+727    @overload
+728    def covariance(self: 'Population[tuple[float, ...]]', i: int,
+729                   j: int) -> float:
+730        ...
+731
+732    def covariance(
+733            self:
+734        'Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]]',
+735            i: int, j: int) -> Fraction | float:
+736        mean_i = self.marginals[i].mean()
+737        mean_j = self.marginals[j].mean()
+738        return try_fraction(
+739            sum((outcome[i] - mean_i) * (outcome[j] - mean_j) * quantity
+740                for outcome, quantity in self.items()), self.denominator())
+741
+742    def correlation(
+743            self:
+744        'Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]]',
+745            i: int, j: int) -> float:
+746        sd_i = self.marginals[i].standard_deviation()
+747        sd_j = self.marginals[j].standard_deviation()
+748        return self.covariance(i, j) / (sd_i * sd_j)
+749
+750    def sample(self) -> T_co:
+751        """A single random sample from this population.
+752
+753        Note that this is always "with replacement" even for `Deck` since
+754        instances are immutable.
+755
+756        This uses the standard `random` package and is not cryptographically
+757        secure.
+758        """
+759        # We don't use random.choices since that is based on floats rather than ints.
+760        r = random.randrange(self.denominator())
+761        index = bisect.bisect_right(self.quantities_le(), r)
+762        return self.outcomes()[index]
+763
+764    def format(self, format_spec: str, /, **kwargs) -> str:
+765        """Formats this mapping as a string.
+766
+767        `format_spec` should start with the output format,
+768        which can be:
+769        * `md` for Markdown (default)
+770        * `bbcode` for BBCode
+771        * `csv` for comma-separated values
+772        * `html` for HTML
+773
+774        After this, you may optionally add a `:` followed by a series of
+775        requested columns. Allowed columns are:
+776
+777        * `o`: Outcomes.
+778        * `*o`: Outcomes, unpacked if applicable.
+779        * `q==`, `q<=`, `q>=`: Quantities ==, <=, or >= each outcome.
+780        * `p==`, `p<=`, `p>=`: Probabilities (0-1) ==, <=, or >= each outcome.
+781        * `%==`, `%<=`, `%>=`: Probabilities (0%-100%) ==, <=, or >= each outcome.
+782
+783        Columns may optionally be separated using `|` characters.
+784
+785        The default columns are `*o|q==|%==`, which are the unpacked outcomes,
+786        the quantities, and the probabilities. The quantities are omitted from
+787        the default columns if any individual quantity is 10**30 or greater.
+788        """
+789        if not self.is_empty() and self.modal_quantity() < 10**30:
+790            default_column_spec = '*oq==%=='
+791        else:
+792            default_column_spec = '*o%=='
+793        if len(format_spec) == 0:
+794            format_spec = 'md:' + default_column_spec
+795
+796        format_spec = format_spec.replace('|', '')
+797
+798        parts = format_spec.split(':')
+799
+800        if len(parts) == 1:
+801            output_format = parts[0]
+802            col_spec = default_column_spec
+803        elif len(parts) == 2:
+804            output_format = parts[0]
+805            col_spec = parts[1]
+806        else:
+807            raise ValueError('format_spec has too many colons.')
+808
+809        if output_format == 'md':
+810            return icepool.population.format.markdown(self, col_spec)
+811        elif output_format == 'bbcode':
+812            return icepool.population.format.bbcode(self, col_spec)
+813        elif output_format == 'csv':
+814            return icepool.population.format.csv(self, col_spec, **kwargs)
+815        elif output_format == 'html':
+816            return icepool.population.format.html(self, col_spec)
+817        else:
+818            raise ValueError(f"Unsupported output format '{output_format}'")
+819
+820    def __format__(self, format_spec: str, /) -> str:
+821        return self.format(format_spec)
+822
+823    def __str__(self) -> str:
+824        return f'{self}'
+
+ + +

A mapping from outcomes to int quantities.

+ +

Outcomes with each instance must be hashable and totally orderable.

+ +

Subclasses include Die and Deck.

+
+ + +
+ +
+
@abstractmethod
+ + def + keys(self) -> CountsKeysView[+T_co]: + + + +
+ + 
42    @abstractmethod
+43    def keys(self) -> CountsKeysView[T_co]:
+44        """The outcomes within the population in sorted order."""
+
+ + +

The outcomes within the population in sorted order.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + values(self) -> CountsValuesView: + + + +
+ + 
46    @abstractmethod
+47    def values(self) -> CountsValuesView:
+48        """The quantities within the population in outcome order."""
+
+ + +

The quantities within the population in outcome order.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + items(self) -> CountsItemsView[+T_co]: + + + +
+ + 
50    @abstractmethod
+51    def items(self) -> CountsItemsView[T_co]:
+52        """The (outcome, quantity)s of the population in sorted order."""
+
+ + +

The (outcome, quantity)s of the population in sorted order.

+
+ + +
+
+ +
+ + def + outcomes(self) -> CountsKeysView[+T_co]: + + + +
+ + 
63    def outcomes(self) -> CountsKeysView[T_co]:
+64        """The outcomes of the mapping in ascending order.
+65
+66        These are also the `keys` of the mapping.
+67        Prefer to use the name `outcomes`.
+68        """
+69        return self.keys()
+
+ + +

The outcomes of the mapping in ascending order.

+ +

These are also the keys of the mapping. +Prefer to use the name outcomes.

+
+ + +
+
+ +
+ + def + common_outcome_length(self) -> int | None: + + + +
+ + 
82    def common_outcome_length(self) -> int | None:
+83        """The common length of all outcomes.
+84
+85        If outcomes have no lengths or different lengths, the result is `None`.
+86        """
+87        return self._common_outcome_length
+
+ + +

The common length of all outcomes.

+ +

If outcomes have no lengths or different lengths, the result is None.

+
+ + +
+
+ +
+ + def + is_empty(self) -> bool: + + + +
+ + 
89    def is_empty(self) -> bool:
+90        """`True` iff this population has no outcomes. """
+91        return len(self) == 0
+
+ + +

True iff this population has no outcomes.

+
+ + +
+
+ +
+ + def + min_outcome(self) -> +T_co: + + + +
+ + 
93    def min_outcome(self) -> T_co:
+94        """The least outcome."""
+95        return self.outcomes()[0]
+
+ + +

The least outcome.

+
+ + +
+
+ +
+ + def + max_outcome(self) -> +T_co: + + + +
+ + 
97    def max_outcome(self) -> T_co:
+98        """The greatest outcome."""
+99        return self.outcomes()[-1]
+
+ + +

The greatest outcome.

+
+ + +
+
+ +
+ + def + nearest_le(self, outcome) -> Optional[+T_co]: + + + +
+ + 
101    def nearest_le(self, outcome) -> T_co | None:
+102        """The nearest outcome that is <= the argument.
+103
+104        Returns `None` if there is no such outcome.
+105        """
+106        if outcome in self:
+107            return outcome
+108        index = bisect.bisect_right(self.outcomes(), outcome) - 1
+109        if index < 0:
+110            return None
+111        return self.outcomes()[index]
+
+ + +

The nearest outcome that is <= the argument.

+ +

Returns None if there is no such outcome.

+
+ + +
+
+ +
+ + def + nearest_lt(self, outcome) -> Optional[+T_co]: + + + +
+ + 
113    def nearest_lt(self, outcome) -> T_co | None:
+114        """The nearest outcome that is < the argument.
+115
+116        Returns `None` if there is no such outcome.
+117        """
+118        index = bisect.bisect_left(self.outcomes(), outcome) - 1
+119        if index < 0:
+120            return None
+121        return self.outcomes()[index]
+
+ + +

The nearest outcome that is < the argument.

+ +

Returns None if there is no such outcome.

+
+ + +
+
+ +
+ + def + nearest_ge(self, outcome) -> Optional[+T_co]: + + + +
+ + 
123    def nearest_ge(self, outcome) -> T_co | None:
+124        """The nearest outcome that is >= the argument.
+125
+126        Returns `None` if there is no such outcome.
+127        """
+128        if outcome in self:
+129            return outcome
+130        index = bisect.bisect_left(self.outcomes(), outcome)
+131        if index >= len(self):
+132            return None
+133        return self.outcomes()[index]
+
+ + +

The nearest outcome that is >= the argument.

+ +

Returns None if there is no such outcome.

+
+ + +
+
+ +
+ + def + nearest_gt(self, outcome) -> Optional[+T_co]: + + + +
+ + 
135    def nearest_gt(self, outcome) -> T_co | None:
+136        """The nearest outcome that is > the argument.
+137
+138        Returns `None` if there is no such outcome.
+139        """
+140        index = bisect.bisect_right(self.outcomes(), outcome)
+141        if index >= len(self):
+142            return None
+143        return self.outcomes()[index]
+
+ + +

The nearest outcome that is > the argument.

+ +

Returns None if there is no such outcome.

+
+ + +
+
+ +
+ + def + quantity(self, outcome: Hashable) -> int: + + + +
+ + 
147    def quantity(self, outcome: Hashable) -> int:
+148        """The quantity of a single outcome, or 0 if not present."""
+149        return self.get(outcome, 0)
+
+ + +

The quantity of a single outcome, or 0 if not present.

+
+ + +
+
+ +
+ + def + quantities( self, outcomes: Optional[Sequence] = None) -> Union[CountsValuesView, Sequence[int]]: + + + +
+ + 
159    def quantities(
+160            self,
+161            outcomes: Sequence | None = None
+162    ) -> CountsValuesView | Sequence[int]:
+163        """The quantities of the mapping in sorted order.
+164
+165        These are also the `values` of the mapping.
+166        Prefer to use the name `quantities`.
+167
+168        Args:
+169            outcomes: If provided, the quantities corresponding to these
+170                outcomes will be returned (or 0 if not present).
+171        """
+172        if outcomes is None:
+173            return self.values()
+174        else:
+175            return tuple(self.quantity(outcome) for outcome in outcomes)
+
+ + +

The quantities of the mapping in sorted order.

+ +

These are also the values of the mapping. +Prefer to use the name quantities.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the quantities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
+
+ + +
+
+ +
+ + def + denominator(self) -> int: + + + +
+ + 
181    def denominator(self) -> int:
+182        """The sum of all quantities (e.g. weights or duplicates).
+183
+184        For the number of unique outcomes, including those with zero quantity,
+185        use `len()`.
+186        """
+187        return self._denominator
+
+ + +

The sum of all quantities (e.g. weights or duplicates).

+ +

For the number of unique outcomes, including those with zero quantity, +use len().

+
+ + +
+
+ +
+ + def + scale_quantities(self: ~C, scale: int) -> ~C: + + + +
+ + 
191    def scale_quantities(self: C, scale: int) -> C:
+192        """Scales all quantities by an integer."""
+193        if scale == 1:
+194            return self
+195        data = {outcome: quantity * scale for outcome, quantity in self.items()}
+196        return self._new_type(data)
+
+ + +

Scales all quantities by an integer.

+
+ + +
+
+ +
+ + def + has_zero_quantities(self) -> bool: + + + +
+ + 
198    def has_zero_quantities(self) -> bool:
+199        """`True` iff `self` contains at least one outcome with zero quantity. """
+200        return 0 in self.values()
+
+ + +

True iff self contains at least one outcome with zero quantity.

+
+ + +
+
+ +
+ + def + quantity_ne(self, outcome) -> int: + + + +
+ + 
202    def quantity_ne(self, outcome) -> int:
+203        """The quantity != a single outcome. """
+204        return self.denominator() - self.quantity(outcome)
+
+ + +

The quantity != a single outcome.

+
+ + +
+
+ +
+ + def + quantity_le(self, outcome) -> int: + + + +
+ + 
215    def quantity_le(self, outcome) -> int:
+216        """The quantity <= a single outcome."""
+217        outcome = self.nearest_le(outcome)
+218        if outcome is None:
+219            return 0
+220        else:
+221            return self._cumulative_quantities[outcome]
+
+ + +

The quantity <= a single outcome.

+
+ + +
+
+ +
+ + def + quantity_lt(self, outcome) -> int: + + + +
+ + 
223    def quantity_lt(self, outcome) -> int:
+224        """The quantity < a single outcome."""
+225        outcome = self.nearest_lt(outcome)
+226        if outcome is None:
+227            return 0
+228        else:
+229            return self._cumulative_quantities[outcome]
+
+ + +

The quantity < a single outcome.

+
+ + +
+
+ +
+ + def + quantity_ge(self, outcome) -> int: + + + +
+ + 
231    def quantity_ge(self, outcome) -> int:
+232        """The quantity >= a single outcome."""
+233        return self.denominator() - self.quantity_lt(outcome)
+
+ + +

The quantity >= a single outcome.

+
+ + +
+
+ +
+ + def + quantity_gt(self, outcome) -> int: + + + +
+ + 
235    def quantity_gt(self, outcome) -> int:
+236        """The quantity > a single outcome."""
+237        return self.denominator() - self.quantity_le(outcome)
+
+ + +

The quantity > a single outcome.

+
+ + +
+
+ +
+ + def + quantities_le(self, outcomes: Optional[Sequence] = None) -> Sequence[int]: + + + +
+ + 
243    def quantities_le(self, outcomes: Sequence | None = None) -> Sequence[int]:
+244        """The quantity <= each outcome in order.
+245
+246        Args:
+247            outcomes: If provided, the quantities corresponding to these
+248                outcomes will be returned (or 0 if not present).
+249        """
+250        if outcomes is None:
+251            return self._quantities_le
+252        else:
+253            return tuple(self.quantity_le(x) for x in outcomes)
+
+ + +

The quantity <= each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the quantities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
+
+ + +
+
+ +
+ + def + quantities_ge(self, outcomes: Optional[Sequence] = None) -> Sequence[int]: + + + +
+ + 
262    def quantities_ge(self, outcomes: Sequence | None = None) -> Sequence[int]:
+263        """The quantity >= each outcome in order.
+264
+265        Args:
+266            outcomes: If provided, the quantities corresponding to these
+267                outcomes will be returned (or 0 if not present).
+268        """
+269        if outcomes is None:
+270            return self._quantities_ge
+271        else:
+272            return tuple(self.quantity_ge(x) for x in outcomes)
+
+ + +

The quantity >= each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the quantities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
+
+ + +
+
+ +
+ + def + quantities_lt(self, outcomes: Optional[Sequence] = None) -> Sequence[int]: + + + +
+ + 
274    def quantities_lt(self, outcomes: Sequence | None = None) -> Sequence[int]:
+275        """The quantity < each outcome in order.
+276
+277        Args:
+278            outcomes: If provided, the quantities corresponding to these
+279                outcomes will be returned (or 0 if not present).
+280        """
+281        return tuple(
+282            self.denominator() - x for x in self.quantities_ge(outcomes))
+
+ + +

The quantity < each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the quantities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
+
+ + +
+
+ +
+ + def + quantities_gt(self, outcomes: Optional[Sequence] = None) -> Sequence[int]: + + + +
+ + 
284    def quantities_gt(self, outcomes: Sequence | None = None) -> Sequence[int]:
+285        """The quantity > each outcome in order.
+286
+287        Args:
+288            outcomes: If provided, the quantities corresponding to these
+289                outcomes will be returned (or 0 if not present).
+290        """
+291        return tuple(
+292            self.denominator() - x for x in self.quantities_le(outcomes))
+
+ + +

The quantity > each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the quantities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
+
+ + +
+
+ +
+ + def + probability(self, outcome: Hashable) -> fractions.Fraction: + + + +
+ + 
296    def probability(self, outcome: Hashable) -> Fraction:
+297        """The probability of a single outcome, or 0.0 if not present. """
+298        return Fraction(self.quantity(outcome), self.denominator())
+
+ + +

The probability of a single outcome, or 0.0 if not present.

+
+ + +
+
+ +
+ + def + probability_le(self, outcome: Hashable) -> fractions.Fraction: + + + +
+ + 
300    def probability_le(self, outcome: Hashable) -> Fraction:
+301        """The probability <= a single outcome. """
+302        return Fraction(self.quantity_le(outcome), self.denominator())
+
+ + +

The probability <= a single outcome.

+
+ + +
+
+ +
+ + def + probability_lt(self, outcome: Hashable) -> fractions.Fraction: + + + +
+ + 
304    def probability_lt(self, outcome: Hashable) -> Fraction:
+305        """The probability < a single outcome. """
+306        return Fraction(self.quantity_lt(outcome), self.denominator())
+
+ + +

The probability < a single outcome.

+
+ + +
+
+ +
+ + def + probability_ge(self, outcome: Hashable) -> fractions.Fraction: + + + +
+ + 
308    def probability_ge(self, outcome: Hashable) -> Fraction:
+309        """The probability >= a single outcome. """
+310        return Fraction(self.quantity_ge(outcome), self.denominator())
+
+ + +

The probability >= a single outcome.

+
+ + +
+
+ +
+ + def + probability_gt(self, outcome: Hashable) -> fractions.Fraction: + + + +
+ + 
312    def probability_gt(self, outcome: Hashable) -> Fraction:
+313        """The probability > a single outcome. """
+314        return Fraction(self.quantity_gt(outcome), self.denominator())
+
+ + +

The probability > a single outcome.

+
+ + +
+
+ +
+ + def + probabilities( self, outcomes: Optional[Sequence] = None, *, percent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]: + + + +
+ + 
339    def probabilities(
+340            self,
+341            outcomes: Sequence | None = None,
+342            *,
+343            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+344        """The probability of each outcome in order.
+345
+346        Also known as the probability mass function (PMF).
+347
+348        Args:
+349            outcomes: If provided, the probabilities corresponding to these
+350                outcomes will be returned (or 0 if not present).
+351            percent: If set, the results will be in percent 
+352                (i.e. total of 100.0) and the values are `float`s.
+353                Otherwise, the total will be 1 and the values are `Fraction`s.
+354        """
+355        if outcomes is None:
+356            result = self._probabilities
+357        else:
+358            result = tuple(self.probability(x) for x in outcomes)
+359
+360        if percent:
+361            return tuple(100.0 * x for x in result)
+362        else:
+363            return result
+
+ + +

The probability of each outcome in order.

+ +

Also known as the probability mass function (PMF).

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the probabilities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
  • percent: If set, the results will be in percent +(i.e. total of 100.0) and the values are floats. +Otherwise, the total will be 1 and the values are Fractions.
    • +
+
+ + +
+
+ +
+ + def + probabilities_le( self, outcomes: Optional[Sequence] = None, *, percent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]: + + + +
+ + 
391    def probabilities_le(
+392            self,
+393            outcomes: Sequence | None = None,
+394            *,
+395            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+396        """The probability of rolling <= each outcome in order.
+397
+398        Also known as the cumulative distribution function (CDF),
+399        though this term is ambigiuous whether it is < or <=.
+400
+401        Args:
+402            outcomes: If provided, the probabilities corresponding to these
+403                outcomes will be returned (or 0 if not present).
+404            percent: If set, the results will be in percent 
+405                (i.e. total of 100.0) and the values are `float`s.
+406                Otherwise, the total will be 1 and the values are `Fraction`s.
+407        """
+408        if outcomes is None:
+409            result = self._probabilities_le
+410        else:
+411            result = tuple(self.probability_le(x) for x in outcomes)
+412
+413        if percent:
+414            return tuple(100.0 * x for x in result)
+415        else:
+416            return result
+
+ + +

The probability of rolling <= each outcome in order.

+ +

Also known as the cumulative distribution function (CDF), +though this term is ambigiuous whether it is < or <=.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the probabilities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
  • percent: If set, the results will be in percent +(i.e. total of 100.0) and the values are floats. +Otherwise, the total will be 1 and the values are Fractions.
    • +
+
+ + +
+
+ +
+ + def + probabilities_ge( self, outcomes: Optional[Sequence] = None, *, percent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]: + + + +
+ + 
444    def probabilities_ge(
+445            self,
+446            outcomes: Sequence | None = None,
+447            *,
+448            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+449        """The probability of rolling >= each outcome in order.
+450
+451        Also known as the survival function (SF) or
+452        complementary cumulative distribution function (CCDF),
+453        though these term are ambigiuous whether they are is > or >=.
+454
+455        Args:
+456            outcomes: If provided, the probabilities corresponding to these
+457                outcomes will be returned (or 0 if not present).
+458            percent: If set, the results will be in percent 
+459                (i.e. total of 100.0) and the values are `float`s.
+460                Otherwise, the total will be 1 and the values are `Fraction`s.
+461        """
+462        if outcomes is None:
+463            result = self._probabilities_ge
+464        else:
+465            result = tuple(self.probability_ge(x) for x in outcomes)
+466
+467        if percent:
+468            return tuple(100.0 * x for x in result)
+469        else:
+470            return result
+
+ + +

The probability of rolling >= each outcome in order.

+ +

Also known as the survival function (SF) or +complementary cumulative distribution function (CCDF), +though these term are ambigiuous whether they are is > or >=.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the probabilities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
  • percent: If set, the results will be in percent +(i.e. total of 100.0) and the values are floats. +Otherwise, the total will be 1 and the values are Fractions.
    • +
+
+ + +
+
+ +
+ + def + probabilities_lt( self, outcomes: Optional[Sequence] = None, *, percent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]: + + + +
+ + 
492    def probabilities_lt(
+493            self,
+494            outcomes: Sequence | None = None,
+495            *,
+496            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+497        """The probability of rolling < each outcome in order.
+498
+499        Args:
+500            outcomes: If provided, the probabilities corresponding to these
+501                outcomes will be returned (or 0 if not present).
+502            percent: If set, the results will be in percent 
+503                (i.e. total of 100.0) and the values are `float`s.
+504                Otherwise, the total will be 1 and the values are `Fraction`s.
+505        """
+506        if outcomes is None:
+507            result = tuple(1 - x for x in self._probabilities_ge)
+508        else:
+509            result = tuple(1 - self.probability_ge(x) for x in outcomes)
+510
+511        if percent:
+512            return tuple(100.0 * x for x in result)
+513        else:
+514            return result
+
+ + +

The probability of rolling < each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the probabilities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
  • percent: If set, the results will be in percent +(i.e. total of 100.0) and the values are floats. +Otherwise, the total will be 1 and the values are Fractions.
    • +
+
+ + +
+
+ +
+ + def + probabilities_gt( self, outcomes: Optional[Sequence] = None, *, percent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]: + + + +
+ + 
536    def probabilities_gt(
+537            self,
+538            outcomes: Sequence | None = None,
+539            *,
+540            percent: bool = False) -> Sequence[Fraction] | Sequence[float]:
+541        """The probability of rolling > each outcome in order.
+542
+543        Args:
+544            outcomes: If provided, the probabilities corresponding to these
+545                outcomes will be returned (or 0 if not present).
+546            percent: If set, the results will be in percent 
+547                (i.e. total of 100.0) and the values are `float`s.
+548                Otherwise, the total will be 1 and the values are `Fraction`s.
+549        """
+550        if outcomes is None:
+551            result = tuple(1 - x for x in self._probabilities_le)
+552        else:
+553            result = tuple(1 - self.probability_le(x) for x in outcomes)
+554
+555        if percent:
+556            return tuple(100.0 * x for x in result)
+557        else:
+558            return result
+
+ + +

The probability of rolling > each outcome in order.

+ +
Arguments:
+ +
    +
  • outcomes: If provided, the probabilities corresponding to these +outcomes will be returned (or 0 if not present).
    • +
  • percent: If set, the results will be in percent +(i.e. total of 100.0) and the values are floats. +Otherwise, the total will be 1 and the values are Fractions.
    • +
+
+ + +
+
+ +
+ + def + mode(self) -> tuple: + + + +
+ + 
562    def mode(self) -> tuple:
+563        """A tuple containing the most common outcome(s) of the population.
+564
+565        These are sorted from lowest to highest.
+566        """
+567        return tuple(outcome for outcome, quantity in self.items()
+568                     if quantity == self.modal_quantity())
+
+ + +

A tuple containing the most common outcome(s) of the population.

+ +

These are sorted from lowest to highest.

+
+ + +
+
+ +
+ + def + modal_quantity(self) -> int: + + + +
+ + 
570    def modal_quantity(self) -> int:
+571        """The highest quantity of any single outcome. """
+572        return max(self.quantities())
+
+ + +

The highest quantity of any single outcome.

+
+ + +
+
+ +
+ + def + kolmogorov_smirnov(self, other) -> fractions.Fraction: + + + +
+ + 
574    def kolmogorov_smirnov(self, other) -> Fraction:
+575        """Kolmogorov–Smirnov statistic. The maximum absolute difference between CDFs. """
+576        a, b = icepool.align(self, other)
+577        return max(
+578            abs(a - b)
+579            for a, b in zip(a.probabilities_le(), b.probabilities_le()))
+
+ + +

Kolmogorov–Smirnov statistic. The maximum absolute difference between CDFs.

+
+ + +
+
+ +
+ + def + cramer_von_mises(self, other) -> fractions.Fraction: + + + +
+ + 
581    def cramer_von_mises(self, other) -> Fraction:
+582        """Cramér-von Mises statistic. The sum-of-squares difference between CDFs. """
+583        a, b = icepool.align(self, other)
+584        return sum(
+585            ((a - b)**2
+586             for a, b in zip(a.probabilities_le(), b.probabilities_le())),
+587            start=Fraction(0, 1))
+
+ + +

Cramér-von Mises statistic. The sum-of-squares difference between CDFs.

+
+ + +
+
+ +
+ + def + median(self): + + + +
+ + 
589    def median(self):
+590        """The median, taking the mean in case of a tie.
+591
+592        This will fail if the outcomes do not support division;
+593        in this case, use `median_low` or `median_high` instead.
+594        """
+595        return self.quantile(1, 2)
+
+ + +

The median, taking the mean in case of a tie.

+ +

This will fail if the outcomes do not support division; +in this case, use median_low or median_high instead.

+
+ + +
+
+ +
+ + def + median_low(self) -> +T_co: + + + +
+ + 
597    def median_low(self) -> T_co:
+598        """The median, taking the lower in case of a tie."""
+599        return self.quantile_low(1, 2)
+
+ + +

The median, taking the lower in case of a tie.

+
+ + +
+
+ +
+ + def + median_high(self) -> +T_co: + + + +
+ + 
601    def median_high(self) -> T_co:
+602        """The median, taking the higher in case of a tie."""
+603        return self.quantile_high(1, 2)
+
+ + +

The median, taking the higher in case of a tie.

+
+ + +
+
+ +
+ + def + quantile(self, n: int, d: int = 100): + + + +
+ + 
605    def quantile(self, n: int, d: int = 100):
+606        """The outcome `n / d` of the way through the CDF, taking the mean in case of a tie.
+607
+608        This will fail if the outcomes do not support addition and division;
+609        in this case, use `quantile_low` or `quantile_high` instead.
+610        """
+611        # Should support addition and division.
+612        return (self.quantile_low(n, d) +
+613                self.quantile_high(n, d)) / 2  # type: ignore
+
+ + +

The outcome n / d of the way through the CDF, taking the mean in case of a tie.

+ +

This will fail if the outcomes do not support addition and division; +in this case, use quantile_low or quantile_high instead.

+
+ + +
+
+ +
+ + def + quantile_low(self, n: int, d: int = 100) -> +T_co: + + + +
+ + 
615    def quantile_low(self, n: int, d: int = 100) -> T_co:
+616        """The outcome `n / d` of the way through the CDF, taking the lesser in case of a tie."""
+617        index = bisect.bisect_left(self.quantities_le(),
+618                                   (n * self.denominator() + d - 1) // d)
+619        if index >= len(self):
+620            return self.max_outcome()
+621        return self.outcomes()[index]
+
+ + +

The outcome n / d of the way through the CDF, taking the lesser in case of a tie.

+
+ + +
+
+ +
+ + def + quantile_high(self, n: int, d: int = 100) -> +T_co: + + + +
+ + 
623    def quantile_high(self, n: int, d: int = 100) -> T_co:
+624        """The outcome `n / d` of the way through the CDF, taking the greater in case of a tie."""
+625        index = bisect.bisect_right(self.quantities_le(),
+626                                    n * self.denominator() // d)
+627        if index >= len(self):
+628            return self.max_outcome()
+629        return self.outcomes()[index]
+
+ + +

The outcome n / d of the way through the CDF, taking the greater in case of a tie.

+
+ + +
+
+ +
+ + def + mean( self: Population[numbers.Rational] | Population[float]) -> fractions.Fraction | float: + + + +
+ + 
639    def mean(
+640        self: 'Population[numbers.Rational] | Population[float]'
+641    ) -> Fraction | float:
+642        return try_fraction(
+643            sum(outcome * quantity for outcome, quantity in self.items()),
+644            self.denominator())
+
+ + + + +
+
+ +
+ + def + variance( self: Population[numbers.Rational] | Population[float]) -> fractions.Fraction | float: + + + +
+ + 
654    def variance(
+655        self: 'Population[numbers.Rational] | Population[float]'
+656    ) -> Fraction | float:
+657        """This is the population variance, not the sample variance."""
+658        mean = self.mean()
+659        mean_of_squares = try_fraction(
+660            sum(quantity * outcome**2 for outcome, quantity in self.items()),
+661            self.denominator())
+662        return mean_of_squares - mean * mean
+
+ + +

This is the population variance, not the sample variance.

+
+ + +
+
+ +
+ + def + standard_deviation( self: Population[numbers.Rational] | Population[float]) -> float: + + + +
+ + 
664    def standard_deviation(
+665            self: 'Population[numbers.Rational] | Population[float]') -> float:
+666        return math.sqrt(self.variance())
+
+ + + + +
+
+ +
+ + def + sd( self: Population[numbers.Rational] | Population[float]) -> float: + + + +
+ + 
664    def standard_deviation(
+665            self: 'Population[numbers.Rational] | Population[float]') -> float:
+666        return math.sqrt(self.variance())
+
+ + + + +
+
+ +
+ + def + standardized_moment( self: Population[numbers.Rational] | Population[float], k: int) -> float: + + + +
+ + 
670    def standardized_moment(
+671            self: 'Population[numbers.Rational] | Population[float]',
+672            k: int) -> float:
+673        sd = self.standard_deviation()
+674        mean = self.mean()
+675        ev = sum(p * (outcome - mean)**k  # type: ignore 
+676                 for outcome, p in zip(self.outcomes(), self.probabilities()))
+677        return ev / (sd**k)
+
+ + + + +
+
+ +
+ + def + skewness( self: Population[numbers.Rational] | Population[float]) -> float: + + + +
+ + 
679    def skewness(
+680            self: 'Population[numbers.Rational] | Population[float]') -> float:
+681        return self.standardized_moment(3)
+
+ + + + +
+
+ +
+ + def + excess_kurtosis( self: Population[numbers.Rational] | Population[float]) -> float: + + + +
+ + 
683    def excess_kurtosis(
+684            self: 'Population[numbers.Rational] | Population[float]') -> float:
+685        return self.standardized_moment(4) - 3.0
+
+ + + + +
+
+ +
+ + def + entropy(self, base: float = 2.0) -> float: + + + +
+ + 
687    def entropy(self, base: float = 2.0) -> float:
+688        """The entropy of a random sample from this population.
+689        
+690        Args:
+691            base: The logarithm base to use. Default is 2.0, which gives the 
+692                entropy in bits.
+693        """
+694        return -sum(
+695            p * math.log(p, base) for p in self.probabilities() if p > 0.0)
+
+ + +

The entropy of a random sample from this population.

+ +
Arguments:
+ +
    +
  • base: The logarithm base to use. Default is 2.0, which gives the +entropy in bits.
    • +
+
+ + +
+
+
+ marginals + + +
+ + +

A property that applies the [] operator to outcomes.

+ +

For example, population.marginals[:2] will marginalize the first two +elements of the outcomes.

+
+ + +
+
+ +
+ + def + covariance( self: Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]], i: int, j: int) -> fractions.Fraction | float: + + + +
+ + 
732    def covariance(
+733            self:
+734        'Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]]',
+735            i: int, j: int) -> Fraction | float:
+736        mean_i = self.marginals[i].mean()
+737        mean_j = self.marginals[j].mean()
+738        return try_fraction(
+739            sum((outcome[i] - mean_i) * (outcome[j] - mean_j) * quantity
+740                for outcome, quantity in self.items()), self.denominator())
+
+ + + + +
+
+ +
+ + def + correlation( self: Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]], i: int, j: int) -> float: + + + +
+ + 
742    def correlation(
+743            self:
+744        'Population[tuple[numbers.Rational, ...]] | Population[tuple[float, ...]]',
+745            i: int, j: int) -> float:
+746        sd_i = self.marginals[i].standard_deviation()
+747        sd_j = self.marginals[j].standard_deviation()
+748        return self.covariance(i, j) / (sd_i * sd_j)
+
+ + + + +
+
+ +
+ + def + sample(self) -> +T_co: + + + +
+ + 
750    def sample(self) -> T_co:
+751        """A single random sample from this population.
+752
+753        Note that this is always "with replacement" even for `Deck` since
+754        instances are immutable.
+755
+756        This uses the standard `random` package and is not cryptographically
+757        secure.
+758        """
+759        # We don't use random.choices since that is based on floats rather than ints.
+760        r = random.randrange(self.denominator())
+761        index = bisect.bisect_right(self.quantities_le(), r)
+762        return self.outcomes()[index]
+
+ + +

A single random sample from this population.

+ +

Note that this is always "with replacement" even for Deck since +instances are immutable.

+ +

This uses the standard random package and is not cryptographically +secure.

+
+ + +
+
+ +
+ + def + format(self, format_spec: str, /, **kwargs) -> str: + + + +
+ + 
764    def format(self, format_spec: str, /, **kwargs) -> str:
+765        """Formats this mapping as a string.
+766
+767        `format_spec` should start with the output format,
+768        which can be:
+769        * `md` for Markdown (default)
+770        * `bbcode` for BBCode
+771        * `csv` for comma-separated values
+772        * `html` for HTML
+773
+774        After this, you may optionally add a `:` followed by a series of
+775        requested columns. Allowed columns are:
+776
+777        * `o`: Outcomes.
+778        * `*o`: Outcomes, unpacked if applicable.
+779        * `q==`, `q<=`, `q>=`: Quantities ==, <=, or >= each outcome.
+780        * `p==`, `p<=`, `p>=`: Probabilities (0-1) ==, <=, or >= each outcome.
+781        * `%==`, `%<=`, `%>=`: Probabilities (0%-100%) ==, <=, or >= each outcome.
+782
+783        Columns may optionally be separated using `|` characters.
+784
+785        The default columns are `*o|q==|%==`, which are the unpacked outcomes,
+786        the quantities, and the probabilities. The quantities are omitted from
+787        the default columns if any individual quantity is 10**30 or greater.
+788        """
+789        if not self.is_empty() and self.modal_quantity() < 10**30:
+790            default_column_spec = '*oq==%=='
+791        else:
+792            default_column_spec = '*o%=='
+793        if len(format_spec) == 0:
+794            format_spec = 'md:' + default_column_spec
+795
+796        format_spec = format_spec.replace('|', '')
+797
+798        parts = format_spec.split(':')
+799
+800        if len(parts) == 1:
+801            output_format = parts[0]
+802            col_spec = default_column_spec
+803        elif len(parts) == 2:
+804            output_format = parts[0]
+805            col_spec = parts[1]
+806        else:
+807            raise ValueError('format_spec has too many colons.')
+808
+809        if output_format == 'md':
+810            return icepool.population.format.markdown(self, col_spec)
+811        elif output_format == 'bbcode':
+812            return icepool.population.format.bbcode(self, col_spec)
+813        elif output_format == 'csv':
+814            return icepool.population.format.csv(self, col_spec, **kwargs)
+815        elif output_format == 'html':
+816            return icepool.population.format.html(self, col_spec)
+817        else:
+818            raise ValueError(f"Unsupported output format '{output_format}'")
+
+ + +

Formats this mapping as a string.

+ +

format_spec should start with the output format, +which can be:

+ +
    +
  • md for Markdown (default)
    • +
  • bbcode for BBCode
    • +
  • csv for comma-separated values
    • +
  • html for HTML
    • +
+ +

After this, you may optionally add a : followed by a series of +requested columns. Allowed columns are:

+ +
    +
  • o: Outcomes.
    • +
  • *o: Outcomes, unpacked if applicable.
    • +
  • q==, q<=, q>=: Quantities ==, <=, or >= each outcome.
    • +
  • p==, p<=, p>=: Probabilities (0-1) ==, <=, or >= each outcome.
    • +
  • %==, %<=, %>=: Probabilities (0%-100%) ==, <=, or >= each outcome.
    • +
+ +

Columns may optionally be separated using | characters.

+ +

The default columns are *o|q==|%==, which are the unpacked outcomes, +the quantities, and the probabilities. The quantities are omitted from +the default columns if any individual quantity is 10**30 or greater.

+
+ + +
+
+
Inherited Members
+
+
collections.abc.Mapping
+
get
+ +
+
+
+
+
+ +
+ + def + tupleize( *args: Union[~T, Population[~T]]) -> tuple[~T, ...] | Population[tuple[~T, ...]]: + + + +
+ + 
49def tupleize(
+50    *args: 'T | icepool.Population[T]'
+51) -> 'tuple[T, ...] | icepool.Population[tuple[T, ...]]':
+52    """Returns the Cartesian product of the arguments as `tuple`s or a `Population` thereof.
+53
+54    For example:
+55    * `tupleize(1, 2)` would produce `(1, 2)`.
+56    * `tupleize(d6, 0)` would produce a `Die` with outcomes `(1, 0)`, `(2, 0)`,
+57        ... `(6, 0)`.
+58    * `tupleize(d6, d6)` would produce a `Die` with outcomes `(1, 1)`, `(1, 2)`,
+59        ... `(6, 5)`, `(6, 6)`.
+60
+61    If `Population`s are provided, they must all be `Die` or all `Deck` and not
+62    a mixture of the two.
+63
+64    Returns:
+65        If none of the outcomes is a `Population`, the result is a `tuple`
+66        with one element per argument. Otherwise, the result is a `Population`
+67        of the same type as the input `Population`, and the outcomes are
+68        `tuple`s with one element per argument.
+69    """
+70    return cartesian_product(*args, outcome_type=tuple)
+
+ + +

Returns the Cartesian product of the arguments as tuples or a Population thereof.

+ +

For example:

+ +
    +
  • tupleize(1, 2) would produce (1, 2).
    • +
  • tupleize(d6, 0) would produce a Die with outcomes (1, 0), (2, 0), +... (6, 0).
    • +
  • tupleize(d6, d6) would produce a Die with outcomes (1, 1), (1, 2), +... (6, 5), (6, 6).
    • +
+ +

If Populations are provided, they must all be Die or all Deck and not +a mixture of the two.

+ +
Returns:
+ +
+

If none of the outcomes is a Population, the result is a tuple + with one element per argument. Otherwise, the result is a Population + of the same type as the input Population, and the outcomes are + tuples with one element per argument.

+
+
+ + +
+
+ +
+ + def + vectorize( *args: Union[~T, Population[~T]]) -> Union[Vector[~T], Population[Vector[~T]]]: + + + +
+ + 
73def vectorize(
+74    *args: 'T | icepool.Population[T]'
+75) -> 'Vector[T] | icepool.Population[Vector[T]]':
+76    """Returns the Cartesian product of the arguments as `Vector`s or a `Population` thereof.
+77
+78    For example:
+79    * `vectorize(1, 2)` would produce `Vector(1, 2)`.
+80    * `vectorize(d6, 0)` would produce a `Die` with outcomes `Vector(1, 0)`,
+81        `Vector(2, 0)`, ... `Vector(6, 0)`.
+82    * `vectorize(d6, d6)` would produce a `Die` with outcomes `Vector(1, 1)`,
+83        `Vector(1, 2)`, ... `Vector(6, 5)`, `Vector(6, 6)`.
+84
+85    If `Population`s are provided, they must all be `Die` or all `Deck` and not
+86    a mixture of the two.
+87
+88    Returns:
+89        If none of the outcomes is a `Population`, the result is a `Vector`
+90        with one element per argument. Otherwise, the result is a `Population`
+91        of the same type as the input `Population`, and the outcomes are
+92        `Vector`s with one element per argument.
+93    """
+94    return cartesian_product(*args, outcome_type=Vector)
+
+ + +

Returns the Cartesian product of the arguments as Vectors or a Population thereof.

+ +

For example:

+ +
    +
  • vectorize(1, 2) would produce Vector(1, 2).
    • +
  • vectorize(d6, 0) would produce a Die with outcomes Vector(1, 0), +Vector(2, 0), ... Vector(6, 0).
    • +
  • vectorize(d6, d6) would produce a Die with outcomes Vector(1, 1), +Vector(1, 2), ... Vector(6, 5), Vector(6, 6).
    • +
+ +

If Populations are provided, they must all be Die or all Deck and not +a mixture of the two.

+ +
Returns:
+ +
+

If none of the outcomes is a Population, the result is a Vector + with one element per argument. Otherwise, the result is a Population + of the same type as the input Population, and the outcomes are + Vectors with one element per argument.

+
+
+ + +
+
+ +
+ + class + Vector(icepool.Outcome, typing.Sequence[+T_co]): + + + +
+ + 
 97class Vector(Outcome, Sequence[T_co]):
+ 98    """Immutable tuple-like class that applies most operators elementwise.
+ 99
+100    May become a variadic generic type in the future.
+101    """
+102    _data: tuple[T_co, ...]
+103
+104    def __init__(self,
+105                 elements: Iterable[T_co],
+106                 *,
+107                 truth_value: bool | None = None) -> None:
+108        self._data = tuple(elements)
+109        if any(isinstance(x, icepool.AgainExpression) for x in self._data):
+110            raise TypeError('Again is not a valid element of Vector.')
+111        self._truth_value = truth_value
+112
+113    def __hash__(self) -> int:
+114        return hash((Vector, self._data))
+115
+116    def __len__(self) -> int:
+117        return len(self._data)
+118
+119    @overload
+120    def __getitem__(self, index: int) -> T_co:
+121        ...
+122
+123    @overload
+124    def __getitem__(self, index: slice) -> 'Vector[T_co]':
+125        ...
+126
+127    def __getitem__(self, index: int | slice) -> 'T_co | Vector[T_co]':
+128        if isinstance(index, int):
+129            return self._data[index]
+130        else:
+131            return Vector(self._data[index])
+132
+133    # Unary operators.
+134
+135    def unary_operator(self, op: Callable[..., U], *args,
+136                       **kwargs) -> 'Vector[U]':
+137        """Unary operators on `Vector` are applied elementwise.
+138
+139        This is used for the standard unary operators
+140        `-, +, abs, ~, round, trunc, floor, ceil`
+141        """
+142        return Vector(op(x, *args, **kwargs) for x in self)
+143
+144    def __neg__(self) -> 'Vector[T_co]':
+145        return self.unary_operator(operator.neg)
+146
+147    def __pos__(self) -> 'Vector[T_co]':
+148        return self.unary_operator(operator.pos)
+149
+150    def __invert__(self) -> 'Vector[T_co]':
+151        return self.unary_operator(operator.invert)
+152
+153    def abs(self) -> 'Vector[T_co]':
+154        return self.unary_operator(operator.abs)
+155
+156    __abs__ = abs
+157
+158    def round(self, ndigits: int | None = None) -> 'Vector':
+159        return self.unary_operator(round, ndigits)
+160
+161    __round__ = round
+162
+163    def trunc(self) -> 'Vector':
+164        return self.unary_operator(math.trunc)
+165
+166    __trunc__ = trunc
+167
+168    def floor(self) -> 'Vector':
+169        return self.unary_operator(math.floor)
+170
+171    __floor__ = floor
+172
+173    def ceil(self) -> 'Vector':
+174        return self.unary_operator(math.ceil)
+175
+176    __ceil__ = ceil
+177
+178    # Binary operators.
+179
+180    def binary_operator(self,
+181                        other,
+182                        op: Callable[..., U],
+183                        *args,
+184                        compare_for_truth: bool = False,
+185                        **kwargs) -> 'Vector[U]':
+186        """Binary operators on `Vector` are applied elementwise.
+187
+188        If the other operand is also a `Vector`, the operator is applied to each
+189        pair of elements from `self` and `other`. Both must have the same
+190        length.
+191
+192        Otherwise the other operand is broadcast to each element of `self`.
+193
+194        This is used for the standard binary operators
+195        `+, -, *, /, //, %, **, <<, >>, &, |, ^`.
+196
+197        `@` is not included due to its different meaning in `Die`.
+198
+199        This is also used for the comparators
+200        `<, <=, >, >=, ==, !=`.
+201
+202        In this case, the result also has a truth value based on lexicographic
+203        ordering.
+204        """
+205        if isinstance(other, (icepool.Population, icepool.AgainExpression)):
+206            return NotImplemented  # delegate to the other
+207        if isinstance(other, Vector):
+208            if len(self) == len(other):
+209                if compare_for_truth:
+210                    truth_value = cast(bool, op(self._data, other._data))
+211                else:
+212                    truth_value = None
+213                return Vector(
+214                    (op(x, y, *args, **kwargs) for x, y in zip(self, other)),
+215                    truth_value=truth_value)
+216            else:
+217                raise IndexError(
+218                    f'Binary operators on Vectors are only valid if both are the same length ({len(self)} vs. {len(other)}).'
+219                )
+220        else:
+221            return Vector((op(x, other, *args, **kwargs) for x in self))
+222
+223    def reverse_binary_operator(self, other, op: Callable[..., U], *args,
+224                                **kwargs) -> 'Vector[U]':
+225        """Reverse version of `binary_operator()`."""
+226        if isinstance(other, (icepool.Population, icepool.AgainExpression)):
+227            return NotImplemented  # delegate to the other
+228        if isinstance(other, Vector):
+229            if len(self) == len(other):
+230                return Vector(
+231                    op(y, x, *args, **kwargs) for x, y in zip(self, other))
+232            else:
+233                raise IndexError(
+234                    f'Binary operators on Vectors are only valid if both are the same length ({len(self)} vs. {len(other)}).'
+235                )
+236        else:
+237            return Vector(op(other, x, *args, **kwargs) for x in self)
+238
+239    def __add__(self, other) -> 'Vector':
+240        return self.binary_operator(other, operator.add)
+241
+242    def __radd__(self, other) -> 'Vector':
+243        return self.reverse_binary_operator(other, operator.add)
+244
+245    def __sub__(self, other) -> 'Vector':
+246        return self.binary_operator(other, operator.sub)
+247
+248    def __rsub__(self, other) -> 'Vector':
+249        return self.reverse_binary_operator(other, operator.sub)
+250
+251    def __mul__(self, other) -> 'Vector':
+252        return self.binary_operator(other, operator.mul)
+253
+254    def __rmul__(self, other) -> 'Vector':
+255        return self.reverse_binary_operator(other, operator.mul)
+256
+257    def __truediv__(self, other) -> 'Vector':
+258        return self.binary_operator(other, operator.truediv)
+259
+260    def __rtruediv__(self, other) -> 'Vector':
+261        return self.reverse_binary_operator(other, operator.truediv)
+262
+263    def __floordiv__(self, other) -> 'Vector':
+264        return self.binary_operator(other, operator.floordiv)
+265
+266    def __rfloordiv__(self, other) -> 'Vector':
+267        return self.reverse_binary_operator(other, operator.floordiv)
+268
+269    def __pow__(self, other) -> 'Vector':
+270        return self.binary_operator(other, operator.pow)
+271
+272    def __rpow__(self, other) -> 'Vector':
+273        return self.reverse_binary_operator(other, operator.pow)
+274
+275    def __mod__(self, other) -> 'Vector':
+276        return self.binary_operator(other, operator.mod)
+277
+278    def __rmod__(self, other) -> 'Vector':
+279        return self.reverse_binary_operator(other, operator.mod)
+280
+281    def __lshift__(self, other) -> 'Vector':
+282        return self.binary_operator(other, operator.lshift)
+283
+284    def __rlshift__(self, other) -> 'Vector':
+285        return self.reverse_binary_operator(other, operator.lshift)
+286
+287    def __rshift__(self, other) -> 'Vector':
+288        return self.binary_operator(other, operator.rshift)
+289
+290    def __rrshift__(self, other) -> 'Vector':
+291        return self.reverse_binary_operator(other, operator.rshift)
+292
+293    def __and__(self, other) -> 'Vector':
+294        return self.binary_operator(other, operator.and_)
+295
+296    def __rand__(self, other) -> 'Vector':
+297        return self.reverse_binary_operator(other, operator.and_)
+298
+299    def __or__(self, other) -> 'Vector':
+300        return self.binary_operator(other, operator.or_)
+301
+302    def __ror__(self, other) -> 'Vector':
+303        return self.reverse_binary_operator(other, operator.or_)
+304
+305    def __xor__(self, other) -> 'Vector':
+306        return self.binary_operator(other, operator.xor)
+307
+308    def __rxor__(self, other) -> 'Vector':
+309        return self.reverse_binary_operator(other, operator.xor)
+310
+311    # Comparators.
+312    # These returns a value with a truth value, but not a bool.
+313
+314    def __lt__(self, other) -> 'Vector':  # type: ignore
+315        if not isinstance(other, Vector):
+316            return NotImplemented
+317        return self.binary_operator(other, operator.lt, compare_for_truth=True)
+318
+319    def __le__(self, other) -> 'Vector':  # type: ignore
+320        if not isinstance(other, Vector):
+321            return NotImplemented
+322        return self.binary_operator(other, operator.le, compare_for_truth=True)
+323
+324    def __gt__(self, other) -> 'Vector':  # type: ignore
+325        if not isinstance(other, Vector):
+326            return NotImplemented
+327        return self.binary_operator(other, operator.gt, compare_for_truth=True)
+328
+329    def __ge__(self, other) -> 'Vector':  # type: ignore
+330        if not isinstance(other, Vector):
+331            return NotImplemented
+332        return self.binary_operator(other, operator.ge, compare_for_truth=True)
+333
+334    def __eq__(self, other) -> 'Vector | bool':  # type: ignore
+335        if not isinstance(other, Vector):
+336            return False
+337        return self.binary_operator(other, operator.eq, compare_for_truth=True)
+338
+339    def __ne__(self, other) -> 'Vector | bool':  # type: ignore
+340        if not isinstance(other, Vector):
+341            return True
+342        return self.binary_operator(other, operator.ne, compare_for_truth=True)
+343
+344    def __bool__(self) -> bool:
+345        if self._truth_value is None:
+346            raise TypeError(
+347                'Vector only has a truth value if it is the result of a comparison operator.'
+348            )
+349        return self._truth_value
+350
+351    # Sequence manipulation.
+352
+353    def append(self, other) -> 'Vector':
+354        return Vector(self._data + (other,))
+355
+356    def concatenate(self, other: 'Iterable') -> 'Vector':
+357        return Vector(itertools.chain(self, other))
+358
+359    # Strings.
+360
+361    def __repr__(self) -> str:
+362        return type(self).__qualname__ + '(' + repr(self._data) + ')'
+363
+364    def __str__(self) -> str:
+365        return type(self).__qualname__ + '(' + str(self._data) + ')'
+
+ + +

Immutable tuple-like class that applies most operators elementwise.

+ +

May become a variadic generic type in the future.

+
+ + +
+ +
+ + def + unary_operator( self, op: Callable[..., ~U], *args, **kwargs) -> Vector[~U]: + + + +
+ + 
135    def unary_operator(self, op: Callable[..., U], *args,
+136                       **kwargs) -> 'Vector[U]':
+137        """Unary operators on `Vector` are applied elementwise.
+138
+139        This is used for the standard unary operators
+140        `-, +, abs, ~, round, trunc, floor, ceil`
+141        """
+142        return Vector(op(x, *args, **kwargs) for x in self)
+
+ + +

Unary operators on Vector are applied elementwise.

+ +

This is used for the standard unary operators +-, +, abs, ~, round, trunc, floor, ceil

+
+ + +
+
+ +
+ + def + abs(self) -> Vector[+T_co]: + + + +
+ + 
153    def abs(self) -> 'Vector[T_co]':
+154        return self.unary_operator(operator.abs)
+
+ + + + +
+
+ +
+ + def + round(self, ndigits: int | None = None) -> Vector: + + + +
+ + 
158    def round(self, ndigits: int | None = None) -> 'Vector':
+159        return self.unary_operator(round, ndigits)
+
+ + + + +
+
+ +
+ + def + trunc(self) -> Vector: + + + +
+ + 
163    def trunc(self) -> 'Vector':
+164        return self.unary_operator(math.trunc)
+
+ + + + +
+
+ +
+ + def + floor(self) -> Vector: + + + +
+ + 
168    def floor(self) -> 'Vector':
+169        return self.unary_operator(math.floor)
+
+ + + + +
+
+ +
+ + def + ceil(self) -> Vector: + + + +
+ + 
173    def ceil(self) -> 'Vector':
+174        return self.unary_operator(math.ceil)
+
+ + + + +
+
+ +
+ + def + binary_operator( self, other, op: Callable[..., ~U], *args, compare_for_truth: bool = False, **kwargs) -> Vector[~U]: + + + +
+ + 
180    def binary_operator(self,
+181                        other,
+182                        op: Callable[..., U],
+183                        *args,
+184                        compare_for_truth: bool = False,
+185                        **kwargs) -> 'Vector[U]':
+186        """Binary operators on `Vector` are applied elementwise.
+187
+188        If the other operand is also a `Vector`, the operator is applied to each
+189        pair of elements from `self` and `other`. Both must have the same
+190        length.
+191
+192        Otherwise the other operand is broadcast to each element of `self`.
+193
+194        This is used for the standard binary operators
+195        `+, -, *, /, //, %, **, <<, >>, &, |, ^`.
+196
+197        `@` is not included due to its different meaning in `Die`.
+198
+199        This is also used for the comparators
+200        `<, <=, >, >=, ==, !=`.
+201
+202        In this case, the result also has a truth value based on lexicographic
+203        ordering.
+204        """
+205        if isinstance(other, (icepool.Population, icepool.AgainExpression)):
+206            return NotImplemented  # delegate to the other
+207        if isinstance(other, Vector):
+208            if len(self) == len(other):
+209                if compare_for_truth:
+210                    truth_value = cast(bool, op(self._data, other._data))
+211                else:
+212                    truth_value = None
+213                return Vector(
+214                    (op(x, y, *args, **kwargs) for x, y in zip(self, other)),
+215                    truth_value=truth_value)
+216            else:
+217                raise IndexError(
+218                    f'Binary operators on Vectors are only valid if both are the same length ({len(self)} vs. {len(other)}).'
+219                )
+220        else:
+221            return Vector((op(x, other, *args, **kwargs) for x in self))
+
+ + +

Binary operators on Vector are applied elementwise.

+ +

If the other operand is also a Vector, the operator is applied to each +pair of elements from self and other. Both must have the same +length.

+ +

Otherwise the other operand is broadcast to each element of self.

+ +

This is used for the standard binary operators ++, -, *, /, //, %, **, <<, >>, &, |, ^.

+ +

@ is not included due to its different meaning in Die.

+ +

This is also used for the comparators +<, <=, >, >=, ==, !=.

+ +

In this case, the result also has a truth value based on lexicographic +ordering.

+
+ + +
+
+ +
+ + def + reverse_binary_operator( self, other, op: Callable[..., ~U], *args, **kwargs) -> Vector[~U]: + + + +
+ + 
223    def reverse_binary_operator(self, other, op: Callable[..., U], *args,
+224                                **kwargs) -> 'Vector[U]':
+225        """Reverse version of `binary_operator()`."""
+226        if isinstance(other, (icepool.Population, icepool.AgainExpression)):
+227            return NotImplemented  # delegate to the other
+228        if isinstance(other, Vector):
+229            if len(self) == len(other):
+230                return Vector(
+231                    op(y, x, *args, **kwargs) for x, y in zip(self, other))
+232            else:
+233                raise IndexError(
+234                    f'Binary operators on Vectors are only valid if both are the same length ({len(self)} vs. {len(other)}).'
+235                )
+236        else:
+237            return Vector(op(other, x, *args, **kwargs) for x in self)
+
+ + +

Reverse version of binary_operator().

+
+ + +
+
+ +
+ + def + append(self, other) -> Vector: + + + +
+ + 
353    def append(self, other) -> 'Vector':
+354        return Vector(self._data + (other,))
+
+ + + + +
+
+ +
+ + def + concatenate(self, other: Iterable) -> Vector: + + + +
+ + 
356    def concatenate(self, other: 'Iterable') -> 'Vector':
+357        return Vector(itertools.chain(self, other))
+
+ + + + +
+
+
Inherited Members
+
+ +
collections.abc.Sequence
+
index
+
count
+ +
+
+
+
+
+
+ Again: Final = +<icepool.population.again.AgainExpression object> + + +
+ + +

A symbol indicating that the die should be rolled again, usually with some operation applied.

+ +

This is designed to be used with the Die() constructor. +AgainExpressions should not be fed to functions or methods other than +Die(), but it can be used with operators. Examples:

+ +
    +
  • Again + 6: Roll again and add 6.
    • +
  • Again + Again: Roll again twice and sum.
    • +
+ +

The again_depth and again_end arguments to Die() affect how these +arguments are processed.

+ +

If you want something more complex, use e.g. Die.map() instead.

+
+ + +
+
+ +
+ + class + CountsKeysView(typing.KeysView[~T], typing.Sequence[~T]): + + + +
+ + 
144class CountsKeysView(KeysView[T], Sequence[T]):
+145    """This functions as both a `KeysView` and a `Sequence`."""
+146
+147    def __init__(self, counts: Counts[T]):
+148        self._mapping = counts
+149
+150    def __getitem__(self, index):
+151        return self._mapping._keys[index]
+152
+153    def __len__(self) -> int:
+154        return len(self._mapping)
+155
+156    def __eq__(self, other):
+157        return self._mapping._keys == other
+
+ + +

This functions as both a KeysView and a Sequence.

+
+ + +
+ +
+ + CountsKeysView(counts: icepool.collection.counts.Counts[~T]) + + + +
+ + 
147    def __init__(self, counts: Counts[T]):
+148        self._mapping = counts
+
+ + + + +
+
+
Inherited Members
+
+
collections.abc.Set
+
isdisjoint
+ +
+
collections.abc.Sequence
+
index
+
count
+ +
+
+
+
+
+ +
+ + class + CountsValuesView(typing.ValuesView[int], typing.Sequence[int]): + + + +
+ + 
160class CountsValuesView(ValuesView[int], Sequence[int]):
+161    """This functions as both a `ValuesView` and a `Sequence`."""
+162
+163    def __init__(self, counts: Counts):
+164        self._mapping = counts
+165
+166    def __getitem__(self, index):
+167        return self._mapping._values[index]
+168
+169    def __len__(self) -> int:
+170        return len(self._mapping)
+171
+172    def __eq__(self, other):
+173        return self._mapping._values == other
+
+ + +

This functions as both a ValuesView and a Sequence.

+
+ + +
+ +
+ + CountsValuesView(counts: icepool.collection.counts.Counts) + + + +
+ + 
163    def __init__(self, counts: Counts):
+164        self._mapping = counts
+
+ + + + +
+
+
Inherited Members
+
+
collections.abc.Sequence
+
index
+
count
+ +
+
+
+
+
+ +
+ + class + CountsItemsView(typing.ItemsView[~T, int], typing.Sequence[tuple[~T, int]]): + + + +
+ + 
176class CountsItemsView(ItemsView[T, int], Sequence[tuple[T, int]]):
+177    """This functions as both an `ItemsView` and a `Sequence`."""
+178
+179    def __init__(self, counts: Counts):
+180        self._mapping = counts
+181
+182    def __getitem__(self, index):
+183        return self._mapping._items[index]
+184
+185    def __eq__(self, other):
+186        return self._mapping._items == other
+
+ + +

This functions as both an ItemsView and a Sequence.

+
+ + +
+ +
+ + CountsItemsView(counts: icepool.collection.counts.Counts) + + + +
+ + 
179    def __init__(self, counts: Counts):
+180        self._mapping = counts
+
+ + + + +
+
+
Inherited Members
+
+
collections.abc.Set
+
isdisjoint
+ +
+
collections.abc.Sequence
+
index
+
count
+ +
+
+
+
+
+ +
+ + def + from_cumulative( outcomes: Sequence[~T], cumulative: Union[Sequence[int], Sequence[Die[bool]]], *, reverse: bool = False) -> Die[~T]: + + + +
+ + 
 84def from_cumulative(outcomes: Sequence[T],
+ 85                    cumulative: 'Sequence[int] | Sequence[icepool.Die[bool]]',
+ 86                    *,
+ 87                    reverse: bool = False) -> 'icepool.Die[T]':
+ 88    """Constructs a `Die` from a sequence of cumulative values.
+ 89
+ 90    Args:
+ 91        outcomes: The outcomes of the resulting die. Sorted order is recommended
+ 92            but not necessary.
+ 93        cumulative: The cumulative values (inclusive) of the outcomes in the
+ 94            order they are given to this function. These may be:
+ 95            * `int` cumulative quantities.
+ 96            * Dice representing the cumulative distribution at that point.
+ 97        reverse: Iff true, both of the arguments will be reversed. This allows
+ 98            e.g. constructing using a survival distribution.
+ 99    """
+100    if len(outcomes) == 0:
+101        return icepool.Die({})
+102
+103    if reverse:
+104        outcomes = list(reversed(outcomes))
+105        cumulative = list(reversed(cumulative))  # type: ignore
+106
+107    prev = 0
+108    d = {}
+109
+110    if isinstance(cumulative[0], icepool.Die):
+111        cumulative = commonize_denominator(*cumulative)
+112        for outcome, die in zip(outcomes, cumulative):
+113            d[outcome] = die.quantity_ne(False) - prev
+114            prev = die.quantity_ne(False)
+115    elif isinstance(cumulative[0], int):
+116        cumulative = cast(Sequence[int], cumulative)
+117        for outcome, quantity in zip(outcomes, cumulative):
+118            d[outcome] = quantity - prev
+119            prev = quantity
+120    else:
+121        raise TypeError(
+122            f'Unsupported type {type(cumulative)} for cumulative values.')
+123
+124    return icepool.Die(d)
+
+ + +

Constructs a Die from a sequence of cumulative values.

+ +
Arguments:
+ +
    +
  • outcomes: The outcomes of the resulting die. Sorted order is recommended +but not necessary.
    • +
  • cumulative: The cumulative values (inclusive) of the outcomes in the +order they are given to this function. These may be: +
      +
    • int cumulative quantities.
      • +
    • Dice representing the cumulative distribution at that point.
      • +
    • +
  • reverse: Iff true, both of the arguments will be reversed. This allows +e.g. constructing using a survival distribution.
    • +
+
+ + +
+
+ +
+ + def + from_rv( rv, outcomes: Union[Sequence[int], Sequence[float]], denominator: int, **kwargs) -> Die[int] | Die[float]: + + + +
+ + 
139def from_rv(rv, outcomes: Sequence[int] | Sequence[float], denominator: int,
+140            **kwargs) -> 'icepool.Die[int] | icepool.Die[float]':
+141    """Constructs a `Die` from a rv object (as `scipy.stats`).
+142    Args:
+143        rv: A rv object (as `scipy.stats`).
+144        outcomes: An iterable of `int`s or `float`s that will be the outcomes
+145            of the resulting `Die`.
+146            If the distribution is discrete, outcomes must be `int`s.
+147        denominator: The denominator of the resulting `Die` will be set to this.
+148        **kwargs: These will be forwarded to `rv.cdf()`.
+149    """
+150    if hasattr(rv, 'pdf'):
+151        # Continuous distributions use midpoints.
+152        midpoints = [(a + b) / 2 for a, b in zip(outcomes[:-1], outcomes[1:])]
+153        cdf = rv.cdf(midpoints, **kwargs)
+154        quantities_le = tuple(
+155            int(round(x * denominator)) for x in cdf) + (denominator,)
+156    else:
+157        cdf = rv.cdf(outcomes, **kwargs)
+158        quantities_le = tuple(int(round(x * denominator)) for x in cdf)
+159    return from_cumulative(outcomes, quantities_le)
+
+ + +

Constructs a Die from a rv object (as scipy.stats).

+ +
Arguments:
+ +
    +
  • rv: A rv object (as scipy.stats).
    • +
  • outcomes: An iterable of ints or floats that will be the outcomes +of the resulting Die. +If the distribution is discrete, outcomes must be ints.
    • +
  • denominator: The denominator of the resulting Die will be set to this.
    • +
  • **kwargs: These will be forwarded to rv.cdf().
    • +
+
+ + +
+
+ +
+ + def + lowest( arg0, /, *more_args: Union[~T, Die[~T]], keep: int = 1, drop: int = 0, default: Optional[~T] = None) -> Die[~T]: + + + +
+ + 
23def lowest(arg0,
+24           /,
+25           *more_args: 'T | icepool.Die[T]',
+26           keep: int = 1,
+27           drop: int = 0,
+28           default: T | None = None) -> 'icepool.Die[T]':
+29    """The lowest outcome among the rolls, or the sum of some of the lowest.
+30
+31    The outcomes should support addition and multiplication if `keep != 1`.
+32
+33    Args:
+34        args: Dice or individual outcomes in a single iterable, or as two or
+35            more separate arguments. Similar to the built-in `min()`.
+36        keep: The number of lowest dice will be summed.
+37        drop: This number of lowest dice will be dropped before keeping dice
+38            to be summed.
+39        default: If an empty iterable is provided, the result will be a die that
+40            always rolls this value.
+41
+42    Raises:
+43        ValueError if an empty iterable is provided with no `default`.
+44    """
+45    if len(more_args) == 0:
+46        args = arg0
+47    else:
+48        args = (arg0, ) + more_args
+49
+50    if len(args) == 0:
+51        if default is None:
+52            raise ValueError(
+53                "lowest() arg is an empty sequence and no default was provided."
+54            )
+55        else:
+56            return icepool.Die([default])
+57
+58    if keep < 0:
+59        raise ValueError(f'keep={keep} cannot be negative.')
+60    if drop < 0:
+61        raise ValueError(f'drop={drop} cannot be negative.')
+62
+63    start = min(drop, len(args))
+64    stop = min(keep + drop, len(args))
+65    return _sum_slice(*args, start=start, stop=stop)
+
+ + +

The lowest outcome among the rolls, or the sum of some of the lowest.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • args: Dice or individual outcomes in a single iterable, or as two or +more separate arguments. Similar to the built-in min().
    • +
  • keep: The number of lowest dice will be summed.
    • +
  • drop: This number of lowest dice will be dropped before keeping dice +to be summed.
    • +
  • default: If an empty iterable is provided, the result will be a die that +always rolls this value.
    • +
+ +
Raises:
+ +
    +
  • ValueError if an empty iterable is provided with no default.
    • +
+
+ + +
+
+ +
+ + def + highest( arg0, /, *more_args: Union[~T, Die[~T]], keep: int = 1, drop: int = 0, default: Optional[~T] = None) -> Die[~T]: + + + +
+ + 
 79def highest(arg0,
+ 80            /,
+ 81            *more_args: 'T | icepool.Die[T]',
+ 82            keep: int = 1,
+ 83            drop: int = 0,
+ 84            default: T | None = None) -> 'icepool.Die[T]':
+ 85    """The highest outcome among the rolls, or the sum of some of the highest.
+ 86
+ 87    The outcomes should support addition and multiplication if `keep != 1`.
+ 88
+ 89    Args:
+ 90        args: Dice or individual outcomes in a single iterable, or as two or
+ 91            more separate arguments. Similar to the built-in `max()`.
+ 92        keep: The number of highest dice will be summed.
+ 93        drop: This number of highest dice will be dropped before keeping dice
+ 94            to be summed.
+ 95        default: If an empty iterable is provided, the result will be a die that
+ 96            always rolls this value.
+ 97
+ 98    Raises:
+ 99        ValueError if an empty iterable is provided with no `default`.
+100    """
+101    if len(more_args) == 0:
+102        args = arg0
+103    else:
+104        args = (arg0, ) + more_args
+105
+106    if len(args) == 0:
+107        if default is None:
+108            raise ValueError(
+109                "highest() arg is an empty sequence and no default was provided."
+110            )
+111        else:
+112            return icepool.Die([default])
+113
+114    if keep < 0:
+115        raise ValueError(f'keep={keep} cannot be negative.')
+116    if drop < 0:
+117        raise ValueError(f'drop={drop} cannot be negative.')
+118
+119    start = len(args) - min(keep + drop, len(args))
+120    stop = len(args) - min(drop, len(args))
+121    return _sum_slice(*args, start=start, stop=stop)
+
+ + +

The highest outcome among the rolls, or the sum of some of the highest.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • args: Dice or individual outcomes in a single iterable, or as two or +more separate arguments. Similar to the built-in max().
    • +
  • keep: The number of highest dice will be summed.
    • +
  • drop: This number of highest dice will be dropped before keeping dice +to be summed.
    • +
  • default: If an empty iterable is provided, the result will be a die that +always rolls this value.
    • +
+ +
Raises:
+ +
    +
  • ValueError if an empty iterable is provided with no default.
    • +
+
+ + +
+
+ +
+ + def + middle( arg0, /, *more_args: Union[~T, Die[~T]], keep: int = 1, tie: Literal['error', 'high', 'low'] = 'error', default: Optional[~T] = None) -> Die[~T]: + + + +
+ + 
135def middle(arg0,
+136           /,
+137           *more_args: 'T | icepool.Die[T]',
+138           keep: int = 1,
+139           tie: Literal['error', 'high', 'low'] = 'error',
+140           default: T | None = None) -> 'icepool.Die[T]':
+141    """The middle of the outcomes among the rolls, or the sum of some of the middle.
+142
+143    The outcomes should support addition and multiplication if `keep != 1`.
+144
+145    Args:
+146        args: Dice or individual outcomes in a single iterable, or as two or
+147            more separate arguments.
+148        keep: The number of outcomes to sum.
+149        tie: What to do if `keep` is odd but the the number of args is even, or
+150            vice versa.
+151            * 'error' (default): Raises `IndexError`.
+152            * 'high': The higher outcome is taken.
+153            * 'low': The lower outcome is taken.
+154        default: If an empty iterable is provided, the result will be a die that
+155            always rolls this value.
+156
+157    Raises:
+158        ValueError if an empty iterable is provided with no `default`.
+159    """
+160    if len(more_args) == 0:
+161        args = arg0
+162    else:
+163        args = (arg0, ) + more_args
+164
+165    if len(args) == 0:
+166        if default is None:
+167            raise ValueError(
+168                "middle() arg is an empty sequence and no default was provided."
+169            )
+170        else:
+171            return icepool.Die([default])
+172
+173    # Expression evaluators are difficult to type.
+174    return icepool.Pool(args).middle(keep, tie=tie).sum()  # type: ignore
+
+ + +

The middle of the outcomes among the rolls, or the sum of some of the middle.

+ +

The outcomes should support addition and multiplication if keep != 1.

+ +
Arguments:
+ +
    +
  • args: Dice or individual outcomes in a single iterable, or as two or +more separate arguments.
    • +
  • keep: The number of outcomes to sum.
    • +
  • tie: What to do if keep is odd but the the number of args is even, or +vice versa. +
      +
    • 'error' (default): Raises IndexError.
      • +
    • 'high': The higher outcome is taken.
      • +
    • 'low': The lower outcome is taken.
      • +
    • +
  • default: If an empty iterable is provided, the result will be a die that +always rolls this value.
    • +
+ +
Raises:
+ +
    +
  • ValueError if an empty iterable is provided with no default.
    • +
+
+ + +
+
+ +
+ + def + min_outcome(*dice: Union[~T, Die[~T]]) -> ~T: + + + +
+ + 
162def min_outcome(*dice: 'T | icepool.Die[T]') -> T:
+163    """The minimum outcome among the dice. """
+164    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+165    return min(die.outcomes()[0] for die in converted_dice)
+
+ + +

The minimum outcome among the dice.

+
+ + +
+
+ +
+ + def + max_outcome(*dice: Union[~T, Die[~T]]) -> ~T: + + + +
+ + 
168def max_outcome(*dice: 'T | icepool.Die[T]') -> T:
+169    """The maximum outcome among the dice. """
+170    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+171    return max(die.outcomes()[-1] for die in converted_dice)
+
+ + +

The maximum outcome among the dice.

+
+ + +
+
+ +
+ + def + align( *dice: Union[~T, Die[~T]]) -> tuple[Die[~T], ...]: + + + +
+ + 
174def align(*dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+175    """Pads dice with zero quantities so that all have the same set of outcomes.
+176
+177    Args:
+178        *dice: Any number of dice or single outcomes convertible to dice.
+179
+180    Returns:
+181        A tuple of aligned dice.
+182    """
+183    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+184    outcomes = set(
+185        itertools.chain.from_iterable(die.outcomes() for die in converted_dice))
+186    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+
+ + +

Pads dice with zero quantities so that all have the same set of outcomes.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of aligned dice.

+
+
+ + +
+
+ +
+ + def + align_range( *dice: int | Die[int]) -> tuple[Die[int], ...]: + + + +
+ + 
189def align_range(
+190        *dice: 'int | icepool.Die[int]') -> tuple['icepool.Die[int]', ...]:
+191    """Pads dice with zero quantities so that all have the same set of consecutive `int` outcomes.
+192
+193    Args:
+194        *dice: Any number of dice or single outcomes convertible to dice.
+195
+196    Returns:
+197        A tuple of aligned dice.
+198    """
+199    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+200    outcomes = range(icepool.min_outcome(*converted_dice),
+201                     icepool.max_outcome(*converted_dice) + 1)
+202    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+
+ + +

Pads dice with zero quantities so that all have the same set of consecutive int outcomes.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of aligned dice.

+
+
+ + +
+
+ +
+ + def + commonize_denominator( *dice: Union[~T, Die[~T]]) -> tuple[Die[~T], ...]: + + + +
+ + 
205def commonize_denominator(
+206        *dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+207    """Scale the weights of the dice so that all of them have the same denominator.
+208
+209    Args:
+210        *dice: Any number of dice or single outcomes convertible to dice.
+211
+212    Returns:
+213        A tuple of dice with the same denominator.
+214    """
+215    converted_dice = [
+216        icepool.implicit_convert_to_die(die).simplify() for die in dice
+217    ]
+218    denominator_lcm = math.lcm(
+219        *(die.denominator() for die in converted_dice if die.denominator() > 0))
+220    return tuple(
+221        die.scale_quantities(denominator_lcm //
+222                             die.denominator() if die.denominator() > 0 else 1)
+223        for die in converted_dice)
+
+ + +

Scale the weights of the dice so that all of them have the same denominator.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of dice with the same denominator.

+
+
+ + +
+
+ +
+ + def + reduce( func: Callable[[~T, ~T], Union[~T, Die[~T], RerollType]], dice: Iterable[Union[~T, Die[~T]]], *, initial: Union[~T, Die[~T], NoneType] = None) -> Die[~T]: + + + +
+ + 
226def reduce(func: 'Callable[[T, T], T | icepool.Die[T] | icepool.RerollType]',
+227           dice: 'Iterable[T | icepool.Die[T]]',
+228           *,
+229           initial: 'T | icepool.Die[T] | None' = None) -> 'icepool.Die[T]':
+230    """Applies a function of two arguments cumulatively to a sequence of dice.
+231
+232    Analogous to
+233    [`functools.reduce()`](https://docs.python.org/3/library/functools.html#functools.reduce).
+234
+235    Args:
+236        func: The function to map. The function should take two arguments,
+237            which are an outcome from each of two dice, and produce an outcome
+238            of the same type. It may also return `Reroll`, in which case the
+239            entire sequence is effectively rerolled.
+240        dice: A sequence of dice to map the function to, from left to right.
+241        initial: If provided, this will be placed at the front of the sequence
+242            of dice.
+243        again_depth: Forwarded to the final die constructor.
+244        again_end: Forwarded to the final die constructor.
+245    """
+246    # Conversion to dice is not necessary since map() takes care of that.
+247    iter_dice = iter(dice)
+248    if initial is not None:
+249        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+250    else:
+251        result = icepool.implicit_convert_to_die(next(iter_dice))
+252    for die in iter_dice:
+253        result = map(func, result, die)
+254    return result
+
+ + +

Applies a function of two arguments cumulatively to a sequence of dice.

+ +

Analogous to +icepool.reduce">functools.reduce().

+ +
Arguments:
+ +
    +
  • func: The function to map. The function should take two arguments, +which are an outcome from each of two dice, and produce an outcome +of the same type. It may also return Reroll, in which case the +entire sequence is effectively rerolled.
    • +
  • dice: A sequence of dice to map the function to, from left to right.
    • +
  • initial: If provided, this will be placed at the front of the sequence +of dice.
    • +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + accumulate( func: Callable[[~T, ~T], Union[~T, Die[~T]]], dice: Iterable[Union[~T, Die[~T]]], *, initial: Union[~T, Die[~T], NoneType] = None) -> Iterator[Die[~T]]: + + + +
+ + 
257def accumulate(
+258        func: 'Callable[[T, T], T | icepool.Die[T]]',
+259        dice: 'Iterable[T | icepool.Die[T]]',
+260        *,
+261        initial: 'T | icepool.Die[T] | None' = None
+262) -> Iterator['icepool.Die[T]']:
+263    """Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.
+264
+265    Analogous to
+266    [`itertools.accumulate()`](https://docs.python.org/3/library/itertools.html#itertools.accumulate)
+267    , though with no default function and
+268    the same parameter order as `reduce()`.
+269
+270    The number of results is equal to the number of elements of `dice`, with
+271    one additional element if `initial` is provided.
+272
+273    Args:
+274        func: The function to map. The function should take two arguments,
+275            which are an outcome from each of two dice.
+276        dice: A sequence of dice to map the function to, from left to right.
+277        initial: If provided, this will be placed at the front of the sequence
+278            of dice.
+279    """
+280    # Conversion to dice is not necessary since map() takes care of that.
+281    iter_dice = iter(dice)
+282    if initial is not None:
+283        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+284    else:
+285        try:
+286            result = icepool.implicit_convert_to_die(next(iter_dice))
+287        except StopIteration:
+288            return
+289    yield result
+290    for die in iter_dice:
+291        result = map(func, result, die)
+292        yield result
+
+ + +

Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.

+ +

Analogous to +icepool.accumulate">itertools.accumulate() +, though with no default function and +the same parameter order as reduce().

+ +

The number of results is equal to the number of elements of dice, with +one additional element if initial is provided.

+ +
Arguments:
+ +
    +
  • func: The function to map. The function should take two arguments, +which are an outcome from each of two dice.
    • +
  • dice: A sequence of dice to map the function to, from left to right.
    • +
  • initial: If provided, this will be placed at the front of the sequence +of dice.
    • +
+
+ + +
+
+ +
+ + def + map( repl: Union[Callable[..., Union[~T, Die[~T], RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, Die[~T], RerollType, icepool.population.again.AgainExpression]]], /, *args: Outcome | Die | MultisetExpression, star: bool | None = None, repeat: int | None = 1, again_depth: int = 1, again_end: Union[~T, Die[~T], RerollType, NoneType] = None) -> Die[~T]: + + + +
+ + 
344def map(
+345    repl:
+346    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+347    /,
+348    *args: 'Outcome | icepool.Die | icepool.MultisetExpression',
+349    star: bool | None = None,
+350    repeat: int | None = 1,
+351    again_depth: int = 1,
+352    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+353) -> 'icepool.Die[T]':
+354    """Applies `func(outcome_of_die_0, outcome_of_die_1, ...)` for all joint outcomes.
+355
+356    See `map_function` for a decorator version of this.
+357
+358    Example: `map(lambda a, b: a + b, d6, d6)` is the same as d6 + d6.
+359
+360    `map()` is flexible but not very efficient for more than a few dice.
+361    If at all possible, use `reduce()`, `MultisetExpression` methods, and/or
+362    `MultisetEvaluator`s. Even `Pool.expand()` (which sorts rolls) is more
+363    efficient than using `map` on the dice in order.
+364
+365    `Again` can be used but is not recommended with `repeat` other than 1.
+366    It will re-roll the current stage, not the entire series.
+367
+368    Args:
+369        repl: One of the following:
+370            * A callable that takes in one outcome per element of args and
+371                produces a new outcome.
+372            * A mapping from old outcomes to new outcomes.
+373                Unmapped old outcomes stay the same.
+374                In this case args must have exactly one element.
+375            The new outcomes may be dice rather than just single outcomes.
+376            The special value `icepool.Reroll` will reroll that old outcome.
+377        *args: `func` will be called with all joint outcomes of these.
+378            Allowed arg types are:
+379            * Single outcome.
+380            * `Die`. All outcomes will be sent to `func`.
+381            * `MultisetExpression`. All sorted tuples of outcomes will be sent
+382                to `func`, as `MultisetExpression.expand()`. The expression must
+383                be fully bound.
+384        star: If `True`, the first of the args will be unpacked before giving
+385            them to `func`.
+386            If not provided, it will be guessed based on the signature of `func`
+387            and the number of arguments.
+388        repeat: This will be repeated with the same arguments on the
+389            result this many times, except the first of args will be replaced
+390            by the result of the previous iteration.
+391
+392            EXPERIMENTAL: If set to `None`, the result will be as if this
+393            were repeated an infinite number of times. In this case, the
+394            result will be in simplest form.
+395        again_depth: Forwarded to the final die constructor.
+396        again_end: Forwarded to the final die constructor.
+397    """
+398    transition_function = _canonicalize_transition_function(repl, len(args), star)
+399
+400    if len(args) == 0:
+401        if repeat != 1:
+402            raise ValueError('If no arguments are given, repeat must be 1.')
+403        return icepool.Die([transition_function()], again_depth=again_depth, again_end=again_end)
+404
+405    # Here len(args) is at least 1.
+406
+407    first_arg = args[0]
+408    extra_args = args[1:]
+409
+410    if repeat is not None:
+411        if repeat < 0:
+412            raise ValueError('repeat cannot be negative.')
+413        elif repeat == 0:
+414            return icepool.Die([first_arg])
+415        elif repeat == 1:
+416            final_outcomes: 'list[T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]' = []
+417            final_quantities: list[int] = []
+418            for outcomes, final_quantity in iter_cartesian_product(*args):
+419                final_outcome = transition_function(*outcomes)
+420                if final_outcome is not icepool.Reroll:
+421                    final_outcomes.append(final_outcome)
+422                    final_quantities.append(final_quantity)
+423            return icepool.Die(final_outcomes,
+424                       final_quantities,
+425                       again_depth=again_depth,
+426                       again_end=again_end)
+427        else:
+428            result: 'icepool.Die[T]' = icepool.Die([first_arg])
+429            for _ in range(repeat):
+430                result = icepool.map(transition_function,
+431                                     result, *extra_args,
+432                                     star=False,
+433                                     again_depth=again_depth,
+434                                     again_end=again_end)
+435            return result
+436    else:
+437        # Infinite repeat.
+438        # T_co and U should be the same in this case.
+439        def unary_transition_function(state):
+440            return map(transition_function, state, *extra_args, star=False, again_depth=again_depth, again_end=again_end)
+441        return icepool.population.markov_chain.absorbing_markov_chain(icepool.Die([args[0]]), unary_transition_function)
+
+ + +

Applies func(outcome_of_die_0, outcome_of_die_1, ...) for all joint outcomes.

+ +

See map_function for a decorator version of this.

+ +

Example: map(lambda a, b: a + b, d6, d6) is the same as d6 + d6.

+ +

map() is flexible but not very efficient for more than a few dice. +If at all possible, use reduce(), MultisetExpression methods, and/or +MultisetEvaluators. Even Pool.expand() (which sorts rolls) is more +efficient than using map on the dice in order.

+ +

Again can be used but is not recommended with repeat other than 1. +It will re-roll the current stage, not the entire series.

+ +
Arguments:
+ +
    +
  • repl: One of the following: +
      +
    • A callable that takes in one outcome per element of args and +produces a new outcome.
      • +
    • A mapping from old outcomes to new outcomes. +Unmapped old outcomes stay the same. +In this case args must have exactly one element. +The new outcomes may be dice rather than just single outcomes. +The special value icepool.Reroll will reroll that old outcome.
      • +
    • +
  • *args: func will be called with all joint outcomes of these. +Allowed arg types are: +
    • +
  • star: If True, the first of the args will be unpacked before giving +them to func. +If not provided, it will be guessed based on the signature of func +and the number of arguments.
    • +

  • repeat: This will be repeated with the same arguments on the +result this many times, except the first of args will be replaced +by the result of the previous iteration.

    + +

    EXPERIMENTAL: If set to None, the result will be as if this +were repeated an infinite number of times. In this case, the +result will be in simplest form.

    • +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + map_function( func: Optional[Callable[..., Union[~T, Die[~T], RerollType, icepool.population.again.AgainExpression]]] = None, /, *, star: bool | None = None, repeat: int | None = 1, again_depth: int = 1, again_end: Union[~T, Die[~T], RerollType, NoneType] = None) -> Union[Callable[..., Die[~T]], Callable[..., Callable[..., Die[~T]]]]: + + + +
+ + 
479def map_function(
+480    func:
+481    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | None' = None,
+482    /,
+483    *,
+484    star: bool | None = None,
+485    repeat: int | None = 1,
+486    again_depth: int = 1,
+487    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+488) -> 'Callable[..., icepool.Die[T]] | Callable[..., Callable[..., icepool.Die[T]]]':
+489    """Decorator that turns a function that takes outcomes into a function that takes dice.
+490
+491    The result must be a `Die`.
+492
+493    This is basically a decorator version of `map()` and produces behavior
+494    similar to AnyDice functions, though Icepool has different typing rules
+495    among other differences.
+496
+497    `map_function` can either be used with no arguments:
+498
+499    ```
+500    @map_function
+501    def explode_six(x):
+502        if x == 6:
+503            return 6 + Again
+504        else:
+505            return x
+506
+507    explode_six(d6, again_depth=2)
+508    ```
+509
+510    Or with keyword arguments, in which case the extra arguments are bound:
+511
+512    ```
+513    @map_function(again_depth=2)
+514    def explode_six(x):
+515        if x == 6:
+516            return 6 + Again
+517        else:
+518            return x
+519
+520    explode_six(d6)
+521    ```
+522
+523    Args:
+524        again_depth: Forwarded to the final die constructor.
+525        again_end: Forwarded to the final die constructor.
+526    """
+527
+528    if func is not None:
+529        return update_wrapper(partial(map, func), func)
+530    else:
+531
+532        def decorator(
+533            func:
+534            'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]'
+535        ) -> 'Callable[..., icepool.Die[T]]':
+536
+537            return update_wrapper(
+538                partial(map,
+539                        func,
+540                        star=star,
+541                        repeat=repeat,
+542                        again_depth=again_depth,
+543                        again_end=again_end), func)
+544
+545        return decorator
+
+ + +

Decorator that turns a function that takes outcomes into a function that takes dice.

+ +

The result must be a Die.

+ +

This is basically a decorator version of map() and produces behavior +similar to AnyDice functions, though Icepool has different typing rules +among other differences.

+ +

map_function can either be used with no arguments:

+ +
@map_function
+def explode_six(x):
+    if x == 6:
+        return 6 + Again
+    else:
+        return x
+
+explode_six(d6, again_depth=2)
+
+ +

Or with keyword arguments, in which case the extra arguments are bound:

+ +
@map_function(again_depth=2)
+def explode_six(x):
+    if x == 6:
+        return 6 + Again
+    else:
+        return x
+
+explode_six(d6)
+
+ +
Arguments:
+ +
    +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + map_and_time( repl: Union[Callable[..., Union[~T, Die[~T], RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, Die[~T], RerollType, icepool.population.again.AgainExpression]]], state, /, *extra_args, star: bool | None = None, repeat: int) -> Die[tuple[~T, int]]: + + + +
+ + 
547def map_and_time(
+548        repl:
+549    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+550        state,
+551        /,
+552        *extra_args,
+553        star: bool | None = None,
+554        repeat: int) -> 'icepool.Die[tuple[T, int]]':
+555    """Repeatedly map outcomes of the state to other outcomes, while also
+556    counting timesteps.
+557
+558    This is useful for representing processes.
+559
+560    The outcomes of the result are  `(outcome, time)`, where `time` is the
+561    number of repeats needed to reach an absorbing outcome (an outcome that
+562    only leads to itself), or `repeat`, whichever is lesser.
+563
+564    This will return early if it reaches a fixed point.
+565    Therefore, you can set `repeat` equal to the maximum number of
+566    time you could possibly be interested in without worrying about
+567    it causing extra computations after the fixed point.
+568
+569    Args:
+570        repl: One of the following:
+571            * A callable returning a new outcome for each old outcome.
+572            * A mapping from old outcomes to new outcomes.
+573                Unmapped old outcomes stay the same.
+574            The new outcomes may be dice rather than just single outcomes.
+575            The special value `icepool.Reroll` will reroll that old outcome.
+576        star: If `True`, the first of the args will be unpacked before giving
+577            them to `func`.
+578            If not provided, it will be guessed based on the signature of `func`
+579            and the number of arguments.
+580        repeat: This will be repeated with the same arguments on the result
+581            this many times.
+582
+583    Returns:
+584        The `Die` after the modification.
+585    """
+586    transition_function = _canonicalize_transition_function(repl, 1 + len(extra_args), star)
+587
+588    result: 'icepool.Die[tuple[T, int]]' = state.map(lambda x: (x, 0))
+589
+590    def transition_with_steps(outcome_and_steps):
+591        outcome, steps = outcome_and_steps
+592        next_outcome = transition_function(outcome, *extra_args)
+593        if icepool.population.markov_chain.is_absorbing(
+594                outcome, next_outcome):
+595            return outcome, steps
+596        else:
+597            return icepool.tupleize(next_outcome, steps + 1)
+598
+599    for _ in range(repeat):
+600        next_result: 'icepool.Die[tuple[T, int]]' = map(
+601            transition_with_steps, result)
+602        if result == next_result:
+603            return next_result
+604        result = next_result
+605    return result
+
+ + +

Repeatedly map outcomes of the state to other outcomes, while also +counting timesteps.

+ +

This is useful for representing processes.

+ +

The outcomes of the result are (outcome, time), where time is the +number of repeats needed to reach an absorbing outcome (an outcome that +only leads to itself), or repeat, whichever is lesser.

+ +

This will return early if it reaches a fixed point. +Therefore, you can set repeat equal to the maximum number of +time you could possibly be interested in without worrying about +it causing extra computations after the fixed point.

+ +
Arguments:
+ +
    +
  • repl: One of the following: +
      +
    • A callable returning a new outcome for each old outcome.
      • +
    • A mapping from old outcomes to new outcomes. +Unmapped old outcomes stay the same. +The new outcomes may be dice rather than just single outcomes. +The special value icepool.Reroll will reroll that old outcome.
      • +
    • +
  • star: If True, the first of the args will be unpacked before giving +them to func. +If not provided, it will be guessed based on the signature of func +and the number of arguments.
    • +
  • repeat: This will be repeated with the same arguments on the result +this many times.
    • +
+ +
Returns:
+ +
+

The Die after the modification.

+
+
+ + +
+
+
+ Reroll: Final = +<RerollType.Reroll: 'Reroll'> + + +
+ + +

Indicates that an outcome should be rerolled (with unlimited depth).

+ +

This can be used in place of outcomes in many places. See individual function +and method descriptions for details.

+ +

This effectively removes the outcome from the probability space, along with its +contribution to the denominator.

+ +

This can be used for conditional probability by removing all outcomes not +consistent with the given observations.

+ +

Operation in specific cases:

+ +
    +
  • When used with Again, only that stage is rerolled, not the entire Again +tree.
    • +
  • To reroll with limited depth, use Die.reroll(), or Again with no +modification.
    • +
  • When used with MultisetEvaluator, the entire evaluation is rerolled.
    • +
+
+ + +
+
+ +
+ + class + RerollType(enum.Enum): + + + +
+ + 
61class RerollType(enum.Enum):
+62    """The type of the Reroll singleton."""
+63    Reroll = 'Reroll'
+64    """Indicates an outcome should be rerolled (with unlimited depth)."""
+
+ + +

The type of the Reroll singleton.

+
+ + +
+
+ Reroll = +<RerollType.Reroll: 'Reroll'> + + +
+ + +

Indicates an outcome should be rerolled (with unlimited depth).

+
+ + +
+
+
Inherited Members
+
+
enum.Enum
+
name
+
value
+ +
+
+
+
+
+ +
+ + class + Pool(icepool.MultisetGenerator[~T, tuple[int]]): + + + +
+ + 
 26class Pool(MultisetGenerator[T, tuple[int]]):
+ 27    """Represents a multiset of outcomes resulting from the roll of several dice.
+ 28
+ 29    This should be used in conjunction with `MultisetEvaluator` to generate a
+ 30    result.
+ 31
+ 32    Note that operators are performed on the multiset of rolls, not the multiset
+ 33    of dice. For example, `d6.pool(3) - d6.pool(3)` is not an empty pool, but
+ 34    an expression meaning "roll two pools of 3d6 and get the rolls from the
+ 35    first pool, with rolls in the second pool cancelling matching rolls in the
+ 36    first pool one-for-one".
+ 37    """
+ 38
+ 39    _keep_tuple: tuple[int, ...]
+ 40    _dice: tuple[tuple['icepool.Die[T]', int]]
+ 41
+ 42    def __new__(
+ 43            cls,
+ 44            dice:
+ 45        'Sequence[icepool.Die[T] | T] | Mapping[icepool.Die[T], int] | Mapping[T, int] | Mapping[icepool.Die[T] | T, int]',
+ 46            times: Sequence[int] | int = 1) -> 'Pool':
+ 47        """Public constructor for a pool.
+ 48
+ 49        Evaulation is most efficient when the dice are the same or same-side
+ 50        truncations of each other. For example, d4, d6, d8, d10, d12 are all
+ 51        same-side truncations of d12.
+ 52
+ 53        It is permissible to create a `Pool` without providing dice, but not all
+ 54        evaluators will handle this case, especially if they depend on the
+ 55        outcome type. In this case you may want to provide a die with zero
+ 56        quantity.
+ 57
+ 58        Args:
+ 59            dice: The dice to put in the `Pool`. This can be one of the following:
+ 60
+ 61                * A `Sequence` of `Die` or outcomes.
+ 62                * A `Mapping` of `Die` or outcomes to how many of that `Die` or
+ 63                    outcome to put in the `Pool`.
+ 64
+ 65                All outcomes within a `Pool` must be totally orderable.
+ 66            times: Multiplies the number of times each element of `dice` will
+ 67                be put into the pool.
+ 68                `times` can either be a sequence of the same length as
+ 69                `outcomes` or a single `int` to apply to all elements of
+ 70                `outcomes`.
+ 71
+ 72        Raises:
+ 73            ValueError: If a bare `Deck` or `Die` argument is provided.
+ 74                A `Pool` of a single `Die` should constructed as `Pool([die])`.
+ 75        """
+ 76        if isinstance(dice, Pool):
+ 77            if times == 1:
+ 78                return dice
+ 79            else:
+ 80                dice = {die: quantity for die, quantity in dice._dice}
+ 81
+ 82        if isinstance(dice, (icepool.Die, icepool.Deck, icepool.Deal)):
+ 83            raise ValueError(
+ 84                f'A Pool cannot be constructed with a {type(dice).__name__} argument.'
+ 85            )
+ 86
+ 87        dice, times = icepool.creation_args.itemize(dice, times)
+ 88        converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+ 89
+ 90        dice_counts: MutableMapping['icepool.Die[T]', int] = defaultdict(int)
+ 91        for die, qty in zip(converted_dice, times):
+ 92            dice_counts[die] += qty
+ 93        keep_tuple = (1,) * sum(times)
+ 94        return cls._new_from_mapping(dice_counts, keep_tuple)
+ 95
+ 96    @classmethod
+ 97    @cache
+ 98    def _new_raw(cls, dice: tuple[tuple['icepool.Die[T]', int]],
+ 99                 keep_tuple: tuple[int, ...]) -> 'Pool[T]':
+100        """All pool creation ends up here. This method is cached.
+101
+102        Args:
+103            dice: A tuple of (die, count) pairs.
+104            keep_tuple: A tuple of how many times to count each die.
+105        """
+106        self = super(Pool, cls).__new__(cls)
+107        self._dice = dice
+108        self._keep_tuple = keep_tuple
+109        return self
+110
+111    @classmethod
+112    def _new_empty(cls) -> 'Pool':
+113        return cls._new_raw((), ())
+114
+115    @classmethod
+116    def clear_cache(cls):
+117        """Clears the global pool cache."""
+118        Pool._new_raw.cache_clear()
+119
+120    @classmethod
+121    def _new_from_mapping(cls, dice_counts: Mapping['icepool.Die[T]', int],
+122                          keep_tuple: Sequence[int]) -> 'Pool[T]':
+123        """Creates a new pool.
+124
+125        Args:
+126            dice_counts: A map from dice to rolls.
+127            keep_tuple: A tuple with length equal to the number of dice.
+128        """
+129        dice = tuple(sorted(dice_counts.items(),
+130                            key=lambda kv: kv[0]._hash_key))
+131        return Pool._new_raw(dice, keep_tuple)
+132
+133    @cached_property
+134    def _raw_size(self) -> int:
+135        return sum(count for _, count in self._dice)
+136
+137    def raw_size(self) -> int:
+138        """The number of dice in this pool before the keep_tuple is applied."""
+139        return self._raw_size
+140
+141    @cached_property
+142    def _keep_size(self) -> int:
+143        return sum(self.keep_tuple())
+144
+145    def keep_size(self) -> int:
+146        """The total count produced by this pool after the keep_tuple is applied."""
+147        return self._keep_size
+148
+149    def _is_resolvable(self) -> bool:
+150        return all(not die.is_empty() for die, _ in self._dice)
+151
+152    @cached_property
+153    def _denominator(self) -> int:
+154        return math.prod(die.denominator()**count for die, count in self._dice)
+155
+156    def denominator(self) -> int:
+157        return self._denominator
+158
+159    @cached_property
+160    def _dice_tuple(self) -> tuple['icepool.Die[T]', ...]:
+161        return sum(((die,) * count for die, count in self._dice), start=())
+162
+163    @cached_property
+164    def _unique_dice(self) -> Collection['icepool.Die[T]']:
+165        return set(die for die, _ in self._dice)
+166
+167    def unique_dice(self) -> Collection['icepool.Die[T]']:
+168        """The collection of unique dice in this pool."""
+169        return self._unique_dice
+170
+171    @cached_property
+172    def _outcomes(self) -> Sequence[T]:
+173        outcome_set = set(
+174            itertools.chain.from_iterable(
+175                die.outcomes() for die in self.unique_dice()))
+176        return tuple(sorted(outcome_set))
+177
+178    def outcomes(self) -> Sequence[T]:
+179        """The union of possible outcomes among all dice in this pool in ascending order."""
+180        return self._outcomes
+181
+182    def output_arity(self) -> int:
+183        return 1
+184
+185    def _estimate_order_costs(self) -> tuple[int, int]:
+186        """Estimates the cost of popping from the min and max sides.
+187
+188        Returns:
+189            pop_min_cost
+190            pop_max_cost
+191        """
+192        return icepool.generator.pool_cost.estimate_costs(self)
+193
+194    def keep_tuple(self) -> tuple[int, ...]:
+195        """The tuple indicating which dice in the pool will be counted.
+196
+197        The tuple has one element per `Die` in the pool, from lowest roll to
+198        highest roll. The `Die` in the corresponding sorted position will be
+199        counted that many times.
+200        """
+201        return self._keep_tuple
+202
+203    @cached_property
+204    def _min_outcome(self) -> T:
+205        return min(die.min_outcome() for die in self.unique_dice())
+206
+207    def min_outcome(self) -> T:
+208        """The min outcome among all dice in this pool."""
+209        return self._min_outcome
+210
+211    @cached_property
+212    def _max_outcome(self) -> T:
+213        return max(die.max_outcome() for die in self.unique_dice())
+214
+215    def max_outcome(self) -> T:
+216        """The max outcome among all dice in this pool."""
+217        return self._max_outcome
+218
+219    def _generate_min(self, min_outcome) -> NextMultisetGenerator:
+220        """Pops the given outcome from this pool, if it is the min outcome.
+221
+222        Yields:
+223            popped_pool: The pool after the min outcome is popped.
+224            count: The number of dice that rolled the min outcome, after
+225                accounting for keep_tuple.
+226            weight: The weight of this incremental result.
+227        """
+228        if not self.outcomes():
+229            yield self, (0,), 1
+230            return
+231        generators = [
+232            iter_die_pop_min(die, die_count, min_outcome)
+233            for die, die_count in self._dice
+234        ]
+235        skip_weight = None
+236        for pop in itertools.product(*generators):
+237            total_hits = 0
+238            result_weight = 1
+239            next_dice_counts: MutableMapping[Any, int] = defaultdict(int)
+240            for popped_die, misses, hits, weight in pop:
+241                if not popped_die.is_empty():
+242                    next_dice_counts[popped_die] += misses
+243                total_hits += hits
+244                result_weight *= weight
+245            if total_hits == 0:
+246                result_count = 0
+247                popped_keep_tuple = self.keep_tuple()
+248            else:
+249                result_count = sum(self.keep_tuple()[:total_hits])
+250                popped_keep_tuple = self.keep_tuple()[total_hits:]
+251            popped_pool = Pool._new_from_mapping(next_dice_counts,
+252                                                 popped_keep_tuple)
+253            if not any(popped_keep_tuple):
+254                # Dump all dice in exchange for the denominator.
+255                skip_weight = (skip_weight or
+256                               0) + result_weight * popped_pool.denominator()
+257                continue
+258
+259            yield popped_pool, (result_count,), result_weight
+260
+261        if skip_weight is not None:
+262            yield Pool._new_empty(), (sum(self.keep_tuple()),), skip_weight
+263
+264    def _generate_max(self, max_outcome) -> NextMultisetGenerator:
+265        """Pops the given outcome from this pool, if it is the max outcome.
+266
+267        Yields:
+268            popped_pool: The pool after the max outcome is popped.
+269            count: The number of dice that rolled the max outcome, after
+270                accounting for keep_tuple.
+271            weight: The weight of this incremental result.
+272        """
+273        if not self.outcomes():
+274            yield self, (0,), 1
+275            return
+276        generators = [
+277            iter_die_pop_max(die, die_count, max_outcome)
+278            for die, die_count in self._dice
+279        ]
+280        skip_weight = None
+281        for pop in itertools.product(*generators):
+282            total_hits = 0
+283            result_weight = 1
+284            next_dice_counts: MutableMapping[Any, int] = defaultdict(int)
+285            for popped_die, misses, hits, weight in pop:
+286                if not popped_die.is_empty():
+287                    next_dice_counts[popped_die] += misses
+288                total_hits += hits
+289                result_weight *= weight
+290            if total_hits == 0:
+291                result_count = 0
+292                popped_keep_tuple = self.keep_tuple()
+293            else:
+294                result_count = sum(self.keep_tuple()[-total_hits:])
+295                popped_keep_tuple = self.keep_tuple()[:-total_hits]
+296            popped_pool = Pool._new_from_mapping(next_dice_counts,
+297                                                 popped_keep_tuple)
+298            if not any(popped_keep_tuple):
+299                # Dump all dice in exchange for the denominator.
+300                skip_weight = (skip_weight or
+301                               0) + result_weight * popped_pool.denominator()
+302                continue
+303
+304            yield popped_pool, (result_count,), result_weight
+305
+306        if skip_weight is not None:
+307            yield Pool._new_empty(), (sum(self.keep_tuple()),), skip_weight
+308
+309    # Overrides to MultisetExpression.
+310
+311    @overload
+312    def keep(self, index: slice | Sequence[int | EllipsisType]) -> 'Pool[T]':
+313        ...
+314
+315    @overload
+316    def keep(self, index: int) -> 'icepool.Die[T]':
+317        ...
+318
+319    def keep(
+320        self, index: slice | Sequence[int | EllipsisType] | int
+321    ) -> 'Pool[T] | icepool.Die[T]':
+322        """A `Pool` with the selected dice counted after rolling and sorting.
+323
+324        Use `pool[index]` for the same effect as this method.
+325
+326        The rolls are sorted in ascending order for this purpose,
+327        regardless of which order the outcomes are evaluated in.
+328
+329        For example, here are some ways of selecting the two highest rolls out
+330        of five:
+331
+332        * `pool[3:5]`
+333        * `pool[3:]`
+334        * `pool[-2:]`
+335        * `pool[..., 1, 1]`
+336        * `pool[0, 0, 0, 1, 1]`
+337
+338        These will count the highest as a positive and the lowest as a negative:
+339
+340        * `pool[-1, 0, 0, 0, 1]`
+341        * `pool[-1, ..., 1]`
+342
+343        The valid types of argument are:
+344
+345        * An `int`. This will count only the roll at the specified index.
+346            In this case, the result is a `Die` rather than a `Pool`.
+347        * A `slice`. The selected dice are counted once each.
+348        * A sequence of one `int` for each `Die`.
+349            Each roll is counted that many times, which could be multiple or
+350            negative times.
+351
+352            Up to one `...` (`Ellipsis`) may be used.
+353            `...` will be replaced with a number of zero
+354            counts depending on the size of the pool.
+355            This number may be "negative" if more `int`s are provided than
+356            the size of the `Pool`. Specifically:
+357
+358            * If `index` is shorter than `size`, `...`
+359                acts as enough zero counts to make up the difference.
+360                E.g. `pool[1, ..., 1]` on five dice would act as
+361                `pool[1, 0, 0, 0, 1]`.
+362            * If `index` has length equal to `size`, `...` has no effect.
+363                E.g. `pool[1, ..., 1]` on two dice would act as `pool[1, 1]`.
+364            * If `index` is longer than `size` and `...` is on one side,
+365                elements will be dropped from `index` on the side with `...`.
+366                E.g. `pool[..., 1, 2, 3]` on two dice would act as `pool[2, 3]`.
+367            * If `index` is longer than `size` and `...`
+368                is in the middle, the counts will be as the sum of two
+369                one-sided `...`.
+370                E.g. `pool[-1, ..., 1]` acts like `[-1, ...]` plus `[..., 1]`.
+371                On a `Pool` consisting of a single `Die` this would have
+372                the -1 and 1 cancel each other out.
+373
+374        If this is called more than once, the selection is applied relative
+375        to the previous keep_tuple. For example, applying `[:2][-1]` would
+376        produce the second-lowest roll.
+377
+378        Raises:
+379            IndexError: If:
+380                * More than one `...` is used.
+381                * The current keep_tuple has negative counts.
+382                * The provided index specifies a fixed length that is
+383                    different than the total of the counts in the current
+384                    keep_tuple.
+385        """
+386        convert_to_die = isinstance(index, int)
+387
+388        if any(x < 0 for x in self.keep_tuple()):
+389            raise IndexError(
+390                'A pool with negative counts cannot be further indexed.')
+391
+392        relative_keep_tuple = make_keep_tuple(self.keep_size(), index)
+393
+394        # Merge keep tuples.
+395        keep_tuple: list[int] = []
+396        for x in self.keep_tuple():
+397            keep_tuple.append(sum(relative_keep_tuple[:x]))
+398            relative_keep_tuple = relative_keep_tuple[x:]
+399
+400        result = Pool._new_raw(self._dice, tuple(keep_tuple))
+401
+402        if convert_to_die:
+403            return cast(icepool.Die[T],
+404                        icepool.evaluator.KeepEvaluator().evaluate(result))
+405        else:
+406            return result
+407
+408    @overload
+409    def __getitem__(self,
+410                    index: slice | Sequence[int | EllipsisType]) -> 'Pool[T]':
+411        ...
+412
+413    @overload
+414    def __getitem__(self, index: int) -> 'icepool.Die[T]':
+415        ...
+416
+417    def __getitem__(
+418        self, index: int | slice | Sequence[int | EllipsisType]
+419    ) -> 'Pool[T] | icepool.Die[T]':
+420        return self.keep(index)
+421
+422    def lowest(self, keep: int = 1, drop: int = 0) -> 'Pool[T]':
+423        if keep < 0:
+424            raise ValueError(f'keep={keep} cannot be negative.')
+425        if drop < 0:
+426            raise ValueError(f'drop={drop} cannot be negative.')
+427
+428        start = min(drop, self.keep_size())
+429        stop = min(keep + drop, self.keep_size())
+430        return self[start:stop]
+431
+432    def highest(self, keep: int = 1, drop: int = 0) -> 'Pool[T]':
+433        if keep < 0:
+434            raise ValueError(f'keep={keep} cannot be negative.')
+435        if drop < 0:
+436            raise ValueError(f'drop={drop} cannot be negative.')
+437
+438        start = self.keep_size() - min(keep + drop, self.keep_size())
+439        stop = self.keep_size() - min(drop, self.keep_size())
+440        return self[start:stop]
+441
+442    def middle(self,
+443               keep: int = 1,
+444               *,
+445               tie: Literal['error', 'high', 'low'] = 'error') -> 'Pool[T]':
+446        """Keep some of the middle elements from this multiset and drop the rest.
+447
+448        In contrast to the die and free function versions, this does not
+449        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+450        Alternatively, you can perform some other evaluation.
+451
+452        Args:
+453            keep: The number of elements to keep. If this is greater than the
+454                current keep_size, all are kept.
+455            tie: What to do if `keep` is odd but the current keep_size
+456                is even, or vice versa.
+457                * 'error' (default): Raises `IndexError`.
+458                * 'low': The lower of the two possible elements is taken.
+459                * 'high': The higher of the two possible elements is taken.
+460        """
+461        if keep < 0:
+462            raise ValueError(f'keep={keep} cannot be negative.')
+463
+464        if keep % 2 == self.keep_size() % 2:
+465            # The "good" case.
+466            start = (self.keep_size() - keep) // 2
+467        else:
+468            # Need to consult the tiebreaker.
+469            match tie:
+470                case 'error':
+471                    raise IndexError(
+472                        f'The middle {keep} of {self.keep_size()} elements is ambiguous.\n'
+473                        "Specify tie='low' or tie='high' to determine what to pick."
+474                    )
+475                case 'high':
+476                    start = (self.keep_size() + 1 - keep) // 2
+477                case 'low':
+478                    start = (self.keep_size() - 1 - keep) // 2
+479                case _:
+480                    raise ValueError(
+481                        f"Invalid value for tie {tie}. Expected 'error', 'low', or 'high'."
+482                    )
+483        stop = start + keep
+484        return self[start:stop]
+485
+486    def __add__(
+487        self, other: 'MultisetExpression[T] | Mapping[T, int] | Sequence[T]'
+488    ) -> 'MultisetExpression[T]':
+489        try:
+490            return self.additive_union(other)
+491        except TypeError:
+492            return NotImplemented
+493
+494    def __radd__(
+495        self, other: 'MultisetExpression[T] | Mapping[T, int] | Sequence[T]'
+496    ) -> 'MultisetExpression[T]':
+497        try:
+498            return self.additive_union(other)
+499        except TypeError:
+500            return NotImplemented
+501
+502    def additive_union(
+503            *args: 'MultisetExpression[T] | Mapping[T, int] | Sequence[T]',
+504            keep_negative_counts: bool = False) -> 'MultisetExpression[T]':
+505        """The combined elements from all the multisets.
+506
+507        We have an optimization here if all arguments are pools with all sorted
+508        positions counted the same. In this case we can merge the pools directly
+509        instead of merging the rolls after the fact.
+510
+511        keep_negative_counts: If set, if the result would have a negative 
+512                count, it is preserved. Otherwise, negative counts in the result
+513                are set to zero, similar to the behavior of
+514                `collections.Counter`.
+515        """
+516        args = tuple(
+517            icepool.expression.implicit_convert_to_expression(arg)
+518            for arg in args)
+519        if all(isinstance(arg, Pool) for arg in args):
+520            pools = cast(tuple[Pool, ...], args)
+521            keep_tuple: tuple[int, ...] = tuple(
+522                reduce(operator.add, (pool.keep_tuple() for pool in pools), ()))
+523            if len(keep_tuple) == 0:
+524                # All empty.
+525                return Pool._new_empty()
+526            if all(x == keep_tuple[0] for x in keep_tuple):
+527                # All sorted positions count the same, so we can merge the
+528                # pools.
+529                if keep_tuple[0] < 0 and not keep_negative_counts:
+530                    return Pool._new_empty()
+531                else:
+532                    dice: 'MutableMapping[icepool.Die, int]' = defaultdict(int)
+533                    for pool in pools:
+534                        for die, die_count in pool._dice:
+535                            dice[die] += die_count
+536                return Pool._new_from_mapping(dice, keep_tuple)
+537        return icepool.expression.MultisetExpression.additive_union(
+538            *args, keep_negative_counts=keep_negative_counts)
+539
+540    def __mul__(self, other: int) -> 'Pool[T]':
+541        if not isinstance(other, int):
+542            return NotImplemented
+543        return self.multiply_counts(other)
+544
+545    # Commutable in this case.
+546    def __rmul__(self, other: int) -> 'Pool[T]':
+547        if not isinstance(other, int):
+548            return NotImplemented
+549        return self.multiply_counts(other)
+550
+551    def multiply_counts(self, constant: int, /) -> 'Pool[T]':
+552        return Pool._new_raw(self._dice,
+553                             tuple(x * constant for x in self.keep_tuple()))
+554
+555    def __str__(self) -> str:
+556        return (
+557            f'Pool of {self.raw_size()} dice with keep_tuple={self.keep_tuple()}\n'
+558            + ''.join(f'  {repr(die)}\n' for die in self._dice_tuple))
+559
+560    @cached_property
+561    def _hash_key(self) -> tuple:
+562        return Pool, self._dice, self._keep_tuple
+
+ + +

Represents a multiset of outcomes resulting from the roll of several dice.

+ +

This should be used in conjunction with MultisetEvaluator to generate a +result.

+ +

Note that operators are performed on the multiset of rolls, not the multiset +of dice. For example, d6.pool(3) - d6.pool(3) is not an empty pool, but +an expression meaning "roll two pools of 3d6 and get the rolls from the +first pool, with rolls in the second pool cancelling matching rolls in the +first pool one-for-one".

+
+ + +
+ +
+ + Pool( dice: Union[Sequence[Union[Die[~T], ~T]], Mapping[Die[~T], int], Mapping[~T, int], Mapping[Union[Die[~T], ~T], int]], times: Union[Sequence[int], int] = 1) + + + +
+ + 
42    def __new__(
+43            cls,
+44            dice:
+45        'Sequence[icepool.Die[T] | T] | Mapping[icepool.Die[T], int] | Mapping[T, int] | Mapping[icepool.Die[T] | T, int]',
+46            times: Sequence[int] | int = 1) -> 'Pool':
+47        """Public constructor for a pool.
+48
+49        Evaulation is most efficient when the dice are the same or same-side
+50        truncations of each other. For example, d4, d6, d8, d10, d12 are all
+51        same-side truncations of d12.
+52
+53        It is permissible to create a `Pool` without providing dice, but not all
+54        evaluators will handle this case, especially if they depend on the
+55        outcome type. In this case you may want to provide a die with zero
+56        quantity.
+57
+58        Args:
+59            dice: The dice to put in the `Pool`. This can be one of the following:
+60
+61                * A `Sequence` of `Die` or outcomes.
+62                * A `Mapping` of `Die` or outcomes to how many of that `Die` or
+63                    outcome to put in the `Pool`.
+64
+65                All outcomes within a `Pool` must be totally orderable.
+66            times: Multiplies the number of times each element of `dice` will
+67                be put into the pool.
+68                `times` can either be a sequence of the same length as
+69                `outcomes` or a single `int` to apply to all elements of
+70                `outcomes`.
+71
+72        Raises:
+73            ValueError: If a bare `Deck` or `Die` argument is provided.
+74                A `Pool` of a single `Die` should constructed as `Pool([die])`.
+75        """
+76        if isinstance(dice, Pool):
+77            if times == 1:
+78                return dice
+79            else:
+80                dice = {die: quantity for die, quantity in dice._dice}
+81
+82        if isinstance(dice, (icepool.Die, icepool.Deck, icepool.Deal)):
+83            raise ValueError(
+84                f'A Pool cannot be constructed with a {type(dice).__name__} argument.'
+85            )
+86
+87        dice, times = icepool.creation_args.itemize(dice, times)
+88        converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+89
+90        dice_counts: MutableMapping['icepool.Die[T]', int] = defaultdict(int)
+91        for die, qty in zip(converted_dice, times):
+92            dice_counts[die] += qty
+93        keep_tuple = (1,) * sum(times)
+94        return cls._new_from_mapping(dice_counts, keep_tuple)
+
+ + +

Public constructor for a pool.

+ +

Evaulation is most efficient when the dice are the same or same-side +truncations of each other. For example, d4, d6, d8, d10, d12 are all +same-side truncations of d12.

+ +

It is permissible to create a Pool without providing dice, but not all +evaluators will handle this case, especially if they depend on the +outcome type. In this case you may want to provide a die with zero +quantity.

+ +
Arguments:
+ +
    +

  • dice: The dice to put in the Pool. This can be one of the following:

    + +
      +
    • A Sequence of Die or outcomes.
      • +
    • A Mapping of Die or outcomes to how many of that Die or +outcome to put in the Pool.
      • +
    + +

    All outcomes within a Pool must be totally orderable.

    • +
  • times: Multiplies the number of times each element of dice will +be put into the pool. +times can either be a sequence of the same length as +outcomes or a single int to apply to all elements of +outcomes.
    • +
+ +
Raises:
+ +
    +
  • ValueError: If a bare Deck or Die argument is provided. +A Pool of a single Die should constructed as Pool([die]).
    • +
+
+ + +
+
+ +
+
@classmethod
+ + def + clear_cache(cls): + + + +
+ + 
115    @classmethod
+116    def clear_cache(cls):
+117        """Clears the global pool cache."""
+118        Pool._new_raw.cache_clear()
+
+ + +

Clears the global pool cache.

+
+ + +
+
+ +
+ + def + raw_size(self) -> int: + + + +
+ + 
137    def raw_size(self) -> int:
+138        """The number of dice in this pool before the keep_tuple is applied."""
+139        return self._raw_size
+
+ + +

The number of dice in this pool before the keep_tuple is applied.

+
+ + +
+
+ +
+ + def + keep_size(self) -> int: + + + +
+ + 
145    def keep_size(self) -> int:
+146        """The total count produced by this pool after the keep_tuple is applied."""
+147        return self._keep_size
+
+ + +

The total count produced by this pool after the keep_tuple is applied.

+
+ + +
+
+ +
+ + def + denominator(self) -> int: + + + +
+ + 
156    def denominator(self) -> int:
+157        return self._denominator
+
+ + +

The total weight of all paths through this generator.

+
+ + +
+
+ +
+ + def + unique_dice(self) -> Collection[Die[~T]]: + + + +
+ + 
167    def unique_dice(self) -> Collection['icepool.Die[T]']:
+168        """The collection of unique dice in this pool."""
+169        return self._unique_dice
+
+ + +

The collection of unique dice in this pool.

+
+ + +
+
+ +
+ + def + outcomes(self) -> Sequence[~T]: + + + +
+ + 
178    def outcomes(self) -> Sequence[T]:
+179        """The union of possible outcomes among all dice in this pool in ascending order."""
+180        return self._outcomes
+
+ + +

The union of possible outcomes among all dice in this pool in ascending order.

+
+ + +
+
+ +
+ + def + output_arity(self) -> int: + + + +
+ + 
182    def output_arity(self) -> int:
+183        return 1
+
+ + +

The number of multisets/counts generated. Must be constant.

+
+ + +
+
+ +
+ + def + keep_tuple(self) -> tuple[int, ...]: + + + +
+ + 
194    def keep_tuple(self) -> tuple[int, ...]:
+195        """The tuple indicating which dice in the pool will be counted.
+196
+197        The tuple has one element per `Die` in the pool, from lowest roll to
+198        highest roll. The `Die` in the corresponding sorted position will be
+199        counted that many times.
+200        """
+201        return self._keep_tuple
+
+ + +

The tuple indicating which dice in the pool will be counted.

+ +

The tuple has one element per Die in the pool, from lowest roll to +highest roll. The Die in the corresponding sorted position will be +counted that many times.

+
+ + +
+
+ +
+ + def + min_outcome(self) -> ~T: + + + +
+ + 
207    def min_outcome(self) -> T:
+208        """The min outcome among all dice in this pool."""
+209        return self._min_outcome
+
+ + +

The min outcome among all dice in this pool.

+
+ + +
+
+ +
+ + def + max_outcome(self) -> ~T: + + + +
+ + 
215    def max_outcome(self) -> T:
+216        """The max outcome among all dice in this pool."""
+217        return self._max_outcome
+
+ + +

The max outcome among all dice in this pool.

+
+ + +
+
+ +
+ + def + keep( self, index: Union[slice, Sequence[int | ellipsis], int]) -> Union[Pool[~T], Die[~T]]: + + + +
+ + 
319    def keep(
+320        self, index: slice | Sequence[int | EllipsisType] | int
+321    ) -> 'Pool[T] | icepool.Die[T]':
+322        """A `Pool` with the selected dice counted after rolling and sorting.
+323
+324        Use `pool[index]` for the same effect as this method.
+325
+326        The rolls are sorted in ascending order for this purpose,
+327        regardless of which order the outcomes are evaluated in.
+328
+329        For example, here are some ways of selecting the two highest rolls out
+330        of five:
+331
+332        * `pool[3:5]`
+333        * `pool[3:]`
+334        * `pool[-2:]`
+335        * `pool[..., 1, 1]`
+336        * `pool[0, 0, 0, 1, 1]`
+337
+338        These will count the highest as a positive and the lowest as a negative:
+339
+340        * `pool[-1, 0, 0, 0, 1]`
+341        * `pool[-1, ..., 1]`
+342
+343        The valid types of argument are:
+344
+345        * An `int`. This will count only the roll at the specified index.
+346            In this case, the result is a `Die` rather than a `Pool`.
+347        * A `slice`. The selected dice are counted once each.
+348        * A sequence of one `int` for each `Die`.
+349            Each roll is counted that many times, which could be multiple or
+350            negative times.
+351
+352            Up to one `...` (`Ellipsis`) may be used.
+353            `...` will be replaced with a number of zero
+354            counts depending on the size of the pool.
+355            This number may be "negative" if more `int`s are provided than
+356            the size of the `Pool`. Specifically:
+357
+358            * If `index` is shorter than `size`, `...`
+359                acts as enough zero counts to make up the difference.
+360                E.g. `pool[1, ..., 1]` on five dice would act as
+361                `pool[1, 0, 0, 0, 1]`.
+362            * If `index` has length equal to `size`, `...` has no effect.
+363                E.g. `pool[1, ..., 1]` on two dice would act as `pool[1, 1]`.
+364            * If `index` is longer than `size` and `...` is on one side,
+365                elements will be dropped from `index` on the side with `...`.
+366                E.g. `pool[..., 1, 2, 3]` on two dice would act as `pool[2, 3]`.
+367            * If `index` is longer than `size` and `...`
+368                is in the middle, the counts will be as the sum of two
+369                one-sided `...`.
+370                E.g. `pool[-1, ..., 1]` acts like `[-1, ...]` plus `[..., 1]`.
+371                On a `Pool` consisting of a single `Die` this would have
+372                the -1 and 1 cancel each other out.
+373
+374        If this is called more than once, the selection is applied relative
+375        to the previous keep_tuple. For example, applying `[:2][-1]` would
+376        produce the second-lowest roll.
+377
+378        Raises:
+379            IndexError: If:
+380                * More than one `...` is used.
+381                * The current keep_tuple has negative counts.
+382                * The provided index specifies a fixed length that is
+383                    different than the total of the counts in the current
+384                    keep_tuple.
+385        """
+386        convert_to_die = isinstance(index, int)
+387
+388        if any(x < 0 for x in self.keep_tuple()):
+389            raise IndexError(
+390                'A pool with negative counts cannot be further indexed.')
+391
+392        relative_keep_tuple = make_keep_tuple(self.keep_size(), index)
+393
+394        # Merge keep tuples.
+395        keep_tuple: list[int] = []
+396        for x in self.keep_tuple():
+397            keep_tuple.append(sum(relative_keep_tuple[:x]))
+398            relative_keep_tuple = relative_keep_tuple[x:]
+399
+400        result = Pool._new_raw(self._dice, tuple(keep_tuple))
+401
+402        if convert_to_die:
+403            return cast(icepool.Die[T],
+404                        icepool.evaluator.KeepEvaluator().evaluate(result))
+405        else:
+406            return result
+
+ + +

A Pool with the selected dice counted after rolling and sorting.

+ +

Use pool[index] for the same effect as this method.

+ +

The rolls are sorted in ascending order for this purpose, +regardless of which order the outcomes are evaluated in.

+ +

For example, here are some ways of selecting the two highest rolls out +of five:

+ +
    +
  • pool[3:5]
    • +
  • pool[3:]
    • +
  • pool[-2:]
    • +
  • pool[..., 1, 1]
    • +
  • pool[0, 0, 0, 1, 1]
    • +
+ +

These will count the highest as a positive and the lowest as a negative:

+ +
    +
  • pool[-1, 0, 0, 0, 1]
    • +
  • pool[-1, ..., 1]
    • +
+ +

The valid types of argument are:

+ +
    +
  • An int. This will count only the roll at the specified index. +In this case, the result is a Die rather than a Pool.
    • +
  • A slice. The selected dice are counted once each.
    • +

  • A sequence of one int for each Die. +Each roll is counted that many times, which could be multiple or +negative times.

    + +

    Up to one ... (Ellipsis) may be used. +... will be replaced with a number of zero +counts depending on the size of the pool. +This number may be "negative" if more ints are provided than +the size of the Pool. Specifically:

    + +
      +
    • If index is shorter than size, ... +acts as enough zero counts to make up the difference. +E.g. pool[1, ..., 1] on five dice would act as +pool[1, 0, 0, 0, 1].
      • +
    • If index has length equal to size, ... has no effect. +E.g. pool[1, ..., 1] on two dice would act as pool[1, 1].
      • +
    • If index is longer than size and ... is on one side, +elements will be dropped from index on the side with .... +E.g. pool[..., 1, 2, 3] on two dice would act as pool[2, 3].
      • +
    • If index is longer than size and ... +is in the middle, the counts will be as the sum of two +one-sided .... +E.g. pool[-1, ..., 1] acts like [-1, ...] plus [..., 1]. +On a Pool consisting of a single Die this would have +the -1 and 1 cancel each other out.
      • +
    • +
+ +

If this is called more than once, the selection is applied relative +to the previous keep_tuple. For example, applying [:2][-1] would +produce the second-lowest roll.

+ +
Raises:
+ +
    +
  • IndexError: If: +
      +
    • More than one ... is used.
      • +
    • The current keep_tuple has negative counts.
      • +
    • The provided index specifies a fixed length that is +different than the total of the counts in the current +keep_tuple.
      • +
    • +
+
+ + +
+
+ +
+ + def + lowest(self, keep: int = 1, drop: int = 0) -> Pool[~T]: + + + +
+ + 
422    def lowest(self, keep: int = 1, drop: int = 0) -> 'Pool[T]':
+423        if keep < 0:
+424            raise ValueError(f'keep={keep} cannot be negative.')
+425        if drop < 0:
+426            raise ValueError(f'drop={drop} cannot be negative.')
+427
+428        start = min(drop, self.keep_size())
+429        stop = min(keep + drop, self.keep_size())
+430        return self[start:stop]
+
+ + +

Keep some of the lowest elements from this multiset and drop the rest.

+ +

In contrast to the die and free function versions, this does not +automatically sum the dice. Use .sum() afterwards if you want to sum. +Alternatively, you can perform some other evaluation.

+ +

This requires the outcomes to be evaluated in ascending order.

+ +
Arguments:
+ +
    +
  • keep: The number of lowest elements will be kept.
    • +
  • drop: This number of lowest elements will be dropped before keeping.
    • +
+
+ + +
+
+ +
+ + def + highest(self, keep: int = 1, drop: int = 0) -> Pool[~T]: + + + +
+ + 
432    def highest(self, keep: int = 1, drop: int = 0) -> 'Pool[T]':
+433        if keep < 0:
+434            raise ValueError(f'keep={keep} cannot be negative.')
+435        if drop < 0:
+436            raise ValueError(f'drop={drop} cannot be negative.')
+437
+438        start = self.keep_size() - min(keep + drop, self.keep_size())
+439        stop = self.keep_size() - min(drop, self.keep_size())
+440        return self[start:stop]
+
+ + +

Keep some of the highest elements from this multiset and drop the rest.

+ +

In contrast to the die and free function versions, this does not +automatically sum the dice. Use .sum() afterwards if you want to sum. +Alternatively, you can perform some other evaluation.

+ +

This requires the outcomes to be evaluated in descending order.

+ +
Arguments:
+ +
    +
  • keep: The number of highest elements will be kept.
    • +
  • drop: This number of highest elements will be dropped before keeping.
    • +
+
+ + +
+
+ +
+ + def + middle( self, keep: int = 1, *, tie: Literal['error', 'high', 'low'] = 'error') -> Pool[~T]: + + + +
+ + 
442    def middle(self,
+443               keep: int = 1,
+444               *,
+445               tie: Literal['error', 'high', 'low'] = 'error') -> 'Pool[T]':
+446        """Keep some of the middle elements from this multiset and drop the rest.
+447
+448        In contrast to the die and free function versions, this does not
+449        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+450        Alternatively, you can perform some other evaluation.
+451
+452        Args:
+453            keep: The number of elements to keep. If this is greater than the
+454                current keep_size, all are kept.
+455            tie: What to do if `keep` is odd but the current keep_size
+456                is even, or vice versa.
+457                * 'error' (default): Raises `IndexError`.
+458                * 'low': The lower of the two possible elements is taken.
+459                * 'high': The higher of the two possible elements is taken.
+460        """
+461        if keep < 0:
+462            raise ValueError(f'keep={keep} cannot be negative.')
+463
+464        if keep % 2 == self.keep_size() % 2:
+465            # The "good" case.
+466            start = (self.keep_size() - keep) // 2
+467        else:
+468            # Need to consult the tiebreaker.
+469            match tie:
+470                case 'error':
+471                    raise IndexError(
+472                        f'The middle {keep} of {self.keep_size()} elements is ambiguous.\n'
+473                        "Specify tie='low' or tie='high' to determine what to pick."
+474                    )
+475                case 'high':
+476                    start = (self.keep_size() + 1 - keep) // 2
+477                case 'low':
+478                    start = (self.keep_size() - 1 - keep) // 2
+479                case _:
+480                    raise ValueError(
+481                        f"Invalid value for tie {tie}. Expected 'error', 'low', or 'high'."
+482                    )
+483        stop = start + keep
+484        return self[start:stop]
+
+ + +

Keep some of the middle elements from this multiset and drop the rest.

+ +

In contrast to the die and free function versions, this does not +automatically sum the dice. Use .sum() afterwards if you want to sum. +Alternatively, you can perform some other evaluation.

+ +
Arguments:
+ +
    +
  • keep: The number of elements to keep. If this is greater than the +current keep_size, all are kept.
    • +
  • tie: What to do if keep is odd but the current keep_size +is even, or vice versa. +
      +
    • 'error' (default): Raises IndexError.
      • +
    • 'low': The lower of the two possible elements is taken.
      • +
    • 'high': The higher of the two possible elements is taken.
      • +
    • +
+
+ + +
+
+ +
+ + def + additive_union( *args: Union[MultisetExpression[~T], Mapping[~T, int], Sequence[~T]], keep_negative_counts: bool = False) -> MultisetExpression[~T]: + + + +
+ + 
502    def additive_union(
+503            *args: 'MultisetExpression[T] | Mapping[T, int] | Sequence[T]',
+504            keep_negative_counts: bool = False) -> 'MultisetExpression[T]':
+505        """The combined elements from all the multisets.
+506
+507        We have an optimization here if all arguments are pools with all sorted
+508        positions counted the same. In this case we can merge the pools directly
+509        instead of merging the rolls after the fact.
+510
+511        keep_negative_counts: If set, if the result would have a negative 
+512                count, it is preserved. Otherwise, negative counts in the result
+513                are set to zero, similar to the behavior of
+514                `collections.Counter`.
+515        """
+516        args = tuple(
+517            icepool.expression.implicit_convert_to_expression(arg)
+518            for arg in args)
+519        if all(isinstance(arg, Pool) for arg in args):
+520            pools = cast(tuple[Pool, ...], args)
+521            keep_tuple: tuple[int, ...] = tuple(
+522                reduce(operator.add, (pool.keep_tuple() for pool in pools), ()))
+523            if len(keep_tuple) == 0:
+524                # All empty.
+525                return Pool._new_empty()
+526            if all(x == keep_tuple[0] for x in keep_tuple):
+527                # All sorted positions count the same, so we can merge the
+528                # pools.
+529                if keep_tuple[0] < 0 and not keep_negative_counts:
+530                    return Pool._new_empty()
+531                else:
+532                    dice: 'MutableMapping[icepool.Die, int]' = defaultdict(int)
+533                    for pool in pools:
+534                        for die, die_count in pool._dice:
+535                            dice[die] += die_count
+536                return Pool._new_from_mapping(dice, keep_tuple)
+537        return icepool.expression.MultisetExpression.additive_union(
+538            *args, keep_negative_counts=keep_negative_counts)
+
+ + +

The combined elements from all the multisets.

+ +

We have an optimization here if all arguments are pools with all sorted +positions counted the same. In this case we can merge the pools directly +instead of merging the rolls after the fact.

+ +

keep_negative_counts: If set, if the result would have a negative + count, it is preserved. Otherwise, negative counts in the result + are set to zero, similar to the behavior of + collections.Counter.

+
+ + +
+
+ +
+ + def + multiply_counts(self, constant: int, /) -> Pool[~T]: + + + +
+ + 
551    def multiply_counts(self, constant: int, /) -> 'Pool[T]':
+552        return Pool._new_raw(self._dice,
+553                             tuple(x * constant for x in self.keep_tuple()))
+
+ + +

Multiplies all counts by a constant.

+ +

Same as self * constant.

+ +

Example:

+ +
Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]
+
+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + def + standard_pool( die_sizes: Union[Collection[int], Mapping[int, int]]) -> Pool[int]: + + + +
+ + 
642def standard_pool(
+643        die_sizes: Collection[int] | Mapping[int, int]) -> 'Pool[int]':
+644    """A `Pool` of standard dice (e.g. d6, d8...).
+645
+646    Args:
+647        die_sizes: A collection of die sizes, which will put one die of that
+648            sizes in the pool for each element.
+649            Or, a mapping of die sizes to how many dice of that size to put
+650            into the pool.
+651            If empty, the pool will be considered to consist of 0d1.
+652    """
+653    if not die_sizes:
+654        return Pool({1: 0})
+655    if isinstance(die_sizes, Mapping):
+656        die_sizes = list(
+657            itertools.chain.from_iterable(
+658                [k] * v for k, v in die_sizes.items()))
+659    return Pool(list(icepool.d(x) for x in die_sizes))
+
+ + +

A Pool of standard dice (e.g. d6, d8...).

+ +
Arguments:
+ +
    +
  • die_sizes: A collection of die sizes, which will put one die of that +sizes in the pool for each element. +Or, a mapping of die sizes to how many dice of that size to put +into the pool. +If empty, the pool will be considered to consist of 0d1.
    • +
+
+ + +
+
+ +
+ + class + MultisetGenerator(typing.Generic[~T, ~Qs], icepool.MultisetExpression[~T]): + + + +
+ + 
 27class MultisetGenerator(Generic[T, Qs], MultisetExpression[T]):
+ 28    """Abstract base class for generating one or more multisets.
+ 29
+ 30    These include dice pools (`Pool`) and card deals (`Deal`). Most likely you
+ 31    will be using one of these two rather than writing your own subclass of
+ 32    `MultisetGenerator`.
+ 33
+ 34    The multisets are incrementally generated one outcome at a time.
+ 35    For each outcome, a `count` and `weight` are generated, along with a
+ 36    smaller generator to produce the rest of the multiset.
+ 37
+ 38    You can perform simple evaluations using built-in operators and methods in
+ 39    this class.
+ 40    For more complex evaluations and better performance, particularly when
+ 41    multiple generators are involved, you will want to write your own subclass
+ 42    of `MultisetEvaluator`.
+ 43    """
+ 44
+ 45    @abstractmethod
+ 46    def outcomes(self) -> Sequence[T]:
+ 47        """The possible outcomes that could be generated, in ascending order."""
+ 48
+ 49    @abstractmethod
+ 50    def output_arity(self) -> int:
+ 51        """The number of multisets/counts generated. Must be constant."""
+ 52
+ 53    @abstractmethod
+ 54    def _is_resolvable(self) -> bool:
+ 55        """`True` iff the generator is capable of producing an overall outcome.
+ 56
+ 57        For example, a dice `Pool` will return `False` if it contains any dice
+ 58        with no outcomes.
+ 59        """
+ 60
+ 61    @abstractmethod
+ 62    def _generate_min(self, min_outcome) -> NextMultisetGenerator:
+ 63        """Pops the min outcome from this generator if it matches the argument.
+ 64
+ 65        Yields:
+ 66            * A generator with the min outcome popped.
+ 67            * A tuple of counts for the min outcome.
+ 68            * The weight for this many of the min outcome appearing.
+ 69
+ 70            If the argument does not match the min outcome, or this generator
+ 71            has no outcomes, only a single tuple is yielded:
+ 72
+ 73            * `self`
+ 74            * A tuple of zeros.
+ 75            * weight = 1.
+ 76        """
+ 77
+ 78    @abstractmethod
+ 79    def _generate_max(self, max_outcome) -> NextMultisetGenerator:
+ 80        """Pops the max outcome from this generator if it matches the argument.
+ 81
+ 82        Yields:
+ 83            * A generator with the min outcome popped.
+ 84            * A tuple of counts for the min outcome.
+ 85            * The weight for this many of the min outcome appearing.
+ 86
+ 87            If the argument does not match the min outcome, or this generator
+ 88            has no outcomes, only a single tuple is yielded:
+ 89
+ 90            * `self`
+ 91            * A tuple of zeros.
+ 92            * weight = 1.
+ 93        """
+ 94
+ 95    @abstractmethod
+ 96    def _estimate_order_costs(self) -> tuple[int, int]:
+ 97        """Estimates the cost of popping from the min and max sides during an evaluation.
+ 98
+ 99        Returns:
+100            pop_min_cost: A positive `int`.
+101            pop_max_cost: A positive `int`.
+102        """
+103
+104    @abstractmethod
+105    def denominator(self) -> int:
+106        """The total weight of all paths through this generator."""
+107
+108    @property
+109    @abstractmethod
+110    def _hash_key(self) -> Hashable:
+111        """A hash key that logically identifies this object among MultisetGenerators.
+112
+113        Used to implement `equals()` and `__hash__()`
+114        """
+115
+116    def equals(self, other) -> bool:
+117        """Whether this generator is logically equal to another object."""
+118        if not isinstance(other, MultisetGenerator):
+119            return False
+120        return self._hash_key == other._hash_key
+121
+122    @cached_property
+123    def _hash(self) -> int:
+124        return hash(self._hash_key)
+125
+126    def __hash__(self) -> int:
+127        return self._hash
+128
+129    # Equality with truth value, needed for hashing.
+130
+131    # The result has a truth value, but is not a bool.
+132    def __eq__(  # type: ignore
+133            self, other) -> 'icepool.DieWithTruth[bool]':
+134
+135        def data_callback() -> Counts[bool]:
+136            die = cast('icepool.Die[bool]',
+137                       MultisetExpression.__eq__(self, other))
+138            if not isinstance(die, icepool.Die):
+139                raise TypeError('Did not resolve to a die.')
+140            return die._data
+141
+142        def truth_value_callback() -> bool:
+143            if not isinstance(other, MultisetGenerator):
+144                return False
+145            return self._hash_key == other._hash_key
+146
+147        return icepool.DieWithTruth(data_callback, truth_value_callback)
+148
+149    # The result has a truth value, but is not a bool.
+150    def __ne__(  # type: ignore
+151            self, other) -> 'icepool.DieWithTruth[bool]':
+152
+153        def data_callback() -> Counts[bool]:
+154            die = cast('icepool.Die[bool]',
+155                       MultisetExpression.__ne__(self, other))
+156            if not isinstance(die, icepool.Die):
+157                raise TypeError('Did not resolve to a die.')
+158            return die._data
+159
+160        def truth_value_callback() -> bool:
+161            if not isinstance(other, MultisetGenerator):
+162                return True
+163            return self._hash_key != other._hash_key
+164
+165        return icepool.DieWithTruth(data_callback, truth_value_callback)
+166
+167    # Expression API.
+168
+169    def _next_state(self, state, outcome: Outcome, *counts:
+170                    int) -> tuple[Hashable, int]:
+171        raise RuntimeError(
+172            'Internal error: Expressions should be unbound before evaluation.')
+173
+174    def _order(self) -> Order:
+175        return Order.Any
+176
+177    def _bound_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+178        return (self,)
+179
+180    def _unbind(self, prefix_start: int,
+181                free_start: int) -> 'tuple[MultisetExpression, int]':
+182        unbound_expression = icepool.expression.MultisetVariable(prefix_start)
+183        return unbound_expression, prefix_start + 1
+184
+185    def _free_arity(self) -> int:
+186        return 0
+187
+188    def min_outcome(self) -> T:
+189        return self.outcomes()[0]
+190
+191    def max_outcome(self) -> T:
+192        return self.outcomes()[-1]
+193
+194    # Sampling.
+195
+196    def sample(self) -> tuple[tuple, ...]:
+197        """EXPERIMENTAL: A single random sample from this generator.
+198
+199        This uses the standard `random` package and is not cryptographically
+200        secure.
+201
+202        Returns:
+203            A sorted tuple of outcomes for each output of this generator.
+204        """
+205        if not self.outcomes():
+206            raise ValueError('Cannot sample from an empty set of outcomes.')
+207
+208        min_cost, max_cost = self._estimate_order_costs()
+209
+210        if min_cost < max_cost:
+211            outcome = self.min_outcome()
+212            generated = tuple(self._generate_min(outcome))
+213        else:
+214            outcome = self.max_outcome()
+215            generated = tuple(self._generate_max(outcome))
+216
+217        cumulative_weights = tuple(
+218            itertools.accumulate(g.denominator() * w for g, _, w in generated))
+219        denominator = cumulative_weights[-1]
+220        # We don't use random.choices since that is based on floats rather than ints.
+221        r = random.randrange(denominator)
+222        index = bisect.bisect_right(cumulative_weights, r)
+223        popped_generator, counts, _ = generated[index]
+224        head = tuple((outcome,) * count for count in counts)
+225        if popped_generator.outcomes():
+226            tail = popped_generator.sample()
+227            return tuple(tuple(sorted(h + t)) for h, t, in zip(head, tail))
+228        else:
+229            return head
+
+ + +

Abstract base class for generating one or more multisets.

+ +

These include dice pools (Pool) and card deals (Deal). Most likely you +will be using one of these two rather than writing your own subclass of +MultisetGenerator.

+ +

The multisets are incrementally generated one outcome at a time. +For each outcome, a count and weight are generated, along with a +smaller generator to produce the rest of the multiset.

+ +

You can perform simple evaluations using built-in operators and methods in +this class. +For more complex evaluations and better performance, particularly when +multiple generators are involved, you will want to write your own subclass +of MultisetEvaluator.

+
+ + +
+ +
+
@abstractmethod
+ + def + outcomes(self) -> Sequence[~T]: + + + +
+ + 
45    @abstractmethod
+46    def outcomes(self) -> Sequence[T]:
+47        """The possible outcomes that could be generated, in ascending order."""
+
+ + +

The possible outcomes that could be generated, in ascending order.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + output_arity(self) -> int: + + + +
+ + 
49    @abstractmethod
+50    def output_arity(self) -> int:
+51        """The number of multisets/counts generated. Must be constant."""
+
+ + +

The number of multisets/counts generated. Must be constant.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + denominator(self) -> int: + + + +
+ + 
104    @abstractmethod
+105    def denominator(self) -> int:
+106        """The total weight of all paths through this generator."""
+
+ + +

The total weight of all paths through this generator.

+
+ + +
+
+ +
+ + def + equals(self, other) -> bool: + + + +
+ + 
116    def equals(self, other) -> bool:
+117        """Whether this generator is logically equal to another object."""
+118        if not isinstance(other, MultisetGenerator):
+119            return False
+120        return self._hash_key == other._hash_key
+
+ + +

Whether this generator is logically equal to another object.

+
+ + +
+
+ +
+ + def + min_outcome(self) -> ~T: + + + +
+ + 
188    def min_outcome(self) -> T:
+189        return self.outcomes()[0]
+
+ + + + +
+
+ +
+ + def + max_outcome(self) -> ~T: + + + +
+ + 
191    def max_outcome(self) -> T:
+192        return self.outcomes()[-1]
+
+ + + + +
+
+ +
+ + def + sample(self) -> tuple[tuple, ...]: + + + +
+ + 
196    def sample(self) -> tuple[tuple, ...]:
+197        """EXPERIMENTAL: A single random sample from this generator.
+198
+199        This uses the standard `random` package and is not cryptographically
+200        secure.
+201
+202        Returns:
+203            A sorted tuple of outcomes for each output of this generator.
+204        """
+205        if not self.outcomes():
+206            raise ValueError('Cannot sample from an empty set of outcomes.')
+207
+208        min_cost, max_cost = self._estimate_order_costs()
+209
+210        if min_cost < max_cost:
+211            outcome = self.min_outcome()
+212            generated = tuple(self._generate_min(outcome))
+213        else:
+214            outcome = self.max_outcome()
+215            generated = tuple(self._generate_max(outcome))
+216
+217        cumulative_weights = tuple(
+218            itertools.accumulate(g.denominator() * w for g, _, w in generated))
+219        denominator = cumulative_weights[-1]
+220        # We don't use random.choices since that is based on floats rather than ints.
+221        r = random.randrange(denominator)
+222        index = bisect.bisect_right(cumulative_weights, r)
+223        popped_generator, counts, _ = generated[index]
+224        head = tuple((outcome,) * count for count in counts)
+225        if popped_generator.outcomes():
+226            tail = popped_generator.sample()
+227            return tuple(tuple(sorted(h + t)) for h, t, in zip(head, tail))
+228        else:
+229            return head
+
+ + +

EXPERIMENTAL: A single random sample from this generator.

+ +

This uses the standard random package and is not cryptographically +secure.

+ +
Returns:
+ +
+

A sorted tuple of outcomes for each output of this generator.

+
+
+ + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Alignment(icepool.MultisetGenerator[~T, tuple[()]]): + + + +
+ + 
14class Alignment(MultisetGenerator[T, tuple[()]]):
+15    """A generator that does not output any counts.
+16
+17    This can be used to enforce that certain outcomes are seen without otherwise
+18    affecting a multiset evaluation.
+19    """
+20
+21    def __init__(self, outcomes: Collection[T]):
+22        self._outcomes = tuple(sorted(outcomes))
+23
+24    def outcomes(self) -> Sequence[T]:
+25        return self._outcomes
+26
+27    def output_arity(self) -> int:
+28        return 0
+29
+30    def _is_resolvable(self) -> bool:
+31        return True
+32
+33    def _generate_min(self, min_outcome) -> AlignmentGenerator:
+34        """`Alignment` only outputs 0 counts with weight 1."""
+35        if not self.outcomes() or min_outcome != self.min_outcome():
+36            yield self, (0,), 1
+37        else:
+38            yield Alignment(self.outcomes()[1:]), (), 1
+39
+40    def _generate_max(self, max_outcome) -> AlignmentGenerator:
+41        """`Alignment` only outputs 0 counts with weight 1."""
+42        if not self.outcomes() or max_outcome != self.max_outcome():
+43            yield self, (0,), 1
+44        else:
+45            yield Alignment(self.outcomes()[:-1]), (), 1
+46
+47    def _estimate_order_costs(self) -> tuple[int, int]:
+48        result = len(self.outcomes())
+49        return result, result
+50
+51    def denominator(self) -> int:
+52        return 0
+53
+54    @cached_property
+55    def _hash_key(self) -> Hashable:
+56        return Alignment, self._outcomes
+
+ + +

A generator that does not output any counts.

+ +

This can be used to enforce that certain outcomes are seen without otherwise +affecting a multiset evaluation.

+
+ + +
+ +
+ + Alignment(outcomes: Collection[~T]) + + + +
+ + 
21    def __init__(self, outcomes: Collection[T]):
+22        self._outcomes = tuple(sorted(outcomes))
+
+ + + + +
+
+ +
+ + def + outcomes(self) -> Sequence[~T]: + + + +
+ + 
24    def outcomes(self) -> Sequence[T]:
+25        return self._outcomes
+
+ + +

The possible outcomes that could be generated, in ascending order.

+
+ + +
+
+ +
+ + def + output_arity(self) -> int: + + + +
+ + 
27    def output_arity(self) -> int:
+28        return 0
+
+ + +

The number of multisets/counts generated. Must be constant.

+
+ + +
+
+ +
+ + def + denominator(self) -> int: + + + +
+ + 
51    def denominator(self) -> int:
+52        return 0
+
+ + +

The total weight of all paths through this generator.

+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + class + MultisetExpression(abc.ABC, typing.Generic[-T_contra]): + + + +
+ + 
 37class MultisetExpression(ABC, Generic[T_contra]):
+ 38    """Abstract base class representing an expression that operates on multisets.
+ 39
+ 40    Expression methods can be applied to `MultisetGenerator`s to do simple
+ 41    evaluations. For joint evaluations, try `multiset_function`.
+ 42
+ 43    Use the provided operations to build up more complicated
+ 44    expressions, or to attach a final evaluator.
+ 45
+ 46    Operations include:
+ 47
+ 48    | Operation                   | Count / notes                      |
+ 49    |:----------------------------|:-----------------------------------|
+ 50    | `additive_union`, `+`       | `l + r`                            |
+ 51    | `difference`, `-`           | `l - r`                            |
+ 52    | `intersection`, `&`         | `min(l, r)`                        |
+ 53    | `union`, `\\|`               | `max(l, r)`                        |
+ 54    | `symmetric_difference`, `^` | `abs(l - r)`                       |
+ 55    | `multiply_counts`, `*`      | `count * n`                        |
+ 56    | `divide_counts`, `//`       | `count // n`                       |
+ 57    | `keep_counts`               | `count if count >= n else 0`       |
+ 58    | unary `+`                   | same as `keep_counts(0)`           |
+ 59    | `unique`                    | `min(count, n)`                    |
+ 60    | `keep_outcomes`             | `count if outcome in t else 0`     |
+ 61    | `drop_outcomes`             | `count if outcome not in t else 0` |
+ 62    | `map_counts`                | `f(outcome, *counts)`              |
+ 63    | `keep`, `[]`                | less capable than `Pool` version   |
+ 64    | `highest`                   | less capable than `Pool` version   |
+ 65    | `lowest`                    | less capable than `Pool` version   |
+ 66
+ 67    | Evaluator                      | Summary                                                                    |
+ 68    |:-------------------------------|:---------------------------------------------------------------------------|
+ 69    | `issubset`, `<=`               | Whether the left side's counts are all <= their counterparts on the right  |
+ 70    | `issuperset`, `>=`             | Whether the left side's counts are all >= their counterparts on the right  |
+ 71    | `isdisjoint`                   | Whether the left side has no positive counts in common with the right side |
+ 72    | `<`                            | As `<=`, but `False` if the two multisets are equal                        |
+ 73    | `>`                            | As `>=`, but `False` if the two multisets are equal                        |
+ 74    | `==`                           | Whether the left side has all the same counts as the right side            |
+ 75    | `!=`                           | Whether the left side has any different counts to the right side           |
+ 76    | `expand`                       | All elements in ascending order                                            |
+ 77    | `sum`                          | Sum of all elements                                                        |
+ 78    | `count`                        | The number of elements                                                     |
+ 79    | `any`                          | Whether there is at least 1 element                                        |
+ 80    | `highest_outcome_and_count`    | The highest outcome and how many of that outcome                           |
+ 81    | `all_counts`                   | All counts in descending order                                             |
+ 82    | `largest_count`                | The single largest count, aka x-of-a-kind                                  |
+ 83    | `largest_count_and_outcome`    | Same but also with the corresponding outcome                               |
+ 84    | `largest_straight`             | Length of longest consecutive sequence                                     |
+ 85    | `largest_straight_and_outcome` | Same but also with the corresponding outcome                               |
+ 86    | `all_straights`                | Lengths of all consecutive sequences in descending order                   |
+ 87    """
+ 88
+ 89    @abstractmethod
+ 90    def _next_state(self, state, outcome: T_contra, *counts:
+ 91                    int) -> tuple[Hashable, int]:
+ 92        """Updates the state for this expression and does any necessary count modification.
+ 93
+ 94        Args:
+ 95            state: The overall state. This will contain all information needed
+ 96                by this expression and any previous expressions.
+ 97            outcome: The current outcome.
+ 98            counts: The raw counts: first, the counts resulting from bound
+ 99                generators, then the counts from free variables.
+100                This must be passed to any previous expressions.
+101
+102        Returns:
+103            * state: The updated state, which will be seen again by this
+104            `next_state` later.
+105            * count: The resulting count, which will be sent forward.
+106        """
+107
+108    @abstractmethod
+109    def _order(self) -> Order:
+110        """Any ordering that is required by this expression.
+111
+112        This should check any previous expressions for their order, and
+113        raise a ValueError for any incompatibilities.
+114
+115        Returns:
+116            The required order.
+117        """
+118
+119    @abstractmethod
+120    def _free_arity(self) -> int:
+121        """The minimum number of multisets/counts that must be provided to this expression.
+122
+123        Any excess multisets/counts that are provided will be ignored.
+124
+125        This does not include bound generators.
+126        """
+127
+128    @abstractmethod
+129    def _bound_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+130        """Returns a sequence of bound generators."""
+131
+132    @abstractmethod
+133    def _unbind(self, prefix_start: int,
+134                free_start: int) -> 'tuple[MultisetExpression, int]':
+135        """Replaces bound generators within this expression with free variables.
+136
+137        Bound generators are replaced with free variables with index equal to
+138        their position in _bound_generators().
+139
+140        Variables that are already free have their indexes shifted by the
+141        number of bound genrators.
+142
+143        Args:
+144            prefix_start: The index of the next bound generator.
+145            free_start: The total number of bound generators.
+146
+147        Returns:
+148            The transformed expression and the new prefix_start.
+149        """
+150
+151    @staticmethod
+152    def _validate_output_arity(inner: 'MultisetExpression') -> None:
+153        """Validates that if the given expression is a generator, its output arity is 1."""
+154        if isinstance(inner,
+155                      icepool.MultisetGenerator) and inner.output_arity() != 1:
+156            raise ValueError(
+157                'Only generators with output arity of 1 may be bound to expressions.\nUse a multiset_function to select individual outputs.'
+158            )
+159
+160    # Binary operators.
+161
+162    def __add__(
+163            self, other:
+164        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+165            /) -> 'MultisetExpression[T_contra]':
+166        try:
+167            other = implicit_convert_to_expression(other)
+168        except TypeError:
+169            return NotImplemented
+170        return icepool.expression.DisjointUnionExpression(
+171            self, other, keep_negative_counts=False)
+172
+173    def __radd__(
+174            self, other:
+175        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+176            /) -> 'MultisetExpression[T_contra]':
+177        try:
+178            other = implicit_convert_to_expression(other)
+179        except TypeError:
+180            return NotImplemented
+181        return icepool.expression.DisjointUnionExpression(
+182            other, self, keep_negative_counts=False)
+183
+184    def additive_union(
+185            *args:
+186        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+187            keep_negative_counts: bool = False
+188    ) -> 'MultisetExpression[T_contra]':
+189        """The combined elements from all of the multisets.
+190
+191        Same as `a + b + c + ...`.
+192
+193        Any resulting counts that would be negative are set to zero.
+194
+195        Example:
+196        ```
+197        [1, 2, 2, 3] + [1, 2, 4] -> [1, 1, 2, 2, 2, 3, 4]
+198        ```
+199
+200        Args:
+201            keep_negative_counts: If set, if the result would have a negative 
+202                count, it is preserved. Otherwise, negative counts in the result
+203                are set to zero, similar to the behavior of
+204                `collections.Counter`.
+205        """
+206        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+207        return icepool.expression.DisjointUnionExpression(
+208            *expressions, keep_negative_counts=keep_negative_counts)
+209
+210    def __sub__(
+211            self, other:
+212        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+213            /) -> 'MultisetExpression[T_contra]':
+214        try:
+215            other = implicit_convert_to_expression(other)
+216        except TypeError:
+217            return NotImplemented
+218        return icepool.expression.DifferenceExpression(
+219            self, other, keep_negative_counts=False)
+220
+221    def __rsub__(
+222            self, other:
+223        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+224            /) -> 'MultisetExpression[T_contra]':
+225        try:
+226            other = implicit_convert_to_expression(other)
+227        except TypeError:
+228            return NotImplemented
+229        return icepool.expression.DifferenceExpression(
+230            other, self, keep_negative_counts=False)
+231
+232    def difference(
+233            *args:
+234        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+235            keep_negative_counts: bool = False
+236    ) -> 'MultisetExpression[T_contra]':
+237        """The elements from the left multiset that are not in any of the others.
+238
+239        Same as `a - b - c - ...`.
+240
+241        Any resulting counts that would be negative are set to zero.
+242
+243        Example:
+244        ```
+245        [1, 2, 2, 3] - [1, 2, 4] -> [2, 3]
+246        ```
+247
+248        If no arguments are given, the result will be an empty multiset, i.e.
+249        all zero counts.
+250
+251        Note that, as a multiset operation, this will only cancel elements 1:1.
+252        If you want to drop all elements in a set of outcomes regardless of
+253        count, either use `drop_outcomes()` instead, or use a large number of
+254        counts on the right side.
+255
+256        Args:
+257            keep_negative_counts: If set, if the result would have a negative 
+258                count, it is preserved. Otherwise, negative counts in the result
+259                are set to zero, similar to the behavior of
+260                `collections.Counter`.
+261        """
+262        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+263        return icepool.expression.DifferenceExpression(
+264            *expressions, keep_negative_counts=keep_negative_counts)
+265
+266    def __and__(
+267            self, other:
+268        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+269            /) -> 'MultisetExpression[T_contra]':
+270        try:
+271            other = implicit_convert_to_expression(other)
+272        except TypeError:
+273            return NotImplemented
+274        return icepool.expression.IntersectionExpression(
+275            self, other, keep_negative_counts=False)
+276
+277    def __rand__(
+278            self, other:
+279        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+280            /) -> 'MultisetExpression[T_contra]':
+281        try:
+282            other = implicit_convert_to_expression(other)
+283        except TypeError:
+284            return NotImplemented
+285        return icepool.expression.IntersectionExpression(
+286            other, self, keep_negative_counts=False)
+287
+288    def intersection(
+289            *args:
+290        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+291            keep_negative_counts: bool = False
+292    ) -> 'MultisetExpression[T_contra]':
+293        """The elements that all the multisets have in common.
+294
+295        Same as `a & b & c & ...`.
+296
+297        Any resulting counts that would be negative are set to zero.
+298
+299        Example:
+300        ```
+301        [1, 2, 2, 3] & [1, 2, 4] -> [1, 2]
+302        ```
+303
+304        Note that, as a multiset operation, this will only intersect elements
+305        1:1.
+306        If you want to keep all elements in a set of outcomes regardless of
+307        count, either use `keep_outcomes()` instead, or use a large number of
+308        counts on the right side.
+309
+310        Args:
+311            keep_negative_counts: If set, if the result would have a negative 
+312                count, it is preserved. Otherwise, negative counts in the result
+313                are set to zero, similar to the behavior of
+314                `collections.Counter`.
+315        """
+316        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+317        return icepool.expression.IntersectionExpression(
+318            *expressions, keep_negative_counts=keep_negative_counts)
+319
+320    def __or__(
+321            self, other:
+322        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+323            /) -> 'MultisetExpression[T_contra]':
+324        try:
+325            other = implicit_convert_to_expression(other)
+326        except TypeError:
+327            return NotImplemented
+328        return icepool.expression.UnionExpression(self,
+329                                                  other,
+330                                                  keep_negative_counts=False)
+331
+332    def __ror__(
+333            self, other:
+334        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+335            /) -> 'MultisetExpression[T_contra]':
+336        try:
+337            other = implicit_convert_to_expression(other)
+338        except TypeError:
+339            return NotImplemented
+340        return icepool.expression.UnionExpression(other,
+341                                                  self,
+342                                                  keep_negative_counts=False)
+343
+344    def union(
+345            *args:
+346        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+347            keep_negative_counts: bool = False
+348    ) -> 'MultisetExpression[T_contra]':
+349        """The most of each outcome that appear in any of the multisets.
+350
+351        Same as `a | b | c | ...`.
+352
+353        Any resulting counts that would be negative are set to zero.
+354
+355        Example:
+356        ```
+357        [1, 2, 2, 3] | [1, 2, 4] -> [1, 2, 2, 3, 4]
+358        ```
+359
+360        Args:
+361            keep_negative_counts: If set, if the result would have a negative 
+362                count, it is preserved. Otherwise, negative counts in the result
+363                are set to zero, similar to the behavior of
+364                `collections.Counter`.
+365        """
+366        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+367        return icepool.expression.UnionExpression(
+368            *expressions, keep_negative_counts=keep_negative_counts)
+369
+370    def __xor__(
+371            self, other:
+372        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+373            /) -> 'MultisetExpression[T_contra]':
+374        try:
+375            other = implicit_convert_to_expression(other)
+376        except TypeError:
+377            return NotImplemented
+378        return icepool.expression.SymmetricDifferenceExpression(
+379            self, other, keep_negative_counts=False)
+380
+381    def __rxor__(
+382            self, other:
+383        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+384            /) -> 'MultisetExpression[T_contra]':
+385        try:
+386            other = implicit_convert_to_expression(other)
+387        except TypeError:
+388            return NotImplemented
+389        return icepool.expression.SymmetricDifferenceExpression(
+390            other, self, keep_negative_counts=False)
+391
+392    def symmetric_difference(
+393            self, other:
+394        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+395            /) -> 'MultisetExpression[T_contra]':
+396        """The elements that appear in the left or right multiset but not both.
+397
+398        Same as `a ^ b`.
+399
+400        Specifically, this produces the absolute difference between counts.
+401        If you don't want negative counts to be used from the inputs, you can
+402        do `left.keep_counts(0) ^ right.keep_counts(0)`.
+403
+404        Example:
+405        ```
+406        [1, 2, 2, 3] ^ [1, 2, 4] -> [2, 3, 4]
+407        ```
+408        """
+409        other = implicit_convert_to_expression(other)
+410        return icepool.expression.SymmetricDifferenceExpression(
+411            self, other, keep_negative_counts=False)
+412
+413    def keep_outcomes(
+414            self, target:
+415        'Callable[[T_contra], bool] | Collection[T_contra] | MultisetExpression[T_contra]',
+416            /) -> 'MultisetExpression[T_contra]':
+417        """Keeps the elements in the target set of outcomes, and drops the rest by setting their counts to zero.
+418
+419        This is similar to `intersection()`, except the right side is considered
+420        to have unlimited multiplicity.
+421
+422        Args:
+423            target: A callable returning `True` iff the outcome should be kept,
+424                or an expression or collection of outcomes to keep.
+425        """
+426        if isinstance(target, MultisetExpression):
+427            return icepool.expression.FilterOutcomesBinaryExpression(
+428                self, target)
+429        else:
+430            return icepool.expression.FilterOutcomesExpression(self, target)
+431
+432    def drop_outcomes(
+433            self, target:
+434        'Callable[[T_contra], bool] | Collection[T_contra] | MultisetExpression[T_contra]',
+435            /) -> 'MultisetExpression[T_contra]':
+436        """Drops the elements in the target set of outcomes by setting their counts to zero, and keeps the rest.
+437
+438        This is similar to `difference()`, except the right side is considered
+439        to have unlimited multiplicity.
+440
+441        Args:
+442            target: A callable returning `True` iff the outcome should be
+443                dropped, or an expression or collection of outcomes to drop.
+444        """
+445        if isinstance(target, MultisetExpression):
+446            return icepool.expression.FilterOutcomesBinaryExpression(
+447                self, target, invert=True)
+448        else:
+449            return icepool.expression.FilterOutcomesExpression(self,
+450                                                               target,
+451                                                               invert=True)
+452
+453    # Adjust counts.
+454
+455    def map_counts(
+456        *args:
+457        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+458        function: Callable[[int], int] | Callable[[T_contra, int], int]
+459    ) -> 'MultisetExpression[T_contra]':
+460        """Maps the counts to new counts.
+461
+462        Args:
+463            function: A function that takes `outcome, *counts` and produces a
+464                combined count.
+465        """
+466        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+467        return icepool.expression.MapCountsExpression(*expressions,
+468                                                      function=function)
+469
+470    def __mul__(self, other: int) -> 'MultisetExpression[T_contra]':
+471        if not isinstance(other, int):
+472            return NotImplemented
+473        return icepool.expression.MultiplyCountsExpression(self, other)
+474
+475    # Commutable in this case.
+476    def __rmul__(self, other: int) -> 'MultisetExpression[T_contra]':
+477        if not isinstance(other, int):
+478            return NotImplemented
+479        return icepool.expression.MultiplyCountsExpression(self, other)
+480
+481    def multiply_counts(self, constant: int,
+482                        /) -> 'MultisetExpression[T_contra]':
+483        """Multiplies all counts by a constant.
+484
+485        Same as `self * constant`.
+486
+487        Example:
+488        ```
+489        Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]
+490        ```
+491        """
+492        return self * constant
+493
+494    def __floordiv__(self, other: int) -> 'MultisetExpression[T_contra]':
+495        if not isinstance(other, int):
+496            return NotImplemented
+497        return icepool.expression.FloorDivCountsExpression(self, other)
+498
+499    def divide_counts(self, constant: int, /) -> 'MultisetExpression[T_contra]':
+500        """Divides all counts by a constant (rounding down).
+501
+502        Same as `self // constant`.
+503
+504        Example:
+505        ```
+506        Pool([1, 2, 2, 3]) // 2 -> [2]
+507        ```
+508        """
+509        return self // constant
+510
+511    def __pos__(self) -> 'MultisetExpression[T_contra]':
+512        return icepool.expression.FilterCountsExpression(self, 0)
+513
+514    def keep_counts(self, min_count: int) -> 'MultisetExpression[T_contra]':
+515        """Counts less than `min_count` are treated as zero.
+516
+517        For example, `expression.keep_counts(2)` would only produce
+518        pairs and better.
+519        
+520        `expression.keep_counts(0)` is useful for removing negative counts. 
+521        You can use the unary operator `+expression` for the same effect.
+522
+523        Example:
+524        ```
+525        Pool([1, 2, 2, 3]).keep_counts(2) -> [2, 2]
+526        ```
+527        """
+528        return icepool.expression.FilterCountsExpression(self, min_count)
+529
+530    def unique(self, max_count: int = 1) -> 'MultisetExpression[T_contra]':
+531        """Counts each outcome at most `max_count` times.
+532
+533        For example, `generator.unique(2)` would count each outcome at most
+534        twice.
+535
+536        Example:
+537        ```
+538        Pool([1, 2, 2, 3]).unique() -> [1, 2, 3]
+539        ```
+540        """
+541        return icepool.expression.UniqueExpression(self, max_count)
+542
+543    # Keep highest / lowest.
+544
+545    @overload
+546    def keep(
+547        self, index: slice | Sequence[int | EllipsisType]
+548    ) -> 'MultisetExpression[T_contra]':
+549        ...
+550
+551    @overload
+552    def keep(
+553        self, index: int
+554    ) -> 'icepool.Die[T_contra] | icepool.MultisetEvaluator[T_contra, T_contra]':
+555        ...
+556
+557    def keep(
+558        self, index: slice | Sequence[int | EllipsisType] | int
+559    ) -> 'MultisetExpression[T_contra] | icepool.Die[T_contra] | icepool.MultisetEvaluator[T_contra, T_contra]':
+560        """Selects pulls after drawing and sorting.
+561
+562        This is less capable and less efficient than the `Pool` version.
+563        In particular, it does not know how many elements it is selecting from,
+564        so it must be anchored at the starting end. The advantage is that it
+565        can be applied to any expression.
+566
+567        The valid types of argument are:
+568
+569        * A `slice`. If both start and stop are provided, they must both be
+570            non-negative or both be negative. step is not supported.
+571        * A sequence of `int` with `...` (`Ellipsis`) at exactly one end.
+572            Each sorted element will be counted that many times, with the
+573            `Ellipsis` treated as enough zeros (possibly "negative") to
+574            fill the rest of the elements.
+575        * An `int`, which evaluates by taking the element at the specified
+576            index. In this case the result is a `Die` (if fully bound) or a
+577            `MultisetEvaluator` (if there are free variables).
+578
+579        Use the `[]` operator for the same effect as this method.
+580        """
+581        if isinstance(index, int):
+582            return self.evaluate(
+583                evaluator=icepool.evaluator.KeepEvaluator(index))
+584        else:
+585            return icepool.expression.KeepExpression(self, index)
+586
+587    @overload
+588    def __getitem__(
+589        self, index: slice | Sequence[int | EllipsisType]
+590    ) -> 'MultisetExpression[T_contra]':
+591        ...
+592
+593    @overload
+594    def __getitem__(
+595        self, index: int
+596    ) -> 'icepool.Die[T_contra] | icepool.MultisetEvaluator[T_contra, T_contra]':
+597        ...
+598
+599    def __getitem__(
+600        self, index: slice | Sequence[int | EllipsisType] | int
+601    ) -> 'MultisetExpression[T_contra] | icepool.Die[T_contra] | icepool.MultisetEvaluator[T_contra, T_contra]':
+602        return self.keep(index)
+603
+604    def lowest(self,
+605               keep: int = 1,
+606               drop: int = 0) -> 'MultisetExpression[T_contra]':
+607        """Keep some of the lowest elements from this multiset and drop the rest.
+608
+609        In contrast to the die and free function versions, this does not
+610        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+611        Alternatively, you can perform some other evaluation.
+612
+613        This requires the outcomes to be evaluated in ascending order.
+614
+615        Args:
+616            keep: The number of lowest elements will be kept.
+617            drop: This number of lowest elements will be dropped before keeping.
+618        """
+619        t = (0,) * drop + (1,) * keep + (...,)
+620        return self.keep(t)
+621
+622    def highest(self,
+623                keep: int = 1,
+624                drop: int = 0) -> 'MultisetExpression[T_contra]':
+625        """Keep some of the highest elements from this multiset and drop the rest.
+626
+627        In contrast to the die and free function versions, this does not
+628        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+629        Alternatively, you can perform some other evaluation.
+630
+631        This requires the outcomes to be evaluated in descending order.
+632
+633        Args:
+634            keep: The number of highest elements will be kept.
+635            drop: This number of highest elements will be dropped before keeping.
+636        """
+637        t = (...,) + (1,) * keep + (0,) * drop
+638        return self.keep(t)
+639
+640    # Evaluations.
+641
+642    def evaluate(
+643        *expressions: 'MultisetExpression[T_contra]',
+644        evaluator: 'icepool.MultisetEvaluator[T_contra, U]'
+645    ) -> 'icepool.Die[U] | icepool.MultisetEvaluator[T_contra, U]':
+646        """Attaches a final `MultisetEvaluator` to expressions.
+647
+648        All of the `MultisetExpression` methods below are evaluations,
+649        as are the operators `<, <=, >, >=, !=, ==`. This means if the
+650        expression is fully bound, it will be evaluated to a `Die`.
+651
+652        Returns:
+653            A `Die` if the expression is are fully bound.
+654            A `MultisetEvaluator` otherwise.
+655        """
+656        if all(
+657                isinstance(expression, icepool.MultisetGenerator)
+658                for expression in expressions):
+659            return evaluator.evaluate(*expressions)
+660        evaluator = icepool.evaluator.ExpressionEvaluator(*expressions,
+661                                                          evaluator=evaluator)
+662        if evaluator._free_arity == 0:
+663            return evaluator.evaluate()
+664        else:
+665            return evaluator
+666
+667    def expand(
+668        self,
+669        order: Order = Order.Ascending
+670    ) -> 'icepool.Die[tuple[T_contra, ...]] | icepool.MultisetEvaluator[T_contra, tuple[T_contra, ...]]':
+671        """Evaluation: All elements of the multiset in ascending order.
+672
+673        This is expensive and not recommended unless there are few possibilities.
+674
+675        Args:
+676            order: Whether the elements are in ascending (default) or descending
+677                order.
+678        """
+679        return self.evaluate(evaluator=icepool.evaluator.ExpandEvaluator(
+680            order=order))
+681
+682    def sum(
+683        self,
+684        map: Callable[[T_contra], U] | Mapping[T_contra, U] | None = None
+685    ) -> 'icepool.Die[U] | icepool.MultisetEvaluator[T_contra, U]':
+686        """Evaluation: The sum of all elements."""
+687        if map is None:
+688            return self.evaluate(evaluator=icepool.evaluator.sum_evaluator)
+689        else:
+690            return self.evaluate(evaluator=icepool.evaluator.SumEvaluator(map))
+691
+692    def count(
+693            self
+694    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[T_contra, int]':
+695        """Evaluation: The total number of elements in the multiset.
+696
+697        This is usually not very interesting unless some other operation is
+698        performed first. Examples:
+699
+700        `generator.unique().count()` will count the number of unique outcomes.
+701
+702        `(generator & [4, 5, 6]).count()` will count up to one each of
+703        4, 5, and 6.
+704        """
+705        return self.evaluate(evaluator=icepool.evaluator.count_evaluator)
+706
+707    def any(
+708        self
+709    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+710        """Evaluation: Whether the multiset has at least one positive count."""
+711        return self.evaluate(evaluator=icepool.evaluator.any_evaluator)
+712
+713    def highest_outcome_and_count(
+714        self
+715    ) -> 'icepool.Die[tuple[T_contra, int]] | icepool.MultisetEvaluator[T_contra, tuple[T_contra, int]]':
+716        """Evaluation: The highest outcome with positive count, along with that count.
+717
+718        If no outcomes have positive count, the min outcome will be returned with 0 count.
+719        """
+720        return self.evaluate(
+721            evaluator=icepool.evaluator.HighestOutcomeAndCountEvaluator())
+722
+723    def all_counts(
+724        self,
+725        filter: int | None = 1
+726    ) -> 'icepool.Die[tuple[int, ...]] | icepool.MultisetEvaluator[T_contra, tuple[int, ...]]':
+727        """Evaluation: Sorted tuple of all counts, i.e. the sizes of all matching sets.
+728
+729        The sizes are in **descending** order.
+730
+731        Args:
+732            filter: Any counts below this value will not be in the output.
+733                For example, `filter=2` will only produce pairs and better.
+734                If `None`, no filtering will be done.
+735
+736                Why not just place `keep_counts()` before this?
+737                `keep_counts()` operates by setting counts to zero, so you
+738                would still need an argument to specify whether you want to
+739                output zero counts. So we might as well use the argument to do
+740                both.
+741        """
+742        return self.evaluate(evaluator=icepool.evaluator.AllCountsEvaluator(
+743            filter=filter))
+744
+745    def largest_count(
+746            self
+747    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[T_contra, int]':
+748        """Evaluation: The size of the largest matching set among the elements."""
+749        return self.evaluate(
+750            evaluator=icepool.evaluator.LargestCountEvaluator())
+751
+752    def largest_count_and_outcome(
+753        self
+754    ) -> 'icepool.Die[tuple[int, T_contra]] | icepool.MultisetEvaluator[T_contra, tuple[int, T_contra]]':
+755        """Evaluation: The largest matching set among the elements and the corresponding outcome."""
+756        return self.evaluate(
+757            evaluator=icepool.evaluator.LargestCountAndOutcomeEvaluator())
+758
+759    def largest_straight(
+760        self: 'MultisetExpression[int]'
+761    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[int, int]':
+762        """Evaluation: The size of the largest straight among the elements.
+763
+764        Outcomes must be `int`s.
+765        """
+766        return self.evaluate(
+767            evaluator=icepool.evaluator.LargestStraightEvaluator())
+768
+769    def largest_straight_and_outcome(
+770        self: 'MultisetExpression[int]'
+771    ) -> 'icepool.Die[tuple[int, int]] | icepool.MultisetEvaluator[int, tuple[int, int]]':
+772        """Evaluation: The size of the largest straight among the elements and the highest outcome in that straight.
+773
+774        Outcomes must be `int`s.
+775        """
+776        return self.evaluate(
+777            evaluator=icepool.evaluator.LargestStraightAndOutcomeEvaluator())
+778
+779    def all_straights(
+780        self: 'MultisetExpression[int]'
+781    ) -> 'icepool.Die[tuple[int, ...]] | icepool.MultisetEvaluator[int, tuple[int, ...]]':
+782        """Evaluation: The sizes of all straights.
+783
+784        The sizes are in **descending** order.
+785
+786        Each element can only contribute to one straight, though duplicates can
+787        produce overlapping straights.
+788        """
+789        return self.evaluate(
+790            evaluator=icepool.evaluator.AllStraightsEvaluator())
+791
+792    # Comparators.
+793
+794    def _compare(
+795        self, right:
+796        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+797        operation_class: Type['icepool.evaluator.ComparisonEvaluator']
+798    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+799        if isinstance(right, MultisetExpression):
+800            evaluator = icepool.evaluator.ExpressionEvaluator(
+801                self, right, evaluator=operation_class())
+802        elif isinstance(right, (Mapping, Sequence)):
+803            right_expression = icepool.implicit_convert_to_expression(right)
+804            evaluator = icepool.evaluator.ExpressionEvaluator(
+805                self, right_expression, evaluator=operation_class())
+806        else:
+807            raise TypeError('Right side is not comparable.')
+808
+809        if evaluator._free_arity == 0:
+810            return evaluator.evaluate()
+811        else:
+812            return evaluator
+813
+814    def __lt__(
+815            self, other:
+816        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+817            /
+818    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+819        try:
+820            return self._compare(other,
+821                                 icepool.evaluator.IsProperSubsetEvaluator)
+822        except TypeError:
+823            return NotImplemented
+824
+825    def __le__(
+826            self, other:
+827        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+828            /
+829    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+830        try:
+831            return self._compare(other, icepool.evaluator.IsSubsetEvaluator)
+832        except TypeError:
+833            return NotImplemented
+834
+835    def issubset(
+836            self, other:
+837        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+838            /
+839    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+840        """Evaluation: Whether this multiset is a subset of the other multiset.
+841
+842        Specifically, if this multiset has a lesser or equal count for each
+843        outcome than the other multiset, this evaluates to `True`; 
+844        if there is some outcome for which this multiset has a greater count 
+845        than the other multiset, this evaluates to `False`.
+846
+847        `issubset` is the same as `self <= other`.
+848        
+849        `self < other` evaluates a proper subset relation, which is the same
+850        except the result is `False` if the two multisets are exactly equal.
+851        """
+852        return self._compare(other, icepool.evaluator.IsSubsetEvaluator)
+853
+854    def __gt__(
+855            self, other:
+856        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+857            /
+858    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+859        try:
+860            return self._compare(other,
+861                                 icepool.evaluator.IsProperSupersetEvaluator)
+862        except TypeError:
+863            return NotImplemented
+864
+865    def __ge__(
+866            self, other:
+867        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+868            /
+869    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+870        try:
+871            return self._compare(other, icepool.evaluator.IsSupersetEvaluator)
+872        except TypeError:
+873            return NotImplemented
+874
+875    def issuperset(
+876            self, other:
+877        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+878            /
+879    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+880        """Evaluation: Whether this multiset is a superset of the other multiset.
+881
+882        Specifically, if this multiset has a greater or equal count for each
+883        outcome than the other multiset, this evaluates to `True`; 
+884        if there is some  outcome for which this multiset has a lesser count 
+885        than the other multiset, this evaluates to `False`.
+886        
+887        A typical use of this evaluation is testing for the presence of a
+888        combo of cards in a hand, e.g.
+889
+890        ```
+891        deck.deal(5) >= ['a', 'a', 'b']
+892        ```
+893
+894        represents the chance that a deal of 5 cards contains at least two 'a's
+895        and one 'b'.
+896
+897        `issuperset` is the same as `self >= other`.
+898
+899        `self > other` evaluates a proper superset relation, which is the same
+900        except the result is `False` if the two multisets are exactly equal.
+901        """
+902        return self._compare(other, icepool.evaluator.IsSupersetEvaluator)
+903
+904    # The result has no truth value.
+905    def __eq__(  # type: ignore
+906            self, other:
+907        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+908            /
+909    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+910        try:
+911            return self._compare(other, icepool.evaluator.IsEqualSetEvaluator)
+912        except TypeError:
+913            return NotImplemented
+914
+915    # The result has no truth value.
+916    def __ne__(  # type: ignore
+917            self, other:
+918        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+919            /
+920    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+921        try:
+922            return self._compare(other,
+923                                 icepool.evaluator.IsNotEqualSetEvaluator)
+924        except TypeError:
+925            return NotImplemented
+926
+927    def isdisjoint(
+928            self, other:
+929        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+930            /
+931    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+932        """Evaluation: Whether this multiset is disjoint from the other multiset.
+933        
+934        Specifically, this evaluates to `False` if there is any outcome for
+935        which both multisets have positive count, and `True` if there is not.
+936        """
+937        return self._compare(other, icepool.evaluator.IsDisjointSetEvaluator)
+938
+939    def compair(
+940        self,
+941        other:
+942        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+943        op: Literal['<', '<=', '>', '>=', '==', '!='] | None = None,
+944        /,
+945        *,
+946        order: Order = Order.Descending,
+947        initial=None,
+948        tie=None,
+949        left=None,
+950        right=None,
+951        extra_left=None,
+952        extra_right=None
+953    ) -> 'icepool.Die | icepool.MultisetEvaluator[T_contra, Any]':
+954        """Evaluation: EXPERIMENTAL: Compares sorted pairs of two multisets and scores wins, ties, and extra elements.
+955
+956        Interface is not stable yet.
+957
+958        For example, `left=1` would count how many pairs were won by the left
+959        side, and `left=1, right=-1` would give the difference in the number of
+960        pairs won by each side.
+961
+962        Any score argument 
+963        (`initial, tie, left, right, extra_left, extra_right`) 
+964        not provided will be set to a zero value determined from another score 
+965        argument times `0`.
+966
+967        Args:
+968            op: Sets the score values based on the given operator and `order`.
+969                Allowed values are `'<', '<=', '>', '>=', '==', '!='`.
+970                Each pair that fits the comparator counts as 1.
+971                If one side has more elements than the other, the extra
+972                elements are ignored.
+973            order: If descending (default), pairs are made in descending order
+974                and the higher element wins. If ascending, pairs are made in
+975                ascending order and the lower element wins.
+976            
+977            initial: The initial score.
+978            tie: The score for each pair that is a tie.
+979            left: The score for each pair that left wins.
+980            right: The score for each pair that right wins.
+981            extra_left: If left has more elements, each extra element scores
+982                this much.
+983            extra_right: If right has more elements, each extra element scores
+984                this much.
+985        """
+986        try:
+987            other = implicit_convert_to_expression(other)
+988        except TypeError:
+989            return NotImplemented
+990        return self.evaluate(other,
+991                             evaluator=icepool.evaluator.CompairEvalautor(
+992                                 op=op,
+993                                 order=order,
+994                                 initial=initial,
+995                                 tie=tie,
+996                                 left=left,
+997                                 right=right,
+998                                 extra_left=extra_left,
+999                                 extra_right=extra_right))
+
+ + +

Abstract base class representing an expression that operates on multisets.

+ +

Expression methods can be applied to MultisetGenerators to do simple +evaluations. For joint evaluations, try multiset_function.

+ +

Use the provided operations to build up more complicated +expressions, or to attach a final evaluator.

+ +

Operations include:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperationCount / notes
additive_union, +l + r
difference, -l - r
intersection, &min(l, r)
union, |max(l, r)
symmetric_difference, ^abs(l - r)
multiply_counts, *count * n
divide_counts, //count // n
keep_countscount if count >= n else 0
unary +same as keep_counts(0)
uniquemin(count, n)
keep_outcomescount if outcome in t else 0
drop_outcomescount if outcome not in t else 0
map_countsf(outcome, *counts)
keep, []less capable than Pool version
highestless capable than Pool version
lowestless capable than Pool version
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EvaluatorSummary
issubset, <=Whether the left side's counts are all <= their counterparts on the right
issuperset, >=Whether the left side's counts are all >= their counterparts on the right
isdisjointWhether the left side has no positive counts in common with the right side
<As <=, but False if the two multisets are equal
>As >=, but False if the two multisets are equal
==Whether the left side has all the same counts as the right side
!=Whether the left side has any different counts to the right side
expandAll elements in ascending order
sumSum of all elements
countThe number of elements
anyWhether there is at least 1 element
highest_outcome_and_countThe highest outcome and how many of that outcome
all_countsAll counts in descending order
largest_countThe single largest count, aka x-of-a-kind
largest_count_and_outcomeSame but also with the corresponding outcome
largest_straightLength of longest consecutive sequence
largest_straight_and_outcomeSame but also with the corresponding outcome
all_straightsLengths of all consecutive sequences in descending order
+
+ + +
+ +
+ + def + additive_union( *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], keep_negative_counts: bool = False) -> MultisetExpression[-T_contra]: + + + +
+ + 
184    def additive_union(
+185            *args:
+186        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+187            keep_negative_counts: bool = False
+188    ) -> 'MultisetExpression[T_contra]':
+189        """The combined elements from all of the multisets.
+190
+191        Same as `a + b + c + ...`.
+192
+193        Any resulting counts that would be negative are set to zero.
+194
+195        Example:
+196        ```
+197        [1, 2, 2, 3] + [1, 2, 4] -> [1, 1, 2, 2, 2, 3, 4]
+198        ```
+199
+200        Args:
+201            keep_negative_counts: If set, if the result would have a negative 
+202                count, it is preserved. Otherwise, negative counts in the result
+203                are set to zero, similar to the behavior of
+204                `collections.Counter`.
+205        """
+206        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+207        return icepool.expression.DisjointUnionExpression(
+208            *expressions, keep_negative_counts=keep_negative_counts)
+
+ + +

The combined elements from all of the multisets.

+ +

Same as a + b + c + ....

+ +

Any resulting counts that would be negative are set to zero.

+ +

Example:

+ +
[1, 2, 2, 3] + [1, 2, 4] -> [1, 1, 2, 2, 2, 3, 4]
+
+ +
Arguments:
+ +
    +
  • keep_negative_counts: If set, if the result would have a negative +count, it is preserved. Otherwise, negative counts in the result +are set to zero, similar to the behavior of +collections.Counter.
    • +
+
+ + +
+
+ +
+ + def + difference( *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], keep_negative_counts: bool = False) -> MultisetExpression[-T_contra]: + + + +
+ + 
232    def difference(
+233            *args:
+234        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+235            keep_negative_counts: bool = False
+236    ) -> 'MultisetExpression[T_contra]':
+237        """The elements from the left multiset that are not in any of the others.
+238
+239        Same as `a - b - c - ...`.
+240
+241        Any resulting counts that would be negative are set to zero.
+242
+243        Example:
+244        ```
+245        [1, 2, 2, 3] - [1, 2, 4] -> [2, 3]
+246        ```
+247
+248        If no arguments are given, the result will be an empty multiset, i.e.
+249        all zero counts.
+250
+251        Note that, as a multiset operation, this will only cancel elements 1:1.
+252        If you want to drop all elements in a set of outcomes regardless of
+253        count, either use `drop_outcomes()` instead, or use a large number of
+254        counts on the right side.
+255
+256        Args:
+257            keep_negative_counts: If set, if the result would have a negative 
+258                count, it is preserved. Otherwise, negative counts in the result
+259                are set to zero, similar to the behavior of
+260                `collections.Counter`.
+261        """
+262        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+263        return icepool.expression.DifferenceExpression(
+264            *expressions, keep_negative_counts=keep_negative_counts)
+
+ + +

The elements from the left multiset that are not in any of the others.

+ +

Same as a - b - c - ....

+ +

Any resulting counts that would be negative are set to zero.

+ +

Example:

+ +
[1, 2, 2, 3] - [1, 2, 4] -> [2, 3]
+
+ +

If no arguments are given, the result will be an empty multiset, i.e. +all zero counts.

+ +

Note that, as a multiset operation, this will only cancel elements 1:1. +If you want to drop all elements in a set of outcomes regardless of +count, either use drop_outcomes() instead, or use a large number of +counts on the right side.

+ +
Arguments:
+ +
    +
  • keep_negative_counts: If set, if the result would have a negative +count, it is preserved. Otherwise, negative counts in the result +are set to zero, similar to the behavior of +collections.Counter.
    • +
+
+ + +
+
+ +
+ + def + intersection( *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], keep_negative_counts: bool = False) -> MultisetExpression[-T_contra]: + + + +
+ + 
288    def intersection(
+289            *args:
+290        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+291            keep_negative_counts: bool = False
+292    ) -> 'MultisetExpression[T_contra]':
+293        """The elements that all the multisets have in common.
+294
+295        Same as `a & b & c & ...`.
+296
+297        Any resulting counts that would be negative are set to zero.
+298
+299        Example:
+300        ```
+301        [1, 2, 2, 3] & [1, 2, 4] -> [1, 2]
+302        ```
+303
+304        Note that, as a multiset operation, this will only intersect elements
+305        1:1.
+306        If you want to keep all elements in a set of outcomes regardless of
+307        count, either use `keep_outcomes()` instead, or use a large number of
+308        counts on the right side.
+309
+310        Args:
+311            keep_negative_counts: If set, if the result would have a negative 
+312                count, it is preserved. Otherwise, negative counts in the result
+313                are set to zero, similar to the behavior of
+314                `collections.Counter`.
+315        """
+316        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+317        return icepool.expression.IntersectionExpression(
+318            *expressions, keep_negative_counts=keep_negative_counts)
+
+ + +

The elements that all the multisets have in common.

+ +

Same as a & b & c & ....

+ +

Any resulting counts that would be negative are set to zero.

+ +

Example:

+ +
[1, 2, 2, 3] & [1, 2, 4] -> [1, 2]
+
+ +

Note that, as a multiset operation, this will only intersect elements +1:1. +If you want to keep all elements in a set of outcomes regardless of +count, either use keep_outcomes() instead, or use a large number of +counts on the right side.

+ +
Arguments:
+ +
    +
  • keep_negative_counts: If set, if the result would have a negative +count, it is preserved. Otherwise, negative counts in the result +are set to zero, similar to the behavior of +collections.Counter.
    • +
+
+ + +
+
+ +
+ + def + union( *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], keep_negative_counts: bool = False) -> MultisetExpression[-T_contra]: + + + +
+ + 
344    def union(
+345            *args:
+346        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+347            keep_negative_counts: bool = False
+348    ) -> 'MultisetExpression[T_contra]':
+349        """The most of each outcome that appear in any of the multisets.
+350
+351        Same as `a | b | c | ...`.
+352
+353        Any resulting counts that would be negative are set to zero.
+354
+355        Example:
+356        ```
+357        [1, 2, 2, 3] | [1, 2, 4] -> [1, 2, 2, 3, 4]
+358        ```
+359
+360        Args:
+361            keep_negative_counts: If set, if the result would have a negative 
+362                count, it is preserved. Otherwise, negative counts in the result
+363                are set to zero, similar to the behavior of
+364                `collections.Counter`.
+365        """
+366        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+367        return icepool.expression.UnionExpression(
+368            *expressions, keep_negative_counts=keep_negative_counts)
+
+ + +

The most of each outcome that appear in any of the multisets.

+ +

Same as a | b | c | ....

+ +

Any resulting counts that would be negative are set to zero.

+ +

Example:

+ +
[1, 2, 2, 3] | [1, 2, 4] -> [1, 2, 2, 3, 4]
+
+ +
Arguments:
+ +
    +
  • keep_negative_counts: If set, if the result would have a negative +count, it is preserved. Otherwise, negative counts in the result +are set to zero, similar to the behavior of +collections.Counter.
    • +
+
+ + +
+
+ +
+ + def + symmetric_difference( self, other: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], /) -> MultisetExpression[-T_contra]: + + + +
+ + 
392    def symmetric_difference(
+393            self, other:
+394        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+395            /) -> 'MultisetExpression[T_contra]':
+396        """The elements that appear in the left or right multiset but not both.
+397
+398        Same as `a ^ b`.
+399
+400        Specifically, this produces the absolute difference between counts.
+401        If you don't want negative counts to be used from the inputs, you can
+402        do `left.keep_counts(0) ^ right.keep_counts(0)`.
+403
+404        Example:
+405        ```
+406        [1, 2, 2, 3] ^ [1, 2, 4] -> [2, 3, 4]
+407        ```
+408        """
+409        other = implicit_convert_to_expression(other)
+410        return icepool.expression.SymmetricDifferenceExpression(
+411            self, other, keep_negative_counts=False)
+
+ + +

The elements that appear in the left or right multiset but not both.

+ +

Same as a ^ b.

+ +

Specifically, this produces the absolute difference between counts. +If you don't want negative counts to be used from the inputs, you can +do left.keep_counts(0) ^ right.keep_counts(0).

+ +

Example:

+ +
[1, 2, 2, 3] ^ [1, 2, 4] -> [2, 3, 4]
+
+
+ + +
+
+ +
+ + def + keep_outcomes( self, target: Union[Callable[[-T_contra], bool], Collection[-T_contra], MultisetExpression[-T_contra]], /) -> MultisetExpression[-T_contra]: + + + +
+ + 
413    def keep_outcomes(
+414            self, target:
+415        'Callable[[T_contra], bool] | Collection[T_contra] | MultisetExpression[T_contra]',
+416            /) -> 'MultisetExpression[T_contra]':
+417        """Keeps the elements in the target set of outcomes, and drops the rest by setting their counts to zero.
+418
+419        This is similar to `intersection()`, except the right side is considered
+420        to have unlimited multiplicity.
+421
+422        Args:
+423            target: A callable returning `True` iff the outcome should be kept,
+424                or an expression or collection of outcomes to keep.
+425        """
+426        if isinstance(target, MultisetExpression):
+427            return icepool.expression.FilterOutcomesBinaryExpression(
+428                self, target)
+429        else:
+430            return icepool.expression.FilterOutcomesExpression(self, target)
+
+ + +

Keeps the elements in the target set of outcomes, and drops the rest by setting their counts to zero.

+ +

This is similar to intersection(), except the right side is considered +to have unlimited multiplicity.

+ +
Arguments:
+ +
    +
  • target: A callable returning True iff the outcome should be kept, +or an expression or collection of outcomes to keep.
    • +
+
+ + +
+
+ +
+ + def + drop_outcomes( self, target: Union[Callable[[-T_contra], bool], Collection[-T_contra], MultisetExpression[-T_contra]], /) -> MultisetExpression[-T_contra]: + + + +
+ + 
432    def drop_outcomes(
+433            self, target:
+434        'Callable[[T_contra], bool] | Collection[T_contra] | MultisetExpression[T_contra]',
+435            /) -> 'MultisetExpression[T_contra]':
+436        """Drops the elements in the target set of outcomes by setting their counts to zero, and keeps the rest.
+437
+438        This is similar to `difference()`, except the right side is considered
+439        to have unlimited multiplicity.
+440
+441        Args:
+442            target: A callable returning `True` iff the outcome should be
+443                dropped, or an expression or collection of outcomes to drop.
+444        """
+445        if isinstance(target, MultisetExpression):
+446            return icepool.expression.FilterOutcomesBinaryExpression(
+447                self, target, invert=True)
+448        else:
+449            return icepool.expression.FilterOutcomesExpression(self,
+450                                                               target,
+451                                                               invert=True)
+
+ + +

Drops the elements in the target set of outcomes by setting their counts to zero, and keeps the rest.

+ +

This is similar to difference(), except the right side is considered +to have unlimited multiplicity.

+ +
Arguments:
+ +
    +
  • target: A callable returning True iff the outcome should be +dropped, or an expression or collection of outcomes to drop.
    • +
+
+ + +
+
+ +
+ + def + map_counts( *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], function: Union[Callable[[int], int], Callable[[-T_contra, int], int]]) -> MultisetExpression[-T_contra]: + + + +
+ + 
455    def map_counts(
+456        *args:
+457        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+458        function: Callable[[int], int] | Callable[[T_contra, int], int]
+459    ) -> 'MultisetExpression[T_contra]':
+460        """Maps the counts to new counts.
+461
+462        Args:
+463            function: A function that takes `outcome, *counts` and produces a
+464                combined count.
+465        """
+466        expressions = tuple(implicit_convert_to_expression(arg) for arg in args)
+467        return icepool.expression.MapCountsExpression(*expressions,
+468                                                      function=function)
+
+ + +

Maps the counts to new counts.

+ +
Arguments:
+ +
    +
  • function: A function that takes outcome, *counts and produces a +combined count.
    • +
+
+ + +
+
+ +
+ + def + multiply_counts( self, constant: int, /) -> MultisetExpression[-T_contra]: + + + +
+ + 
481    def multiply_counts(self, constant: int,
+482                        /) -> 'MultisetExpression[T_contra]':
+483        """Multiplies all counts by a constant.
+484
+485        Same as `self * constant`.
+486
+487        Example:
+488        ```
+489        Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]
+490        ```
+491        """
+492        return self * constant
+
+ + +

Multiplies all counts by a constant.

+ +

Same as self * constant.

+ +

Example:

+ +
Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]
+
+
+ + +
+
+ +
+ + def + divide_counts( self, constant: int, /) -> MultisetExpression[-T_contra]: + + + +
+ + 
499    def divide_counts(self, constant: int, /) -> 'MultisetExpression[T_contra]':
+500        """Divides all counts by a constant (rounding down).
+501
+502        Same as `self // constant`.
+503
+504        Example:
+505        ```
+506        Pool([1, 2, 2, 3]) // 2 -> [2]
+507        ```
+508        """
+509        return self // constant
+
+ + +

Divides all counts by a constant (rounding down).

+ +

Same as self // constant.

+ +

Example:

+ +
Pool([1, 2, 2, 3]) // 2 -> [2]
+
+
+ + +
+
+ +
+ + def + keep_counts( self, min_count: int) -> MultisetExpression[-T_contra]: + + + +
+ + 
514    def keep_counts(self, min_count: int) -> 'MultisetExpression[T_contra]':
+515        """Counts less than `min_count` are treated as zero.
+516
+517        For example, `expression.keep_counts(2)` would only produce
+518        pairs and better.
+519        
+520        `expression.keep_counts(0)` is useful for removing negative counts. 
+521        You can use the unary operator `+expression` for the same effect.
+522
+523        Example:
+524        ```
+525        Pool([1, 2, 2, 3]).keep_counts(2) -> [2, 2]
+526        ```
+527        """
+528        return icepool.expression.FilterCountsExpression(self, min_count)
+
+ + +

Counts less than min_count are treated as zero.

+ +

For example, expression.keep_counts(2) would only produce +pairs and better.

+ +

expression.keep_counts(0) is useful for removing negative counts. +You can use the unary operator +expression for the same effect.

+ +

Example:

+ +
Pool([1, 2, 2, 3]).keep_counts(2) -> [2, 2]
+
+
+ + +
+
+ +
+ + def + unique( self, max_count: int = 1) -> MultisetExpression[-T_contra]: + + + +
+ + 
530    def unique(self, max_count: int = 1) -> 'MultisetExpression[T_contra]':
+531        """Counts each outcome at most `max_count` times.
+532
+533        For example, `generator.unique(2)` would count each outcome at most
+534        twice.
+535
+536        Example:
+537        ```
+538        Pool([1, 2, 2, 3]).unique() -> [1, 2, 3]
+539        ```
+540        """
+541        return icepool.expression.UniqueExpression(self, max_count)
+
+ + +

Counts each outcome at most max_count times.

+ +

For example, generator.unique(2) would count each outcome at most +twice.

+ +

Example:

+ +
Pool([1, 2, 2, 3]).unique() -> [1, 2, 3]
+
+
+ + +
+
+ +
+ + def + keep( self, index: Union[slice, Sequence[int | ellipsis], int]) -> Union[MultisetExpression[-T_contra], Die[-T_contra], MultisetEvaluator[-T_contra, -T_contra]]: + + + +
+ + 
557    def keep(
+558        self, index: slice | Sequence[int | EllipsisType] | int
+559    ) -> 'MultisetExpression[T_contra] | icepool.Die[T_contra] | icepool.MultisetEvaluator[T_contra, T_contra]':
+560        """Selects pulls after drawing and sorting.
+561
+562        This is less capable and less efficient than the `Pool` version.
+563        In particular, it does not know how many elements it is selecting from,
+564        so it must be anchored at the starting end. The advantage is that it
+565        can be applied to any expression.
+566
+567        The valid types of argument are:
+568
+569        * A `slice`. If both start and stop are provided, they must both be
+570            non-negative or both be negative. step is not supported.
+571        * A sequence of `int` with `...` (`Ellipsis`) at exactly one end.
+572            Each sorted element will be counted that many times, with the
+573            `Ellipsis` treated as enough zeros (possibly "negative") to
+574            fill the rest of the elements.
+575        * An `int`, which evaluates by taking the element at the specified
+576            index. In this case the result is a `Die` (if fully bound) or a
+577            `MultisetEvaluator` (if there are free variables).
+578
+579        Use the `[]` operator for the same effect as this method.
+580        """
+581        if isinstance(index, int):
+582            return self.evaluate(
+583                evaluator=icepool.evaluator.KeepEvaluator(index))
+584        else:
+585            return icepool.expression.KeepExpression(self, index)
+
+ + +

Selects pulls after drawing and sorting.

+ +

This is less capable and less efficient than the Pool version. +In particular, it does not know how many elements it is selecting from, +so it must be anchored at the starting end. The advantage is that it +can be applied to any expression.

+ +

The valid types of argument are:

+ +
    +
  • A slice. If both start and stop are provided, they must both be +non-negative or both be negative. step is not supported.
    • +
  • A sequence of int with ... (Ellipsis) at exactly one end. +Each sorted element will be counted that many times, with the +Ellipsis treated as enough zeros (possibly "negative") to +fill the rest of the elements.
    • +
  • An int, which evaluates by taking the element at the specified +index. In this case the result is a Die (if fully bound) or a +MultisetEvaluator (if there are free variables).
    • +
+ +

Use the [] operator for the same effect as this method.

+
+ + +
+
+ +
+ + def + lowest( self, keep: int = 1, drop: int = 0) -> MultisetExpression[-T_contra]: + + + +
+ + 
604    def lowest(self,
+605               keep: int = 1,
+606               drop: int = 0) -> 'MultisetExpression[T_contra]':
+607        """Keep some of the lowest elements from this multiset and drop the rest.
+608
+609        In contrast to the die and free function versions, this does not
+610        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+611        Alternatively, you can perform some other evaluation.
+612
+613        This requires the outcomes to be evaluated in ascending order.
+614
+615        Args:
+616            keep: The number of lowest elements will be kept.
+617            drop: This number of lowest elements will be dropped before keeping.
+618        """
+619        t = (0,) * drop + (1,) * keep + (...,)
+620        return self.keep(t)
+
+ + +

Keep some of the lowest elements from this multiset and drop the rest.

+ +

In contrast to the die and free function versions, this does not +automatically sum the dice. Use .sum() afterwards if you want to sum. +Alternatively, you can perform some other evaluation.

+ +

This requires the outcomes to be evaluated in ascending order.

+ +
Arguments:
+ +
    +
  • keep: The number of lowest elements will be kept.
    • +
  • drop: This number of lowest elements will be dropped before keeping.
    • +
+
+ + +
+
+ +
+ + def + highest( self, keep: int = 1, drop: int = 0) -> MultisetExpression[-T_contra]: + + + +
+ + 
622    def highest(self,
+623                keep: int = 1,
+624                drop: int = 0) -> 'MultisetExpression[T_contra]':
+625        """Keep some of the highest elements from this multiset and drop the rest.
+626
+627        In contrast to the die and free function versions, this does not
+628        automatically sum the dice. Use `.sum()` afterwards if you want to sum.
+629        Alternatively, you can perform some other evaluation.
+630
+631        This requires the outcomes to be evaluated in descending order.
+632
+633        Args:
+634            keep: The number of highest elements will be kept.
+635            drop: This number of highest elements will be dropped before keeping.
+636        """
+637        t = (...,) + (1,) * keep + (0,) * drop
+638        return self.keep(t)
+
+ + +

Keep some of the highest elements from this multiset and drop the rest.

+ +

In contrast to the die and free function versions, this does not +automatically sum the dice. Use .sum() afterwards if you want to sum. +Alternatively, you can perform some other evaluation.

+ +

This requires the outcomes to be evaluated in descending order.

+ +
Arguments:
+ +
    +
  • keep: The number of highest elements will be kept.
    • +
  • drop: This number of highest elements will be dropped before keeping.
    • +
+
+ + +
+
+ +
+ + def + evaluate( *expressions: MultisetExpression[-T_contra], evaluator: MultisetEvaluator[-T_contra, ~U]) -> Union[Die[~U], MultisetEvaluator[-T_contra, ~U]]: + + + +
+ + 
642    def evaluate(
+643        *expressions: 'MultisetExpression[T_contra]',
+644        evaluator: 'icepool.MultisetEvaluator[T_contra, U]'
+645    ) -> 'icepool.Die[U] | icepool.MultisetEvaluator[T_contra, U]':
+646        """Attaches a final `MultisetEvaluator` to expressions.
+647
+648        All of the `MultisetExpression` methods below are evaluations,
+649        as are the operators `<, <=, >, >=, !=, ==`. This means if the
+650        expression is fully bound, it will be evaluated to a `Die`.
+651
+652        Returns:
+653            A `Die` if the expression is are fully bound.
+654            A `MultisetEvaluator` otherwise.
+655        """
+656        if all(
+657                isinstance(expression, icepool.MultisetGenerator)
+658                for expression in expressions):
+659            return evaluator.evaluate(*expressions)
+660        evaluator = icepool.evaluator.ExpressionEvaluator(*expressions,
+661                                                          evaluator=evaluator)
+662        if evaluator._free_arity == 0:
+663            return evaluator.evaluate()
+664        else:
+665            return evaluator
+
+ + +

Attaches a final MultisetEvaluator to expressions.

+ +

All of the MultisetExpression methods below are evaluations, +as are the operators <, <=, >, >=, !=, ==. This means if the +expression is fully bound, it will be evaluated to a Die.

+ +
Returns:
+ +
+

A Die if the expression is are fully bound. + A MultisetEvaluator otherwise.

+
+
+ + +
+
+ +
+ + def + expand( self, order: Order = <Order.Ascending: 1>) -> Union[Die[tuple[-T_contra, ...]], MultisetEvaluator[-T_contra, tuple[-T_contra, ...]]]: + + + +
+ + 
667    def expand(
+668        self,
+669        order: Order = Order.Ascending
+670    ) -> 'icepool.Die[tuple[T_contra, ...]] | icepool.MultisetEvaluator[T_contra, tuple[T_contra, ...]]':
+671        """Evaluation: All elements of the multiset in ascending order.
+672
+673        This is expensive and not recommended unless there are few possibilities.
+674
+675        Args:
+676            order: Whether the elements are in ascending (default) or descending
+677                order.
+678        """
+679        return self.evaluate(evaluator=icepool.evaluator.ExpandEvaluator(
+680            order=order))
+
+ + +

Evaluation: All elements of the multiset in ascending order.

+ +

This is expensive and not recommended unless there are few possibilities.

+ +
Arguments:
+ +
    +
  • order: Whether the elements are in ascending (default) or descending +order.
    • +
+
+ + +
+
+ +
+ + def + sum( self, map: Union[Callable[[-T_contra], ~U], Mapping[-T_contra, ~U], NoneType] = None) -> Union[Die[~U], MultisetEvaluator[-T_contra, ~U]]: + + + +
+ + 
682    def sum(
+683        self,
+684        map: Callable[[T_contra], U] | Mapping[T_contra, U] | None = None
+685    ) -> 'icepool.Die[U] | icepool.MultisetEvaluator[T_contra, U]':
+686        """Evaluation: The sum of all elements."""
+687        if map is None:
+688            return self.evaluate(evaluator=icepool.evaluator.sum_evaluator)
+689        else:
+690            return self.evaluate(evaluator=icepool.evaluator.SumEvaluator(map))
+
+ + +

Evaluation: The sum of all elements.

+
+ + +
+
+ +
+ + def + count( self) -> Union[Die[int], MultisetEvaluator[-T_contra, int]]: + + + +
+ + 
692    def count(
+693            self
+694    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[T_contra, int]':
+695        """Evaluation: The total number of elements in the multiset.
+696
+697        This is usually not very interesting unless some other operation is
+698        performed first. Examples:
+699
+700        `generator.unique().count()` will count the number of unique outcomes.
+701
+702        `(generator & [4, 5, 6]).count()` will count up to one each of
+703        4, 5, and 6.
+704        """
+705        return self.evaluate(evaluator=icepool.evaluator.count_evaluator)
+
+ + +

Evaluation: The total number of elements in the multiset.

+ +

This is usually not very interesting unless some other operation is +performed first. Examples:

+ +

generator.unique().count() will count the number of unique outcomes.

+ +

(generator & [4, 5, 6]).count() will count up to one each of +4, 5, and 6.

+
+ + +
+
+ +
+ + def + any( self) -> Union[Die[bool], MultisetEvaluator[-T_contra, bool]]: + + + +
+ + 
707    def any(
+708        self
+709    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+710        """Evaluation: Whether the multiset has at least one positive count."""
+711        return self.evaluate(evaluator=icepool.evaluator.any_evaluator)
+
+ + +

Evaluation: Whether the multiset has at least one positive count.

+
+ + +
+
+ +
+ + def + highest_outcome_and_count( self) -> Union[Die[tuple[-T_contra, int]], MultisetEvaluator[-T_contra, tuple[-T_contra, int]]]: + + + +
+ + 
713    def highest_outcome_and_count(
+714        self
+715    ) -> 'icepool.Die[tuple[T_contra, int]] | icepool.MultisetEvaluator[T_contra, tuple[T_contra, int]]':
+716        """Evaluation: The highest outcome with positive count, along with that count.
+717
+718        If no outcomes have positive count, the min outcome will be returned with 0 count.
+719        """
+720        return self.evaluate(
+721            evaluator=icepool.evaluator.HighestOutcomeAndCountEvaluator())
+
+ + +

Evaluation: The highest outcome with positive count, along with that count.

+ +

If no outcomes have positive count, the min outcome will be returned with 0 count.

+
+ + +
+
+ +
+ + def + all_counts( self, filter: int | None = 1) -> Union[Die[tuple[int, ...]], MultisetEvaluator[-T_contra, tuple[int, ...]]]: + + + +
+ + 
723    def all_counts(
+724        self,
+725        filter: int | None = 1
+726    ) -> 'icepool.Die[tuple[int, ...]] | icepool.MultisetEvaluator[T_contra, tuple[int, ...]]':
+727        """Evaluation: Sorted tuple of all counts, i.e. the sizes of all matching sets.
+728
+729        The sizes are in **descending** order.
+730
+731        Args:
+732            filter: Any counts below this value will not be in the output.
+733                For example, `filter=2` will only produce pairs and better.
+734                If `None`, no filtering will be done.
+735
+736                Why not just place `keep_counts()` before this?
+737                `keep_counts()` operates by setting counts to zero, so you
+738                would still need an argument to specify whether you want to
+739                output zero counts. So we might as well use the argument to do
+740                both.
+741        """
+742        return self.evaluate(evaluator=icepool.evaluator.AllCountsEvaluator(
+743            filter=filter))
+
+ + +

Evaluation: Sorted tuple of all counts, i.e. the sizes of all matching sets.

+ +

The sizes are in descending order.

+ +
Arguments:
+ +
    +

  • filter: Any counts below this value will not be in the output. +For example, filter=2 will only produce pairs and better. +If None, no filtering will be done.

    + +

    Why not just place keep_counts() before this? +keep_counts() operates by setting counts to zero, so you +would still need an argument to specify whether you want to +output zero counts. So we might as well use the argument to do +both.

    • +
+
+ + +
+
+ +
+ + def + largest_count( self) -> Union[Die[int], MultisetEvaluator[-T_contra, int]]: + + + +
+ + 
745    def largest_count(
+746            self
+747    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[T_contra, int]':
+748        """Evaluation: The size of the largest matching set among the elements."""
+749        return self.evaluate(
+750            evaluator=icepool.evaluator.LargestCountEvaluator())
+
+ + +

Evaluation: The size of the largest matching set among the elements.

+
+ + +
+
+ +
+ + def + largest_count_and_outcome( self) -> Union[Die[tuple[int, -T_contra]], MultisetEvaluator[-T_contra, tuple[int, -T_contra]]]: + + + +
+ + 
752    def largest_count_and_outcome(
+753        self
+754    ) -> 'icepool.Die[tuple[int, T_contra]] | icepool.MultisetEvaluator[T_contra, tuple[int, T_contra]]':
+755        """Evaluation: The largest matching set among the elements and the corresponding outcome."""
+756        return self.evaluate(
+757            evaluator=icepool.evaluator.LargestCountAndOutcomeEvaluator())
+
+ + +

Evaluation: The largest matching set among the elements and the corresponding outcome.

+
+ + +
+
+ +
+ + def + largest_straight( self: MultisetExpression[int]) -> Union[Die[int], MultisetEvaluator[int, int]]: + + + +
+ + 
759    def largest_straight(
+760        self: 'MultisetExpression[int]'
+761    ) -> 'icepool.Die[int] | icepool.MultisetEvaluator[int, int]':
+762        """Evaluation: The size of the largest straight among the elements.
+763
+764        Outcomes must be `int`s.
+765        """
+766        return self.evaluate(
+767            evaluator=icepool.evaluator.LargestStraightEvaluator())
+
+ + +

Evaluation: The size of the largest straight among the elements.

+ +

Outcomes must be ints.

+
+ + +
+
+ +
+ + def + largest_straight_and_outcome( self: MultisetExpression[int]) -> Union[Die[tuple[int, int]], MultisetEvaluator[int, tuple[int, int]]]: + + + +
+ + 
769    def largest_straight_and_outcome(
+770        self: 'MultisetExpression[int]'
+771    ) -> 'icepool.Die[tuple[int, int]] | icepool.MultisetEvaluator[int, tuple[int, int]]':
+772        """Evaluation: The size of the largest straight among the elements and the highest outcome in that straight.
+773
+774        Outcomes must be `int`s.
+775        """
+776        return self.evaluate(
+777            evaluator=icepool.evaluator.LargestStraightAndOutcomeEvaluator())
+
+ + +

Evaluation: The size of the largest straight among the elements and the highest outcome in that straight.

+ +

Outcomes must be ints.

+
+ + +
+
+ +
+ + def + all_straights( self: MultisetExpression[int]) -> Union[Die[tuple[int, ...]], MultisetEvaluator[int, tuple[int, ...]]]: + + + +
+ + 
779    def all_straights(
+780        self: 'MultisetExpression[int]'
+781    ) -> 'icepool.Die[tuple[int, ...]] | icepool.MultisetEvaluator[int, tuple[int, ...]]':
+782        """Evaluation: The sizes of all straights.
+783
+784        The sizes are in **descending** order.
+785
+786        Each element can only contribute to one straight, though duplicates can
+787        produce overlapping straights.
+788        """
+789        return self.evaluate(
+790            evaluator=icepool.evaluator.AllStraightsEvaluator())
+
+ + +

Evaluation: The sizes of all straights.

+ +

The sizes are in descending order.

+ +

Each element can only contribute to one straight, though duplicates can +produce overlapping straights.

+
+ + +
+
+ +
+ + def + issubset( self, other: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], /) -> Union[Die[bool], MultisetEvaluator[-T_contra, bool]]: + + + +
+ + 
835    def issubset(
+836            self, other:
+837        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+838            /
+839    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+840        """Evaluation: Whether this multiset is a subset of the other multiset.
+841
+842        Specifically, if this multiset has a lesser or equal count for each
+843        outcome than the other multiset, this evaluates to `True`; 
+844        if there is some outcome for which this multiset has a greater count 
+845        than the other multiset, this evaluates to `False`.
+846
+847        `issubset` is the same as `self <= other`.
+848        
+849        `self < other` evaluates a proper subset relation, which is the same
+850        except the result is `False` if the two multisets are exactly equal.
+851        """
+852        return self._compare(other, icepool.evaluator.IsSubsetEvaluator)
+
+ + +

Evaluation: Whether this multiset is a subset of the other multiset.

+ +

Specifically, if this multiset has a lesser or equal count for each +outcome than the other multiset, this evaluates to True; +if there is some outcome for which this multiset has a greater count +than the other multiset, this evaluates to False.

+ +

issubset is the same as self <= other.

+ +

self < other evaluates a proper subset relation, which is the same +except the result is False if the two multisets are exactly equal.

+
+ + +
+
+ +
+ + def + issuperset( self, other: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], /) -> Union[Die[bool], MultisetEvaluator[-T_contra, bool]]: + + + +
+ + 
875    def issuperset(
+876            self, other:
+877        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+878            /
+879    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+880        """Evaluation: Whether this multiset is a superset of the other multiset.
+881
+882        Specifically, if this multiset has a greater or equal count for each
+883        outcome than the other multiset, this evaluates to `True`; 
+884        if there is some  outcome for which this multiset has a lesser count 
+885        than the other multiset, this evaluates to `False`.
+886        
+887        A typical use of this evaluation is testing for the presence of a
+888        combo of cards in a hand, e.g.
+889
+890        ```
+891        deck.deal(5) >= ['a', 'a', 'b']
+892        ```
+893
+894        represents the chance that a deal of 5 cards contains at least two 'a's
+895        and one 'b'.
+896
+897        `issuperset` is the same as `self >= other`.
+898
+899        `self > other` evaluates a proper superset relation, which is the same
+900        except the result is `False` if the two multisets are exactly equal.
+901        """
+902        return self._compare(other, icepool.evaluator.IsSupersetEvaluator)
+
+ + +

Evaluation: Whether this multiset is a superset of the other multiset.

+ +

Specifically, if this multiset has a greater or equal count for each +outcome than the other multiset, this evaluates to True; +if there is some outcome for which this multiset has a lesser count +than the other multiset, this evaluates to False.

+ +

A typical use of this evaluation is testing for the presence of a +combo of cards in a hand, e.g.

+ +
deck.deal(5) >= ['a', 'a', 'b']
+
+ +

represents the chance that a deal of 5 cards contains at least two 'a's +and one 'b'.

+ +

issuperset is the same as self >= other.

+ +

self > other evaluates a proper superset relation, which is the same +except the result is False if the two multisets are exactly equal.

+
+ + +
+
+ +
+ + def + isdisjoint( self, other: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], /) -> Union[Die[bool], MultisetEvaluator[-T_contra, bool]]: + + + +
+ + 
927    def isdisjoint(
+928            self, other:
+929        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+930            /
+931    ) -> 'icepool.Die[bool] | icepool.MultisetEvaluator[T_contra, bool]':
+932        """Evaluation: Whether this multiset is disjoint from the other multiset.
+933        
+934        Specifically, this evaluates to `False` if there is any outcome for
+935        which both multisets have positive count, and `True` if there is not.
+936        """
+937        return self._compare(other, icepool.evaluator.IsDisjointSetEvaluator)
+
+ + +

Evaluation: Whether this multiset is disjoint from the other multiset.

+ +

Specifically, this evaluates to False if there is any outcome for +which both multisets have positive count, and True if there is not.

+
+ + +
+
+ +
+ + def + compair( self, other: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]], op: Optional[Literal['<', '<=', '>', '>=', '==', '!=']] = None, /, *, order: Order = <Order.Descending: -1>, initial=None, tie=None, left=None, right=None, extra_left=None, extra_right=None) -> Union[Die, MultisetEvaluator[-T_contra, Any]]: + + + +
+ + 
939    def compair(
+940        self,
+941        other:
+942        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]',
+943        op: Literal['<', '<=', '>', '>=', '==', '!='] | None = None,
+944        /,
+945        *,
+946        order: Order = Order.Descending,
+947        initial=None,
+948        tie=None,
+949        left=None,
+950        right=None,
+951        extra_left=None,
+952        extra_right=None
+953    ) -> 'icepool.Die | icepool.MultisetEvaluator[T_contra, Any]':
+954        """Evaluation: EXPERIMENTAL: Compares sorted pairs of two multisets and scores wins, ties, and extra elements.
+955
+956        Interface is not stable yet.
+957
+958        For example, `left=1` would count how many pairs were won by the left
+959        side, and `left=1, right=-1` would give the difference in the number of
+960        pairs won by each side.
+961
+962        Any score argument 
+963        (`initial, tie, left, right, extra_left, extra_right`) 
+964        not provided will be set to a zero value determined from another score 
+965        argument times `0`.
+966
+967        Args:
+968            op: Sets the score values based on the given operator and `order`.
+969                Allowed values are `'<', '<=', '>', '>=', '==', '!='`.
+970                Each pair that fits the comparator counts as 1.
+971                If one side has more elements than the other, the extra
+972                elements are ignored.
+973            order: If descending (default), pairs are made in descending order
+974                and the higher element wins. If ascending, pairs are made in
+975                ascending order and the lower element wins.
+976            
+977            initial: The initial score.
+978            tie: The score for each pair that is a tie.
+979            left: The score for each pair that left wins.
+980            right: The score for each pair that right wins.
+981            extra_left: If left has more elements, each extra element scores
+982                this much.
+983            extra_right: If right has more elements, each extra element scores
+984                this much.
+985        """
+986        try:
+987            other = implicit_convert_to_expression(other)
+988        except TypeError:
+989            return NotImplemented
+990        return self.evaluate(other,
+991                             evaluator=icepool.evaluator.CompairEvalautor(
+992                                 op=op,
+993                                 order=order,
+994                                 initial=initial,
+995                                 tie=tie,
+996                                 left=left,
+997                                 right=right,
+998                                 extra_left=extra_left,
+999                                 extra_right=extra_right))
+
+ + +

Evaluation: EXPERIMENTAL: Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

+ +

Interface is not stable yet.

+ +

For example, left=1 would count how many pairs were won by the left +side, and left=1, right=-1 would give the difference in the number of +pairs won by each side.

+ +

Any score argument +(initial, tie, left, right, extra_left, extra_right) +not provided will be set to a zero value determined from another score +argument times 0.

+ +
Arguments:
+ +
    +
  • op: Sets the score values based on the given operator and order. +Allowed values are '<', '<=', '>', '>=', '==', '!='. +Each pair that fits the comparator counts as 1. +If one side has more elements than the other, the extra +elements are ignored.
    • +
  • order: If descending (default), pairs are made in descending order +and the higher element wins. If ascending, pairs are made in +ascending order and the lower element wins.
    • +
  • initial: The initial score.
    • +
  • tie: The score for each pair that is a tie.
    • +
  • left: The score for each pair that left wins.
    • +
  • right: The score for each pair that right wins.
    • +
  • extra_left: If left has more elements, each extra element scores +this much.
    • +
  • extra_right: If right has more elements, each extra element scores +this much.
    • +
+
+ + +
+
+
+ +
+ + class + MultisetEvaluator(abc.ABC, typing.Generic[-T_contra, +U_co]): + + + +
+ + 
 26class MultisetEvaluator(ABC, Generic[T_contra, U_co]):
+ 27    """An abstract, immutable, callable class for evaulating one or more `MultisetGenerator`s.
+ 28
+ 29    There is one abstract method to implement: `next_state()`.
+ 30    This should incrementally calculate the result given one outcome at a time
+ 31    along with how many of that outcome were produced.
+ 32
+ 33    An example sequence of calls, as far as `next_state()` is concerned, is:
+ 34
+ 35    1. `state = next_state(state=None, outcome=1, count_of_1s)`
+ 36    2. `state = next_state(state, 2, count_of_2s)`
+ 37    3. `state = next_state(state, 3, count_of_3s)`
+ 38    4. `state = next_state(state, 4, count_of_4s)`
+ 39    5. `state = next_state(state, 5, count_of_5s)`
+ 40    6. `state = next_state(state, 6, count_of_6s)`
+ 41    7. `outcome = final_outcome(state)`
+ 42
+ 43    A few other methods can optionally be overridden to further customize behavior.
+ 44
+ 45    It is not expected that subclasses of `MultisetEvaluator`
+ 46    be able to handle arbitrary types or numbers of generators.
+ 47    Indeed, most are expected to handle only a fixed number of generators,
+ 48    and often even only generators with a particular type of `Die`.
+ 49
+ 50    Instances cache all intermediate state distributions.
+ 51    You should therefore reuse instances when possible.
+ 52
+ 53    Instances should not be modified after construction
+ 54    in any way that affects the return values of these methods.
+ 55    Otherwise, values in the cache may be incorrect.
+ 56    """
+ 57
+ 58    @abstractmethod
+ 59    def next_state(self, state: Hashable, outcome: T_contra, /, *counts:
+ 60                   int) -> Hashable:
+ 61        """State transition function.
+ 62
+ 63        This should produce a state given the previous state, an outcome,
+ 64        and the number that outcome produced by each generator.
+ 65
+ 66        `evaluate()` will always call this using only positional arguments.
+ 67        Furthermore, there is no expectation that a subclass be able to handle
+ 68        an arbitrary number of counts. Thus, you are free to rename any of
+ 69        the parameters in a subclass, or to replace `*counts` with a fixed set
+ 70        of parameters.
+ 71
+ 72        Make sure to handle the base case where `state is None`.
+ 73
+ 74        States must be hashable. At current, they do not have to be orderable.
+ 75        However, this may change in the future, and if they are not totally
+ 76        orderable, you must override `final_outcome` to create totally orderable
+ 77        final outcomes.
+ 78
+ 79        The behavior of returning a `Die` from `next_state` is currently
+ 80        undefined.
+ 81
+ 82        Args:
+ 83            state: A hashable object indicating the state before rolling the
+ 84                current outcome. If this is the first outcome being considered,
+ 85                `state` will be `None`.
+ 86            outcome: The current outcome.
+ 87                `next_state` will see all rolled outcomes in monotonic order;
+ 88                either ascending or descending depending on `order()`.
+ 89                If there are multiple generators, the set of outcomes is the
+ 90                union of the outcomes of the invididual generators. All outcomes
+ 91                with nonzero count will be seen. Outcomes with zero count
+ 92                may or may not be seen. If you need to enforce that certain
+ 93                outcomes are seen even if they have zero count, see
+ 94                `alignment()`.
+ 95            *counts: One value (usually an `int`) for each generator output
+ 96                indicating how many of the current outcome were produced.
+ 97                All outcomes with nonzero count are guaranteed to be seen.
+ 98                To guarantee that outcomes are seen even if they have zero
+ 99                count, override `alignment()`.
+100
+101        Returns:
+102            A hashable object indicating the next state.
+103            The special value `icepool.Reroll` can be used to immediately remove
+104            the state from consideration, effectively performing a full reroll.
+105        """
+106
+107    def final_outcome(
+108        self, final_state: Hashable
+109    ) -> 'U_co | icepool.Die[U_co] | icepool.RerollType':
+110        """Optional function to generate a final outcome from a final state.
+111
+112        By default, the final outcome is equal to the final state.
+113        Note that `None` is not a valid outcome for a `Die`,
+114        and if there are no outcomes, `final_outcome` will be immediately
+115        be callled with `final_state=None`.
+116        Subclasses that want to handle this case should explicitly define what
+117        happens.
+118
+119        Args:
+120            final_state: A state after all outcomes have been processed.
+121
+122        Returns:
+123            A final outcome that will be used as part of constructing the result `Die`.
+124            As usual for `Die()`, this could itself be a `Die` or `icepool.Reroll`.
+125        """
+126        # If not overriden, the final_state should have type U_co.
+127        return cast(U_co, final_state)
+128
+129    def order(self) -> Order:
+130        """Optional function to determine the order in which `next_state()` will see outcomes.
+131
+132        The default is ascending order. This has better caching behavior with 
+133        mixed standard dice.
+134
+135        Returns:
+136            * Order.Ascending (= 1)
+137                if `next_state()` should always see the outcomes in ascending order.
+138            * Order.Descending (= -1)
+139                if `next_state()` should always see the outcomes in descending order.
+140            * Order.Any (= 0)
+141                if the result of the evaluation is order-independent.
+142        """
+143        return Order.Ascending
+144
+145    def alignment(self, outcomes: Sequence[T_contra]) -> Collection[T_contra]:
+146        """Optional method to specify additional outcomes that should be seen by `next_state()`.
+147
+148        These will be seen by `next_state` even if they have zero count or do
+149        not appear in the generator(s) at all.
+150
+151        The default implementation returns `()`; this means outcomes with zero
+152        count may or may not be seen by `next_state`.
+153
+154        If you want `next_state` to see consecutive `int` outcomes, you can set
+155        `alignment = icepool.MultisetEvaluator.range_alignment`.
+156        See `range_alignment()` below.
+157
+158        If you want `next_state` to see all generator outcomes, you can return
+159        `outcomes` as-is.
+160
+161        Args:
+162            outcomes: The outcomes that could be produced by the generators, in
+163            ascending order.
+164        """
+165        return ()
+166
+167    def range_alignment(self, outcomes: Sequence[int]) -> Collection[int]:
+168        """Example implementation of `alignment()` that produces consecutive `int` outcomes.
+169
+170        There is no expectation that a subclass be able to handle
+171        an arbitrary number of generators. Thus, you are free to rename any of
+172        the parameters in a subclass, or to replace `*generators` with a fixed
+173        set of parameters.
+174
+175        Set `alignment = icepool.MultisetEvaluator.range_alignment` to use this.
+176
+177        Returns:
+178            All `int`s from the min outcome to the max outcome among the generators,
+179            inclusive.
+180
+181        Raises:
+182            TypeError: if any generator has any non-`int` outcome.
+183        """
+184        if not outcomes:
+185            return ()
+186
+187        if any(not isinstance(x, int) for x in outcomes):
+188            raise TypeError(
+189                "range_alignment cannot be used with outcomes of type other than 'int'."
+190            )
+191
+192        return range(outcomes[0], outcomes[-1] + 1)
+193
+194    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+195        """An optional sequence of extra generators whose counts will be prepended to *counts."""
+196        return ()
+197
+198    def validate_arity(self, arity: int) -> None:
+199        """An optional method to verify the total input arity.
+200
+201        This is called after any implicit conversion to generators, but does
+202        not include any `extra_generators()`.
+203
+204        Overriding `next_state` with a fixed number of counts will make this
+205        check redundant.
+206
+207        Raises:
+208            `ValueError` if the total input arity is not valid.
+209        """
+210
+211    @cached_property
+212    def _cache(self) -> MutableMapping[Any, Mapping[Any, int]]:
+213        """A cache of (order, generators) -> weight distribution over states. """
+214        return {}
+215
+216    @overload
+217    def evaluate(
+218        self, *args: 'Mapping[T_contra, int] | Sequence[T_contra]'
+219    ) -> 'icepool.Die[U_co]':
+220        ...
+221
+222    @overload
+223    def evaluate(
+224        self, *args: 'MultisetExpression[T_contra]'
+225    ) -> 'MultisetEvaluator[T_contra, U_co]':
+226        ...
+227
+228    @overload
+229    def evaluate(
+230        self, *args:
+231        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]'
+232    ) -> 'icepool.Die[U_co] | MultisetEvaluator[T_contra, U_co]':
+233        ...
+234
+235    def evaluate(
+236        self, *args:
+237        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]'
+238    ) -> 'icepool.Die[U_co] | MultisetEvaluator[T_contra, U_co]':
+239        """Evaluates generator(s).
+240
+241        You can call the `MultisetEvaluator` object directly for the same effect,
+242        e.g. `sum_evaluator(generator)` is an alias for `sum_evaluator.evaluate(generator)`.
+243
+244        Most evaluators will expect a fixed number of input multisets.
+245        The union of the outcomes of the generator(s) must be totally orderable.
+246
+247        Args:
+248            *args: Each may be one of the following:
+249                * A `GeneratorsWithExpression`.
+250                * A `MultisetGenerator`.
+251                * A mappable mapping outcomes to the number of those outcomes.
+252                * A sequence of outcomes.
+253
+254        Returns:
+255            A `Die` representing the distribution of the final outcome if no
+256            arg contains a free variable. Otherwise, returns a new evaluator.
+257        """
+258        from icepool.generator.alignment import Alignment
+259
+260        # Convert arguments to expressions.
+261        expressions = tuple(
+262            icepool.implicit_convert_to_expression(arg) for arg in args)
+263
+264        if any(expression._free_arity() > 0 for expression in expressions):
+265            from icepool.evaluator.expression import ExpressionEvaluator
+266            return ExpressionEvaluator(*expressions, evaluator=self)
+267
+268        generators = cast(tuple[icepool.MultisetGenerator, ...], expressions)
+269
+270        self.validate_arity(
+271            sum(generator.output_arity() for generator in generators))
+272
+273        generators = self.prefix_generators() + generators
+274
+275        if not all(generator._is_resolvable() for generator in generators):
+276            return icepool.Die([])
+277
+278        algorithm, order = self._select_algorithm(*generators)
+279
+280        # We use a separate class to guarantee all outcomes are visited.
+281        outcomes = sorted_union(*(generator.outcomes()
+282                                  for generator in generators))
+283        alignment = Alignment(self.alignment(outcomes))
+284
+285        dist = algorithm(order, alignment, generators)
+286
+287        final_outcomes = []
+288        final_weights = []
+289        for state, weight in dist.items():
+290            outcome = self.final_outcome(state)
+291            if outcome is None:
+292                raise TypeError(
+293                    "None is not a valid final outcome.\n"
+294                    "This may have been a result of not supplying any generator with an outcome."
+295                )
+296            if outcome is not icepool.Reroll:
+297                final_outcomes.append(outcome)
+298                final_weights.append(weight)
+299
+300        return icepool.Die(final_outcomes, final_weights)
+301
+302    __call__ = evaluate
+303
+304    def _select_algorithm(
+305        self, *generators: 'icepool.MultisetGenerator[T_contra, Any]'
+306    ) -> tuple[
+307            'Callable[[Order, Alignment[T_contra], tuple[icepool.MultisetGenerator[T_contra, Any], ...]], Mapping[Any, int]]',
+308            Order]:
+309        """Selects an algorithm and iteration order.
+310
+311        Returns:
+312            * The algorithm to use (`_eval_internal*`).
+313            * The order in which `next_state()` sees outcomes.
+314                1 for ascending and -1 for descending.
+315        """
+316        eval_order = self.order()
+317
+318        if not generators:
+319            # No generators.
+320            return self._eval_internal, eval_order
+321
+322        pop_min_costs, pop_max_costs = zip(*(generator._estimate_order_costs()
+323                                             for generator in generators))
+324
+325        pop_min_cost = math.prod(pop_min_costs)
+326        pop_max_cost = math.prod(pop_max_costs)
+327
+328        # No preferred order case: go directly with cost.
+329        if eval_order == Order.Any:
+330            if pop_max_cost <= pop_min_cost:
+331                return self._eval_internal, Order.Ascending
+332            else:
+333                return self._eval_internal, Order.Descending
+334
+335        # Preferred order case.
+336        # Go with the preferred order unless there is a "significant"
+337        # cost factor.
+338
+339        if PREFERRED_ORDER_COST_FACTOR * pop_max_cost < pop_min_cost:
+340            cost_order = Order.Ascending
+341        elif PREFERRED_ORDER_COST_FACTOR * pop_min_cost < pop_max_cost:
+342            cost_order = Order.Descending
+343        else:
+344            cost_order = Order.Any
+345
+346        if cost_order == Order.Any or eval_order == cost_order:
+347            # Use the preferred algorithm.
+348            return self._eval_internal, eval_order
+349        else:
+350            # Use the less-preferred algorithm.
+351            return self._eval_internal_iterative, eval_order
+352
+353    def _eval_internal(
+354        self, order: Order, alignment: 'Alignment[T_contra]',
+355        generators: 'tuple[icepool.MultisetGenerator[T_contra, Any], ...]'
+356    ) -> Mapping[Any, int]:
+357        """Internal algorithm for iterating in the more-preferred order,
+358        i.e. giving outcomes to `next_state()` from wide to narrow.
+359
+360        All intermediate return values are cached in the instance.
+361
+362        Arguments:
+363            order: The order in which to send outcomes to `next_state()`.
+364            alignment: As `alignment()`. Elements will be popped off this
+365                during recursion.
+366            generators: One or more `MultisetGenerators`s to evaluate. Elements
+367                will be popped off this during recursion.
+368
+369        Returns:
+370            A dict `{ state : weight }` describing the probability distribution
+371                over states.
+372        """
+373        cache_key = (order, alignment, generators)
+374        if cache_key in self._cache:
+375            return self._cache[cache_key]
+376
+377        result: MutableMapping[Any, int] = defaultdict(int)
+378
+379        if all(not generator.outcomes()
+380               for generator in generators) and not alignment.outcomes():
+381            result = {None: 1}
+382        else:
+383            outcome, prev_alignment, iterators = MultisetEvaluator._pop_generators(
+384                order, alignment, generators)
+385            for p in itertools.product(*iterators):
+386                prev_generators, counts, weights = zip(*p)
+387                counts = tuple(itertools.chain.from_iterable(counts))
+388                prod_weight = math.prod(weights)
+389                prev = self._eval_internal(order, prev_alignment,
+390                                           prev_generators)
+391                for prev_state, prev_weight in prev.items():
+392                    state = self.next_state(prev_state, outcome, *counts)
+393                    if state is not icepool.Reroll:
+394                        result[state] += prev_weight * prod_weight
+395
+396        self._cache[cache_key] = result
+397        return result
+398
+399    def _eval_internal_iterative(
+400        self, order: int, alignment: 'Alignment[T_contra]',
+401        generators: 'tuple[icepool.MultisetGenerator[T_contra, Any], ...]'
+402    ) -> Mapping[Any, int]:
+403        """Internal algorithm for iterating in the less-preferred order,
+404        i.e. giving outcomes to `next_state()` from narrow to wide.
+405
+406        This algorithm does not perform persistent memoization.
+407        """
+408        if all(not generator.outcomes()
+409               for generator in generators) and not alignment.outcomes():
+410            return {None: 1}
+411        dist: MutableMapping[Any, int] = defaultdict(int)
+412        dist[None, alignment, generators] = 1
+413        final_dist: MutableMapping[Any, int] = defaultdict(int)
+414        while dist:
+415            next_dist: MutableMapping[Any, int] = defaultdict(int)
+416            for (prev_state, prev_alignment,
+417                 prev_generators), weight in dist.items():
+418                # The order flip here is the only purpose of this algorithm.
+419                outcome, alignment, iterators = MultisetEvaluator._pop_generators(
+420                    -order, prev_alignment, prev_generators)
+421                for p in itertools.product(*iterators):
+422                    generators, counts, weights = zip(*p)
+423                    counts = tuple(itertools.chain.from_iterable(counts))
+424                    prod_weight = math.prod(weights)
+425                    state = self.next_state(prev_state, outcome, *counts)
+426                    if state is not icepool.Reroll:
+427                        if all(not generator.outcomes()
+428                               for generator in generators):
+429                            final_dist[state] += weight * prod_weight
+430                        else:
+431                            next_dist[state, alignment,
+432                                      generators] += weight * prod_weight
+433            dist = next_dist
+434        return final_dist
+435
+436    @staticmethod
+437    def _pop_generators(
+438        side: int, alignment: 'Alignment[T_contra]',
+439        generators: 'tuple[icepool.MultisetGenerator[T_contra, Any], ...]'
+440    ) -> 'tuple[T_contra, Alignment[T_contra], tuple[icepool.NextMultisetGenerator, ...]]':
+441        """Pops a single outcome from the generators.
+442
+443        Returns:
+444            * The popped outcome.
+445            * The remaining alignment.
+446            * A tuple of iterators over the resulting generators, counts, and weights.
+447        """
+448        alignment_and_generators = (alignment, ) + generators
+449        if side >= 0:
+450            outcome = max(generator.max_outcome()
+451                          for generator in alignment_and_generators
+452                          if generator.outcomes())
+453
+454            next_alignment, _, _ = next(alignment._generate_max(outcome))
+455
+456            return outcome, next_alignment, tuple(
+457                generator._generate_max(outcome) for generator in generators)
+458        else:
+459            outcome = min(generator.min_outcome()
+460                          for generator in alignment_and_generators
+461                          if generator.outcomes())
+462
+463            next_alignment, _, _ = next(alignment._generate_min(outcome))
+464
+465            return outcome, next_alignment, tuple(
+466                generator._generate_min(outcome) for generator in generators)
+467
+468    def sample(
+469        self, *generators:
+470        'icepool.MultisetGenerator[T_contra, Any] | Mapping[T_contra, int] | Sequence[T_contra]'
+471    ):
+472        """EXPERIMENTAL: Samples one result from the generator(s) and evaluates the result."""
+473        # Convert non-`Pool` arguments to `Pool`.
+474        converted_generators = tuple(
+475            generator if isinstance(generator, icepool.MultisetGenerator
+476                                    ) else icepool.Pool(generator)
+477            for generator in generators)
+478
+479        result = self.evaluate(*itertools.chain.from_iterable(
+480            generator.sample() for generator in converted_generators))
+481
+482        if not result.is_empty():
+483            return result.outcomes()[0]
+484        else:
+485            return result
+486
+487    def __bool__(self) -> bool:
+488        raise TypeError('MultisetEvaluator does not have a truth value.')
+489
+490    def __str__(self) -> str:
+491        return type(self).__name__
+
+ + +

An abstract, immutable, callable class for evaulating one or more MultisetGenerators.

+ +

There is one abstract method to implement: next_state(). +This should incrementally calculate the result given one outcome at a time +along with how many of that outcome were produced.

+ +

An example sequence of calls, as far as next_state() is concerned, is:

+ +
    +
  1. state = next_state(state=None, outcome=1, count_of_1s)
    2. +
  2. state = next_state(state, 2, count_of_2s)
    3. +
  3. state = next_state(state, 3, count_of_3s)
    4. +
  4. state = next_state(state, 4, count_of_4s)
    5. +
  5. state = next_state(state, 5, count_of_5s)
    6. +
  6. state = next_state(state, 6, count_of_6s)
    7. +
  7. outcome = final_outcome(state)
    8. +
+ +

A few other methods can optionally be overridden to further customize behavior.

+ +

It is not expected that subclasses of MultisetEvaluator +be able to handle arbitrary types or numbers of generators. +Indeed, most are expected to handle only a fixed number of generators, +and often even only generators with a particular type of Die.

+ +

Instances cache all intermediate state distributions. +You should therefore reuse instances when possible.

+ +

Instances should not be modified after construction +in any way that affects the return values of these methods. +Otherwise, values in the cache may be incorrect.

+
+ + +
+ +
+
@abstractmethod
+ + def + next_state(self, state: Hashable, outcome: -T_contra, /, *counts: int) -> Hashable: + + + +
+ + 
 58    @abstractmethod
+ 59    def next_state(self, state: Hashable, outcome: T_contra, /, *counts:
+ 60                   int) -> Hashable:
+ 61        """State transition function.
+ 62
+ 63        This should produce a state given the previous state, an outcome,
+ 64        and the number that outcome produced by each generator.
+ 65
+ 66        `evaluate()` will always call this using only positional arguments.
+ 67        Furthermore, there is no expectation that a subclass be able to handle
+ 68        an arbitrary number of counts. Thus, you are free to rename any of
+ 69        the parameters in a subclass, or to replace `*counts` with a fixed set
+ 70        of parameters.
+ 71
+ 72        Make sure to handle the base case where `state is None`.
+ 73
+ 74        States must be hashable. At current, they do not have to be orderable.
+ 75        However, this may change in the future, and if they are not totally
+ 76        orderable, you must override `final_outcome` to create totally orderable
+ 77        final outcomes.
+ 78
+ 79        The behavior of returning a `Die` from `next_state` is currently
+ 80        undefined.
+ 81
+ 82        Args:
+ 83            state: A hashable object indicating the state before rolling the
+ 84                current outcome. If this is the first outcome being considered,
+ 85                `state` will be `None`.
+ 86            outcome: The current outcome.
+ 87                `next_state` will see all rolled outcomes in monotonic order;
+ 88                either ascending or descending depending on `order()`.
+ 89                If there are multiple generators, the set of outcomes is the
+ 90                union of the outcomes of the invididual generators. All outcomes
+ 91                with nonzero count will be seen. Outcomes with zero count
+ 92                may or may not be seen. If you need to enforce that certain
+ 93                outcomes are seen even if they have zero count, see
+ 94                `alignment()`.
+ 95            *counts: One value (usually an `int`) for each generator output
+ 96                indicating how many of the current outcome were produced.
+ 97                All outcomes with nonzero count are guaranteed to be seen.
+ 98                To guarantee that outcomes are seen even if they have zero
+ 99                count, override `alignment()`.
+100
+101        Returns:
+102            A hashable object indicating the next state.
+103            The special value `icepool.Reroll` can be used to immediately remove
+104            the state from consideration, effectively performing a full reroll.
+105        """
+
+ + +

State transition function.

+ +

This should produce a state given the previous state, an outcome, +and the number that outcome produced by each generator.

+ +

evaluate() will always call this using only positional arguments. +Furthermore, there is no expectation that a subclass be able to handle +an arbitrary number of counts. Thus, you are free to rename any of +the parameters in a subclass, or to replace *counts with a fixed set +of parameters.

+ +

Make sure to handle the base case where state is None.

+ +

States must be hashable. At current, they do not have to be orderable. +However, this may change in the future, and if they are not totally +orderable, you must override final_outcome to create totally orderable +final outcomes.

+ +

The behavior of returning a Die from next_state is currently +undefined.

+ +
Arguments:
+ +
    +
  • state: A hashable object indicating the state before rolling the +current outcome. If this is the first outcome being considered, +state will be None.
    • +
  • outcome: The current outcome. +next_state will see all rolled outcomes in monotonic order; +either ascending or descending depending on order(). +If there are multiple generators, the set of outcomes is the +union of the outcomes of the invididual generators. All outcomes +with nonzero count will be seen. Outcomes with zero count +may or may not be seen. If you need to enforce that certain +outcomes are seen even if they have zero count, see +alignment().
    • +
  • *counts: One value (usually an int) for each generator output +indicating how many of the current outcome were produced. +All outcomes with nonzero count are guaranteed to be seen. +To guarantee that outcomes are seen even if they have zero +count, override alignment().
    • +
+ +
Returns:
+ +
+

A hashable object indicating the next state. + The special value icepool.Reroll can be used to immediately remove + the state from consideration, effectively performing a full reroll.

+
+
+ + +
+
+ +
+ + def + final_outcome( self, final_state: Hashable) -> Union[+U_co, Die[+U_co], RerollType]: + + + +
+ + 
107    def final_outcome(
+108        self, final_state: Hashable
+109    ) -> 'U_co | icepool.Die[U_co] | icepool.RerollType':
+110        """Optional function to generate a final outcome from a final state.
+111
+112        By default, the final outcome is equal to the final state.
+113        Note that `None` is not a valid outcome for a `Die`,
+114        and if there are no outcomes, `final_outcome` will be immediately
+115        be callled with `final_state=None`.
+116        Subclasses that want to handle this case should explicitly define what
+117        happens.
+118
+119        Args:
+120            final_state: A state after all outcomes have been processed.
+121
+122        Returns:
+123            A final outcome that will be used as part of constructing the result `Die`.
+124            As usual for `Die()`, this could itself be a `Die` or `icepool.Reroll`.
+125        """
+126        # If not overriden, the final_state should have type U_co.
+127        return cast(U_co, final_state)
+
+ + +

Optional function to generate a final outcome from a final state.

+ +

By default, the final outcome is equal to the final state. +Note that None is not a valid outcome for a Die, +and if there are no outcomes, final_outcome will be immediately +be callled with final_state=None. +Subclasses that want to handle this case should explicitly define what +happens.

+ +
Arguments:
+ +
    +
  • final_state: A state after all outcomes have been processed.
    • +
+ +
Returns:
+ +
+

A final outcome that will be used as part of constructing the result Die. + As usual for Die(), this could itself be a Die or icepool.Reroll.

+
+
+ + +
+
+ +
+ + def + order(self) -> Order: + + + +
+ + 
129    def order(self) -> Order:
+130        """Optional function to determine the order in which `next_state()` will see outcomes.
+131
+132        The default is ascending order. This has better caching behavior with 
+133        mixed standard dice.
+134
+135        Returns:
+136            * Order.Ascending (= 1)
+137                if `next_state()` should always see the outcomes in ascending order.
+138            * Order.Descending (= -1)
+139                if `next_state()` should always see the outcomes in descending order.
+140            * Order.Any (= 0)
+141                if the result of the evaluation is order-independent.
+142        """
+143        return Order.Ascending
+
+ + +

Optional function to determine the order in which next_state() will see outcomes.

+ +

The default is ascending order. This has better caching behavior with +mixed standard dice.

+ +
Returns:
+ +
+ +
+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence[-T_contra]) -> Collection[-T_contra]: + + + +
+ + 
145    def alignment(self, outcomes: Sequence[T_contra]) -> Collection[T_contra]:
+146        """Optional method to specify additional outcomes that should be seen by `next_state()`.
+147
+148        These will be seen by `next_state` even if they have zero count or do
+149        not appear in the generator(s) at all.
+150
+151        The default implementation returns `()`; this means outcomes with zero
+152        count may or may not be seen by `next_state`.
+153
+154        If you want `next_state` to see consecutive `int` outcomes, you can set
+155        `alignment = icepool.MultisetEvaluator.range_alignment`.
+156        See `range_alignment()` below.
+157
+158        If you want `next_state` to see all generator outcomes, you can return
+159        `outcomes` as-is.
+160
+161        Args:
+162            outcomes: The outcomes that could be produced by the generators, in
+163            ascending order.
+164        """
+165        return ()
+
+ + +

Optional method to specify additional outcomes that should be seen by next_state().

+ +

These will be seen by next_state even if they have zero count or do +not appear in the generator(s) at all.

+ +

The default implementation returns (); this means outcomes with zero +count may or may not be seen by next_state.

+ +

If you want next_state to see consecutive int outcomes, you can set +alignment = icepool.MultisetEvaluator.range_alignment. +See range_alignment() below.

+ +

If you want next_state to see all generator outcomes, you can return +outcomes as-is.

+ +
Arguments:
+ +
    +
  • outcomes: The outcomes that could be produced by the generators, in
    • +
  • ascending order.
    • +
+
+ + +
+
+ +
+ + def + range_alignment(self, outcomes: Sequence[int]) -> Collection[int]: + + + +
+ + 
167    def range_alignment(self, outcomes: Sequence[int]) -> Collection[int]:
+168        """Example implementation of `alignment()` that produces consecutive `int` outcomes.
+169
+170        There is no expectation that a subclass be able to handle
+171        an arbitrary number of generators. Thus, you are free to rename any of
+172        the parameters in a subclass, or to replace `*generators` with a fixed
+173        set of parameters.
+174
+175        Set `alignment = icepool.MultisetEvaluator.range_alignment` to use this.
+176
+177        Returns:
+178            All `int`s from the min outcome to the max outcome among the generators,
+179            inclusive.
+180
+181        Raises:
+182            TypeError: if any generator has any non-`int` outcome.
+183        """
+184        if not outcomes:
+185            return ()
+186
+187        if any(not isinstance(x, int) for x in outcomes):
+188            raise TypeError(
+189                "range_alignment cannot be used with outcomes of type other than 'int'."
+190            )
+191
+192        return range(outcomes[0], outcomes[-1] + 1)
+
+ + +

Example implementation of alignment() that produces consecutive int outcomes.

+ +

There is no expectation that a subclass be able to handle +an arbitrary number of generators. Thus, you are free to rename any of +the parameters in a subclass, or to replace *generators with a fixed +set of parameters.

+ +

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

+ +
Returns:
+ +
+

All ints from the min outcome to the max outcome among the generators, + inclusive.

+
+ +
Raises:
+ +
    +
  • TypeError: if any generator has any non-int outcome.
    • +
+
+ + +
+
+ +
+ + def + prefix_generators( self) -> tuple[MultisetGenerator, ...]: + + + +
+ + 
194    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+195        """An optional sequence of extra generators whose counts will be prepended to *counts."""
+196        return ()
+
+ + +

An optional sequence of extra generators whose counts will be prepended to *counts.

+
+ + +
+
+ +
+ + def + validate_arity(self, arity: int) -> None: + + + +
+ + 
198    def validate_arity(self, arity: int) -> None:
+199        """An optional method to verify the total input arity.
+200
+201        This is called after any implicit conversion to generators, but does
+202        not include any `extra_generators()`.
+203
+204        Overriding `next_state` with a fixed number of counts will make this
+205        check redundant.
+206
+207        Raises:
+208            `ValueError` if the total input arity is not valid.
+209        """
+
+ + +

An optional method to verify the total input arity.

+ +

This is called after any implicit conversion to generators, but does +not include any extra_generators().

+ +

Overriding next_state with a fixed number of counts will make this +check redundant.

+ +
Raises:
+ +
    +
  • ValueError if the total input arity is not valid.
    • +
+
+ + +
+
+ +
+ + def + evaluate( self, *args: Union[MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]]) -> Union[Die[+U_co], MultisetEvaluator[-T_contra, +U_co]]: + + + +
+ + 
235    def evaluate(
+236        self, *args:
+237        'MultisetExpression[T_contra] | Mapping[T_contra, int] | Sequence[T_contra]'
+238    ) -> 'icepool.Die[U_co] | MultisetEvaluator[T_contra, U_co]':
+239        """Evaluates generator(s).
+240
+241        You can call the `MultisetEvaluator` object directly for the same effect,
+242        e.g. `sum_evaluator(generator)` is an alias for `sum_evaluator.evaluate(generator)`.
+243
+244        Most evaluators will expect a fixed number of input multisets.
+245        The union of the outcomes of the generator(s) must be totally orderable.
+246
+247        Args:
+248            *args: Each may be one of the following:
+249                * A `GeneratorsWithExpression`.
+250                * A `MultisetGenerator`.
+251                * A mappable mapping outcomes to the number of those outcomes.
+252                * A sequence of outcomes.
+253
+254        Returns:
+255            A `Die` representing the distribution of the final outcome if no
+256            arg contains a free variable. Otherwise, returns a new evaluator.
+257        """
+258        from icepool.generator.alignment import Alignment
+259
+260        # Convert arguments to expressions.
+261        expressions = tuple(
+262            icepool.implicit_convert_to_expression(arg) for arg in args)
+263
+264        if any(expression._free_arity() > 0 for expression in expressions):
+265            from icepool.evaluator.expression import ExpressionEvaluator
+266            return ExpressionEvaluator(*expressions, evaluator=self)
+267
+268        generators = cast(tuple[icepool.MultisetGenerator, ...], expressions)
+269
+270        self.validate_arity(
+271            sum(generator.output_arity() for generator in generators))
+272
+273        generators = self.prefix_generators() + generators
+274
+275        if not all(generator._is_resolvable() for generator in generators):
+276            return icepool.Die([])
+277
+278        algorithm, order = self._select_algorithm(*generators)
+279
+280        # We use a separate class to guarantee all outcomes are visited.
+281        outcomes = sorted_union(*(generator.outcomes()
+282                                  for generator in generators))
+283        alignment = Alignment(self.alignment(outcomes))
+284
+285        dist = algorithm(order, alignment, generators)
+286
+287        final_outcomes = []
+288        final_weights = []
+289        for state, weight in dist.items():
+290            outcome = self.final_outcome(state)
+291            if outcome is None:
+292                raise TypeError(
+293                    "None is not a valid final outcome.\n"
+294                    "This may have been a result of not supplying any generator with an outcome."
+295                )
+296            if outcome is not icepool.Reroll:
+297                final_outcomes.append(outcome)
+298                final_weights.append(weight)
+299
+300        return icepool.Die(final_outcomes, final_weights)
+
+ + +

Evaluates generator(s).

+ +

You can call the MultisetEvaluator object directly for the same effect, +e.g. sum_evaluator(generator) is an alias for sum_evaluator.evaluate(generator).

+ +

Most evaluators will expect a fixed number of input multisets. +The union of the outcomes of the generator(s) must be totally orderable.

+ +
Arguments:
+ +
    +
  • *args: Each may be one of the following: +
      +
    • A GeneratorsWithExpression.
      • +
    • A MultisetGenerator.
      • +
    • A mappable mapping outcomes to the number of those outcomes.
      • +
    • A sequence of outcomes.
      • +
    • +
+ +
Returns:
+ +
+

A Die representing the distribution of the final outcome if no + arg contains a free variable. Otherwise, returns a new evaluator.

+
+
+ + +
+
+ +
+ + def + sample( self, *generators: Union[MultisetGenerator[-T_contra, Any], Mapping[-T_contra, int], Sequence[-T_contra]]): + + + +
+ + 
468    def sample(
+469        self, *generators:
+470        'icepool.MultisetGenerator[T_contra, Any] | Mapping[T_contra, int] | Sequence[T_contra]'
+471    ):
+472        """EXPERIMENTAL: Samples one result from the generator(s) and evaluates the result."""
+473        # Convert non-`Pool` arguments to `Pool`.
+474        converted_generators = tuple(
+475            generator if isinstance(generator, icepool.MultisetGenerator
+476                                    ) else icepool.Pool(generator)
+477            for generator in generators)
+478
+479        result = self.evaluate(*itertools.chain.from_iterable(
+480            generator.sample() for generator in converted_generators))
+481
+482        if not result.is_empty():
+483            return result.outcomes()[0]
+484        else:
+485            return result
+
+ + +

EXPERIMENTAL: Samples one result from the generator(s) and evaluates the result.

+
+ + +
+
+
+ +
+ + class + Order(enum.IntEnum): + + + +
+ + 
34class Order(enum.IntEnum):
+35    """Can be used to define what order outcomes are seen in by MultisetEvaluators."""
+36    Ascending = 1
+37    Descending = -1
+38    Any = 0
+39
+40    def merge(*orders: 'Order') -> 'Order':
+41        """Merges the given Orders.
+42
+43        Returns:
+44            `Any` if all arguments are `Any`.
+45            `Ascending` if there is at least one `Ascending` in the arguments.
+46            `Descending` if there is at least one `Descending` in the arguments.
+47
+48        Raises:
+49            `ValueError` if both `Ascending` and `Descending` are in the
+50            arguments.
+51        """
+52        result = Order.Any
+53        for order in orders:
+54            if (result > 0 and order < 0) or (result < 0 and order > 0):
+55                raise ValueError(f'Conflicting orders {orders}.')
+56            if result == Order.Any:
+57                result = order
+58        return result
+
+ + +

Can be used to define what order outcomes are seen in by MultisetEvaluators.

+
+ + +
+
+ Ascending = +<Order.Ascending: 1> + + +
+ + + + +
+
+
+ Descending = +<Order.Descending: -1> + + +
+ + + + +
+
+
+ Any = +<Order.Any: 0> + + +
+ + + + +
+
+ +
+ + def + merge(*orders: Order) -> Order: + + + +
+ + 
40    def merge(*orders: 'Order') -> 'Order':
+41        """Merges the given Orders.
+42
+43        Returns:
+44            `Any` if all arguments are `Any`.
+45            `Ascending` if there is at least one `Ascending` in the arguments.
+46            `Descending` if there is at least one `Descending` in the arguments.
+47
+48        Raises:
+49            `ValueError` if both `Ascending` and `Descending` are in the
+50            arguments.
+51        """
+52        result = Order.Any
+53        for order in orders:
+54            if (result > 0 and order < 0) or (result < 0 and order > 0):
+55                raise ValueError(f'Conflicting orders {orders}.')
+56            if result == Order.Any:
+57                result = order
+58        return result
+
+ + +

Merges the given Orders.

+ +
Returns:
+ +
+

Any if all arguments are Any. + Ascending if there is at least one Ascending in the arguments. + Descending if there is at least one Descending in the arguments.

+
+ +
Raises:
+ + +
+ + +
+
+
Inherited Members
+
+
enum.Enum
+
name
+
value
+ +
+
builtins.int
+
conjugate
+
bit_length
+
bit_count
+
to_bytes
+
from_bytes
+
as_integer_ratio
+
is_integer
+
real
+
imag
+
numerator
+
denominator
+ +
+
+
+
+
+ +
+ + class + Deck(icepool.Population[+T_co]): + + + +
+ + 
 17class Deck(Population[T_co]):
+ 18    """Sampling without replacement (within a single evaluation).
+ 19
+ 20    Quantities represent duplicates.
+ 21    """
+ 22
+ 23    _data: Counts[T_co]
+ 24    _deal: int
+ 25
+ 26    @property
+ 27    def _new_type(self) -> type:
+ 28        return Deck
+ 29
+ 30    def __new__(cls,
+ 31                outcomes: Sequence | Mapping[Any, int],
+ 32                times: Sequence[int] | int = 1) -> 'Deck[T_co]':
+ 33        """Constructor for a `Deck`.
+ 34
+ 35        Args:
+ 36            outcomes: The cards of the `Deck`. This can be one of the following:
+ 37                * A `Sequence` of outcomes. Duplicates will contribute
+ 38                    quantity for each appearance.
+ 39                * A `Mapping` from outcomes to quantities.
+ 40
+ 41                Each outcome may be one of the following:
+ 42                * An outcome, which must be hashable and totally orderable.
+ 43                * A `Deck`, which will be flattened into the result. If a
+ 44                    `times` is assigned to the `Deck`, the entire `Deck` will
+ 45                    be duplicated that many times.
+ 46            times: Multiplies the number of times each element of `outcomes`
+ 47                will be put into the `Deck`.
+ 48                `times` can either be a sequence of the same length as
+ 49                `outcomes` or a single `int` to apply to all elements of
+ 50                `outcomes`.
+ 51        """
+ 52
+ 53        if icepool.population.again.contains_again(outcomes):
+ 54            raise ValueError('Again cannot be used with Decks.')
+ 55
+ 56        outcomes, times = icepool.creation_args.itemize(outcomes, times)
+ 57
+ 58        if len(outcomes) == 1 and times[0] == 1 and isinstance(
+ 59                outcomes[0], Deck):
+ 60            return outcomes[0]
+ 61
+ 62        counts: Counts[T_co] = icepool.creation_args.expand_args_for_deck(
+ 63            outcomes, times)
+ 64
+ 65        return Deck._new_raw(counts)
+ 66
+ 67    @classmethod
+ 68    def _new_raw(cls, data: Counts[T_co]) -> 'Deck[T_co]':
+ 69        """Creates a new `Deck` using already-processed arguments.
+ 70
+ 71        Args:
+ 72            data: At this point, this is a Counts.
+ 73        """
+ 74        self = super(Population, cls).__new__(cls)
+ 75        self._data = data
+ 76        return self
+ 77
+ 78    def keys(self) -> CountsKeysView[T_co]:
+ 79        return self._data.keys()
+ 80
+ 81    def values(self) -> CountsValuesView:
+ 82        return self._data.values()
+ 83
+ 84    def items(self) -> CountsItemsView[T_co]:
+ 85        return self._data.items()
+ 86
+ 87    def __getitem__(self, outcome) -> int:
+ 88        return self._data[outcome]
+ 89
+ 90    def __iter__(self) -> Iterator[T_co]:
+ 91        return iter(self.keys())
+ 92
+ 93    def __len__(self) -> int:
+ 94        return len(self._data)
+ 95
+ 96    size = icepool.Population.denominator
+ 97
+ 98    @cached_property
+ 99    def _popped_min(self) -> tuple['Deck[T_co]', int]:
+100        return self._new_raw(self._data.remove_min()), self.quantities()[0]
+101
+102    def _pop_min(self) -> tuple['Deck[T_co]', int]:
+103        """A `Deck` with the min outcome removed."""
+104        return self._popped_min
+105
+106    @cached_property
+107    def _popped_max(self) -> tuple['Deck[T_co]', int]:
+108        return self._new_raw(self._data.remove_max()), self.quantities()[-1]
+109
+110    def _pop_max(self) -> tuple['Deck[T_co]', int]:
+111        """A `Deck` with the max outcome removed."""
+112        return self._popped_max
+113
+114    def deal(self, *hand_sizes: int) -> 'icepool.Deal[T_co, tuple[int, ...]]':
+115        """Creates a `Deal` object from this deck.
+116
+117        See `Deal()` for details.
+118        """
+119        return icepool.Deal(self, *hand_sizes)
+120
+121    def map(
+122            self,
+123            repl:
+124        'Callable[..., U | Deck[U] | icepool.RerollType] | Mapping[T_co, U | Deck[U] | icepool.RerollType]',
+125            /,
+126            star: bool | None = None) -> 'Deck[U]':
+127        """Maps outcomes of this `Deck` to other outcomes.
+128
+129        Args:
+130            repl: One of the following:
+131                * A callable returning a new outcome for each old outcome.
+132                * A map from old outcomes to new outcomes.
+133                    Unmapped old outcomes stay the same.
+134                The new outcomes may be `Deck`s, in which case one card is
+135                replaced with several. This is not recommended.
+136            star: Whether outcomes should be unpacked into separate arguments
+137                before sending them to a callable `repl`.
+138                If not provided, this will be guessed based on the function
+139                signature.
+140        """
+141        # Convert to a single-argument function.
+142        if callable(repl):
+143            if star is None:
+144                star = guess_star(repl)
+145            if star:
+146
+147                def transition_function(outcome):
+148                    return repl(*outcome)
+149            else:
+150
+151                def transition_function(outcome):
+152                    return repl(outcome)
+153        else:
+154            # repl is a mapping.
+155            def transition_function(outcome):
+156                if outcome in repl:
+157                    return repl[outcome]
+158                else:
+159                    return outcome
+160
+161        return Deck(
+162            [transition_function(outcome) for outcome in self.outcomes()],
+163            times=self.quantities())
+164
+165    @cached_property
+166    def _hash_key(self) -> tuple:
+167        return Deck, tuple(self.items())
+168
+169    def __eq__(self, other) -> bool:
+170        if not isinstance(other, Deck):
+171            return False
+172        return self._hash_key == other._hash_key
+173
+174    @cached_property
+175    def _hash(self) -> int:
+176        return hash(self._hash_key)
+177
+178    def __hash__(self) -> int:
+179        return self._hash
+180
+181    def __repr__(self) -> str:
+182        inner = ', '.join(
+183            f'{outcome}: {quantity}' for outcome, quantity in self.items())
+184        return type(self).__qualname__ + '({' + inner + '})'
+
+ + +

Sampling without replacement (within a single evaluation).

+ +

Quantities represent duplicates.

+
+ + +
+ +
+ + Deck( outcomes: Union[Sequence, Mapping[Any, int]], times: Union[Sequence[int], int] = 1) + + + +
+ + 
30    def __new__(cls,
+31                outcomes: Sequence | Mapping[Any, int],
+32                times: Sequence[int] | int = 1) -> 'Deck[T_co]':
+33        """Constructor for a `Deck`.
+34
+35        Args:
+36            outcomes: The cards of the `Deck`. This can be one of the following:
+37                * A `Sequence` of outcomes. Duplicates will contribute
+38                    quantity for each appearance.
+39                * A `Mapping` from outcomes to quantities.
+40
+41                Each outcome may be one of the following:
+42                * An outcome, which must be hashable and totally orderable.
+43                * A `Deck`, which will be flattened into the result. If a
+44                    `times` is assigned to the `Deck`, the entire `Deck` will
+45                    be duplicated that many times.
+46            times: Multiplies the number of times each element of `outcomes`
+47                will be put into the `Deck`.
+48                `times` can either be a sequence of the same length as
+49                `outcomes` or a single `int` to apply to all elements of
+50                `outcomes`.
+51        """
+52
+53        if icepool.population.again.contains_again(outcomes):
+54            raise ValueError('Again cannot be used with Decks.')
+55
+56        outcomes, times = icepool.creation_args.itemize(outcomes, times)
+57
+58        if len(outcomes) == 1 and times[0] == 1 and isinstance(
+59                outcomes[0], Deck):
+60            return outcomes[0]
+61
+62        counts: Counts[T_co] = icepool.creation_args.expand_args_for_deck(
+63            outcomes, times)
+64
+65        return Deck._new_raw(counts)
+
+ + +

Constructor for a Deck.

+ +
Arguments:
+ +
    +

  • outcomes: The cards of the Deck. This can be one of the following:

    + +
      +
    • A Sequence of outcomes. Duplicates will contribute +quantity for each appearance.
      • +
    • A Mapping from outcomes to quantities.
      • +
    + +

    Each outcome may be one of the following:

    + +
      +
    • An outcome, which must be hashable and totally orderable.
      • +
    • A Deck, which will be flattened into the result. If a +times is assigned to the Deck, the entire Deck will +be duplicated that many times.
      • +
    • +
  • times: Multiplies the number of times each element of outcomes +will be put into the Deck. +times can either be a sequence of the same length as +outcomes or a single int to apply to all elements of +outcomes.
    • +
+
+ + +
+
+ +
+ + def + keys(self) -> CountsKeysView[+T_co]: + + + +
+ + 
78    def keys(self) -> CountsKeysView[T_co]:
+79        return self._data.keys()
+
+ + +

The outcomes within the population in sorted order.

+
+ + +
+
+ +
+ + def + values(self) -> CountsValuesView: + + + +
+ + 
81    def values(self) -> CountsValuesView:
+82        return self._data.values()
+
+ + +

The quantities within the population in outcome order.

+
+ + +
+
+ +
+ + def + items(self) -> CountsItemsView[+T_co]: + + + +
+ + 
84    def items(self) -> CountsItemsView[T_co]:
+85        return self._data.items()
+
+ + +

The (outcome, quantity)s of the population in sorted order.

+
+ + +
+
+ +
+ + def + size(self) -> int: + + + +
+ + 
181    def denominator(self) -> int:
+182        """The sum of all quantities (e.g. weights or duplicates).
+183
+184        For the number of unique outcomes, including those with zero quantity,
+185        use `len()`.
+186        """
+187        return self._denominator
+
+ + +

The sum of all quantities (e.g. weights or duplicates).

+ +

For the number of unique outcomes, including those with zero quantity, +use len().

+
+ + +
+
+ +
+ + def + deal( self, *hand_sizes: int) -> Deal[+T_co, tuple[int, ...]]: + + + +
+ + 
114    def deal(self, *hand_sizes: int) -> 'icepool.Deal[T_co, tuple[int, ...]]':
+115        """Creates a `Deal` object from this deck.
+116
+117        See `Deal()` for details.
+118        """
+119        return icepool.Deal(self, *hand_sizes)
+
+ + +

Creates a Deal object from this deck.

+ +

See Deal() for details.

+
+ + +
+
+ +
+ + def + map( self, repl: Union[Callable[..., Union[~U, Deck[~U], RerollType]], Mapping[+T_co, Union[~U, Deck[~U], RerollType]]], /, star: bool | None = None) -> Deck[~U]: + + + +
+ + 
121    def map(
+122            self,
+123            repl:
+124        'Callable[..., U | Deck[U] | icepool.RerollType] | Mapping[T_co, U | Deck[U] | icepool.RerollType]',
+125            /,
+126            star: bool | None = None) -> 'Deck[U]':
+127        """Maps outcomes of this `Deck` to other outcomes.
+128
+129        Args:
+130            repl: One of the following:
+131                * A callable returning a new outcome for each old outcome.
+132                * A map from old outcomes to new outcomes.
+133                    Unmapped old outcomes stay the same.
+134                The new outcomes may be `Deck`s, in which case one card is
+135                replaced with several. This is not recommended.
+136            star: Whether outcomes should be unpacked into separate arguments
+137                before sending them to a callable `repl`.
+138                If not provided, this will be guessed based on the function
+139                signature.
+140        """
+141        # Convert to a single-argument function.
+142        if callable(repl):
+143            if star is None:
+144                star = guess_star(repl)
+145            if star:
+146
+147                def transition_function(outcome):
+148                    return repl(*outcome)
+149            else:
+150
+151                def transition_function(outcome):
+152                    return repl(outcome)
+153        else:
+154            # repl is a mapping.
+155            def transition_function(outcome):
+156                if outcome in repl:
+157                    return repl[outcome]
+158                else:
+159                    return outcome
+160
+161        return Deck(
+162            [transition_function(outcome) for outcome in self.outcomes()],
+163            times=self.quantities())
+
+ + +

Maps outcomes of this Deck to other outcomes.

+ +
Arguments:
+ +
    +
  • repl: One of the following: +
      +
    • A callable returning a new outcome for each old outcome.
      • +
    • A map from old outcomes to new outcomes. +Unmapped old outcomes stay the same. +The new outcomes may be Decks, in which case one card is +replaced with several. This is not recommended.
      • +
    • +
  • star: Whether outcomes should be unpacked into separate arguments +before sending them to a callable repl. +If not provided, this will be guessed based on the function +signature.
    • +
+
+ + +
+
+
Inherited Members
+
+
Population
+
outcomes
+
common_outcome_length
+
is_empty
+
min_outcome
+
max_outcome
+
nearest_le
+
nearest_lt
+
nearest_ge
+
nearest_gt
+
quantity
+
quantities
+
denominator
+
scale_quantities
+
has_zero_quantities
+
quantity_ne
+
quantity_le
+
quantity_lt
+
quantity_ge
+
quantity_gt
+
quantities_le
+
quantities_ge
+
quantities_lt
+
quantities_gt
+
probability
+
probability_le
+
probability_lt
+
probability_ge
+
probability_gt
+
probabilities
+
probabilities_le
+
probabilities_ge
+
probabilities_lt
+
probabilities_gt
+
mode
+
modal_quantity
+
kolmogorov_smirnov
+
cramer_von_mises
+
median
+
median_low
+
median_high
+
quantile
+
quantile_low
+
quantile_high
+
mean
+
variance
+
standard_deviation
+
sd
+
standardized_moment
+
skewness
+
excess_kurtosis
+
entropy
+
marginals
+
covariance
+
correlation
+
sample
+
format
+ +
+
collections.abc.Mapping
+
get
+ +
+
+
+
+
+ +
+ + class + Deal(icepool.MultisetGenerator[~T, ~Qs]): + + + +
+ + 
 16class Deal(MultisetGenerator[T, Qs]):
+ 17    """Represents an sorted/unordered deal of cards from a `Deck`."""
+ 18
+ 19    _deck: 'icepool.Deck[T]'
+ 20    _hand_sizes: Qs
+ 21
+ 22    def __init__(self, deck: 'icepool.Deck[T]', *hand_sizes: int) -> None:
+ 23        """Constructor.
+ 24
+ 25        For algorithmic reasons, you must pre-commit to the number of cards to
+ 26        deal for each hand.
+ 27
+ 28        It is permissible to `Deal` zero cards from an empty deck, but not all
+ 29        evaluators will handle this case, especially if they depend on the
+ 30        outcome type. Dealing zero cards from a non-empty deck does not have
+ 31        this issue.
+ 32
+ 33        Args:
+ 34            deck: The `Deck` to deal from.
+ 35            *hand_sizes: How many cards to deal. If multiple `hand_sizes` are
+ 36                provided, `MultisetEvaluator.next_state` will recieve one count
+ 37                per hand in order. Try to keep the number of hands to a minimum
+ 38                as this can be computationally intensive.
+ 39        """
+ 40        if any(hand < 0 for hand in hand_sizes):
+ 41            raise ValueError('hand_sizes cannot be negative.')
+ 42        self._deck = deck
+ 43        self._hand_sizes = cast(Qs, hand_sizes)
+ 44        if self.total_cards_dealt() > self.deck().size():
+ 45            raise ValueError(
+ 46                'The total number of cards dealt cannot exceed the size of the deck.'
+ 47            )
+ 48
+ 49    @classmethod
+ 50    def _new_raw(cls, deck: 'icepool.Deck[T]', hand_sizes: Qs) -> 'Deal[T, Qs]':
+ 51        self = super(Deal, cls).__new__(cls)
+ 52        self._deck = deck
+ 53        self._hand_sizes = hand_sizes
+ 54        return self
+ 55
+ 56    def deck(self) -> 'icepool.Deck[T]':
+ 57        """The `Deck` the cards are dealt from."""
+ 58        return self._deck
+ 59
+ 60    def hand_sizes(self) -> Qs:
+ 61        """The number of cards dealt to each hand as a tuple."""
+ 62        return self._hand_sizes
+ 63
+ 64    def total_cards_dealt(self) -> int:
+ 65        """The total number of cards dealt."""
+ 66        return sum(self.hand_sizes())
+ 67
+ 68    def outcomes(self) -> CountsKeysView[T]:
+ 69        """The outcomes of the `Deck` in ascending order.
+ 70
+ 71        These are also the `keys` of the `Deck` as a `Mapping`.
+ 72        Prefer to use the name `outcomes`.
+ 73        """
+ 74        return self.deck().outcomes()
+ 75
+ 76    def output_arity(self) -> int:
+ 77        return len(self._hand_sizes)
+ 78
+ 79    def _is_resolvable(self) -> bool:
+ 80        return len(self.outcomes()) > 0
+ 81
+ 82    @cached_property
+ 83    def _denomiator(self) -> int:
+ 84        d_total = icepool.math.comb(self.deck().size(),
+ 85                                    self.total_cards_dealt())
+ 86        d_split = math.prod(
+ 87            icepool.math.comb(self.total_cards_dealt(), h)
+ 88            for h in self.hand_sizes()[1:])
+ 89        return d_total * d_split
+ 90
+ 91    def denominator(self) -> int:
+ 92        return self._denomiator
+ 93
+ 94    def _generate_common(self, popped_deck: 'icepool.Deck[T]',
+ 95                         deck_count: int) -> NextMultisetGenerator:
+ 96        """Common implementation for _generate_min and _generate_max."""
+ 97        min_count = max(
+ 98            0, deck_count + self.total_cards_dealt() - self.deck().size())
+ 99        max_count = min(deck_count, self.total_cards_dealt())
+100        for count_total in range(min_count, max_count + 1):
+101            weight_total = icepool.math.comb(deck_count, count_total)
+102            # The "deck" is the hand sizes.
+103            for counts, weight_split in iter_hypergeom(self.hand_sizes(),
+104                                                       count_total):
+105                popped_deal = Deal._new_raw(
+106                    popped_deck,
+107                    tuple(h - c for h, c in zip(self.hand_sizes(), counts)))
+108                weight = weight_total * weight_split
+109                yield popped_deal, counts, weight
+110
+111    def _generate_min(self, min_outcome) -> NextMultisetGenerator:
+112        if not self.outcomes() or min_outcome != self.min_outcome():
+113            yield self, (0,), 1
+114            return
+115
+116        popped_deck, deck_count = self.deck()._pop_min()
+117
+118        yield from self._generate_common(popped_deck, deck_count)
+119
+120    def _generate_max(self, max_outcome) -> NextMultisetGenerator:
+121        if not self.outcomes() or max_outcome != self.max_outcome():
+122            yield self, (0,), 1
+123            return
+124
+125        popped_deck, deck_count = self.deck()._pop_max()
+126
+127        yield from self._generate_common(popped_deck, deck_count)
+128
+129    def _estimate_order_costs(self) -> tuple[int, int]:
+130        result = len(self.outcomes()) * math.prod(self.hand_sizes())
+131        return result, result
+132
+133    @cached_property
+134    def _hash_key(self) -> Hashable:
+135        return Deal, self.deck(), self.hand_sizes()
+136
+137    def __repr__(self) -> str:
+138        return type(
+139            self
+140        ).__qualname__ + f'({repr(self.deck())}, hand_sizes={self.hand_sizes()})'
+141
+142    def __str__(self) -> str:
+143        return f'Deal of hand_sizes={self.hand_sizes()} from deck:\n' + str(
+144            self.deck())
+
+ + +

Represents an sorted/unordered deal of cards from a Deck.

+
+ + +
+ +
+ + Deal(deck: Deck[~T], *hand_sizes: int) + + + +
+ + 
22    def __init__(self, deck: 'icepool.Deck[T]', *hand_sizes: int) -> None:
+23        """Constructor.
+24
+25        For algorithmic reasons, you must pre-commit to the number of cards to
+26        deal for each hand.
+27
+28        It is permissible to `Deal` zero cards from an empty deck, but not all
+29        evaluators will handle this case, especially if they depend on the
+30        outcome type. Dealing zero cards from a non-empty deck does not have
+31        this issue.
+32
+33        Args:
+34            deck: The `Deck` to deal from.
+35            *hand_sizes: How many cards to deal. If multiple `hand_sizes` are
+36                provided, `MultisetEvaluator.next_state` will recieve one count
+37                per hand in order. Try to keep the number of hands to a minimum
+38                as this can be computationally intensive.
+39        """
+40        if any(hand < 0 for hand in hand_sizes):
+41            raise ValueError('hand_sizes cannot be negative.')
+42        self._deck = deck
+43        self._hand_sizes = cast(Qs, hand_sizes)
+44        if self.total_cards_dealt() > self.deck().size():
+45            raise ValueError(
+46                'The total number of cards dealt cannot exceed the size of the deck.'
+47            )
+
+ + +

Constructor.

+ +

For algorithmic reasons, you must pre-commit to the number of cards to +deal for each hand.

+ +

It is permissible to Deal zero cards from an empty deck, but not all +evaluators will handle this case, especially if they depend on the +outcome type. Dealing zero cards from a non-empty deck does not have +this issue.

+ +
Arguments:
+ +
    +
  • deck: The Deck to deal from.
    • +
  • *hand_sizes: How many cards to deal. If multiple hand_sizes are +provided, MultisetEvaluator.next_state will recieve one count +per hand in order. Try to keep the number of hands to a minimum +as this can be computationally intensive.
    • +
+
+ + +
+
+ +
+ + def + deck(self) -> Deck[~T]: + + + +
+ + 
56    def deck(self) -> 'icepool.Deck[T]':
+57        """The `Deck` the cards are dealt from."""
+58        return self._deck
+
+ + +

The Deck the cards are dealt from.

+
+ + +
+
+ +
+ + def + hand_sizes(self) -> ~Qs: + + + +
+ + 
60    def hand_sizes(self) -> Qs:
+61        """The number of cards dealt to each hand as a tuple."""
+62        return self._hand_sizes
+
+ + +

The number of cards dealt to each hand as a tuple.

+
+ + +
+
+ +
+ + def + total_cards_dealt(self) -> int: + + + +
+ + 
64    def total_cards_dealt(self) -> int:
+65        """The total number of cards dealt."""
+66        return sum(self.hand_sizes())
+
+ + +

The total number of cards dealt.

+
+ + +
+
+ +
+ + def + outcomes(self) -> CountsKeysView[~T]: + + + +
+ + 
68    def outcomes(self) -> CountsKeysView[T]:
+69        """The outcomes of the `Deck` in ascending order.
+70
+71        These are also the `keys` of the `Deck` as a `Mapping`.
+72        Prefer to use the name `outcomes`.
+73        """
+74        return self.deck().outcomes()
+
+ + +

The outcomes of the Deck in ascending order.

+ +

These are also the keys of the Deck as a Mapping. +Prefer to use the name outcomes.

+
+ + +
+
+ +
+ + def + output_arity(self) -> int: + + + +
+ + 
76    def output_arity(self) -> int:
+77        return len(self._hand_sizes)
+
+ + +

The number of multisets/counts generated. Must be constant.

+
+ + +
+
+ +
+ + def + denominator(self) -> int: + + + +
+ + 
91    def denominator(self) -> int:
+92        return self._denomiator
+
+ + +

The total weight of all paths through this generator.

+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + def + multiset_function( function: Callable[..., Union[MultisetEvaluator[-T_contra, +U_co], tuple[Union[MultisetEvaluator[-T_contra, +U_co], tuple[ForwardRef('NestedTupleOrEvaluator[T_contra, U_co]'), ...]], ...]]], /) -> MultisetEvaluator[-T_contra, typing.Union[+U_co, tuple[typing.Union[+U_co, tuple[ForwardRef('NestedTupleOrOutcome[U_co]'), ...]], ...]]]: + + + +
+ + 
 65def multiset_function(
+ 66        function: Callable[..., NestedTupleOrEvaluator[T_contra, U_co]],
+ 67        /) -> MultisetEvaluator[T_contra, NestedTupleOrOutcome[U_co]]:
+ 68    """EXPERIMENTAL: A decorator that turns a function into a `MultisetEvaluator`.
+ 69
+ 70    The provided function should take in arguments representing multisets,
+ 71    do a limited set of operations on them (see `MultisetExpression`), and
+ 72    finish off with an evaluation. You can return tuples to perform a joint
+ 73    evaluation.
+ 74
+ 75    For example, to create an evaluator which computes the elements each of two
+ 76    multisets has that the other doesn't:
+ 77
+ 78    ```
+ 79    @multiset_function
+ 80    def two_way_difference(a, b):
+ 81        return (a - b).expand(), (b - a).expand()
+ 82    ```
+ 83
+ 84    Any globals inside `function` are effectively bound at the time
+ 85    `multiset_function` is invoked. Note that this is different than how
+ 86    ordinary Python closures behave. For example,
+ 87
+ 88    ```
+ 89    target = [1, 2, 3]
+ 90
+ 91    @multiset_function
+ 92    def count_intersection(a):
+ 93        return (a & target).count()
+ 94
+ 95    print(count_intersection(d6.pool(3)))
+ 96
+ 97    target = [1]
+ 98    print(count_intersection(d6.pool(3)))
+ 99    ```
+100
+101    would produce the same thing both times. Likewise, the function should not
+102    have any side effects.
+103
+104    Be careful when using control structures: you cannot branch on the value of
+105    a multiset expression or evaluation, so e.g.
+106
+107    ```
+108    @multiset_function
+109    def bad(a, b)
+110        if a == b:
+111            ...
+112    ```
+113
+114    is not allowed.
+115
+116    `multiset_function` has considerable overhead, being effectively a
+117    mini-language within Python. For better performance, you can try
+118    implementing your own subclass of `MultisetEvaluator` directly.
+119
+120    Args:
+121        function: This should take in a fixed number of multiset variables and
+122            output an evaluator or a nested tuple of evaluators. Tuples will
+123            result in a `JointEvaluator`.
+124    """
+125    parameters = inspect.signature(function, follow_wrapped=False).parameters
+126    for parameter in parameters.values():
+127        if parameter.kind not in [
+128                inspect.Parameter.POSITIONAL_ONLY,
+129                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+130        ] or parameter.default != inspect.Parameter.empty:
+131            raise ValueError(
+132                'Callable must take only a fixed number of positional arguments.'
+133            )
+134    tuple_or_evaluator = function(*(MV(i) for i in range(len(parameters))))
+135    evaluator = replace_tuples_with_joint_evaluator(tuple_or_evaluator)
+136    return update_wrapper(evaluator, function)
+
+ + +

EXPERIMENTAL: A decorator that turns a function into a MultisetEvaluator.

+ +

The provided function should take in arguments representing multisets, +do a limited set of operations on them (see MultisetExpression), and +finish off with an evaluation. You can return tuples to perform a joint +evaluation.

+ +

For example, to create an evaluator which computes the elements each of two +multisets has that the other doesn't:

+ +
@multiset_function
+def two_way_difference(a, b):
+    return (a - b).expand(), (b - a).expand()
+
+ +

Any globals inside function are effectively bound at the time +multiset_function is invoked. Note that this is different than how +ordinary Python closures behave. For example,

+ +
target = [1, 2, 3]
+
+@multiset_function
+def count_intersection(a):
+    return (a & target).count()
+
+print(count_intersection(d6.pool(3)))
+
+target = [1]
+print(count_intersection(d6.pool(3)))
+
+ +

would produce the same thing both times. Likewise, the function should not +have any side effects.

+ +

Be careful when using control structures: you cannot branch on the value of +a multiset expression or evaluation, so e.g.

+ +
@multiset_function
+def bad(a, b)
+    if a == b:
+        ...
+
+ +

is not allowed.

+ +

multiset_function has considerable overhead, being effectively a +mini-language within Python. For better performance, you can try +implementing your own subclass of MultisetEvaluator directly.

+ +
Arguments:
+ +
    +
  • function: This should take in a fixed number of multiset variables and +output an evaluator or a nested tuple of evaluators. Tuples will +result in a JointEvaluator.
    • +
+
+ + +
+
+ + \ No newline at end of file diff --git a/apidoc/v1.1.1/icepool/evaluator.html b/apidoc/v1.1.1/icepool/evaluator.html new file mode 100644 index 00000000..0acf6089 --- /dev/null +++ b/apidoc/v1.1.1/icepool/evaluator.html @@ -0,0 +1,4813 @@ + + + + + + + icepool.evaluator API documentation + + + + + + + + + + +
+
+

+icepool.evaluator

+ +

Submodule containing evaluators.

+
+ + + + + + 
 1"""Submodule containing evaluators."""
+ 2
+ 3__docformat__ = 'google'
+ 4
+ 5from icepool.evaluator.basic import (ExpandEvaluator, SumEvaluator,
+ 6                                     sum_evaluator, CountEvaluator,
+ 7                                     count_evaluator, AnyEvaluator,
+ 8                                     any_evaluator)
+ 9from icepool.evaluator.poker import (
+10    HighestOutcomeAndCountEvaluator, LargestCountEvaluator,
+11    LargestCountAndOutcomeEvaluator, AllCountsEvaluator,
+12    LargestStraightEvaluator, LargestStraightAndOutcomeEvaluator,
+13    AllStraightsEvaluator)
+14from icepool.evaluator.comparison import (
+15    ComparisonEvaluator, IsSubsetEvaluator, IsProperSubsetEvaluator,
+16    IsSupersetEvaluator, IsProperSupersetEvaluator, IsEqualSetEvaluator,
+17    IsNotEqualSetEvaluator, IsDisjointSetEvaluator)
+18from icepool.evaluator.joint import JointEvaluator
+19from icepool.evaluator.constant import ConstantEvaluator
+20from icepool.evaluator.keep import KeepEvaluator
+21from icepool.evaluator.compair import CompairEvalautor
+22from icepool.evaluator.expression import ExpressionEvaluator
+23
+24__all__ = [
+25    'JointEvaluator', 'ExpandEvaluator', 'SumEvaluator', 'sum_evaluator',
+26    'CountEvaluator', 'count_evaluator', 'AnyEvaluator', 'any_evaluator',
+27    'HighestOutcomeAndCountEvaluator', 'LargestCountEvaluator',
+28    'LargestCountAndOutcomeEvaluator', 'AllCountsEvaluator',
+29    'LargestStraightEvaluator', 'LargestStraightAndOutcomeEvaluator',
+30    'AllStraightsEvaluator', 'ComparisonEvaluator', 'IsSubsetEvaluator',
+31    'IsProperSubsetEvaluator', 'IsSupersetEvaluator',
+32    'IsProperSupersetEvaluator', 'IsEqualSetEvaluator',
+33    'IsNotEqualSetEvaluator', 'IsDisjointSetEvaluator', 'ConstantEvaluator',
+34    'CompairEvalautor', 'KeepEvaluator', 'ExpressionEvaluator'
+35]
+
+ + +
+
+ +
+ + class + JointEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple]): + + + +
+ + 
 16class JointEvaluator(MultisetEvaluator[T_contra, tuple]):
+ 17    """A `MultisetEvaluator` that jointly evaluates sub-evaluators on the same set of input generators."""
+ 18
+ 19    def __init__(self, *inners: MultisetEvaluator) -> None:
+ 20        self._inners = inners
+ 21
+ 22    def next_state(self, state, outcome, *counts):
+ 23        """Runs `next_state` for all sub-evaluator.
+ 24
+ 25        The state is a tuple of the sub-states.
+ 26
+ 27        If any sub-evaluator returns `Reroll`, the result as a whole is `Reroll`.
+ 28        """
+ 29        prefix_counts = counts[:self._extra_arity]
+ 30        counts = counts[self._extra_arity:]
+ 31
+ 32        if state is None:
+ 33            result = tuple(
+ 34                evaluator.next_state(
+ 35                    None,
+ 36                    outcome,
+ 37                    *evaluator_prefix_counts,
+ 38                    *counts,
+ 39                ) for evaluator, evaluator_prefix_counts in zip(
+ 40                    self._inners, self._split_prefix_counts(*prefix_counts)))
+ 41        else:
+ 42            result = tuple(
+ 43                evaluator.next_state(
+ 44                    substate,
+ 45                    outcome,
+ 46                    *evaluator_prefix_counts,
+ 47                    *counts,
+ 48                ) for evaluator, substate, evaluator_prefix_counts in zip(
+ 49                    self._inners, state,
+ 50                    self._split_prefix_counts(*prefix_counts)))
+ 51        if icepool.Reroll in result:
+ 52            return icepool.Reroll
+ 53        else:
+ 54            return result
+ 55
+ 56    def final_outcome(self, final_state) -> 'tuple | icepool.RerollType':
+ 57        """Runs `final_state` for all sub-evaluators.
+ 58
+ 59        The final outcome is a tuple of the final suboutcomes.
+ 60
+ 61        If any sub-evaluator returns `Reroll`, the result as a whole is `Reroll`.
+ 62        """
+ 63        if final_state is None:
+ 64            result = tuple(inner.final_outcome(None) for inner in self._inners)
+ 65        else:
+ 66            result = tuple(
+ 67                inner.final_outcome(final_substate)
+ 68                for inner, final_substate in zip(self._inners, final_state))
+ 69        if icepool.Reroll in result:
+ 70            return icepool.Reroll
+ 71        else:
+ 72            return result
+ 73
+ 74    def order(self) -> Order:
+ 75        """Determines the common order of the sub-evaluators.
+ 76
+ 77        Raises:
+ 78            ValueError: If sub-evaluators have conflicting orders, i.e. some are
+ 79                ascending and others are descending.
+ 80        """
+ 81        return Order.merge(*(inner.order() for inner in self._inners))
+ 82
+ 83    def alignment(self, outcomes) -> Collection[T_contra]:
+ 84        return sorted_union(
+ 85            *(evaluator.alignment(outcomes) for evaluator in self._inners))
+ 86
+ 87    @cached_property
+ 88    def _prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+ 89        return tuple(
+ 90            itertools.chain.from_iterable(
+ 91                expression.prefix_generators() for expression in self._inners))
+ 92
+ 93    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+ 94        return self._prefix_generators
+ 95
+ 96    def validate_arity(self, arity: int) -> None:
+ 97        for evaluator in self._inners:
+ 98            evaluator.validate_arity(arity)
+ 99
+100    @cached_property
+101    def _extra_arity(self) -> int:
+102        return sum(
+103            generator.output_arity() for generator in self.prefix_generators())
+104
+105    @cached_property
+106    def _prefix_slices(self) -> tuple[slice, ...]:
+107        """Precomputed slices for determining which prefix counts go with which sub-evaluator."""
+108        result = []
+109        index = 0
+110        for expression in self._inners:
+111            counts_length = sum(generator.output_arity()
+112                                for generator in expression.prefix_generators())
+113            result.append(slice(index, index + counts_length))
+114            index += counts_length
+115        return tuple(result)
+116
+117    def _split_prefix_counts(self,
+118                             *extra_counts: int) -> Iterator[tuple[int, ...]]:
+119        for index in self._prefix_slices:
+120            yield extra_counts[index]
+121
+122    def __str__(self) -> str:
+123        return 'JointEvaluator(\n' + ''.join(
+124            f'    {evaluator},\n' for evaluator in self._inners) + ')'
+
+ + +

A MultisetEvaluator that jointly evaluates sub-evaluators on the same set of input generators.

+
+ + +
+ +
+ + JointEvaluator(*inners: icepool.evaluator.multiset_evaluator.MultisetEvaluator) + + + +
+ + 
19    def __init__(self, *inners: MultisetEvaluator) -> None:
+20        self._inners = inners
+
+ + + + +
+
+ +
+ + def + next_state(self, state, outcome, *counts): + + + +
+ + 
22    def next_state(self, state, outcome, *counts):
+23        """Runs `next_state` for all sub-evaluator.
+24
+25        The state is a tuple of the sub-states.
+26
+27        If any sub-evaluator returns `Reroll`, the result as a whole is `Reroll`.
+28        """
+29        prefix_counts = counts[:self._extra_arity]
+30        counts = counts[self._extra_arity:]
+31
+32        if state is None:
+33            result = tuple(
+34                evaluator.next_state(
+35                    None,
+36                    outcome,
+37                    *evaluator_prefix_counts,
+38                    *counts,
+39                ) for evaluator, evaluator_prefix_counts in zip(
+40                    self._inners, self._split_prefix_counts(*prefix_counts)))
+41        else:
+42            result = tuple(
+43                evaluator.next_state(
+44                    substate,
+45                    outcome,
+46                    *evaluator_prefix_counts,
+47                    *counts,
+48                ) for evaluator, substate, evaluator_prefix_counts in zip(
+49                    self._inners, state,
+50                    self._split_prefix_counts(*prefix_counts)))
+51        if icepool.Reroll in result:
+52            return icepool.Reroll
+53        else:
+54            return result
+
+ + +

Runs next_state for all sub-evaluator.

+ +

The state is a tuple of the sub-states.

+ +

If any sub-evaluator returns Reroll, the result as a whole is Reroll.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> tuple | icepool.typing.RerollType: + + + +
+ + 
56    def final_outcome(self, final_state) -> 'tuple | icepool.RerollType':
+57        """Runs `final_state` for all sub-evaluators.
+58
+59        The final outcome is a tuple of the final suboutcomes.
+60
+61        If any sub-evaluator returns `Reroll`, the result as a whole is `Reroll`.
+62        """
+63        if final_state is None:
+64            result = tuple(inner.final_outcome(None) for inner in self._inners)
+65        else:
+66            result = tuple(
+67                inner.final_outcome(final_substate)
+68                for inner, final_substate in zip(self._inners, final_state))
+69        if icepool.Reroll in result:
+70            return icepool.Reroll
+71        else:
+72            return result
+
+ + +

Runs final_state for all sub-evaluators.

+ +

The final outcome is a tuple of the final suboutcomes.

+ +

If any sub-evaluator returns Reroll, the result as a whole is Reroll.

+
+ + +
+
+ +
+ + def + order(self) -> icepool.typing.Order: + + + +
+ + 
74    def order(self) -> Order:
+75        """Determines the common order of the sub-evaluators.
+76
+77        Raises:
+78            ValueError: If sub-evaluators have conflicting orders, i.e. some are
+79                ascending and others are descending.
+80        """
+81        return Order.merge(*(inner.order() for inner in self._inners))
+
+ + +

Determines the common order of the sub-evaluators.

+ +
Raises:
+ +
    +
  • ValueError: If sub-evaluators have conflicting orders, i.e. some are +ascending and others are descending.
    • +
+
+ + +
+
+ +
+ + def + alignment(self, outcomes) -> Collection[-T_contra]: + + + +
+ + 
83    def alignment(self, outcomes) -> Collection[T_contra]:
+84        return sorted_union(
+85            *(evaluator.alignment(outcomes) for evaluator in self._inners))
+
+ + +

Optional method to specify additional outcomes that should be seen by next_state().

+ +

These will be seen by next_state even if they have zero count or do +not appear in the generator(s) at all.

+ +

The default implementation returns (); this means outcomes with zero +count may or may not be seen by next_state.

+ +

If you want next_state to see consecutive int outcomes, you can set +alignment = icepool.MultisetEvaluator.range_alignment. +See range_alignment() below.

+ +

If you want next_state to see all generator outcomes, you can return +outcomes as-is.

+ +
Arguments:
+ +
    +
  • outcomes: The outcomes that could be produced by the generators, in
    • +
  • ascending order.
    • +
+
+ + +
+
+ +
+ + def + prefix_generators( self) -> tuple[icepool.generator.multiset_generator.MultisetGenerator, ...]: + + + +
+ + 
93    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+94        return self._prefix_generators
+
+ + +

An optional sequence of extra generators whose counts will be prepended to *counts.

+
+ + +
+
+ +
+ + def + validate_arity(self, arity: int) -> None: + + + +
+ + 
96    def validate_arity(self, arity: int) -> None:
+97        for evaluator in self._inners:
+98            evaluator.validate_arity(arity)
+
+ + +

An optional method to verify the total input arity.

+ +

This is called after any implicit conversion to generators, but does +not include any extra_generators().

+ +

Overriding next_state with a fixed number of counts will make this +check redundant.

+ +
Raises:
+ +
    +
  • ValueError if the total input arity is not valid.
    • +
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + ExpandEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple]): + + + +
+ + 
14class ExpandEvaluator(MultisetEvaluator[Any, tuple]):
+15    """All elements of the multiset.
+16
+17    This is expensive and not recommended unless there are few possibilities.
+18
+19    Outcomes with negative count will be treated as 0 count.
+20    """
+21
+22    def __init__(self, order: Order = Order.Ascending):
+23        self._order = order
+24
+25    def next_state(self, state, outcome, count):
+26        """Implementation."""
+27        return (state or ()) + (outcome,) * count
+28
+29    def order(self) -> Literal[Order.Any]:
+30        """Allows any order."""
+31        return Order.Any
+32
+33    def final_outcome(self, final_state) -> tuple:
+34        """Implementation."""
+35        if final_state is None:
+36            return ()
+37        reverse = self._order != Order.Ascending
+38        return tuple(sorted(final_state, reverse=reverse))
+
+ + +

All elements of the multiset.

+ +

This is expensive and not recommended unless there are few possibilities.

+ +

Outcomes with negative count will be treated as 0 count.

+
+ + +
+ +
+ + ExpandEvaluator(order: icepool.typing.Order = <Order.Ascending: 1>) + + + +
+ + 
22    def __init__(self, order: Order = Order.Ascending):
+23        self._order = order
+
+ + + + +
+
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
25    def next_state(self, state, outcome, count):
+26        """Implementation."""
+27        return (state or ()) + (outcome,) * count
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
29    def order(self) -> Literal[Order.Any]:
+30        """Allows any order."""
+31        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> tuple: + + + +
+ + 
33    def final_outcome(self, final_state) -> tuple:
+34        """Implementation."""
+35        if final_state is None:
+36            return ()
+37        reverse = self._order != Order.Ascending
+38        return tuple(sorted(final_state, reverse=reverse))
+
+ + +

Implementation.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + SumEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, typing.Any]): + + + +
+ + 
41class SumEvaluator(MultisetEvaluator[Any, Any]):
+42    """Sums all outcomes."""
+43
+44    def __init__(self, map: Callable | Mapping | None = None) -> None:
+45        """Constructor.
+46
+47        map: If provided, outcomes will be mapped according to this just
+48            before summing.
+49        """
+50        if map is None:
+51
+52            def map_func(outcome):
+53                return outcome
+54
+55            self._map = map_func
+56        elif callable(map):
+57            self._map = map
+58        else:
+59            map_dict = {k: v for k, v in map.items()}
+60
+61            def map_func(outcome):
+62                return map_dict[outcome]
+63
+64            self._map = map_func
+65
+66    def next_state(self, state, outcome, count):
+67        """Implementation."""
+68        outcome = self._map(outcome)
+69        if state is None:
+70            if count == 1:
+71                # The outcome does not need to support addition or
+72                # multiplication in this case.
+73                return outcome
+74            return outcome * count
+75        else:
+76            return state + outcome * count
+77
+78    def order(self) -> Literal[Order.Any]:
+79        """Allows any order."""
+80        return Order.Any
+
+ + +

Sums all outcomes.

+
+ + +
+ +
+ + SumEvaluator(map: Union[Callable, Mapping, NoneType] = None) + + + +
+ + 
44    def __init__(self, map: Callable | Mapping | None = None) -> None:
+45        """Constructor.
+46
+47        map: If provided, outcomes will be mapped according to this just
+48            before summing.
+49        """
+50        if map is None:
+51
+52            def map_func(outcome):
+53                return outcome
+54
+55            self._map = map_func
+56        elif callable(map):
+57            self._map = map
+58        else:
+59            map_dict = {k: v for k, v in map.items()}
+60
+61            def map_func(outcome):
+62                return map_dict[outcome]
+63
+64            self._map = map_func
+
+ + +

Constructor.

+ +

map: If provided, outcomes will be mapped according to this just + before summing.

+
+ + +
+
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
66    def next_state(self, state, outcome, count):
+67        """Implementation."""
+68        outcome = self._map(outcome)
+69        if state is None:
+70            if count == 1:
+71                # The outcome does not need to support addition or
+72                # multiplication in this case.
+73                return outcome
+74            return outcome * count
+75        else:
+76            return state + outcome * count
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
78    def order(self) -> Literal[Order.Any]:
+79        """Allows any order."""
+80        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
final_outcome
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+
+ sum_evaluator = +<SumEvaluator object> + + +
+ + + + +
+
+ +
+ + class + CountEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]): + + + +
+ + 
 87class CountEvaluator(MultisetEvaluator[Any, int]):
+ 88    """Returns the total count of outcomes.
+ 89
+ 90    Usually not very interesting unless the counts are adjusted by
+ 91    `unique` etc.
+ 92    """
+ 93
+ 94    def next_state(self, state, outcome, count):
+ 95        """Implementation."""
+ 96        return (state or 0) + count
+ 97
+ 98    def final_outcome(self, final_state) -> int:
+ 99        """Implementation."""
+100        return final_state or 0
+101
+102    def order(self) -> Literal[Order.Any]:
+103        """Allows any order."""
+104        return Order.Any
+
+ + +

Returns the total count of outcomes.

+ +

Usually not very interesting unless the counts are adjusted by +unique etc.

+
+ + +
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
94    def next_state(self, state, outcome, count):
+95        """Implementation."""
+96        return (state or 0) + count
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> int: + + + +
+ + 
 98    def final_outcome(self, final_state) -> int:
+ 99        """Implementation."""
+100        return final_state or 0
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
102    def order(self) -> Literal[Order.Any]:
+103        """Allows any order."""
+104        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+
+ count_evaluator = +<CountEvaluator object> + + +
+ + + + +
+
+ +
+ + class + AnyEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
111class AnyEvaluator(MultisetEvaluator[Any, bool]):
+112    """Returns `True` iff at least one count is positive."""
+113
+114    def next_state(self, state, outcome, count):
+115        """Implementation."""
+116        return state or (count > 0)
+117
+118    def final_outcome(self, final_state) -> bool:
+119        """Implementation."""
+120        return final_state or False
+121
+122    def order(self) -> Literal[Order.Any]:
+123        """Allows any order."""
+124        return Order.Any
+
+ + +

Returns True iff at least one count is positive.

+
+ + +
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
114    def next_state(self, state, outcome, count):
+115        """Implementation."""
+116        return state or (count > 0)
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> bool: + + + +
+ + 
118    def final_outcome(self, final_state) -> bool:
+119        """Implementation."""
+120        return final_state or False
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
122    def order(self) -> Literal[Order.Any]:
+123        """Allows any order."""
+124        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+
+ any_evaluator = +<AnyEvaluator object> + + +
+ + + + +
+
+ +
+ + class + HighestOutcomeAndCountEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[typing.Any, int]]): + + + +
+ + 
13class HighestOutcomeAndCountEvaluator(MultisetEvaluator[Any, tuple[Any, int]]):
+14    """The highest outcome that has positive count, along with that count.
+15
+16    If no outcomes have positive count, the result is the min outcome with a count of 0.
+17    """
+18
+19    def next_state(self, state, outcome, count):
+20        """Implementation."""
+21        count = max(count, 0)
+22
+23        if state is None:
+24            return outcome, count
+25
+26        if count > 0 and outcome > state[0]:
+27            return outcome, count
+28
+29        if count == 0 and state[1] == 0:
+30            return min(outcome, state[0]), 0
+31
+32        return state
+33
+34    def order(self) -> Literal[Order.Any]:
+35        """Allows any order."""
+36        return Order.Any
+37
+38    def alignment(self, outcomes: Sequence) -> Collection:
+39        """Always sees zero counts."""
+40        return outcomes
+
+ + +

The highest outcome that has positive count, along with that count.

+ +

If no outcomes have positive count, the result is the min outcome with a count of 0.

+
+ + +
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
19    def next_state(self, state, outcome, count):
+20        """Implementation."""
+21        count = max(count, 0)
+22
+23        if state is None:
+24            return outcome, count
+25
+26        if count > 0 and outcome > state[0]:
+27            return outcome, count
+28
+29        if count == 0 and state[1] == 0:
+30            return min(outcome, state[0]), 0
+31
+32        return state
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
34    def order(self) -> Literal[Order.Any]:
+35        """Allows any order."""
+36        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence) -> Collection: + + + +
+ + 
38    def alignment(self, outcomes: Sequence) -> Collection:
+39        """Always sees zero counts."""
+40        return outcomes
+
+ + +

Always sees zero counts.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
final_outcome
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + LargestCountEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]): + + + +
+ + 
83class LargestCountEvaluator(MultisetEvaluator[Any, int]):
+84    """The largest count of any outcome."""
+85
+86    def next_state(self, state, _, count):
+87        """Implementation."""
+88        return max(state or count, count)
+89
+90    def order(self) -> Literal[Order.Any]:
+91        """Allows any order."""
+92        return Order.Any
+
+ + +

The largest count of any outcome.

+
+ + +
+ +
+ + def + next_state(self, state, _, count): + + + +
+ + 
86    def next_state(self, state, _, count):
+87        """Implementation."""
+88        return max(state or count, count)
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
90    def order(self) -> Literal[Order.Any]:
+91        """Allows any order."""
+92        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
final_outcome
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + LargestCountAndOutcomeEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[int, typing.Any]]): + + + +
+ + 
 95class LargestCountAndOutcomeEvaluator(MultisetEvaluator[Any, tuple[int, Any]]):
+ 96    """The largest count of any outcome, along with that outcome."""
+ 97
+ 98    def next_state(self, state, outcome, count):
+ 99        """Implementation."""
+100        return max(state or (count, outcome), (count, outcome))
+101
+102    def order(self) -> Literal[Order.Any]:
+103        """Allows any order."""
+104        return Order.Any
+
+ + +

The largest count of any outcome, along with that outcome.

+
+ + +
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
 98    def next_state(self, state, outcome, count):
+ 99        """Implementation."""
+100        return max(state or (count, outcome), (count, outcome))
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
102    def order(self) -> Literal[Order.Any]:
+103        """Allows any order."""
+104        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
final_outcome
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + AllCountsEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[int, ...]]): + + + +
+ + 
43class AllCountsEvaluator(MultisetEvaluator[Any, tuple[int, ...]]):
+44    """All counts in descending order.
+45
+46    In other words, this produces tuples of the sizes of all matching sets.
+47    """
+48
+49    def __init__(self, *, filter: int | None = 1) -> None:
+50        """
+51        Args:
+52            filter: Any counts below this value will not be in the output.
+53                For example, `filter=2` will only produce pairs and better.
+54                If `None`, no filtering will be done.
+55        """
+56        self._filter = filter
+57
+58    def next_state(self, state, outcome, count):
+59        """Implementation."""
+60        state = state or ()
+61        if self._filter is None or count >= self._filter:
+62            state = state + (count,)
+63            return tuple(sorted(state, reverse=True))
+64        else:
+65            return state
+66
+67    def final_outcome(self, final_state) -> tuple:
+68        """Implementation."""
+69        if final_state is None:
+70            return ()
+71        else:
+72            return final_state
+73
+74    def order(self) -> Literal[Order.Any]:
+75        """Allows any order."""
+76        return Order.Any
+77
+78    def alignment(self, outcomes: Sequence) -> Collection:
+79        """Always sees zero counts."""
+80        return outcomes
+
+ + +

All counts in descending order.

+ +

In other words, this produces tuples of the sizes of all matching sets.

+
+ + +
+ +
+ + AllCountsEvaluator(*, filter: int | None = 1) + + + +
+ + 
49    def __init__(self, *, filter: int | None = 1) -> None:
+50        """
+51        Args:
+52            filter: Any counts below this value will not be in the output.
+53                For example, `filter=2` will only produce pairs and better.
+54                If `None`, no filtering will be done.
+55        """
+56        self._filter = filter
+
+ + +
Arguments:
+ +
    +
  • filter: Any counts below this value will not be in the output. +For example, filter=2 will only produce pairs and better. +If None, no filtering will be done.
    • +
+
+ + +
+
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
58    def next_state(self, state, outcome, count):
+59        """Implementation."""
+60        state = state or ()
+61        if self._filter is None or count >= self._filter:
+62            state = state + (count,)
+63            return tuple(sorted(state, reverse=True))
+64        else:
+65            return state
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> tuple: + + + +
+ + 
67    def final_outcome(self, final_state) -> tuple:
+68        """Implementation."""
+69        if final_state is None:
+70            return ()
+71        else:
+72            return final_state
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
74    def order(self) -> Literal[Order.Any]:
+75        """Allows any order."""
+76        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence) -> Collection: + + + +
+ + 
78    def alignment(self, outcomes: Sequence) -> Collection:
+79        """Always sees zero counts."""
+80        return outcomes
+
+ + +

Always sees zero counts.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + LargestStraightEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, int]): + + + +
+ + 
107class LargestStraightEvaluator(MultisetEvaluator[int, int]):
+108    """The size of the largest straight."""
+109
+110    def next_state(self, state, _, count):
+111        """Implementation."""
+112        best_run, run = state or (0, 0)
+113        if count >= 1:
+114            run += 1
+115        else:
+116            run = 0
+117        return max(best_run, run), run
+118
+119    def final_outcome(self, final_state) -> int:
+120        """Implementation."""
+121        if final_state is None:
+122            return 0
+123        return final_state[0]
+124
+125    def order(self) -> Literal[Order.Ascending]:
+126        """Ascending order."""
+127        return Order.Ascending
+128
+129    alignment = MultisetEvaluator.range_alignment
+
+ + +

The size of the largest straight.

+
+ + +
+ +
+ + def + next_state(self, state, _, count): + + + +
+ + 
110    def next_state(self, state, _, count):
+111        """Implementation."""
+112        best_run, run = state or (0, 0)
+113        if count >= 1:
+114            run += 1
+115        else:
+116            run = 0
+117        return max(best_run, run), run
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> int: + + + +
+ + 
119    def final_outcome(self, final_state) -> int:
+120        """Implementation."""
+121        if final_state is None:
+122            return 0
+123        return final_state[0]
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Ascending: 1>]: + + + +
+ + 
125    def order(self) -> Literal[Order.Ascending]:
+126        """Ascending order."""
+127        return Order.Ascending
+
+ + +

Ascending order.

+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence[int]) -> Collection[int]: + + + +
+ + 
167    def range_alignment(self, outcomes: Sequence[int]) -> Collection[int]:
+168        """Example implementation of `alignment()` that produces consecutive `int` outcomes.
+169
+170        There is no expectation that a subclass be able to handle
+171        an arbitrary number of generators. Thus, you are free to rename any of
+172        the parameters in a subclass, or to replace `*generators` with a fixed
+173        set of parameters.
+174
+175        Set `alignment = icepool.MultisetEvaluator.range_alignment` to use this.
+176
+177        Returns:
+178            All `int`s from the min outcome to the max outcome among the generators,
+179            inclusive.
+180
+181        Raises:
+182            TypeError: if any generator has any non-`int` outcome.
+183        """
+184        if not outcomes:
+185            return ()
+186
+187        if any(not isinstance(x, int) for x in outcomes):
+188            raise TypeError(
+189                "range_alignment cannot be used with outcomes of type other than 'int'."
+190            )
+191
+192        return range(outcomes[0], outcomes[-1] + 1)
+
+ + +

Example implementation of alignment() that produces consecutive int outcomes.

+ +

There is no expectation that a subclass be able to handle +an arbitrary number of generators. Thus, you are free to rename any of +the parameters in a subclass, or to replace *generators with a fixed +set of parameters.

+ +

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

+ +
Returns:
+ +
+

All ints from the min outcome to the max outcome among the generators, + inclusive.

+
+ +
Raises:
+ +
    +
  • TypeError: if any generator has any non-int outcome.
    • +
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + LargestStraightAndOutcomeEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, int]]): + + + +
+ + 
132class LargestStraightAndOutcomeEvaluator(MultisetEvaluator[int, tuple[int,
+133                                                                      int]]):
+134    """The size of the largest straight, along with the greatest outcome in that straight."""
+135
+136    def next_state(self, state, outcome, count):
+137        """Implementation."""
+138        best_run_and_outcome, run = state or ((0, outcome), 0)
+139        if count >= 1:
+140            run += 1
+141        else:
+142            run = 0
+143        return max(best_run_and_outcome, (run, outcome)), run
+144
+145    def final_outcome(self, final_state) -> tuple[int, int]:
+146        """Implementation."""
+147        return final_state[0]
+148
+149    def order(self) -> Literal[Order.Ascending]:
+150        """Ascending order."""
+151        return Order.Ascending
+152
+153    alignment = MultisetEvaluator.range_alignment
+
+ + +

The size of the largest straight, along with the greatest outcome in that straight.

+
+ + +
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
136    def next_state(self, state, outcome, count):
+137        """Implementation."""
+138        best_run_and_outcome, run = state or ((0, outcome), 0)
+139        if count >= 1:
+140            run += 1
+141        else:
+142            run = 0
+143        return max(best_run_and_outcome, (run, outcome)), run
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> tuple[int, int]: + + + +
+ + 
145    def final_outcome(self, final_state) -> tuple[int, int]:
+146        """Implementation."""
+147        return final_state[0]
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Ascending: 1>]: + + + +
+ + 
149    def order(self) -> Literal[Order.Ascending]:
+150        """Ascending order."""
+151        return Order.Ascending
+
+ + +

Ascending order.

+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence[int]) -> Collection[int]: + + + +
+ + 
167    def range_alignment(self, outcomes: Sequence[int]) -> Collection[int]:
+168        """Example implementation of `alignment()` that produces consecutive `int` outcomes.
+169
+170        There is no expectation that a subclass be able to handle
+171        an arbitrary number of generators. Thus, you are free to rename any of
+172        the parameters in a subclass, or to replace `*generators` with a fixed
+173        set of parameters.
+174
+175        Set `alignment = icepool.MultisetEvaluator.range_alignment` to use this.
+176
+177        Returns:
+178            All `int`s from the min outcome to the max outcome among the generators,
+179            inclusive.
+180
+181        Raises:
+182            TypeError: if any generator has any non-`int` outcome.
+183        """
+184        if not outcomes:
+185            return ()
+186
+187        if any(not isinstance(x, int) for x in outcomes):
+188            raise TypeError(
+189                "range_alignment cannot be used with outcomes of type other than 'int'."
+190            )
+191
+192        return range(outcomes[0], outcomes[-1] + 1)
+
+ + +

Example implementation of alignment() that produces consecutive int outcomes.

+ +

There is no expectation that a subclass be able to handle +an arbitrary number of generators. Thus, you are free to rename any of +the parameters in a subclass, or to replace *generators with a fixed +set of parameters.

+ +

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

+ +
Returns:
+ +
+

All ints from the min outcome to the max outcome among the generators, + inclusive.

+
+ +
Raises:
+ +
    +
  • TypeError: if any generator has any non-int outcome.
    • +
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + AllStraightsEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, ...]]): + + + +
+ + 
156class AllStraightsEvaluator(MultisetEvaluator[int, tuple[int, ...]]):
+157    """The sizes of all straights in descending order.
+158
+159    Each element can only contribute to one straight, though duplicates can
+160    produce overlapping straights.
+161    """
+162
+163    def next_state(self, state, _, count):
+164        """Implementation."""
+165        current_runs, ended_runs = state or ((), ())
+166        if count < len(current_runs):
+167            next_current_runs = tuple(x + 1 for x in current_runs[:count])
+168            next_ended_runs = tuple(sorted(ended_runs + current_runs[count:]))
+169        else:
+170            next_current_runs = tuple(
+171                x + 1
+172                for x in current_runs) + (1,) * (count - len(current_runs))
+173            next_ended_runs = ended_runs
+174        return next_current_runs, next_ended_runs
+175
+176    def final_outcome(self, final_state) -> tuple[int, ...]:
+177        """Implementation."""
+178        current_runs, ended_runs = final_state or ((), ())
+179        return tuple(sorted(current_runs + ended_runs, reverse=True))
+180
+181    def order(self) -> Literal[Order.Ascending]:
+182        """Ascending order."""
+183        return Order.Ascending
+184
+185    alignment = MultisetEvaluator.range_alignment
+
+ + +

The sizes of all straights in descending order.

+ +

Each element can only contribute to one straight, though duplicates can +produce overlapping straights.

+
+ + +
+ +
+ + def + next_state(self, state, _, count): + + + +
+ + 
163    def next_state(self, state, _, count):
+164        """Implementation."""
+165        current_runs, ended_runs = state or ((), ())
+166        if count < len(current_runs):
+167            next_current_runs = tuple(x + 1 for x in current_runs[:count])
+168            next_ended_runs = tuple(sorted(ended_runs + current_runs[count:]))
+169        else:
+170            next_current_runs = tuple(
+171                x + 1
+172                for x in current_runs) + (1,) * (count - len(current_runs))
+173            next_ended_runs = ended_runs
+174        return next_current_runs, next_ended_runs
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> tuple[int, ...]: + + + +
+ + 
176    def final_outcome(self, final_state) -> tuple[int, ...]:
+177        """Implementation."""
+178        current_runs, ended_runs = final_state or ((), ())
+179        return tuple(sorted(current_runs + ended_runs, reverse=True))
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Ascending: 1>]: + + + +
+ + 
181    def order(self) -> Literal[Order.Ascending]:
+182        """Ascending order."""
+183        return Order.Ascending
+
+ + +

Ascending order.

+
+ + +
+
+ +
+ + def + alignment(self, outcomes: Sequence[int]) -> Collection[int]: + + + +
+ + 
167    def range_alignment(self, outcomes: Sequence[int]) -> Collection[int]:
+168        """Example implementation of `alignment()` that produces consecutive `int` outcomes.
+169
+170        There is no expectation that a subclass be able to handle
+171        an arbitrary number of generators. Thus, you are free to rename any of
+172        the parameters in a subclass, or to replace `*generators` with a fixed
+173        set of parameters.
+174
+175        Set `alignment = icepool.MultisetEvaluator.range_alignment` to use this.
+176
+177        Returns:
+178            All `int`s from the min outcome to the max outcome among the generators,
+179            inclusive.
+180
+181        Raises:
+182            TypeError: if any generator has any non-`int` outcome.
+183        """
+184        if not outcomes:
+185            return ()
+186
+187        if any(not isinstance(x, int) for x in outcomes):
+188            raise TypeError(
+189                "range_alignment cannot be used with outcomes of type other than 'int'."
+190            )
+191
+192        return range(outcomes[0], outcomes[-1] + 1)
+
+ + +

Example implementation of alignment() that produces consecutive int outcomes.

+ +

There is no expectation that a subclass be able to handle +an arbitrary number of generators. Thus, you are free to rename any of +the parameters in a subclass, or to replace *generators with a fixed +set of parameters.

+ +

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

+ +
Returns:
+ +
+

All ints from the min outcome to the max outcome among the generators, + inclusive.

+
+ +
Raises:
+ +
    +
  • TypeError: if any generator has any non-int outcome.
    • +
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + ComparisonEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
15class ComparisonEvaluator(MultisetEvaluator[Any, bool]):
+16    """Compares the multisets produced by two generators."""
+17
+18    @abstractmethod
+19    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+20        """Called for each outcome and produces a pair of bools.
+21
+22        The final outcome is true iff any of the first and all of the second
+23        bool are `True`.
+24        """
+25
+26    @staticmethod
+27    @abstractmethod
+28    def default_outcome() -> bool:
+29        """The final outcome if both left and right have no outcomes."""
+30
+31    def next_state(self, state, outcome, left, right):
+32        """Implementation."""
+33        has_any, has_all = state or (False, True)
+34        this_any, this_all = self.any_all(left, right)
+35        has_all = has_all and this_all
+36        has_any = has_all and (has_any or this_any)
+37        return has_any, has_all
+38
+39    def final_outcome(self, final_state) -> bool:
+40        """Implementation."""
+41        if final_state is None:
+42            return self.default_outcome()
+43        has_any, has_all = final_state
+44        return has_any and has_all
+45
+46    def order(self) -> Literal[Order.Any]:
+47        """Allows any order."""
+48        return Order.Any
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+
@abstractmethod
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
18    @abstractmethod
+19    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+20        """Called for each outcome and produces a pair of bools.
+21
+22        The final outcome is true iff any of the first and all of the second
+23        bool are `True`.
+24        """
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+
@abstractmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
26    @staticmethod
+27    @abstractmethod
+28    def default_outcome() -> bool:
+29        """The final outcome if both left and right have no outcomes."""
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+ +
+ + def + next_state(self, state, outcome, left, right): + + + +
+ + 
31    def next_state(self, state, outcome, left, right):
+32        """Implementation."""
+33        has_any, has_all = state or (False, True)
+34        this_any, this_all = self.any_all(left, right)
+35        has_all = has_all and this_all
+36        has_any = has_all and (has_any or this_any)
+37        return has_any, has_all
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> bool: + + + +
+ + 
39    def final_outcome(self, final_state) -> bool:
+40        """Implementation."""
+41        if final_state is None:
+42            return self.default_outcome()
+43        has_any, has_all = final_state
+44        return has_any and has_all
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> Literal[<Order.Any: 0>]: + + + +
+ + 
46    def order(self) -> Literal[Order.Any]:
+47        """Allows any order."""
+48        return Order.Any
+
+ + +

Allows any order.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsSubsetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
61class IsSubsetEvaluator(ComparisonEvaluator):
+62
+63    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+64        return True, left <= right
+65
+66    @staticmethod
+67    def default_outcome() -> bool:
+68        return True
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
63    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+64        return True, left <= right
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
66    @staticmethod
+67    def default_outcome() -> bool:
+68        return True
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsProperSubsetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
51class IsProperSubsetEvaluator(ComparisonEvaluator):
+52
+53    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+54        return left < right, left <= right
+55
+56    @staticmethod
+57    def default_outcome() -> bool:
+58        return False
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
53    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+54        return left < right, left <= right
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
56    @staticmethod
+57    def default_outcome() -> bool:
+58        return False
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsSupersetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
81class IsSupersetEvaluator(ComparisonEvaluator):
+82
+83    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+84        return True, left >= right
+85
+86    @staticmethod
+87    def default_outcome() -> bool:
+88        return True
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
83    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+84        return True, left >= right
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
86    @staticmethod
+87    def default_outcome() -> bool:
+88        return True
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsProperSupersetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
71class IsProperSupersetEvaluator(ComparisonEvaluator):
+72
+73    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+74        return left > right, left >= right
+75
+76    @staticmethod
+77    def default_outcome() -> bool:
+78        return False
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
73    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+74        return left > right, left >= right
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
76    @staticmethod
+77    def default_outcome() -> bool:
+78        return False
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsEqualSetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
91class IsEqualSetEvaluator(ComparisonEvaluator):
+92
+93    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+94        return True, left == right
+95
+96    @staticmethod
+97    def default_outcome() -> bool:
+98        return True
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
93    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+94        return True, left == right
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
96    @staticmethod
+97    def default_outcome() -> bool:
+98        return True
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsNotEqualSetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
101class IsNotEqualSetEvaluator(ComparisonEvaluator):
+102
+103    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+104        return left != right, True
+105
+106    @staticmethod
+107    def default_outcome() -> bool:
+108        return False
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
103    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+104        return left != right, True
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
106    @staticmethod
+107    def default_outcome() -> bool:
+108        return False
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + IsDisjointSetEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]): + + + +
+ + 
111class IsDisjointSetEvaluator(ComparisonEvaluator):
+112
+113    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+114        return True, not ((left > 0) and right > 0)
+115
+116    @staticmethod
+117    def default_outcome() -> bool:
+118        return True
+
+ + +

Compares the multisets produced by two generators.

+
+ + +
+ +
+ + def + any_all(self, left: int, right: int) -> tuple[bool, bool]: + + + +
+ + 
113    def any_all(self, left: int, right: int) -> tuple[bool, bool]:
+114        return True, not ((left > 0) and right > 0)
+
+ + +

Called for each outcome and produces a pair of bools.

+ +

The final outcome is true iff any of the first and all of the second +bool are True.

+
+ + +
+
+ +
+
@staticmethod
+ + def + default_outcome() -> bool: + + + +
+ + 
116    @staticmethod
+117    def default_outcome() -> bool:
+118        return True
+
+ + +

The final outcome if both left and right have no outcomes.

+
+ + +
+
+
Inherited Members
+
+ +
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + ConstantEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, +U_co]): + + + +
+ + 
12class ConstantEvaluator(MultisetEvaluator[Any, U_co]):
+13    """An evaluator that ignores its arguments and returns a constant result."""
+14
+15    def __init__(self, result: 'icepool.Die[U_co]') -> None:
+16        self._result = result
+17
+18    def next_state(self, state, outcome, *counts):
+19        return None
+20
+21    def final_outcome(self, final_state) -> 'icepool.Die[U_co]':
+22        return self._result
+
+ + +

An evaluator that ignores its arguments and returns a constant result.

+
+ + +
+ +
+ + ConstantEvaluator(result: icepool.population.die.Die[+U_co]) + + + +
+ + 
15    def __init__(self, result: 'icepool.Die[U_co]') -> None:
+16        self._result = result
+
+ + + + +
+
+ +
+ + def + next_state(self, state, outcome, *counts): + + + +
+ + 
18    def next_state(self, state, outcome, *counts):
+19        return None
+
+ + +

State transition function.

+ +

This should produce a state given the previous state, an outcome, +and the number that outcome produced by each generator.

+ +

evaluate() will always call this using only positional arguments. +Furthermore, there is no expectation that a subclass be able to handle +an arbitrary number of counts. Thus, you are free to rename any of +the parameters in a subclass, or to replace *counts with a fixed set +of parameters.

+ +

Make sure to handle the base case where state is None.

+ +

States must be hashable. At current, they do not have to be orderable. +However, this may change in the future, and if they are not totally +orderable, you must override final_outcome to create totally orderable +final outcomes.

+ +

The behavior of returning a Die from next_state is currently +undefined.

+ +
Arguments:
+ +
    +
  • state: A hashable object indicating the state before rolling the +current outcome. If this is the first outcome being considered, +state will be None.
    • +
  • outcome: The current outcome. +next_state will see all rolled outcomes in monotonic order; +either ascending or descending depending on order(). +If there are multiple generators, the set of outcomes is the +union of the outcomes of the invididual generators. All outcomes +with nonzero count will be seen. Outcomes with zero count +may or may not be seen. If you need to enforce that certain +outcomes are seen even if they have zero count, see +alignment().
    • +
  • *counts: One value (usually an int) for each generator output +indicating how many of the current outcome were produced. +All outcomes with nonzero count are guaranteed to be seen. +To guarantee that outcomes are seen even if they have zero +count, override alignment().
    • +
+ +
Returns:
+ +
+

A hashable object indicating the next state. + The special value icepool.Reroll can be used to immediately remove + the state from consideration, effectively performing a full reroll.

+
+
+ + +
+
+ +
+ + def + final_outcome(self, final_state) -> icepool.population.die.Die[+U_co]: + + + +
+ + 
21    def final_outcome(self, final_state) -> 'icepool.Die[U_co]':
+22        return self._result
+
+ + +

Optional function to generate a final outcome from a final state.

+ +

By default, the final outcome is equal to the final state. +Note that None is not a valid outcome for a Die, +and if there are no outcomes, final_outcome will be immediately +be callled with final_state=None. +Subclasses that want to handle this case should explicitly define what +happens.

+ +
Arguments:
+ +
    +
  • final_state: A state after all outcomes have been processed.
    • +
+ +
Returns:
+ +
+

A final outcome that will be used as part of constructing the result Die. + As usual for Die(), this could itself be a Die or icepool.Reroll.

+
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
order
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + CompairEvalautor(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]): + + + +
+ + 
 13class CompairEvalautor(MultisetEvaluator[Any, int]):
+ 14    """Compares sorted pairs of two multisets and scores wins, ties, and extra elements.
+ 15
+ 16    This can be used for e.g. RISK-like mechanics.
+ 17    """
+ 18
+ 19    def __init__(self,
+ 20                 op: Literal['<', '<=', '>', '>=', '==', '!='] | None = None,
+ 21                 *,
+ 22                 order: Order = Order.Descending,
+ 23                 initial=None,
+ 24                 tie=None,
+ 25                 left=None,
+ 26                 right=None,
+ 27                 extra_left=None,
+ 28                 extra_right=None):
+ 29        """Compares sorted pairs of two multisets and scores wins, ties, and extra elements.
+ 30
+ 31        For example, `left=1` would count how many pairs were won by the left
+ 32        side, and `left=1, right=-1` would give the difference in the number of
+ 33        pairs won by each side.
+ 34
+ 35        Any score argument 
+ 36        (`initial, tie, left, right, extra_left, extra_right`) 
+ 37        not provided will be set to a zero value determined from another score 
+ 38        argument times `0`.
+ 39
+ 40        Args:
+ 41            op: Sets the score values based on the given operator and `order`.
+ 42                Allowed values are `'<', '<=', '>', '>=', '==', '!='`.
+ 43                Each pair that fits the comparator counts as 1.
+ 44                If one side has more elements than the other, the extra
+ 45                elements are ignored.
+ 46            order: If descending (default), pairs are made in descending order
+ 47                and the higher element wins. If ascending, pairs are made in
+ 48                ascending order and the lower element wins.
+ 49            
+ 50            initial: The initial score.
+ 51            tie: The score for each pair that is a tie.
+ 52            left: The score for each pair that left wins.
+ 53            right: The score for each pair that right wins.
+ 54            extra_left: If left has more elements, each extra element scores
+ 55                this much.
+ 56            extra_right: If right has more elements, each extra element scores
+ 57                this much.
+ 58        """
+ 59        if order == Order.Any:
+ 60            order = Order.Descending
+ 61        self._order = order
+ 62
+ 63        if op is not None:
+ 64            if not all(x is None for x in [tie, left, right]):
+ 65                raise TypeError(
+ 66                    'Named operators cannot be combined with tie, left, or right.'
+ 67                )
+ 68            default_score = 0
+ 69            if op == '<':
+ 70                right = 1
+ 71            elif op == '<=':
+ 72                tie = 1
+ 73                right = 1
+ 74            elif op == '>':
+ 75                left = 1
+ 76            elif op == '>=':
+ 77                tie = 1
+ 78                left = 1
+ 79            elif op == '==':
+ 80                tie = 1
+ 81            elif op == '!=':
+ 82                left = 1
+ 83                right = 1
+ 84            if order > 0:
+ 85                left, right = right, left
+ 86        else:
+ 87            all_scores = (initial, tie, left, right, extra_left, extra_right)
+ 88            default_score = None
+ 89            if None in all_scores:
+ 90                for score in all_scores:
+ 91                    if score is not None:
+ 92                        default_score = score * 0
+ 93                        break
+ 94                else:
+ 95                    raise TypeError(
+ 96                        'An operator or at least one score must be specified.')
+ 97
+ 98        self._initial = initial if initial is not None else default_score
+ 99        self._tie = tie if tie is not None else default_score
+100        self._left = left if left is not None else default_score
+101        self._right = right if right is not None else default_score
+102        self._extra_left = extra_left if extra_left is not None else default_score
+103        self._extra_right = extra_right if extra_right is not None else default_score
+104
+105    def next_state(self, state, _, left, right):
+106        if left < 0 or right < 0:
+107            raise ValueError('Negative counts not supported.')
+108        # positive advantage favors left, negative favors right
+109        score, advantage = state or (self._initial, 0)
+110        if advantage > 0:
+111            # How many left wins.
+112            wins = min(advantage, right)
+113            score += wins * self._left
+114            advantage -= wins
+115            right -= wins
+116        else:
+117            # How many right wins.
+118            wins = min(-advantage, left)
+119            score += wins * self._right
+120            advantage += wins
+121            left -= wins
+122        ties = min(left, right)
+123        score += ties * self._tie
+124        # Rest goes into advantage.
+125        advantage += left - right
+126        return score, advantage
+127
+128    def final_outcome(self, final_state):
+129        score, advantage = final_state or (self._initial, 0)
+130        if advantage > 0:
+131            score += advantage * self._extra_left
+132        elif advantage < 0:
+133            score -= advantage * self._extra_right
+134        return score
+135
+136    def order(self) -> Order:
+137        return self._order
+
+ + +

Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

+ +

This can be used for e.g. RISK-like mechanics.

+
+ + +
+ +
+ + CompairEvalautor( op: Optional[Literal['<', '<=', '>', '>=', '==', '!=']] = None, *, order: icepool.typing.Order = <Order.Descending: -1>, initial=None, tie=None, left=None, right=None, extra_left=None, extra_right=None) + + + +
+ + 
 19    def __init__(self,
+ 20                 op: Literal['<', '<=', '>', '>=', '==', '!='] | None = None,
+ 21                 *,
+ 22                 order: Order = Order.Descending,
+ 23                 initial=None,
+ 24                 tie=None,
+ 25                 left=None,
+ 26                 right=None,
+ 27                 extra_left=None,
+ 28                 extra_right=None):
+ 29        """Compares sorted pairs of two multisets and scores wins, ties, and extra elements.
+ 30
+ 31        For example, `left=1` would count how many pairs were won by the left
+ 32        side, and `left=1, right=-1` would give the difference in the number of
+ 33        pairs won by each side.
+ 34
+ 35        Any score argument 
+ 36        (`initial, tie, left, right, extra_left, extra_right`) 
+ 37        not provided will be set to a zero value determined from another score 
+ 38        argument times `0`.
+ 39
+ 40        Args:
+ 41            op: Sets the score values based on the given operator and `order`.
+ 42                Allowed values are `'<', '<=', '>', '>=', '==', '!='`.
+ 43                Each pair that fits the comparator counts as 1.
+ 44                If one side has more elements than the other, the extra
+ 45                elements are ignored.
+ 46            order: If descending (default), pairs are made in descending order
+ 47                and the higher element wins. If ascending, pairs are made in
+ 48                ascending order and the lower element wins.
+ 49            
+ 50            initial: The initial score.
+ 51            tie: The score for each pair that is a tie.
+ 52            left: The score for each pair that left wins.
+ 53            right: The score for each pair that right wins.
+ 54            extra_left: If left has more elements, each extra element scores
+ 55                this much.
+ 56            extra_right: If right has more elements, each extra element scores
+ 57                this much.
+ 58        """
+ 59        if order == Order.Any:
+ 60            order = Order.Descending
+ 61        self._order = order
+ 62
+ 63        if op is not None:
+ 64            if not all(x is None for x in [tie, left, right]):
+ 65                raise TypeError(
+ 66                    'Named operators cannot be combined with tie, left, or right.'
+ 67                )
+ 68            default_score = 0
+ 69            if op == '<':
+ 70                right = 1
+ 71            elif op == '<=':
+ 72                tie = 1
+ 73                right = 1
+ 74            elif op == '>':
+ 75                left = 1
+ 76            elif op == '>=':
+ 77                tie = 1
+ 78                left = 1
+ 79            elif op == '==':
+ 80                tie = 1
+ 81            elif op == '!=':
+ 82                left = 1
+ 83                right = 1
+ 84            if order > 0:
+ 85                left, right = right, left
+ 86        else:
+ 87            all_scores = (initial, tie, left, right, extra_left, extra_right)
+ 88            default_score = None
+ 89            if None in all_scores:
+ 90                for score in all_scores:
+ 91                    if score is not None:
+ 92                        default_score = score * 0
+ 93                        break
+ 94                else:
+ 95                    raise TypeError(
+ 96                        'An operator or at least one score must be specified.')
+ 97
+ 98        self._initial = initial if initial is not None else default_score
+ 99        self._tie = tie if tie is not None else default_score
+100        self._left = left if left is not None else default_score
+101        self._right = right if right is not None else default_score
+102        self._extra_left = extra_left if extra_left is not None else default_score
+103        self._extra_right = extra_right if extra_right is not None else default_score
+
+ + +

Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

+ +

For example, left=1 would count how many pairs were won by the left +side, and left=1, right=-1 would give the difference in the number of +pairs won by each side.

+ +

Any score argument +(initial, tie, left, right, extra_left, extra_right) +not provided will be set to a zero value determined from another score +argument times 0.

+ +
Arguments:
+ +
    +
  • op: Sets the score values based on the given operator and order. +Allowed values are '<', '<=', '>', '>=', '==', '!='. +Each pair that fits the comparator counts as 1. +If one side has more elements than the other, the extra +elements are ignored.
    • +
  • order: If descending (default), pairs are made in descending order +and the higher element wins. If ascending, pairs are made in +ascending order and the lower element wins.
    • +
  • initial: The initial score.
    • +
  • tie: The score for each pair that is a tie.
    • +
  • left: The score for each pair that left wins.
    • +
  • right: The score for each pair that right wins.
    • +
  • extra_left: If left has more elements, each extra element scores +this much.
    • +
  • extra_right: If right has more elements, each extra element scores +this much.
    • +
+
+ + +
+
+ +
+ + def + next_state(self, state, _, left, right): + + + +
+ + 
105    def next_state(self, state, _, left, right):
+106        if left < 0 or right < 0:
+107            raise ValueError('Negative counts not supported.')
+108        # positive advantage favors left, negative favors right
+109        score, advantage = state or (self._initial, 0)
+110        if advantage > 0:
+111            # How many left wins.
+112            wins = min(advantage, right)
+113            score += wins * self._left
+114            advantage -= wins
+115            right -= wins
+116        else:
+117            # How many right wins.
+118            wins = min(-advantage, left)
+119            score += wins * self._right
+120            advantage += wins
+121            left -= wins
+122        ties = min(left, right)
+123        score += ties * self._tie
+124        # Rest goes into advantage.
+125        advantage += left - right
+126        return score, advantage
+
+ + +

State transition function.

+ +

This should produce a state given the previous state, an outcome, +and the number that outcome produced by each generator.

+ +

evaluate() will always call this using only positional arguments. +Furthermore, there is no expectation that a subclass be able to handle +an arbitrary number of counts. Thus, you are free to rename any of +the parameters in a subclass, or to replace *counts with a fixed set +of parameters.

+ +

Make sure to handle the base case where state is None.

+ +

States must be hashable. At current, they do not have to be orderable. +However, this may change in the future, and if they are not totally +orderable, you must override final_outcome to create totally orderable +final outcomes.

+ +

The behavior of returning a Die from next_state is currently +undefined.

+ +
Arguments:
+ +
    +
  • state: A hashable object indicating the state before rolling the +current outcome. If this is the first outcome being considered, +state will be None.
    • +
  • outcome: The current outcome. +next_state will see all rolled outcomes in monotonic order; +either ascending or descending depending on order(). +If there are multiple generators, the set of outcomes is the +union of the outcomes of the invididual generators. All outcomes +with nonzero count will be seen. Outcomes with zero count +may or may not be seen. If you need to enforce that certain +outcomes are seen even if they have zero count, see +alignment().
    • +
  • *counts: One value (usually an int) for each generator output +indicating how many of the current outcome were produced. +All outcomes with nonzero count are guaranteed to be seen. +To guarantee that outcomes are seen even if they have zero +count, override alignment().
    • +
+ +
Returns:
+ +
+

A hashable object indicating the next state. + The special value icepool.Reroll can be used to immediately remove + the state from consideration, effectively performing a full reroll.

+
+
+ + +
+
+ +
+ + def + final_outcome(self, final_state): + + + +
+ + 
128    def final_outcome(self, final_state):
+129        score, advantage = final_state or (self._initial, 0)
+130        if advantage > 0:
+131            score += advantage * self._extra_left
+132        elif advantage < 0:
+133            score -= advantage * self._extra_right
+134        return score
+
+ + +

Optional function to generate a final outcome from a final state.

+ +

By default, the final outcome is equal to the final state. +Note that None is not a valid outcome for a Die, +and if there are no outcomes, final_outcome will be immediately +be callled with final_state=None. +Subclasses that want to handle this case should explicitly define what +happens.

+ +
Arguments:
+ +
    +
  • final_state: A state after all outcomes have been processed.
    • +
+ +
Returns:
+ +
+

A final outcome that will be used as part of constructing the result Die. + As usual for Die(), this could itself be a Die or icepool.Reroll.

+
+
+ + +
+
+ +
+ + def + order(self) -> icepool.typing.Order: + + + +
+ + 
136    def order(self) -> Order:
+137        return self._order
+
+ + +

Optional function to determine the order in which next_state() will see outcomes.

+ +

The default is ascending order. This has better caching behavior with +mixed standard dice.

+ +
Returns:
+ +
+
    +
  • Order.Ascending (= 1) + if next_state() should always see the outcomes in ascending order.
    • +
  • Order.Descending (= -1) + if next_state() should always see the outcomes in descending order.
    • +
  • Order.Any (= 0) + if the result of the evaluation is order-independent.
    • +
+
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + KeepEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, typing.Any]): + + + +
+ + 
 9class KeepEvaluator(MultisetEvaluator[Any, Any]):
+10    """Produces the outcome at a given sorted index.
+11
+12    The attached generator or expression must produce enough values to reach
+13    the sorted index; otherwise, this raises `IndexError`.
+14    """
+15
+16    def __init__(self, index: int | None = None) -> None:
+17        """Constructor.
+18
+19        Args:
+20            index: The index to keep.
+21                * If non-negative, this runs in ascending order.
+22                * If negative, this runs in descending order.
+23                * If `None`, this assumes only one element is produced.
+24        """
+25        if index is None:
+26            self._skip = 1
+27            self._order = Order.Any
+28        elif index >= 0:
+29            self._skip = index + 1
+30            self._order = Order.Ascending
+31        else:
+32            self._skip = -index
+33            self._order = Order.Descending
+34
+35    def next_state(self, state, outcome, count):
+36        """Implementation."""
+37        if count < 0:
+38            raise IndexError(
+39                'KeepEvaluator is not compatible with incoming negative counts.'
+40            )
+41        result, remaining = state or (None, self._skip)
+42        if count > 0 and self._order == Order.Any and result is not None:
+43            raise IndexError('Expected exactly one element.')
+44        remaining -= count
+45        if remaining <= 0 and result is None:
+46            result = outcome
+47        return result, remaining
+48
+49    def final_outcome(self, final_state):
+50        """Implementation."""
+51        if final_state is None:
+52            raise IndexError('No outcomes were seen.')
+53        if final_state[0] is None:
+54            if self._order == Order.Any:
+55                raise IndexError('Expected exactly one element.')
+56            else:
+57                raise IndexError(
+58                    f'Evaluation ended {final_state[1]} element(s) short of reaching the kept index.'
+59                )
+60        return final_state[0]
+61
+62    def order(self) -> Order:
+63        """The required order is determined by whether the index is negative."""
+64        return self._order
+
+ + +

Produces the outcome at a given sorted index.

+ +

The attached generator or expression must produce enough values to reach +the sorted index; otherwise, this raises IndexError.

+
+ + +
+ +
+ + KeepEvaluator(index: int | None = None) + + + +
+ + 
16    def __init__(self, index: int | None = None) -> None:
+17        """Constructor.
+18
+19        Args:
+20            index: The index to keep.
+21                * If non-negative, this runs in ascending order.
+22                * If negative, this runs in descending order.
+23                * If `None`, this assumes only one element is produced.
+24        """
+25        if index is None:
+26            self._skip = 1
+27            self._order = Order.Any
+28        elif index >= 0:
+29            self._skip = index + 1
+30            self._order = Order.Ascending
+31        else:
+32            self._skip = -index
+33            self._order = Order.Descending
+
+ + +

Constructor.

+ +
Arguments:
+ +
    +
  • index: The index to keep. +
      +
    • If non-negative, this runs in ascending order.
      • +
    • If negative, this runs in descending order.
      • +
    • If None, this assumes only one element is produced.
      • +
    • +
+
+ + +
+
+ +
+ + def + next_state(self, state, outcome, count): + + + +
+ + 
35    def next_state(self, state, outcome, count):
+36        """Implementation."""
+37        if count < 0:
+38            raise IndexError(
+39                'KeepEvaluator is not compatible with incoming negative counts.'
+40            )
+41        result, remaining = state or (None, self._skip)
+42        if count > 0 and self._order == Order.Any and result is not None:
+43            raise IndexError('Expected exactly one element.')
+44        remaining -= count
+45        if remaining <= 0 and result is None:
+46            result = outcome
+47        return result, remaining
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + final_outcome(self, final_state): + + + +
+ + 
49    def final_outcome(self, final_state):
+50        """Implementation."""
+51        if final_state is None:
+52            raise IndexError('No outcomes were seen.')
+53        if final_state[0] is None:
+54            if self._order == Order.Any:
+55                raise IndexError('Expected exactly one element.')
+56            else:
+57                raise IndexError(
+58                    f'Evaluation ended {final_state[1]} element(s) short of reaching the kept index.'
+59                )
+60        return final_state[0]
+
+ + +

Implementation.

+
+ + +
+
+ +
+ + def + order(self) -> icepool.typing.Order: + + + +
+ + 
62    def order(self) -> Order:
+63        """The required order is determined by whether the index is negative."""
+64        return self._order
+
+ + +

The required order is determined by whether the index is negative.

+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
alignment
+
range_alignment
+
prefix_generators
+
validate_arity
+
evaluate
+
sample
+ +
+
+
+
+
+ +
+ + class + ExpressionEvaluator(icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co]): + + + +
+ + 
 15class ExpressionEvaluator(MultisetEvaluator[T_contra, U_co]):
+ 16    """Assigns an expression to be evaluated first to each input of an evaluator."""
+ 17
+ 18    def __init__(
+ 19            self,
+ 20            *expressions: 'icepool.expression.MultisetExpression[T_contra]',
+ 21            evaluator: MultisetEvaluator[T_contra, U_co],
+ 22            truth_value: bool | None = None) -> None:
+ 23        self._evaluator = evaluator
+ 24        self._bound_generators = tuple(
+ 25            itertools.chain.from_iterable(
+ 26                expression._bound_generators() for expression in expressions))
+ 27        self._bound_arity = len(self._bound_generators)
+ 28        self._free_arity = max(
+ 29            (expression._free_arity() for expression in expressions), default=0)
+ 30
+ 31        unbound_expressions: 'list[icepool.expression.MultisetExpression[T_contra]]' = []
+ 32        prefix_start = 0
+ 33        for expression in expressions:
+ 34            unbound_expression, prefix_start = expression._unbind(
+ 35                prefix_start, len(self._bound_generators))
+ 36            unbound_expressions.append(unbound_expression)
+ 37        self._expressions = tuple(unbound_expressions)
+ 38        self._truth_value = truth_value
+ 39
+ 40    def next_state(self, state, outcome, *counts):
+ 41        """Adjusts the counts, then forwards to inner."""
+ 42        if state is None:
+ 43            expression_states = (None,) * len(self._expressions)
+ 44            evaluator_state = None
+ 45        else:
+ 46            expression_states, evaluator_state = state
+ 47
+ 48        prefix_counts = counts[:len(self._evaluator.prefix_generators())]
+ 49        counts = counts[len(self._evaluator.prefix_generators()):]
+ 50
+ 51        expression_states, expression_counts = zip(
+ 52            *(expression._next_state(expression_state, outcome, *counts)
+ 53              for expression, expression_state in zip(self._expressions,
+ 54                                                      expression_states)))
+ 55        evaluator_state = self._evaluator.next_state(evaluator_state, outcome,
+ 56                                                     *prefix_counts,
+ 57                                                     *expression_counts)
+ 58        return expression_states, evaluator_state
+ 59
+ 60    def final_outcome(
+ 61            self,
+ 62            final_state) -> 'U_co | icepool.Die[U_co] | icepool.RerollType':
+ 63        if final_state is None:
+ 64            return self._evaluator.final_outcome(None)
+ 65        else:
+ 66            _, evaluator_state = final_state
+ 67        return self._evaluator.final_outcome(evaluator_state)
+ 68
+ 69    def order(self) -> Order:
+ 70        """Forwards to inner."""
+ 71        expression_order = Order.merge(
+ 72            *(expression._order() for expression in self._expressions))
+ 73        return Order.merge(expression_order, self._evaluator.order())
+ 74
+ 75    def alignment(self, *generators) -> Collection[T_contra]:
+ 76        """Forwards to inner."""
+ 77        return self._evaluator.alignment(*generators)
+ 78
+ 79    @cached_property
+ 80    def _prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+ 81        return self._bound_generators + self._evaluator.prefix_generators()
+ 82
+ 83    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+ 84        return self._prefix_generators
+ 85
+ 86    def validate_arity(self, arity: int) -> None:
+ 87        if arity < self._free_arity:
+ 88            raise ValueError(
+ 89                f'Expected arity of {self._free_arity}, got {arity}.')
+ 90
+ 91    def __bool__(self) -> bool:
+ 92        if self._truth_value is None:
+ 93            raise TypeError(
+ 94                'MultisetExpression only has a truth value if it is the result of the == or != operator.'
+ 95            )
+ 96        return self._truth_value
+ 97
+ 98    def __str__(self) -> str:
+ 99        input_string = f'{self._bound_arity} bound, {self._free_arity} free'
+100        if len(self._expressions) == 1:
+101            expression_string = f'{self._expressions[0]}'
+102        else:
+103            expression_string = ', '.join(
+104                str(expression) for expression in self._expressions)
+105        output_string = str(self._evaluator)
+106        return f'Expression: {input_string} -> {expression_string} -> {output_string}'
+
+ + +

Assigns an expression to be evaluated first to each input of an evaluator.

+
+ + +
+ +
+ + ExpressionEvaluator( *expressions: icepool.expression.multiset_expression.MultisetExpression[-T_contra], evaluator: icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co], truth_value: bool | None = None) + + + +
+ + 
18    def __init__(
+19            self,
+20            *expressions: 'icepool.expression.MultisetExpression[T_contra]',
+21            evaluator: MultisetEvaluator[T_contra, U_co],
+22            truth_value: bool | None = None) -> None:
+23        self._evaluator = evaluator
+24        self._bound_generators = tuple(
+25            itertools.chain.from_iterable(
+26                expression._bound_generators() for expression in expressions))
+27        self._bound_arity = len(self._bound_generators)
+28        self._free_arity = max(
+29            (expression._free_arity() for expression in expressions), default=0)
+30
+31        unbound_expressions: 'list[icepool.expression.MultisetExpression[T_contra]]' = []
+32        prefix_start = 0
+33        for expression in expressions:
+34            unbound_expression, prefix_start = expression._unbind(
+35                prefix_start, len(self._bound_generators))
+36            unbound_expressions.append(unbound_expression)
+37        self._expressions = tuple(unbound_expressions)
+38        self._truth_value = truth_value
+
+ + + + +
+
+ +
+ + def + next_state(self, state, outcome, *counts): + + + +
+ + 
40    def next_state(self, state, outcome, *counts):
+41        """Adjusts the counts, then forwards to inner."""
+42        if state is None:
+43            expression_states = (None,) * len(self._expressions)
+44            evaluator_state = None
+45        else:
+46            expression_states, evaluator_state = state
+47
+48        prefix_counts = counts[:len(self._evaluator.prefix_generators())]
+49        counts = counts[len(self._evaluator.prefix_generators()):]
+50
+51        expression_states, expression_counts = zip(
+52            *(expression._next_state(expression_state, outcome, *counts)
+53              for expression, expression_state in zip(self._expressions,
+54                                                      expression_states)))
+55        evaluator_state = self._evaluator.next_state(evaluator_state, outcome,
+56                                                     *prefix_counts,
+57                                                     *expression_counts)
+58        return expression_states, evaluator_state
+
+ + +

Adjusts the counts, then forwards to inner.

+
+ + +
+
+ +
+ + def + final_outcome( self, final_state) -> Union[+U_co, icepool.population.die.Die[+U_co], icepool.typing.RerollType]: + + + +
+ + 
60    def final_outcome(
+61            self,
+62            final_state) -> 'U_co | icepool.Die[U_co] | icepool.RerollType':
+63        if final_state is None:
+64            return self._evaluator.final_outcome(None)
+65        else:
+66            _, evaluator_state = final_state
+67        return self._evaluator.final_outcome(evaluator_state)
+
+ + +

Optional function to generate a final outcome from a final state.

+ +

By default, the final outcome is equal to the final state. +Note that None is not a valid outcome for a Die, +and if there are no outcomes, final_outcome will be immediately +be callled with final_state=None. +Subclasses that want to handle this case should explicitly define what +happens.

+ +
Arguments:
+ +
    +
  • final_state: A state after all outcomes have been processed.
    • +
+ +
Returns:
+ +
+

A final outcome that will be used as part of constructing the result Die. + As usual for Die(), this could itself be a Die or icepool.Reroll.

+
+
+ + +
+
+ +
+ + def + order(self) -> icepool.typing.Order: + + + +
+ + 
69    def order(self) -> Order:
+70        """Forwards to inner."""
+71        expression_order = Order.merge(
+72            *(expression._order() for expression in self._expressions))
+73        return Order.merge(expression_order, self._evaluator.order())
+
+ + +

Forwards to inner.

+
+ + +
+
+ +
+ + def + alignment(self, *generators) -> Collection[-T_contra]: + + + +
+ + 
75    def alignment(self, *generators) -> Collection[T_contra]:
+76        """Forwards to inner."""
+77        return self._evaluator.alignment(*generators)
+
+ + +

Forwards to inner.

+
+ + +
+
+ +
+ + def + prefix_generators( self) -> tuple[icepool.generator.multiset_generator.MultisetGenerator, ...]: + + + +
+ + 
83    def prefix_generators(self) -> 'tuple[icepool.MultisetGenerator, ...]':
+84        return self._prefix_generators
+
+ + +

An optional sequence of extra generators whose counts will be prepended to *counts.

+
+ + +
+
+ +
+ + def + validate_arity(self, arity: int) -> None: + + + +
+ + 
86    def validate_arity(self, arity: int) -> None:
+87        if arity < self._free_arity:
+88            raise ValueError(
+89                f'Expected arity of {self._free_arity}, got {arity}.')
+
+ + +

An optional method to verify the total input arity.

+ +

This is called after any implicit conversion to generators, but does +not include any extra_generators().

+ +

Overriding next_state with a fixed number of counts will make this +check redundant.

+ +
Raises:
+ +
    +
  • ValueError if the total input arity is not valid.
    • +
+
+ + +
+
+
Inherited Members
+
+
icepool.evaluator.multiset_evaluator.MultisetEvaluator
+
range_alignment
+
evaluate
+
sample
+ +
+
+
+
+
+ + \ No newline at end of file diff --git a/apidoc/v1.1.1/icepool/function.html b/apidoc/v1.1.1/icepool/function.html new file mode 100644 index 00000000..524d5129 --- /dev/null +++ b/apidoc/v1.1.1/icepool/function.html @@ -0,0 +1,1930 @@ + + + + + + + icepool.function API documentation + + + + + + + + + + +
+
+

+icepool.function

+ +

Free functions.

+
+ + + + + + 
  1"""Free functions."""
+  2
+  3__docformat__ = 'google'
+  4
+  5import icepool
+  6import icepool.population.markov_chain
+  7from icepool.typing import Outcome, T, U, guess_star
+  8
+  9from collections import defaultdict
+ 10from functools import cache, partial, update_wrapper, wraps
+ 11import itertools
+ 12import math
+ 13
+ 14from typing import Any, Callable, Final, Hashable, Iterable, Iterator, Literal, Mapping, Sequence, TypeAlias, cast, overload
+ 15
+ 16
+ 17@cache
+ 18def d(sides: int, /) -> 'icepool.Die[int]':
+ 19    """A standard die.
+ 20
+ 21    Specifically, the outcomes are `int`s from `1` to `sides` inclusive,
+ 22    with quantity 1 each.
+ 23
+ 24    Don't confuse this with `icepool.Die()`:
+ 25
+ 26    * `icepool.Die([6])`: A `Die` that always rolls the integer 6.
+ 27    * `icepool.d(6)`: A d6.
+ 28
+ 29    You can also import individual standard dice from the `icepool` module, e.g.
+ 30    `from icepool import d6`.
+ 31    """
+ 32    if not isinstance(sides, int):
+ 33        raise TypeError('Argument to standard() must be an int.')
+ 34    elif sides < 1:
+ 35        raise ValueError('Standard die must have at least one side.')
+ 36    return icepool.Die(range(1, sides + 1))
+ 37
+ 38
+ 39def __getattr__(key: str) -> 'icepool.Die[int]':
+ 40    """Implements the `dX` syntax for standard die with no parentheses.
+ 41
+ 42    For example, `icepool.d6`.
+ 43
+ 44    Note that this behavior can't be imported into the global scope, but the
+ 45    function `d()` can be.
+ 46    """
+ 47    if key[0] == 'd':
+ 48        try:
+ 49            return d(int(key[1:]))
+ 50        except ValueError:
+ 51            pass
+ 52    raise AttributeError(key)
+ 53
+ 54
+ 55def coin(n: int, d: int, /) -> 'icepool.Die[bool]':
+ 56    """A `Die` that rolls `True` with probability `n / d`, and `False` otherwise.
+ 57
+ 58    If `n == 0` or `n == d` the result will have only one outcome.
+ 59    """
+ 60    data = {}
+ 61    if n != d:
+ 62        data[False] = d - n
+ 63    if n != 0:
+ 64        data[True] = n
+ 65    return icepool.Die(data)
+ 66
+ 67
+ 68def one_hot(sides: int, /) -> 'icepool.Die[tuple[bool, ...]]':
+ 69    """A `Die` with `Vector` outcomes with one element set to `True` uniformly at random and the rest `False`.
+ 70
+ 71    This is an easy (if somewhat expensive) way of representing how many dice
+ 72    in a pool rolled each number. For example, the outcomes of `10 @ one_hot(6)`
+ 73    are the `(ones, twos, threes, fours, fives, sixes)` rolled in 10d6.
+ 74    """
+ 75    data = []
+ 76    for i in range(sides):
+ 77        outcome = [False] * sides
+ 78        outcome[i] = True
+ 79        data.append(icepool.Vector(outcome))
+ 80    return icepool.Die(data)
+ 81
+ 82
+ 83def from_cumulative(outcomes: Sequence[T],
+ 84                    cumulative: 'Sequence[int] | Sequence[icepool.Die[bool]]',
+ 85                    *,
+ 86                    reverse: bool = False) -> 'icepool.Die[T]':
+ 87    """Constructs a `Die` from a sequence of cumulative values.
+ 88
+ 89    Args:
+ 90        outcomes: The outcomes of the resulting die. Sorted order is recommended
+ 91            but not necessary.
+ 92        cumulative: The cumulative values (inclusive) of the outcomes in the
+ 93            order they are given to this function. These may be:
+ 94            * `int` cumulative quantities.
+ 95            * Dice representing the cumulative distribution at that point.
+ 96        reverse: Iff true, both of the arguments will be reversed. This allows
+ 97            e.g. constructing using a survival distribution.
+ 98    """
+ 99    if len(outcomes) == 0:
+100        return icepool.Die({})
+101
+102    if reverse:
+103        outcomes = list(reversed(outcomes))
+104        cumulative = list(reversed(cumulative))  # type: ignore
+105
+106    prev = 0
+107    d = {}
+108
+109    if isinstance(cumulative[0], icepool.Die):
+110        cumulative = commonize_denominator(*cumulative)
+111        for outcome, die in zip(outcomes, cumulative):
+112            d[outcome] = die.quantity_ne(False) - prev
+113            prev = die.quantity_ne(False)
+114    elif isinstance(cumulative[0], int):
+115        cumulative = cast(Sequence[int], cumulative)
+116        for outcome, quantity in zip(outcomes, cumulative):
+117            d[outcome] = quantity - prev
+118            prev = quantity
+119    else:
+120        raise TypeError(
+121            f'Unsupported type {type(cumulative)} for cumulative values.')
+122
+123    return icepool.Die(d)
+124
+125
+126@overload
+127def from_rv(rv, outcomes: Sequence[int], denominator: int,
+128            **kwargs) -> 'icepool.Die[int]':
+129    ...
+130
+131
+132@overload
+133def from_rv(rv, outcomes: Sequence[float], denominator: int,
+134            **kwargs) -> 'icepool.Die[float]':
+135    ...
+136
+137
+138def from_rv(rv, outcomes: Sequence[int] | Sequence[float], denominator: int,
+139            **kwargs) -> 'icepool.Die[int] | icepool.Die[float]':
+140    """Constructs a `Die` from a rv object (as `scipy.stats`).
+141    Args:
+142        rv: A rv object (as `scipy.stats`).
+143        outcomes: An iterable of `int`s or `float`s that will be the outcomes
+144            of the resulting `Die`.
+145            If the distribution is discrete, outcomes must be `int`s.
+146        denominator: The denominator of the resulting `Die` will be set to this.
+147        **kwargs: These will be forwarded to `rv.cdf()`.
+148    """
+149    if hasattr(rv, 'pdf'):
+150        # Continuous distributions use midpoints.
+151        midpoints = [(a + b) / 2 for a, b in zip(outcomes[:-1], outcomes[1:])]
+152        cdf = rv.cdf(midpoints, **kwargs)
+153        quantities_le = tuple(
+154            int(round(x * denominator)) for x in cdf) + (denominator,)
+155    else:
+156        cdf = rv.cdf(outcomes, **kwargs)
+157        quantities_le = tuple(int(round(x * denominator)) for x in cdf)
+158    return from_cumulative(outcomes, quantities_le)
+159
+160
+161def min_outcome(*dice: 'T | icepool.Die[T]') -> T:
+162    """The minimum outcome among the dice. """
+163    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+164    return min(die.outcomes()[0] for die in converted_dice)
+165
+166
+167def max_outcome(*dice: 'T | icepool.Die[T]') -> T:
+168    """The maximum outcome among the dice. """
+169    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+170    return max(die.outcomes()[-1] for die in converted_dice)
+171
+172
+173def align(*dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+174    """Pads dice with zero quantities so that all have the same set of outcomes.
+175
+176    Args:
+177        *dice: Any number of dice or single outcomes convertible to dice.
+178
+179    Returns:
+180        A tuple of aligned dice.
+181    """
+182    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+183    outcomes = set(
+184        itertools.chain.from_iterable(die.outcomes() for die in converted_dice))
+185    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+186
+187
+188def align_range(
+189        *dice: 'int | icepool.Die[int]') -> tuple['icepool.Die[int]', ...]:
+190    """Pads dice with zero quantities so that all have the same set of consecutive `int` outcomes.
+191
+192    Args:
+193        *dice: Any number of dice or single outcomes convertible to dice.
+194
+195    Returns:
+196        A tuple of aligned dice.
+197    """
+198    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+199    outcomes = range(icepool.min_outcome(*converted_dice),
+200                     icepool.max_outcome(*converted_dice) + 1)
+201    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+202
+203
+204def commonize_denominator(
+205        *dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+206    """Scale the weights of the dice so that all of them have the same denominator.
+207
+208    Args:
+209        *dice: Any number of dice or single outcomes convertible to dice.
+210
+211    Returns:
+212        A tuple of dice with the same denominator.
+213    """
+214    converted_dice = [
+215        icepool.implicit_convert_to_die(die).simplify() for die in dice
+216    ]
+217    denominator_lcm = math.lcm(
+218        *(die.denominator() for die in converted_dice if die.denominator() > 0))
+219    return tuple(
+220        die.scale_quantities(denominator_lcm //
+221                             die.denominator() if die.denominator() > 0 else 1)
+222        for die in converted_dice)
+223
+224
+225def reduce(func: 'Callable[[T, T], T | icepool.Die[T] | icepool.RerollType]',
+226           dice: 'Iterable[T | icepool.Die[T]]',
+227           *,
+228           initial: 'T | icepool.Die[T] | None' = None) -> 'icepool.Die[T]':
+229    """Applies a function of two arguments cumulatively to a sequence of dice.
+230
+231    Analogous to
+232    [`functools.reduce()`](https://docs.python.org/3/library/functools.html#functools.reduce).
+233
+234    Args:
+235        func: The function to map. The function should take two arguments,
+236            which are an outcome from each of two dice, and produce an outcome
+237            of the same type. It may also return `Reroll`, in which case the
+238            entire sequence is effectively rerolled.
+239        dice: A sequence of dice to map the function to, from left to right.
+240        initial: If provided, this will be placed at the front of the sequence
+241            of dice.
+242        again_depth: Forwarded to the final die constructor.
+243        again_end: Forwarded to the final die constructor.
+244    """
+245    # Conversion to dice is not necessary since map() takes care of that.
+246    iter_dice = iter(dice)
+247    if initial is not None:
+248        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+249    else:
+250        result = icepool.implicit_convert_to_die(next(iter_dice))
+251    for die in iter_dice:
+252        result = map(func, result, die)
+253    return result
+254
+255
+256def accumulate(
+257        func: 'Callable[[T, T], T | icepool.Die[T]]',
+258        dice: 'Iterable[T | icepool.Die[T]]',
+259        *,
+260        initial: 'T | icepool.Die[T] | None' = None
+261) -> Iterator['icepool.Die[T]']:
+262    """Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.
+263
+264    Analogous to
+265    [`itertools.accumulate()`](https://docs.python.org/3/library/itertools.html#itertools.accumulate)
+266    , though with no default function and
+267    the same parameter order as `reduce()`.
+268
+269    The number of results is equal to the number of elements of `dice`, with
+270    one additional element if `initial` is provided.
+271
+272    Args:
+273        func: The function to map. The function should take two arguments,
+274            which are an outcome from each of two dice.
+275        dice: A sequence of dice to map the function to, from left to right.
+276        initial: If provided, this will be placed at the front of the sequence
+277            of dice.
+278    """
+279    # Conversion to dice is not necessary since map() takes care of that.
+280    iter_dice = iter(dice)
+281    if initial is not None:
+282        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+283    else:
+284        try:
+285            result = icepool.implicit_convert_to_die(next(iter_dice))
+286        except StopIteration:
+287            return
+288    yield result
+289    for die in iter_dice:
+290        result = map(func, result, die)
+291        yield result
+292
+293
+294def iter_cartesian_product(
+295    *args: 'Outcome | icepool.Population | icepool.MultisetExpression'
+296) -> Iterator[tuple[tuple, int]]:
+297    """Yields the independent joint distribution of the arguments.
+298
+299    Args:
+300        *args: These may be dice, which will be expanded into their joint
+301            outcomes. Non-dice are left as-is.
+302
+303    Yields:
+304        Tuples containing one outcome per arg and the joint quantity.
+305    """
+306
+307    def arg_items(arg) -> Sequence[tuple[Any, int]]:
+308        if isinstance(arg, icepool.Population):
+309            return arg.items()
+310        elif isinstance(arg, icepool.MultisetExpression):
+311            if arg._free_arity() > 0:
+312                raise ValueError('Expression must be fully bound.')
+313            # Expression evaluators are difficult to type.
+314            return arg.expand().items()  # type: ignore
+315        else:
+316            return [(arg, 1)]
+317
+318    for t in itertools.product(*(arg_items(arg) for arg in args)):
+319        outcomes, quantities = zip(*t)
+320        final_quantity = math.prod(quantities)
+321        yield outcomes, final_quantity
+322
+323def _canonicalize_transition_function(repl:
+324    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+325    arg_count: int,
+326    star: bool | None) -> 'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]':
+327    if callable(repl):
+328        if star is None:
+329            star = guess_star(repl, arg_count)
+330        if star:
+331            func = cast(Callable, repl)
+332            return lambda o, *extra_args: func(*o, *extra_args)
+333        else:
+334            return repl
+335    elif isinstance(repl, Mapping):
+336        if arg_count != 1:
+337            raise ValueError('If a mapping is provided for repl, len(args) must be 1.')
+338        mapping = cast(Mapping, repl)
+339        return lambda o: mapping.get(o, o)
+340    else:
+341        raise TypeError('repl must be a callable or a mapping.')
+342
+343def map(
+344    repl:
+345    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+346    /,
+347    *args: 'Outcome | icepool.Die | icepool.MultisetExpression',
+348    star: bool | None = None,
+349    repeat: int | None = 1,
+350    again_depth: int = 1,
+351    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+352) -> 'icepool.Die[T]':
+353    """Applies `func(outcome_of_die_0, outcome_of_die_1, ...)` for all joint outcomes.
+354
+355    See `map_function` for a decorator version of this.
+356
+357    Example: `map(lambda a, b: a + b, d6, d6)` is the same as d6 + d6.
+358
+359    `map()` is flexible but not very efficient for more than a few dice.
+360    If at all possible, use `reduce()`, `MultisetExpression` methods, and/or
+361    `MultisetEvaluator`s. Even `Pool.expand()` (which sorts rolls) is more
+362    efficient than using `map` on the dice in order.
+363
+364    `Again` can be used but is not recommended with `repeat` other than 1.
+365    It will re-roll the current stage, not the entire series.
+366
+367    Args:
+368        repl: One of the following:
+369            * A callable that takes in one outcome per element of args and
+370                produces a new outcome.
+371            * A mapping from old outcomes to new outcomes.
+372                Unmapped old outcomes stay the same.
+373                In this case args must have exactly one element.
+374            The new outcomes may be dice rather than just single outcomes.
+375            The special value `icepool.Reroll` will reroll that old outcome.
+376        *args: `func` will be called with all joint outcomes of these.
+377            Allowed arg types are:
+378            * Single outcome.
+379            * `Die`. All outcomes will be sent to `func`.
+380            * `MultisetExpression`. All sorted tuples of outcomes will be sent
+381                to `func`, as `MultisetExpression.expand()`. The expression must
+382                be fully bound.
+383        star: If `True`, the first of the args will be unpacked before giving
+384            them to `func`.
+385            If not provided, it will be guessed based on the signature of `func`
+386            and the number of arguments.
+387        repeat: This will be repeated with the same arguments on the
+388            result this many times, except the first of args will be replaced
+389            by the result of the previous iteration.
+390
+391            EXPERIMENTAL: If set to `None`, the result will be as if this
+392            were repeated an infinite number of times. In this case, the
+393            result will be in simplest form.
+394        again_depth: Forwarded to the final die constructor.
+395        again_end: Forwarded to the final die constructor.
+396    """
+397    transition_function = _canonicalize_transition_function(repl, len(args), star)
+398
+399    if len(args) == 0:
+400        if repeat != 1:
+401            raise ValueError('If no arguments are given, repeat must be 1.')
+402        return icepool.Die([transition_function()], again_depth=again_depth, again_end=again_end)
+403
+404    # Here len(args) is at least 1.
+405
+406    first_arg = args[0]
+407    extra_args = args[1:]
+408
+409    if repeat is not None:
+410        if repeat < 0:
+411            raise ValueError('repeat cannot be negative.')
+412        elif repeat == 0:
+413            return icepool.Die([first_arg])
+414        elif repeat == 1:
+415            final_outcomes: 'list[T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]' = []
+416            final_quantities: list[int] = []
+417            for outcomes, final_quantity in iter_cartesian_product(*args):
+418                final_outcome = transition_function(*outcomes)
+419                if final_outcome is not icepool.Reroll:
+420                    final_outcomes.append(final_outcome)
+421                    final_quantities.append(final_quantity)
+422            return icepool.Die(final_outcomes,
+423                       final_quantities,
+424                       again_depth=again_depth,
+425                       again_end=again_end)
+426        else:
+427            result: 'icepool.Die[T]' = icepool.Die([first_arg])
+428            for _ in range(repeat):
+429                result = icepool.map(transition_function,
+430                                     result, *extra_args,
+431                                     star=False,
+432                                     again_depth=again_depth,
+433                                     again_end=again_end)
+434            return result
+435    else:
+436        # Infinite repeat.
+437        # T_co and U should be the same in this case.
+438        def unary_transition_function(state):
+439            return map(transition_function, state, *extra_args, star=False, again_depth=again_depth, again_end=again_end)
+440        return icepool.population.markov_chain.absorbing_markov_chain(icepool.Die([args[0]]), unary_transition_function)
+441
+442
+443@overload
+444def map_function(
+445        func:
+446    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+447        /) -> 'Callable[..., icepool.Die[T]]':
+448    ...
+449
+450
+451@overload
+452def map_function(
+453    func: None,
+454    /,
+455    *,
+456    star: bool | None = None,
+457    repeat: int | None = 1,
+458    again_depth: int = 1,
+459    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+460) -> 'Callable[..., Callable[..., icepool.Die[T]]]':
+461    ...
+462
+463
+464@overload
+465def map_function(
+466    func:
+467    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | None' = None,
+468    /,
+469    *,
+470    star: bool | None = None,
+471    repeat: int | None = 1,
+472    again_depth: int = 1,
+473    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+474) -> 'Callable[..., icepool.Die[T]] | Callable[..., Callable[..., icepool.Die[T]]]':
+475    ...
+476
+477
+478def map_function(
+479    func:
+480    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | None' = None,
+481    /,
+482    *,
+483    star: bool | None = None,
+484    repeat: int | None = 1,
+485    again_depth: int = 1,
+486    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+487) -> 'Callable[..., icepool.Die[T]] | Callable[..., Callable[..., icepool.Die[T]]]':
+488    """Decorator that turns a function that takes outcomes into a function that takes dice.
+489
+490    The result must be a `Die`.
+491
+492    This is basically a decorator version of `map()` and produces behavior
+493    similar to AnyDice functions, though Icepool has different typing rules
+494    among other differences.
+495
+496    `map_function` can either be used with no arguments:
+497
+498    ```
+499    @map_function
+500    def explode_six(x):
+501        if x == 6:
+502            return 6 + Again
+503        else:
+504            return x
+505
+506    explode_six(d6, again_depth=2)
+507    ```
+508
+509    Or with keyword arguments, in which case the extra arguments are bound:
+510
+511    ```
+512    @map_function(again_depth=2)
+513    def explode_six(x):
+514        if x == 6:
+515            return 6 + Again
+516        else:
+517            return x
+518
+519    explode_six(d6)
+520    ```
+521
+522    Args:
+523        again_depth: Forwarded to the final die constructor.
+524        again_end: Forwarded to the final die constructor.
+525    """
+526
+527    if func is not None:
+528        return update_wrapper(partial(map, func), func)
+529    else:
+530
+531        def decorator(
+532            func:
+533            'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]'
+534        ) -> 'Callable[..., icepool.Die[T]]':
+535
+536            return update_wrapper(
+537                partial(map,
+538                        func,
+539                        star=star,
+540                        repeat=repeat,
+541                        again_depth=again_depth,
+542                        again_end=again_end), func)
+543
+544        return decorator
+545
+546def map_and_time(
+547        repl:
+548    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+549        state,
+550        /,
+551        *extra_args,
+552        star: bool | None = None,
+553        repeat: int) -> 'icepool.Die[tuple[T, int]]':
+554    """Repeatedly map outcomes of the state to other outcomes, while also
+555    counting timesteps.
+556
+557    This is useful for representing processes.
+558
+559    The outcomes of the result are  `(outcome, time)`, where `time` is the
+560    number of repeats needed to reach an absorbing outcome (an outcome that
+561    only leads to itself), or `repeat`, whichever is lesser.
+562
+563    This will return early if it reaches a fixed point.
+564    Therefore, you can set `repeat` equal to the maximum number of
+565    time you could possibly be interested in without worrying about
+566    it causing extra computations after the fixed point.
+567
+568    Args:
+569        repl: One of the following:
+570            * A callable returning a new outcome for each old outcome.
+571            * A mapping from old outcomes to new outcomes.
+572                Unmapped old outcomes stay the same.
+573            The new outcomes may be dice rather than just single outcomes.
+574            The special value `icepool.Reroll` will reroll that old outcome.
+575        star: If `True`, the first of the args will be unpacked before giving
+576            them to `func`.
+577            If not provided, it will be guessed based on the signature of `func`
+578            and the number of arguments.
+579        repeat: This will be repeated with the same arguments on the result
+580            this many times.
+581
+582    Returns:
+583        The `Die` after the modification.
+584    """
+585    transition_function = _canonicalize_transition_function(repl, 1 + len(extra_args), star)
+586
+587    result: 'icepool.Die[tuple[T, int]]' = state.map(lambda x: (x, 0))
+588
+589    def transition_with_steps(outcome_and_steps):
+590        outcome, steps = outcome_and_steps
+591        next_outcome = transition_function(outcome, *extra_args)
+592        if icepool.population.markov_chain.is_absorbing(
+593                outcome, next_outcome):
+594            return outcome, steps
+595        else:
+596            return icepool.tupleize(next_outcome, steps + 1)
+597
+598    for _ in range(repeat):
+599        next_result: 'icepool.Die[tuple[T, int]]' = map(
+600            transition_with_steps, result)
+601        if result == next_result:
+602            return next_result
+603        result = next_result
+604    return result
+
+ + +
+
+ +
+
@cache
+ + def + d(sides: int, /) -> icepool.population.die.Die[int]: + + + +
+ + 
18@cache
+19def d(sides: int, /) -> 'icepool.Die[int]':
+20    """A standard die.
+21
+22    Specifically, the outcomes are `int`s from `1` to `sides` inclusive,
+23    with quantity 1 each.
+24
+25    Don't confuse this with `icepool.Die()`:
+26
+27    * `icepool.Die([6])`: A `Die` that always rolls the integer 6.
+28    * `icepool.d(6)`: A d6.
+29
+30    You can also import individual standard dice from the `icepool` module, e.g.
+31    `from icepool import d6`.
+32    """
+33    if not isinstance(sides, int):
+34        raise TypeError('Argument to standard() must be an int.')
+35    elif sides < 1:
+36        raise ValueError('Standard die must have at least one side.')
+37    return icepool.Die(range(1, sides + 1))
+
+ + +

A standard die.

+ +

Specifically, the outcomes are ints from 1 to sides inclusive, +with quantity 1 each.

+ +

Don't confuse this with icepool.Die():

+ + + +

You can also import individual standard dice from the icepool module, e.g. +from icepool import d6.

+
+ + +
+
+ +
+ + def + coin(n: int, d: int, /) -> icepool.population.die.Die[bool]: + + + +
+ + 
56def coin(n: int, d: int, /) -> 'icepool.Die[bool]':
+57    """A `Die` that rolls `True` with probability `n / d`, and `False` otherwise.
+58
+59    If `n == 0` or `n == d` the result will have only one outcome.
+60    """
+61    data = {}
+62    if n != d:
+63        data[False] = d - n
+64    if n != 0:
+65        data[True] = n
+66    return icepool.Die(data)
+
+ + +

A Die that rolls True with probability n / d, and False otherwise.

+ +

If n == 0 or n == d the result will have only one outcome.

+
+ + +
+
+ +
+ + def + one_hot(sides: int, /) -> icepool.population.die.Die[tuple[bool, ...]]: + + + +
+ + 
69def one_hot(sides: int, /) -> 'icepool.Die[tuple[bool, ...]]':
+70    """A `Die` with `Vector` outcomes with one element set to `True` uniformly at random and the rest `False`.
+71
+72    This is an easy (if somewhat expensive) way of representing how many dice
+73    in a pool rolled each number. For example, the outcomes of `10 @ one_hot(6)`
+74    are the `(ones, twos, threes, fours, fives, sixes)` rolled in 10d6.
+75    """
+76    data = []
+77    for i in range(sides):
+78        outcome = [False] * sides
+79        outcome[i] = True
+80        data.append(icepool.Vector(outcome))
+81    return icepool.Die(data)
+
+ + +

A Die with Vector outcomes with one element set to True uniformly at random and the rest False.

+ +

This is an easy (if somewhat expensive) way of representing how many dice +in a pool rolled each number. For example, the outcomes of 10 @ one_hot(6) +are the (ones, twos, threes, fours, fives, sixes) rolled in 10d6.

+
+ + +
+
+ +
+ + def + from_cumulative( outcomes: Sequence[~T], cumulative: Union[Sequence[int], Sequence[icepool.population.die.Die[bool]]], *, reverse: bool = False) -> icepool.population.die.Die[~T]: + + + +
+ + 
 84def from_cumulative(outcomes: Sequence[T],
+ 85                    cumulative: 'Sequence[int] | Sequence[icepool.Die[bool]]',
+ 86                    *,
+ 87                    reverse: bool = False) -> 'icepool.Die[T]':
+ 88    """Constructs a `Die` from a sequence of cumulative values.
+ 89
+ 90    Args:
+ 91        outcomes: The outcomes of the resulting die. Sorted order is recommended
+ 92            but not necessary.
+ 93        cumulative: The cumulative values (inclusive) of the outcomes in the
+ 94            order they are given to this function. These may be:
+ 95            * `int` cumulative quantities.
+ 96            * Dice representing the cumulative distribution at that point.
+ 97        reverse: Iff true, both of the arguments will be reversed. This allows
+ 98            e.g. constructing using a survival distribution.
+ 99    """
+100    if len(outcomes) == 0:
+101        return icepool.Die({})
+102
+103    if reverse:
+104        outcomes = list(reversed(outcomes))
+105        cumulative = list(reversed(cumulative))  # type: ignore
+106
+107    prev = 0
+108    d = {}
+109
+110    if isinstance(cumulative[0], icepool.Die):
+111        cumulative = commonize_denominator(*cumulative)
+112        for outcome, die in zip(outcomes, cumulative):
+113            d[outcome] = die.quantity_ne(False) - prev
+114            prev = die.quantity_ne(False)
+115    elif isinstance(cumulative[0], int):
+116        cumulative = cast(Sequence[int], cumulative)
+117        for outcome, quantity in zip(outcomes, cumulative):
+118            d[outcome] = quantity - prev
+119            prev = quantity
+120    else:
+121        raise TypeError(
+122            f'Unsupported type {type(cumulative)} for cumulative values.')
+123
+124    return icepool.Die(d)
+
+ + +

Constructs a Die from a sequence of cumulative values.

+ +
Arguments:
+ +
    +
  • outcomes: The outcomes of the resulting die. Sorted order is recommended +but not necessary.
    • +
  • cumulative: The cumulative values (inclusive) of the outcomes in the +order they are given to this function. These may be: +
      +
    • int cumulative quantities.
      • +
    • Dice representing the cumulative distribution at that point.
      • +
    • +
  • reverse: Iff true, both of the arguments will be reversed. This allows +e.g. constructing using a survival distribution.
    • +
+
+ + +
+
+ +
+ + def + from_rv( rv, outcomes: Union[Sequence[int], Sequence[float]], denominator: int, **kwargs) -> icepool.population.die.Die[int] | icepool.population.die.Die[float]: + + + +
+ + 
139def from_rv(rv, outcomes: Sequence[int] | Sequence[float], denominator: int,
+140            **kwargs) -> 'icepool.Die[int] | icepool.Die[float]':
+141    """Constructs a `Die` from a rv object (as `scipy.stats`).
+142    Args:
+143        rv: A rv object (as `scipy.stats`).
+144        outcomes: An iterable of `int`s or `float`s that will be the outcomes
+145            of the resulting `Die`.
+146            If the distribution is discrete, outcomes must be `int`s.
+147        denominator: The denominator of the resulting `Die` will be set to this.
+148        **kwargs: These will be forwarded to `rv.cdf()`.
+149    """
+150    if hasattr(rv, 'pdf'):
+151        # Continuous distributions use midpoints.
+152        midpoints = [(a + b) / 2 for a, b in zip(outcomes[:-1], outcomes[1:])]
+153        cdf = rv.cdf(midpoints, **kwargs)
+154        quantities_le = tuple(
+155            int(round(x * denominator)) for x in cdf) + (denominator,)
+156    else:
+157        cdf = rv.cdf(outcomes, **kwargs)
+158        quantities_le = tuple(int(round(x * denominator)) for x in cdf)
+159    return from_cumulative(outcomes, quantities_le)
+
+ + +

Constructs a Die from a rv object (as scipy.stats).

+ +
Arguments:
+ +
    +
  • rv: A rv object (as scipy.stats).
    • +
  • outcomes: An iterable of ints or floats that will be the outcomes +of the resulting Die. +If the distribution is discrete, outcomes must be ints.
    • +
  • denominator: The denominator of the resulting Die will be set to this.
    • +
  • **kwargs: These will be forwarded to rv.cdf().
    • +
+
+ + +
+
+ +
+ + def + min_outcome(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T: + + + +
+ + 
162def min_outcome(*dice: 'T | icepool.Die[T]') -> T:
+163    """The minimum outcome among the dice. """
+164    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+165    return min(die.outcomes()[0] for die in converted_dice)
+
+ + +

The minimum outcome among the dice.

+
+ + +
+
+ +
+ + def + max_outcome(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T: + + + +
+ + 
168def max_outcome(*dice: 'T | icepool.Die[T]') -> T:
+169    """The maximum outcome among the dice. """
+170    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+171    return max(die.outcomes()[-1] for die in converted_dice)
+
+ + +

The maximum outcome among the dice.

+
+ + +
+
+ +
+ + def + align( *dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]: + + + +
+ + 
174def align(*dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+175    """Pads dice with zero quantities so that all have the same set of outcomes.
+176
+177    Args:
+178        *dice: Any number of dice or single outcomes convertible to dice.
+179
+180    Returns:
+181        A tuple of aligned dice.
+182    """
+183    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+184    outcomes = set(
+185        itertools.chain.from_iterable(die.outcomes() for die in converted_dice))
+186    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+
+ + +

Pads dice with zero quantities so that all have the same set of outcomes.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of aligned dice.

+
+
+ + +
+
+ +
+ + def + align_range( *dice: int | icepool.population.die.Die[int]) -> tuple[icepool.population.die.Die[int], ...]: + + + +
+ + 
189def align_range(
+190        *dice: 'int | icepool.Die[int]') -> tuple['icepool.Die[int]', ...]:
+191    """Pads dice with zero quantities so that all have the same set of consecutive `int` outcomes.
+192
+193    Args:
+194        *dice: Any number of dice or single outcomes convertible to dice.
+195
+196    Returns:
+197        A tuple of aligned dice.
+198    """
+199    converted_dice = [icepool.implicit_convert_to_die(die) for die in dice]
+200    outcomes = range(icepool.min_outcome(*converted_dice),
+201                     icepool.max_outcome(*converted_dice) + 1)
+202    return tuple(die.set_outcomes(outcomes) for die in converted_dice)
+
+ + +

Pads dice with zero quantities so that all have the same set of consecutive int outcomes.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of aligned dice.

+
+
+ + +
+
+ +
+ + def + commonize_denominator( *dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]: + + + +
+ + 
205def commonize_denominator(
+206        *dice: 'T | icepool.Die[T]') -> tuple['icepool.Die[T]', ...]:
+207    """Scale the weights of the dice so that all of them have the same denominator.
+208
+209    Args:
+210        *dice: Any number of dice or single outcomes convertible to dice.
+211
+212    Returns:
+213        A tuple of dice with the same denominator.
+214    """
+215    converted_dice = [
+216        icepool.implicit_convert_to_die(die).simplify() for die in dice
+217    ]
+218    denominator_lcm = math.lcm(
+219        *(die.denominator() for die in converted_dice if die.denominator() > 0))
+220    return tuple(
+221        die.scale_quantities(denominator_lcm //
+222                             die.denominator() if die.denominator() > 0 else 1)
+223        for die in converted_dice)
+
+ + +

Scale the weights of the dice so that all of them have the same denominator.

+ +
Arguments:
+ +
    +
  • *dice: Any number of dice or single outcomes convertible to dice.
    • +
+ +
Returns:
+ +
+

A tuple of dice with the same denominator.

+
+
+ + +
+
+ +
+ + def + reduce( func: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType]], dice: Iterable[Union[~T, icepool.population.die.Die[~T]]], *, initial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> icepool.population.die.Die[~T]: + + + +
+ + 
226def reduce(func: 'Callable[[T, T], T | icepool.Die[T] | icepool.RerollType]',
+227           dice: 'Iterable[T | icepool.Die[T]]',
+228           *,
+229           initial: 'T | icepool.Die[T] | None' = None) -> 'icepool.Die[T]':
+230    """Applies a function of two arguments cumulatively to a sequence of dice.
+231
+232    Analogous to
+233    [`functools.reduce()`](https://docs.python.org/3/library/functools.html#functools.reduce).
+234
+235    Args:
+236        func: The function to map. The function should take two arguments,
+237            which are an outcome from each of two dice, and produce an outcome
+238            of the same type. It may also return `Reroll`, in which case the
+239            entire sequence is effectively rerolled.
+240        dice: A sequence of dice to map the function to, from left to right.
+241        initial: If provided, this will be placed at the front of the sequence
+242            of dice.
+243        again_depth: Forwarded to the final die constructor.
+244        again_end: Forwarded to the final die constructor.
+245    """
+246    # Conversion to dice is not necessary since map() takes care of that.
+247    iter_dice = iter(dice)
+248    if initial is not None:
+249        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+250    else:
+251        result = icepool.implicit_convert_to_die(next(iter_dice))
+252    for die in iter_dice:
+253        result = map(func, result, die)
+254    return result
+
+ + +

Applies a function of two arguments cumulatively to a sequence of dice.

+ +

Analogous to +icepool.reduce">functools.reduce().

+ +
Arguments:
+ +
    +
  • func: The function to map. The function should take two arguments, +which are an outcome from each of two dice, and produce an outcome +of the same type. It may also return Reroll, in which case the +entire sequence is effectively rerolled.
    • +
  • dice: A sequence of dice to map the function to, from left to right.
    • +
  • initial: If provided, this will be placed at the front of the sequence +of dice.
    • +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + accumulate( func: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T]]], dice: Iterable[Union[~T, icepool.population.die.Die[~T]]], *, initial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> Iterator[icepool.population.die.Die[~T]]: + + + +
+ + 
257def accumulate(
+258        func: 'Callable[[T, T], T | icepool.Die[T]]',
+259        dice: 'Iterable[T | icepool.Die[T]]',
+260        *,
+261        initial: 'T | icepool.Die[T] | None' = None
+262) -> Iterator['icepool.Die[T]']:
+263    """Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.
+264
+265    Analogous to
+266    [`itertools.accumulate()`](https://docs.python.org/3/library/itertools.html#itertools.accumulate)
+267    , though with no default function and
+268    the same parameter order as `reduce()`.
+269
+270    The number of results is equal to the number of elements of `dice`, with
+271    one additional element if `initial` is provided.
+272
+273    Args:
+274        func: The function to map. The function should take two arguments,
+275            which are an outcome from each of two dice.
+276        dice: A sequence of dice to map the function to, from left to right.
+277        initial: If provided, this will be placed at the front of the sequence
+278            of dice.
+279    """
+280    # Conversion to dice is not necessary since map() takes care of that.
+281    iter_dice = iter(dice)
+282    if initial is not None:
+283        result: 'icepool.Die[T]' = icepool.implicit_convert_to_die(initial)
+284    else:
+285        try:
+286            result = icepool.implicit_convert_to_die(next(iter_dice))
+287        except StopIteration:
+288            return
+289    yield result
+290    for die in iter_dice:
+291        result = map(func, result, die)
+292        yield result
+
+ + +

Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.

+ +

Analogous to +icepool.accumulate">itertools.accumulate() +, though with no default function and +the same parameter order as reduce().

+ +

The number of results is equal to the number of elements of dice, with +one additional element if initial is provided.

+ +
Arguments:
+ +
    +
  • func: The function to map. The function should take two arguments, +which are an outcome from each of two dice.
    • +
  • dice: A sequence of dice to map the function to, from left to right.
    • +
  • initial: If provided, this will be placed at the front of the sequence +of dice.
    • +
+
+ + +
+
+ +
+ + def + iter_cartesian_product( *args: icepool.typing.Outcome | icepool.population.base.Population | icepool.expression.multiset_expression.MultisetExpression) -> Iterator[tuple[tuple, int]]: + + + +
+ + 
295def iter_cartesian_product(
+296    *args: 'Outcome | icepool.Population | icepool.MultisetExpression'
+297) -> Iterator[tuple[tuple, int]]:
+298    """Yields the independent joint distribution of the arguments.
+299
+300    Args:
+301        *args: These may be dice, which will be expanded into their joint
+302            outcomes. Non-dice are left as-is.
+303
+304    Yields:
+305        Tuples containing one outcome per arg and the joint quantity.
+306    """
+307
+308    def arg_items(arg) -> Sequence[tuple[Any, int]]:
+309        if isinstance(arg, icepool.Population):
+310            return arg.items()
+311        elif isinstance(arg, icepool.MultisetExpression):
+312            if arg._free_arity() > 0:
+313                raise ValueError('Expression must be fully bound.')
+314            # Expression evaluators are difficult to type.
+315            return arg.expand().items()  # type: ignore
+316        else:
+317            return [(arg, 1)]
+318
+319    for t in itertools.product(*(arg_items(arg) for arg in args)):
+320        outcomes, quantities = zip(*t)
+321        final_quantity = math.prod(quantities)
+322        yield outcomes, final_quantity
+
+ + +

Yields the independent joint distribution of the arguments.

+ +
Arguments:
+ +
    +
  • *args: These may be dice, which will be expanded into their joint +outcomes. Non-dice are left as-is.
    • +
+ +
Yields:
+ +
+

Tuples containing one outcome per arg and the joint quantity.

+
+
+ + +
+
+ +
+ + def + map( repl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]], /, *args: icepool.typing.Outcome | icepool.population.die.Die | icepool.expression.multiset_expression.MultisetExpression, star: bool | None = None, repeat: int | None = 1, again_depth: int = 1, again_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> icepool.population.die.Die[~T]: + + + +
+ + 
344def map(
+345    repl:
+346    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+347    /,
+348    *args: 'Outcome | icepool.Die | icepool.MultisetExpression',
+349    star: bool | None = None,
+350    repeat: int | None = 1,
+351    again_depth: int = 1,
+352    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+353) -> 'icepool.Die[T]':
+354    """Applies `func(outcome_of_die_0, outcome_of_die_1, ...)` for all joint outcomes.
+355
+356    See `map_function` for a decorator version of this.
+357
+358    Example: `map(lambda a, b: a + b, d6, d6)` is the same as d6 + d6.
+359
+360    `map()` is flexible but not very efficient for more than a few dice.
+361    If at all possible, use `reduce()`, `MultisetExpression` methods, and/or
+362    `MultisetEvaluator`s. Even `Pool.expand()` (which sorts rolls) is more
+363    efficient than using `map` on the dice in order.
+364
+365    `Again` can be used but is not recommended with `repeat` other than 1.
+366    It will re-roll the current stage, not the entire series.
+367
+368    Args:
+369        repl: One of the following:
+370            * A callable that takes in one outcome per element of args and
+371                produces a new outcome.
+372            * A mapping from old outcomes to new outcomes.
+373                Unmapped old outcomes stay the same.
+374                In this case args must have exactly one element.
+375            The new outcomes may be dice rather than just single outcomes.
+376            The special value `icepool.Reroll` will reroll that old outcome.
+377        *args: `func` will be called with all joint outcomes of these.
+378            Allowed arg types are:
+379            * Single outcome.
+380            * `Die`. All outcomes will be sent to `func`.
+381            * `MultisetExpression`. All sorted tuples of outcomes will be sent
+382                to `func`, as `MultisetExpression.expand()`. The expression must
+383                be fully bound.
+384        star: If `True`, the first of the args will be unpacked before giving
+385            them to `func`.
+386            If not provided, it will be guessed based on the signature of `func`
+387            and the number of arguments.
+388        repeat: This will be repeated with the same arguments on the
+389            result this many times, except the first of args will be replaced
+390            by the result of the previous iteration.
+391
+392            EXPERIMENTAL: If set to `None`, the result will be as if this
+393            were repeated an infinite number of times. In this case, the
+394            result will be in simplest form.
+395        again_depth: Forwarded to the final die constructor.
+396        again_end: Forwarded to the final die constructor.
+397    """
+398    transition_function = _canonicalize_transition_function(repl, len(args), star)
+399
+400    if len(args) == 0:
+401        if repeat != 1:
+402            raise ValueError('If no arguments are given, repeat must be 1.')
+403        return icepool.Die([transition_function()], again_depth=again_depth, again_end=again_end)
+404
+405    # Here len(args) is at least 1.
+406
+407    first_arg = args[0]
+408    extra_args = args[1:]
+409
+410    if repeat is not None:
+411        if repeat < 0:
+412            raise ValueError('repeat cannot be negative.')
+413        elif repeat == 0:
+414            return icepool.Die([first_arg])
+415        elif repeat == 1:
+416            final_outcomes: 'list[T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]' = []
+417            final_quantities: list[int] = []
+418            for outcomes, final_quantity in iter_cartesian_product(*args):
+419                final_outcome = transition_function(*outcomes)
+420                if final_outcome is not icepool.Reroll:
+421                    final_outcomes.append(final_outcome)
+422                    final_quantities.append(final_quantity)
+423            return icepool.Die(final_outcomes,
+424                       final_quantities,
+425                       again_depth=again_depth,
+426                       again_end=again_end)
+427        else:
+428            result: 'icepool.Die[T]' = icepool.Die([first_arg])
+429            for _ in range(repeat):
+430                result = icepool.map(transition_function,
+431                                     result, *extra_args,
+432                                     star=False,
+433                                     again_depth=again_depth,
+434                                     again_end=again_end)
+435            return result
+436    else:
+437        # Infinite repeat.
+438        # T_co and U should be the same in this case.
+439        def unary_transition_function(state):
+440            return map(transition_function, state, *extra_args, star=False, again_depth=again_depth, again_end=again_end)
+441        return icepool.population.markov_chain.absorbing_markov_chain(icepool.Die([args[0]]), unary_transition_function)
+
+ + +

Applies func(outcome_of_die_0, outcome_of_die_1, ...) for all joint outcomes.

+ +

See map_function for a decorator version of this.

+ +

Example: map(lambda a, b: a + b, d6, d6) is the same as d6 + d6.

+ +

map() is flexible but not very efficient for more than a few dice. +If at all possible, use reduce(), MultisetExpression methods, and/or +MultisetEvaluators. Even Pool.expand() (which sorts rolls) is more +efficient than using map on the dice in order.

+ +

Again can be used but is not recommended with repeat other than 1. +It will re-roll the current stage, not the entire series.

+ +
Arguments:
+ +
    +
  • repl: One of the following: +
      +
    • A callable that takes in one outcome per element of args and +produces a new outcome.
      • +
    • A mapping from old outcomes to new outcomes. +Unmapped old outcomes stay the same. +In this case args must have exactly one element. +The new outcomes may be dice rather than just single outcomes. +The special value icepool.Reroll will reroll that old outcome.
      • +
    • +
  • *args: func will be called with all joint outcomes of these. +Allowed arg types are: +
      +
    • Single outcome.
      • +
    • Die. All outcomes will be sent to func.
      • +
    • MultisetExpression. All sorted tuples of outcomes will be sent +to func, as MultisetExpression.expand(). The expression must +be fully bound.
      • +
    • +
  • star: If True, the first of the args will be unpacked before giving +them to func. +If not provided, it will be guessed based on the signature of func +and the number of arguments.
    • +

  • repeat: This will be repeated with the same arguments on the +result this many times, except the first of args will be replaced +by the result of the previous iteration.

    + +

    EXPERIMENTAL: If set to None, the result will be as if this +were repeated an infinite number of times. In this case, the +result will be in simplest form.

    • +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + map_function( func: Optional[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]] = None, /, *, star: bool | None = None, repeat: int | None = 1, again_depth: int = 1, again_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> Union[Callable[..., icepool.population.die.Die[~T]], Callable[..., Callable[..., icepool.population.die.Die[~T]]]]: + + + +
+ + 
479def map_function(
+480    func:
+481    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | None' = None,
+482    /,
+483    *,
+484    star: bool | None = None,
+485    repeat: int | None = 1,
+486    again_depth: int = 1,
+487    again_end: 'T | icepool.Die[T] | icepool.RerollType | None' = None
+488) -> 'Callable[..., icepool.Die[T]] | Callable[..., Callable[..., icepool.Die[T]]]':
+489    """Decorator that turns a function that takes outcomes into a function that takes dice.
+490
+491    The result must be a `Die`.
+492
+493    This is basically a decorator version of `map()` and produces behavior
+494    similar to AnyDice functions, though Icepool has different typing rules
+495    among other differences.
+496
+497    `map_function` can either be used with no arguments:
+498
+499    ```
+500    @map_function
+501    def explode_six(x):
+502        if x == 6:
+503            return 6 + Again
+504        else:
+505            return x
+506
+507    explode_six(d6, again_depth=2)
+508    ```
+509
+510    Or with keyword arguments, in which case the extra arguments are bound:
+511
+512    ```
+513    @map_function(again_depth=2)
+514    def explode_six(x):
+515        if x == 6:
+516            return 6 + Again
+517        else:
+518            return x
+519
+520    explode_six(d6)
+521    ```
+522
+523    Args:
+524        again_depth: Forwarded to the final die constructor.
+525        again_end: Forwarded to the final die constructor.
+526    """
+527
+528    if func is not None:
+529        return update_wrapper(partial(map, func), func)
+530    else:
+531
+532        def decorator(
+533            func:
+534            'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]'
+535        ) -> 'Callable[..., icepool.Die[T]]':
+536
+537            return update_wrapper(
+538                partial(map,
+539                        func,
+540                        star=star,
+541                        repeat=repeat,
+542                        again_depth=again_depth,
+543                        again_end=again_end), func)
+544
+545        return decorator
+
+ + +

Decorator that turns a function that takes outcomes into a function that takes dice.

+ +

The result must be a Die.

+ +

This is basically a decorator version of map() and produces behavior +similar to AnyDice functions, though Icepool has different typing rules +among other differences.

+ +

map_function can either be used with no arguments:

+ +
@map_function
+def explode_six(x):
+    if x == 6:
+        return 6 + Again
+    else:
+        return x
+
+explode_six(d6, again_depth=2)
+
+ +

Or with keyword arguments, in which case the extra arguments are bound:

+ +
@map_function(again_depth=2)
+def explode_six(x):
+    if x == 6:
+        return 6 + Again
+    else:
+        return x
+
+explode_six(d6)
+
+ +
Arguments:
+ +
    +
  • again_depth: Forwarded to the final die constructor.
    • +
  • again_end: Forwarded to the final die constructor.
    • +
+
+ + +
+
+ +
+ + def + map_and_time( repl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]], state, /, *extra_args, star: bool | None = None, repeat: int) -> icepool.population.die.Die[tuple[~T, int]]: + + + +
+ + 
547def map_and_time(
+548        repl:
+549    'Callable[..., T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression] | Mapping[Any, T | icepool.Die[T] | icepool.RerollType | icepool.AgainExpression]',
+550        state,
+551        /,
+552        *extra_args,
+553        star: bool | None = None,
+554        repeat: int) -> 'icepool.Die[tuple[T, int]]':
+555    """Repeatedly map outcomes of the state to other outcomes, while also
+556    counting timesteps.
+557
+558    This is useful for representing processes.
+559
+560    The outcomes of the result are  `(outcome, time)`, where `time` is the
+561    number of repeats needed to reach an absorbing outcome (an outcome that
+562    only leads to itself), or `repeat`, whichever is lesser.
+563
+564    This will return early if it reaches a fixed point.
+565    Therefore, you can set `repeat` equal to the maximum number of
+566    time you could possibly be interested in without worrying about
+567    it causing extra computations after the fixed point.
+568
+569    Args:
+570        repl: One of the following:
+571            * A callable returning a new outcome for each old outcome.
+572            * A mapping from old outcomes to new outcomes.
+573                Unmapped old outcomes stay the same.
+574            The new outcomes may be dice rather than just single outcomes.
+575            The special value `icepool.Reroll` will reroll that old outcome.
+576        star: If `True`, the first of the args will be unpacked before giving
+577            them to `func`.
+578            If not provided, it will be guessed based on the signature of `func`
+579            and the number of arguments.
+580        repeat: This will be repeated with the same arguments on the result
+581            this many times.
+582
+583    Returns:
+584        The `Die` after the modification.
+585    """
+586    transition_function = _canonicalize_transition_function(repl, 1 + len(extra_args), star)
+587
+588    result: 'icepool.Die[tuple[T, int]]' = state.map(lambda x: (x, 0))
+589
+590    def transition_with_steps(outcome_and_steps):
+591        outcome, steps = outcome_and_steps
+592        next_outcome = transition_function(outcome, *extra_args)
+593        if icepool.population.markov_chain.is_absorbing(
+594                outcome, next_outcome):
+595            return outcome, steps
+596        else:
+597            return icepool.tupleize(next_outcome, steps + 1)
+598
+599    for _ in range(repeat):
+600        next_result: 'icepool.Die[tuple[T, int]]' = map(
+601            transition_with_steps, result)
+602        if result == next_result:
+603            return next_result
+604        result = next_result
+605    return result
+
+ + +

Repeatedly map outcomes of the state to other outcomes, while also +counting timesteps.

+ +

This is useful for representing processes.

+ +

The outcomes of the result are (outcome, time), where time is the +number of repeats needed to reach an absorbing outcome (an outcome that +only leads to itself), or repeat, whichever is lesser.

+ +

This will return early if it reaches a fixed point. +Therefore, you can set repeat equal to the maximum number of +time you could possibly be interested in without worrying about +it causing extra computations after the fixed point.

+ +
Arguments:
+ +
    +
  • repl: One of the following: +
      +
    • A callable returning a new outcome for each old outcome.
      • +
    • A mapping from old outcomes to new outcomes. +Unmapped old outcomes stay the same. +The new outcomes may be dice rather than just single outcomes. +The special value icepool.Reroll will reroll that old outcome.
      • +
    • +
  • star: If True, the first of the args will be unpacked before giving +them to func. +If not provided, it will be guessed based on the signature of func +and the number of arguments.
    • +
  • repeat: This will be repeated with the same arguments on the result +this many times.
    • +
+ +
Returns:
+ +
+

The Die after the modification.

+
+
+ + +
+
+ + \ No newline at end of file diff --git a/apidoc/v1.1.1/icepool/typing.html b/apidoc/v1.1.1/icepool/typing.html new file mode 100644 index 00000000..3c1c9e2c --- /dev/null +++ b/apidoc/v1.1.1/icepool/typing.html @@ -0,0 +1,828 @@ + + + + + + + icepool.typing API documentation + + + + + + + + + + +
+
+

+icepool.typing

+ + + + + + + 
  1__docformat__ = 'google'
+  2
+  3import enum
+  4import inspect
+  5
+  6from typing import Any, Callable, Hashable, Iterable, Literal, Mapping, Protocol, Sequence, Sized, TypeAlias, TypeGuard, TypeVar, TYPE_CHECKING
+  7
+  8if TYPE_CHECKING:
+  9    from icepool.expression.multiset_expression import MultisetExpression
+ 10
+ 11S = TypeVar('S', bound='Sequence')
+ 12"""A sequence type."""
+ 13
+ 14T = TypeVar('T', bound='Outcome')
+ 15"""An outcome type."""
+ 16
+ 17T_co = TypeVar('T_co', bound='Outcome', covariant=True)
+ 18"""An outcome type."""
+ 19
+ 20T_contra = TypeVar('T_contra', bound='Outcome', contravariant=True)
+ 21"""An outcome type."""
+ 22
+ 23U = TypeVar('U', bound='Outcome')
+ 24"""Another outcome type."""
+ 25
+ 26U_co = TypeVar('U_co', bound='Outcome', covariant=True)
+ 27"""Another outcome type."""
+ 28
+ 29Qs = TypeVar('Qs', bound=tuple[int, ...])
+ 30"""A tuple of count types. In this future this may be replaced with a TypeVarTuple."""
+ 31
+ 32
+ 33class Order(enum.IntEnum):
+ 34    """Can be used to define what order outcomes are seen in by MultisetEvaluators."""
+ 35    Ascending = 1
+ 36    Descending = -1
+ 37    Any = 0
+ 38
+ 39    def merge(*orders: 'Order') -> 'Order':
+ 40        """Merges the given Orders.
+ 41
+ 42        Returns:
+ 43            `Any` if all arguments are `Any`.
+ 44            `Ascending` if there is at least one `Ascending` in the arguments.
+ 45            `Descending` if there is at least one `Descending` in the arguments.
+ 46
+ 47        Raises:
+ 48            `ValueError` if both `Ascending` and `Descending` are in the
+ 49            arguments.
+ 50        """
+ 51        result = Order.Any
+ 52        for order in orders:
+ 53            if (result > 0 and order < 0) or (result < 0 and order > 0):
+ 54                raise ValueError(f'Conflicting orders {orders}.')
+ 55            if result == Order.Any:
+ 56                result = order
+ 57        return result
+ 58
+ 59
+ 60class RerollType(enum.Enum):
+ 61    """The type of the Reroll singleton."""
+ 62    Reroll = 'Reroll'
+ 63    """Indicates an outcome should be rerolled (with unlimited depth)."""
+ 64
+ 65
+ 66class Outcome(Hashable, Protocol[T_contra]):
+ 67    """Protocol to attempt to verify that outcome types are hashable and sortable.
+ 68
+ 69    Far from foolproof, e.g. it cannot enforce total ordering.
+ 70    """
+ 71
+ 72    def __lt__(self, other: T_contra) -> bool:
+ 73        ...
+ 74
+ 75def count_positional_parameters(function: Callable) -> tuple[int, int | None]:
+ 76    """Counts the number of positional parameters of the callable.
+ 77
+ 78    Returns:
+ 79        Two `int`s. The first is the number of required positional arguments;
+ 80        the second is total number of positional arguments, or `None` if there
+ 81        is a variadic `*args`.
+ 82    """
+ 83    required = 0
+ 84    total = 0
+ 85    parameters = inspect.signature(function, follow_wrapped=False).parameters
+ 86    for parameter in parameters.values():
+ 87        match parameter.kind:
+ 88            case inspect.Parameter.POSITIONAL_ONLY | inspect.Parameter.POSITIONAL_OR_KEYWORD:
+ 89                total += 1
+ 90                if parameter.default == inspect.Parameter.empty:
+ 91                    required += 1
+ 92            case inspect.Parameter.VAR_POSITIONAL:
+ 93                return required, None
+ 94            case _:
+ 95                break
+ 96    return required, total
+ 97
+ 98def guess_star(function, arg_count=1) -> bool:
+ 99    """Guesses whether the first argument should be unpacked before giving it to the function.
+100
+101    Args:
+102        arg_count: The number of arguments that will be provided to the function.
+103    """
+104    try:
+105        required_count, _ = count_positional_parameters(function)
+106    except ValueError:
+107        raise ValueError(f'Could not guess whether to unpack the first argument to the function.\n'
+108                         'You may need to specify `star` explicitly.')
+109    return required_count > arg_count
+
+ + +
+
+
+ S = +~S + + +
+ + +

A sequence type.

+
+ + +
+
+
+ T = +~T + + +
+ + +

An outcome type.

+
+ + +
+
+
+ T_co = ++T_co + + +
+ + +

An outcome type.

+
+ + +
+
+
+ T_contra = +-T_contra + + +
+ + +

An outcome type.

+
+ + +
+
+
+ U = +~U + + +
+ + +

Another outcome type.

+
+ + +
+
+
+ U_co = ++U_co + + +
+ + +

Another outcome type.

+
+ + +
+
+
+ Qs = +~Qs + + +
+ + +

A tuple of count types. In this future this may be replaced with a TypeVarTuple.

+
+ + +
+
+ +
+ + class + Order(enum.IntEnum): + + + +
+ + 
34class Order(enum.IntEnum):
+35    """Can be used to define what order outcomes are seen in by MultisetEvaluators."""
+36    Ascending = 1
+37    Descending = -1
+38    Any = 0
+39
+40    def merge(*orders: 'Order') -> 'Order':
+41        """Merges the given Orders.
+42
+43        Returns:
+44            `Any` if all arguments are `Any`.
+45            `Ascending` if there is at least one `Ascending` in the arguments.
+46            `Descending` if there is at least one `Descending` in the arguments.
+47
+48        Raises:
+49            `ValueError` if both `Ascending` and `Descending` are in the
+50            arguments.
+51        """
+52        result = Order.Any
+53        for order in orders:
+54            if (result > 0 and order < 0) or (result < 0 and order > 0):
+55                raise ValueError(f'Conflicting orders {orders}.')
+56            if result == Order.Any:
+57                result = order
+58        return result
+
+ + +

Can be used to define what order outcomes are seen in by MultisetEvaluators.

+
+ + +
+
+ Ascending = +<Order.Ascending: 1> + + +
+ + + + +
+
+
+ Descending = +<Order.Descending: -1> + + +
+ + + + +
+
+
+ Any = +<Order.Any: 0> + + +
+ + + + +
+
+ +
+ + def + merge(*orders: Order) -> Order: + + + +
+ + 
40    def merge(*orders: 'Order') -> 'Order':
+41        """Merges the given Orders.
+42
+43        Returns:
+44            `Any` if all arguments are `Any`.
+45            `Ascending` if there is at least one `Ascending` in the arguments.
+46            `Descending` if there is at least one `Descending` in the arguments.
+47
+48        Raises:
+49            `ValueError` if both `Ascending` and `Descending` are in the
+50            arguments.
+51        """
+52        result = Order.Any
+53        for order in orders:
+54            if (result > 0 and order < 0) or (result < 0 and order > 0):
+55                raise ValueError(f'Conflicting orders {orders}.')
+56            if result == Order.Any:
+57                result = order
+58        return result
+
+ + +

Merges the given Orders.

+ +
Returns:
+ +
+

Any if all arguments are Any. + Ascending if there is at least one Ascending in the arguments. + Descending if there is at least one Descending in the arguments.

+
+ +
Raises:
+ + +
+ + +
+
+
Inherited Members
+
+
enum.Enum
+
name
+
value
+ +
+
builtins.int
+
conjugate
+
bit_length
+
bit_count
+
to_bytes
+
from_bytes
+
as_integer_ratio
+
is_integer
+
real
+
imag
+
numerator
+
denominator
+ +
+
+
+
+
+ +
+ + class + RerollType(enum.Enum): + + + +
+ + 
61class RerollType(enum.Enum):
+62    """The type of the Reroll singleton."""
+63    Reroll = 'Reroll'
+64    """Indicates an outcome should be rerolled (with unlimited depth)."""
+
+ + +

The type of the Reroll singleton.

+
+ + +
+
+ Reroll = +<RerollType.Reroll: 'Reroll'> + + +
+ + +

Indicates an outcome should be rerolled (with unlimited depth).

+
+ + +
+
+
Inherited Members
+
+
enum.Enum
+
name
+
value
+ +
+
+
+
+
+ +
+ + class + Outcome(typing.Hashable, typing.Protocol[-T_contra]): + + + +
+ + 
67class Outcome(Hashable, Protocol[T_contra]):
+68    """Protocol to attempt to verify that outcome types are hashable and sortable.
+69
+70    Far from foolproof, e.g. it cannot enforce total ordering.
+71    """
+72
+73    def __lt__(self, other: T_contra) -> bool:
+74        ...
+
+ + +

Protocol to attempt to verify that outcome types are hashable and sortable.

+ +

Far from foolproof, e.g. it cannot enforce total ordering.

+
+ + +
+
+ +
+ + def + count_positional_parameters(function: Callable) -> tuple[int, int | None]: + + + +
+ + 
76def count_positional_parameters(function: Callable) -> tuple[int, int | None]:
+77    """Counts the number of positional parameters of the callable.
+78
+79    Returns:
+80        Two `int`s. The first is the number of required positional arguments;
+81        the second is total number of positional arguments, or `None` if there
+82        is a variadic `*args`.
+83    """
+84    required = 0
+85    total = 0
+86    parameters = inspect.signature(function, follow_wrapped=False).parameters
+87    for parameter in parameters.values():
+88        match parameter.kind:
+89            case inspect.Parameter.POSITIONAL_ONLY | inspect.Parameter.POSITIONAL_OR_KEYWORD:
+90                total += 1
+91                if parameter.default == inspect.Parameter.empty:
+92                    required += 1
+93            case inspect.Parameter.VAR_POSITIONAL:
+94                return required, None
+95            case _:
+96                break
+97    return required, total
+
+ + +

Counts the number of positional parameters of the callable.

+ +
Returns:
+ +
+

Two ints. The first is the number of required positional arguments; + the second is total number of positional arguments, or None if there + is a variadic *args.

+
+
+ + +
+
+ +
+ + def + guess_star(function, arg_count=1) -> bool: + + + +
+ + 
 99def guess_star(function, arg_count=1) -> bool:
+100    """Guesses whether the first argument should be unpacked before giving it to the function.
+101
+102    Args:
+103        arg_count: The number of arguments that will be provided to the function.
+104    """
+105    try:
+106        required_count, _ = count_positional_parameters(function)
+107    except ValueError:
+108        raise ValueError(f'Could not guess whether to unpack the first argument to the function.\n'
+109                         'You may need to specify `star` explicitly.')
+110    return required_count > arg_count
+
+ + +

Guesses whether the first argument should be unpacked before giving it to the function.

+ +
Arguments:
+ +
    +
  • arg_count: The number of arguments that will be provided to the function.
    • +
+
+ + +
+
+ + \ No newline at end of file diff --git a/apidoc/v1.1.1/index.html b/apidoc/v1.1.1/index.html new file mode 100644 index 00000000..6439f190 --- /dev/null +++ b/apidoc/v1.1.1/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/apidoc/v1.1.1/search.js b/apidoc/v1.1.1/search.js new file mode 100644 index 00000000..449fb78c --- /dev/null +++ b/apidoc/v1.1.1/search.js @@ -0,0 +1,46 @@ +window.pdocSearch = (function(){ +/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();oPackage for computing dice and card probabilities.

\n\n

Starting with v0.25.1, you can replace latest in the URL with an old version\nnumber to get the documentation for that version.

\n\n

See this JupyterLite distribution\nfor examples.

\n\n

Visit the project page.

\n\n

General conventions:

\n\n
    \n
  • Instances are immutable (apart from internal caching). Anything that looks\nlike it mutates an instance actually returns a separate instance with the\nchange.
    • \n
  • Unless explictly specified otherwise, elements with zero quantity, rolls, etc.\nare considered.
    • \n
\n"}, "icepool.d": {"fullname": "icepool.d", "modulename": "icepool", "qualname": "d", "kind": "function", "doc": "

A standard die.

\n\n

Specifically, the outcomes are ints from 1 to sides inclusive,\nwith quantity 1 each.

\n\n

Don't confuse this with icepool.Die():

\n\n
    \n
  • icepool.Die([6]): A Die that always rolls the integer 6.
    • \n
  • icepool.d(6): A d6.
    • \n
\n\n

You can also import individual standard dice from the icepool module, e.g.\nfrom icepool import d6.

\n", "signature": "(sides: int, /) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.coin": {"fullname": "icepool.coin", "modulename": "icepool", "qualname": "coin", "kind": "function", "doc": "

A Die that rolls True with probability n / d, and False otherwise.

\n\n

If n == 0 or n == d the result will have only one outcome.

\n", "signature": "(n: int, d: int, /) -> icepool.population.die.Die[bool]:", "funcdef": "def"}, "icepool.one_hot": {"fullname": "icepool.one_hot", "modulename": "icepool", "qualname": "one_hot", "kind": "function", "doc": "

A Die with Vector outcomes with one element set to True uniformly at random and the rest False.

\n\n

This is an easy (if somewhat expensive) way of representing how many dice\nin a pool rolled each number. For example, the outcomes of 10 @ one_hot(6)\nare the (ones, twos, threes, fours, fives, sixes) rolled in 10d6.

\n", "signature": "(sides: int, /) -> icepool.population.die.Die[tuple[bool, ...]]:", "funcdef": "def"}, "icepool.Outcome": {"fullname": "icepool.Outcome", "modulename": "icepool", "qualname": "Outcome", "kind": "class", "doc": "

Protocol to attempt to verify that outcome types are hashable and sortable.

\n\n

Far from foolproof, e.g. it cannot enforce total ordering.

\n", "bases": "typing.Hashable, typing.Protocol[-T_contra]"}, "icepool.Die": {"fullname": "icepool.Die", "modulename": "icepool", "qualname": "Die", "kind": "class", "doc": "

Sampling with replacement. Quantities represent weights.

\n\n

Dice are immutable. Methods do not modify the Die in-place;\nrather they return a Die representing the result.

\n\n

It is (mostly) well-defined to have a Die with zero-quantity outcomes.\nThese can be useful in a few cases, such as:

\n\n
    \n
  • MultisetEvaluator will iterate through zero-quantity outcomes,\nrather than possibly skipping that outcome. (Though in most cases it's\nbetter to use MultisetEvaluator.alignment().)
    • \n
  • icepool.align() and the like are convenient for making dice share the\nsame set of outcomes.
    • \n
\n\n

However, zero-quantity outcomes have a computational cost like any other\noutcome. Unless you have a specific use case in mind, it's best to leave\nthem out.

\n\n

Most operators and methods will not introduce zero-quantity outcomes if\ntheir arguments do not have any; nor remove zero-quantity outcomes.

\n\n

It's also possible to have \"empty\" dice with no outcomes at all,\nthough these have little use other than being sentinel values.

\n", "bases": "icepool.population.base.Population[+T_co]"}, "icepool.Die.__init__": {"fullname": "icepool.Die.__init__", "modulename": "icepool", "qualname": "Die.__init__", "kind": "function", "doc": "

Constructor for a Die.

\n\n

Don't confuse this with d():

\n\n
    \n
  • Die([6]): A Die that always rolls the int 6.
    • \n
  • d(6): A d6.
    • \n
\n\n

Also, don't confuse this with Pool():

\n\n
    \n
  • Die([1, 2, 3, 4, 5, 6]): A d6.
    • \n
  • Pool([1, 2, 3, 4, 5, 6]): A Pool of six dice that always rolls one\nof each number.
    • \n
\n\n

Here are some different ways of constructing a d6:

\n\n
    \n
  • Just import it: from icepool import d6
    • \n
  • Use the d() function: icepool.d(6)
    • \n
  • Use a d6 that you already have: Die(d6) or Die([d6])
    • \n
  • Mix a d3 and a d3+3: Die([d3, d3+3])
    • \n
  • Use a dict: Die({1:1, 2:1, 3:1, 4:1, 5:1, 6:1})
    • \n
  • Give the faces as a sequence: Die([1, 2, 3, 4, 5, 6])
    • \n
\n\n

All quantities must be non-negative, though they can be zero.

\n\n

Several methods and functions foward **kwargs to this constructor.\nHowever, these only affect the construction of the returned or yielded\ndice. Any other implicit conversions of arguments or operands to dice\nwill be done with the default keyword arguments.

\n\n

EXPERIMENTAL: Use icepool.Again to roll the dice again, usually with\nsome modification. For example,

\n\n
Die([1, 2, 3, 4, 5, 6 + Again])\n
\n\n

would be an exploding d6. Use the again_depth parameter to control\nthe maximum depth. again_depth does not apply to Reroll.

\n\n

If the roll reaches the maximum depth, the again_end is used instead\nof rolling again. Options for again_end include:

\n\n
    \n
  • No value (None), which will attempt to determine a zero value from\nthe outcomes that don't involve Again.
    • \n
  • A single outcome, or a Die.
    • \n
  • Reroll, which will reroll any end roll involving Again.
    • \n
  • You could also consider some sort of placeholder value such as\nmath.inf.
    • \n
\n\n

Denominator: For a flat set of outcomes, the denominator is just the\nsum of the corresponding quantities. If the outcomes themselves have\nsecondary denominators, then the overall denominator is the primary\ndenominator times the LCM of the outcome denominators.

\n\n

For example, Die([d3, d4, d6]) has a final denominator of 36: 3 for\nthe primary selection between the three secondary dice, times 12 for\nthe LCM of 3, 4, and 6.

\n\n
Arguments:
\n\n
    \n

  • outcomes: The faces of the Die. This can be one of the following:

    \n\n
      \n
    • A Sequence of outcomes. Duplicates will contribute\nquantity for each appearance.
      • \n
    • A Mapping from outcomes to quantities.
      • \n
    \n\n

    Individual outcomes can each be one of the following:

    \n\n
      \n
    • An outcome, which must be hashable and totally orderable.
      • \n
    • A Die, which will be flattened into the result.\nThe quantity assigned to a Die is shared among its\noutcomes. The total denominator will be scaled up if\nnecessary.
      • \n
    • icepool.Reroll, which will drop itself from consideration.
      • \n
    • EXPERIMENTAL: icepool.Again. See the main text for\nexplanation.
      • \n
    • \n
  • times: Multiplies the quantity of each element of outcomes.\ntimes can either be a sequence of the same length as\noutcomes or a single int to apply to all elements of\noutcomes.
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError: None is not a valid outcome for a Die.
    • \n
\n", "signature": "(\toutcomes: Union[Sequence, Mapping[Any, int]],\ttimes: Union[Sequence[int], int] = 1,\t*,\tagain_depth: int = 1,\tagain_end: icepool.typing.Outcome | icepool.population.die.Die | icepool.typing.RerollType | None = None)"}, "icepool.Die.unary_operator": {"fullname": "icepool.Die.unary_operator", "modulename": "icepool", "qualname": "Die.unary_operator", "kind": "function", "doc": "

Performs the unary operation on the outcomes.

\n\n

This is used for the standard unary operators\n-, +, abs, ~, round, trunc, floor, ceil\nas well as the additional methods\nzero, bool.

\n\n

This is NOT used for the [] operator; when used directly, this is\ninterpreted as a Mapping operation and returns the count corresponding\nto a given outcome. See marginals() for applying the [] operator to\noutcomes.

\n\n
Returns:
\n\n
\n

A Die representing the result.

\n
\n\n
Raises:
\n\n
    \n
  • ValueError: If tuples are of mismatched length.
    • \n
\n", "signature": "(\tself: icepool.population.die.Die[+T_co],\top: Callable[..., ~U],\t*args,\t**kwargs) -> icepool.population.die.Die[~U]:", "funcdef": "def"}, "icepool.Die.binary_operator": {"fullname": "icepool.Die.binary_operator", "modulename": "icepool", "qualname": "Die.binary_operator", "kind": "function", "doc": "

Performs the operation on pairs of outcomes.

\n\n

By the time this is called, the other operand has already been\nconverted to a Die.

\n\n

If one side of a binary operator is a tuple and the other is not, the\nbinary operator is applied to each element of the tuple with the\nnon-tuple side. For example, the following are equivalent:

\n\n
cartesian_product(d6, d8) * 2\ncartesian_product(d6 * 2, d8 * 2)\n
\n\n

This is used for the standard binary operators\n+, -, *, /, //, %, **, <<, >>, &, |, ^\nand the standard binary comparators\n<, <=, >=, >, ==, !=, cmp.

\n\n

== and != additionally set the truth value of the Die according to\nwhether the dice themselves are the same or not.

\n\n

The @ operator does NOT use this method directly.\nIt rolls the left Die, which must have integer outcomes,\nthen rolls the right Die that many times and sums the outcomes.

\n\n
Returns:
\n\n
\n

A Die representing the result.

\n
\n\n
Raises:
\n\n
    \n
  • ValueError: If tuples are of mismatched length within one of the\ndice or between the dice.
    • \n
\n", "signature": "(\tself,\tother: icepool.population.die.Die,\top: Callable[..., ~U],\t*args,\t**kwargs) -> icepool.population.die.Die[~U]:", "funcdef": "def"}, "icepool.Die.keys": {"fullname": "icepool.Die.keys", "modulename": "icepool", "qualname": "Die.keys", "kind": "function", "doc": "

The outcomes within the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsKeysView[+T_co]:", "funcdef": "def"}, "icepool.Die.values": {"fullname": "icepool.Die.values", "modulename": "icepool", "qualname": "Die.values", "kind": "function", "doc": "

The quantities within the population in outcome order.

\n", "signature": "(self) -> icepool.collection.counts.CountsValuesView:", "funcdef": "def"}, "icepool.Die.items": {"fullname": "icepool.Die.items", "modulename": "icepool", "qualname": "Die.items", "kind": "function", "doc": "

The (outcome, quantity)s of the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsItemsView[+T_co]:", "funcdef": "def"}, "icepool.Die.simplify": {"fullname": "icepool.Die.simplify", "modulename": "icepool", "qualname": "Die.simplify", "kind": "function", "doc": "

Divides all quantities by their greatest common denominator.

\n", "signature": "(self) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.reroll": {"fullname": "icepool.Die.reroll", "modulename": "icepool", "qualname": "Die.reroll", "kind": "function", "doc": "

Rerolls the given outcomes.

\n\n
Arguments:
\n\n
    \n
  • which: Selects which outcomes to reroll. Options:\n
      \n
    • A single outcome to reroll.
      • \n
    • A collection of outcomes to reroll.
      • \n
    • A callable that takes an outcome and returns True if it\nshould be rerolled.
      • \n
    • If not provided, the min outcome will be rerolled.
      • \n
    • \n
  • star: Whether outcomes should be unpacked into separate arguments\nbefore sending them to a callable which.\nIf not provided, this will be guessed based on the function\nsignature.
    • \n
  • depth: The maximum number of times to reroll.\nIf omitted, rerolls an unlimited number of times.
    • \n
\n\n
Returns:
\n\n
\n

A Die representing the reroll.\n If the reroll would never terminate, the result has no outcomes.

\n
\n", "signature": "(\tself,\twhich: Union[Callable[..., bool], Collection[+T_co], NoneType] = None,\t/,\t*,\tstar: bool | None = None,\tdepth: int | None = None) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.filter": {"fullname": "icepool.Die.filter", "modulename": "icepool", "qualname": "Die.filter", "kind": "function", "doc": "

Rerolls until getting one of the given outcomes.

\n\n

Essentially the complement of reroll().

\n\n
Arguments:
\n\n
    \n
  • which: Selects which outcomes to reroll until. Options:\n
      \n
    • A callable that takes an outcome and returns True if it\nshould be accepted.
      • \n
    • A collection of outcomes to reroll until.
      • \n
    • \n
  • star: Whether outcomes should be unpacked into separate arguments\nbefore sending them to a callable which.\nIf not provided, this will be guessed based on the function\nsignature.
    • \n
  • depth: The maximum number of times to reroll.\nIf omitted, rerolls an unlimited number of times.
    • \n
\n\n
Returns:
\n\n
\n

A Die representing the reroll.\n If the reroll would never terminate, the result has no outcomes.

\n
\n", "signature": "(\tself,\twhich: Union[Callable[..., bool], Collection[+T_co]],\t/,\t*,\tstar: bool | None = None,\tdepth: int | None = None) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.truncate": {"fullname": "icepool.Die.truncate", "modulename": "icepool", "qualname": "Die.truncate", "kind": "function", "doc": "

Truncates the outcomes of this Die to the given range.

\n\n

The endpoints are included in the result if applicable.\nIf one of the arguments is not provided, that side will not be truncated.

\n\n

This effectively rerolls outcomes outside the given range.\nIf instead you want to replace those outcomes with the nearest endpoint,\nuse clip().

\n\n

Not to be confused with trunc(die), which performs integer truncation\non each outcome.

\n", "signature": "(\tself,\tmin_outcome=None,\tmax_outcome=None) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.clip": {"fullname": "icepool.Die.clip", "modulename": "icepool", "qualname": "Die.clip", "kind": "function", "doc": "

Clips the outcomes of this Die to the given values.

\n\n

The endpoints are included in the result if applicable.\nIf one of the arguments is not provided, that side will not be clipped.

\n\n

This is not the same as rerolling outcomes beyond this range;\nthe outcome is simply adjusted to fit within the range.\nThis will typically cause some quantity to bunch up at the endpoint.\nIf you want to reroll outcomes beyond this range, use truncate().

\n", "signature": "(\tself,\tmin_outcome=None,\tmax_outcome=None) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.set_range": {"fullname": "icepool.Die.set_range", "modulename": "icepool", "qualname": "Die.set_range", "kind": "function", "doc": "

Sets the outcomes of this Die to the given int range (inclusive).

\n\n

This may remove outcomes (if they are not within the range)\nand/or add zero-quantity outcomes (if they are in range but not present\nin this Die).

\n\n
Arguments:
\n\n
    \n
  • min_outcome: The min outcome of the result.\nIf omitted, the min outcome of this Die will be used.
    • \n
  • max_outcome: The max outcome of the result.\nIf omitted, the max outcome of this Die will be used.
    • \n
\n", "signature": "(\tself: icepool.population.die.Die[int],\tmin_outcome: int | None = None,\tmax_outcome: int | None = None) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.Die.set_outcomes": {"fullname": "icepool.Die.set_outcomes", "modulename": "icepool", "qualname": "Die.set_outcomes", "kind": "function", "doc": "

Sets the set of outcomes to the argument.

\n\n

This may remove outcomes (if they are not present in the argument)\nand/or add zero-quantity outcomes (if they are not present in this Die).

\n", "signature": "(self, outcomes: Iterable[+T_co]) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.trim": {"fullname": "icepool.Die.trim", "modulename": "icepool", "qualname": "Die.trim", "kind": "function", "doc": "

Removes all zero-quantity outcomes.

\n", "signature": "(self) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.map": {"fullname": "icepool.Die.map", "modulename": "icepool", "qualname": "Die.map", "kind": "function", "doc": "

Maps outcomes of the Die to other outcomes.

\n\n

This is also useful for representing processes.

\n\n

As icepool.map(repl, self, ...).

\n", "signature": "(\tself,\trepl: Union[Callable[..., Union[~U, icepool.population.die.Die[~U], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[+T_co, Union[~U, icepool.population.die.Die[~U], icepool.typing.RerollType, icepool.population.again.AgainExpression]]],\t/,\t*extra_args,\tstar: bool | None = None,\trepeat: int | None = 1,\tagain_depth: int = 1,\tagain_end: Union[~U, icepool.population.die.Die[~U], icepool.typing.RerollType, NoneType] = None) -> icepool.population.die.Die[~U]:", "funcdef": "def"}, "icepool.Die.map_and_time": {"fullname": "icepool.Die.map_and_time", "modulename": "icepool", "qualname": "Die.map_and_time", "kind": "function", "doc": "

Repeatedly map outcomes of the state to other outcomes, while also\ncounting timesteps.

\n\n

This is useful for representing processes.

\n\n

As map_and_time(repl, self, ...).

\n", "signature": "(\tself,\trepl: Union[Callable[..., Union[+T_co, icepool.population.die.Die[+T_co], icepool.typing.RerollType]], Mapping[+T_co, Union[+T_co, icepool.population.die.Die[+T_co], icepool.typing.RerollType]]],\t/,\t*extra_args,\tstar: bool | None = None,\trepeat: int) -> icepool.population.die.Die[tuple[+T_co, int]]:", "funcdef": "def"}, "icepool.Die.explode": {"fullname": "icepool.Die.explode", "modulename": "icepool", "qualname": "Die.explode", "kind": "function", "doc": "

Causes outcomes to be rolled again and added to the total.

\n\n
Arguments:
\n\n
    \n
  • which: Which outcomes to explode. Options:\n
      \n
    • A single outcome to explode.
      • \n
    • An collection of outcomes to explode.
      • \n
    • A callable that takes an outcome and returns True if it\nshould be exploded.
      • \n
    • If not supplied, the max outcome will explode.
      • \n
    • \n
  • star: Whether outcomes should be unpacked into separate arguments\nbefore sending them to a callable which.\nIf not provided, this will be guessed based on the function\nsignature.
    • \n
  • depth: The maximum number of additional dice to roll.\nIf not supplied, a default value will be used.
    • \n
  • end: Once depth is reached, further explosions will be treated\nas this value. By default, a zero value will be used.
    • \n
\n", "signature": "(\tself,\twhich: Union[Callable[..., bool], Collection[+T_co], NoneType] = None,\t*,\tstar: bool | None = None,\tdepth: int = 9,\tend=None) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.if_else": {"fullname": "icepool.Die.if_else", "modulename": "icepool", "qualname": "Die.if_else", "kind": "function", "doc": "

Ternary conditional operator.

\n\n

This replaces truthy outcomes with the first argument and falsy outcomes\nwith the second argument.

\n\n
Arguments:
\n\n
    \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\tself,\toutcome_if_true: Union[~U, icepool.population.die.Die[~U]],\toutcome_if_false: Union[~U, icepool.population.die.Die[~U]],\t*,\tagain_depth: int = 1,\tagain_end: Union[~U, icepool.population.die.Die[~U], icepool.typing.RerollType, NoneType] = None) -> icepool.population.die.Die[~U]:", "funcdef": "def"}, "icepool.Die.is_in": {"fullname": "icepool.Die.is_in", "modulename": "icepool", "qualname": "Die.is_in", "kind": "function", "doc": "

A die that returns True iff the roll of the die is contained in the target.

\n", "signature": "(self, target: Container[+T_co], /) -> icepool.population.die.Die[bool]:", "funcdef": "def"}, "icepool.Die.count": {"fullname": "icepool.Die.count", "modulename": "icepool", "qualname": "Die.count", "kind": "function", "doc": "

Roll this dice a number of times and count how many are in the target.

\n", "signature": "(\tself,\trolls: int,\ttarget: Container[+T_co],\t/) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.Die.pool": {"fullname": "icepool.Die.pool", "modulename": "icepool", "qualname": "Die.pool", "kind": "function", "doc": "

Creates a Pool from this Die.

\n\n

You might subscript the pool immediately afterwards, e.g.\nd6.pool(5)[-1, ..., 1] takes the difference between the highest and\nlowest of 5d6.

\n\n
Arguments:
\n\n
    \n
  • rolls: The number of copies of this Die to put in the pool.\nOr, a sequence of one int per die acting as\nkeep_tuple. Note that ... cannot be used in the\nargument to this method, as the argument determines the size of\nthe pool.
    • \n
\n", "signature": "(\tself,\trolls: Union[int, Sequence[int]] = 1,\t/) -> icepool.generator.pool.Pool[+T_co]:", "funcdef": "def"}, "icepool.Die.lowest": {"fullname": "icepool.Die.lowest", "modulename": "icepool", "qualname": "Die.lowest", "kind": "function", "doc": "

Roll several of this Die and return the lowest result, or the sum of some of the lowest.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • rolls: The number of dice to roll. All dice will have the same\noutcomes as self.
    • \n
  • keep: The number of dice to keep.
    • \n
  • drop: If provided, this many lowest dice will be dropped before\nkeeping.
    • \n
\n\n
Returns:
\n\n
\n

A Die representing the probability distribution of the sum.

\n
\n", "signature": "(\tself,\trolls: int,\t/,\tkeep: int = 1,\tdrop: int = 0) -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.highest": {"fullname": "icepool.Die.highest", "modulename": "icepool", "qualname": "Die.highest", "kind": "function", "doc": "

Roll several of this Die and return the highest result, or the sum of some of the highest.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • rolls: The number of dice to roll.
    • \n
  • keep: The number of dice to keep.
    • \n
  • drop: If provided, this many highest dice will be dropped before\nkeeping.
    • \n
\n\n
Returns:
\n\n
\n

A Die representing the probability distribution of the sum.

\n
\n", "signature": "(\tself,\trolls: int,\t/,\tkeep: int = 1,\tdrop: int = 0) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.middle": {"fullname": "icepool.Die.middle", "modulename": "icepool", "qualname": "Die.middle", "kind": "function", "doc": "

Roll several of this Die and sum the sorted results in the middle.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • rolls: The number of dice to roll.
    • \n
  • keep: The number of outcomes to sum. If this is greater than the\ncurrent keep_size, all are kept.
    • \n
  • tie: What to do if keep is odd but the current keep_size\nis even, or vice versa.\n
      \n
    • 'error' (default): Raises IndexError.
      • \n
    • 'high': The higher outcome is taken.
      • \n
    • 'low': The lower outcome is taken.
      • \n
    • \n
\n", "signature": "(\tself,\trolls: int,\t/,\tkeep: int = 1,\t*,\ttie: Literal['error', 'high', 'low'] = 'error') -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.abs": {"fullname": "icepool.Die.abs", "modulename": "icepool", "qualname": "Die.abs", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.round": {"fullname": "icepool.Die.round", "modulename": "icepool", "qualname": "Die.round", "kind": "function", "doc": "

\n", "signature": "(self, ndigits: int | None = None) -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.trunc": {"fullname": "icepool.Die.trunc", "modulename": "icepool", "qualname": "Die.trunc", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.floor": {"fullname": "icepool.Die.floor", "modulename": "icepool", "qualname": "Die.floor", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.ceil": {"fullname": "icepool.Die.ceil", "modulename": "icepool", "qualname": "Die.ceil", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.population.die.Die:", "funcdef": "def"}, "icepool.Die.zero": {"fullname": "icepool.Die.zero", "modulename": "icepool", "qualname": "Die.zero", "kind": "function", "doc": "

Zeros all outcomes of this die.

\n\n

This is done by multiplying all outcomes by 0.

\n\n

The result will have the same denominator as this die.

\n\n
Raises:
\n\n
    \n
  • ValueError: If the zeros did not resolve to a single outcome.
    • \n
\n", "signature": "(self) -> icepool.population.die.Die[+T_co]:", "funcdef": "def"}, "icepool.Die.zero_outcome": {"fullname": "icepool.Die.zero_outcome", "modulename": "icepool", "qualname": "Die.zero_outcome", "kind": "function", "doc": "

A zero-outcome for this die.

\n\n

E.g. 0 for a Die whose outcomes are ints.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Die.cmp": {"fullname": "icepool.Die.cmp", "modulename": "icepool", "qualname": "Die.cmp", "kind": "function", "doc": "

A Die with outcomes 1, -1, and 0.

\n\n

The quantities are equal to the positive outcome of self > other,\nself < other, and the remainder respectively.

\n\n

This will include all three outcomes even if they have zero quantity.

\n", "signature": "(self, other) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.Die.sign": {"fullname": "icepool.Die.sign", "modulename": "icepool", "qualname": "Die.sign", "kind": "function", "doc": "

Outcomes become 1 if greater than zero(), -1 if less than zero(), and 0 otherwise.

\n\n

Note that for floats, +0.0, -0.0, and nan all become 0.

\n", "signature": "(self) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.Die.equals": {"fullname": "icepool.Die.equals", "modulename": "icepool", "qualname": "Die.equals", "kind": "function", "doc": "

True iff both dice have the same outcomes and quantities.

\n\n

This is False if other is not a Die, even if it would convert\nto an equal Die.

\n\n

Truth value does NOT matter.

\n\n

If one Die has a zero-quantity outcome and the other Die does not\ncontain that outcome, they are treated as unequal by this function.

\n\n

The == and != operators have a dual purpose; they return a Die\nwith a truth value determined by this method.\nOnly dice returned by these methods have a truth value. The data of\nthese dice is lazily evaluated since the caller may only be interested\nin the Die value or the truth value.

\n\n
Arguments:
\n\n
    \n
  • simplify: If True, the dice will be simplified before comparing.\nOtherwise, e.g. a 2:2 coin is not equals() to a 1:1 coin.
    • \n
\n", "signature": "(self, other, *, simplify: bool = False) -> bool:", "funcdef": "def"}, "icepool.Population": {"fullname": "icepool.Population", "modulename": "icepool", "qualname": "Population", "kind": "class", "doc": "

A mapping from outcomes to int quantities.

\n\n

Outcomes with each instance must be hashable and totally orderable.

\n\n

Subclasses include Die and Deck.

\n", "bases": "abc.ABC, typing.Generic[+T_co], typing.Mapping[typing.Any, int]"}, "icepool.Population.keys": {"fullname": "icepool.Population.keys", "modulename": "icepool", "qualname": "Population.keys", "kind": "function", "doc": "

The outcomes within the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsKeysView[+T_co]:", "funcdef": "def"}, "icepool.Population.values": {"fullname": "icepool.Population.values", "modulename": "icepool", "qualname": "Population.values", "kind": "function", "doc": "

The quantities within the population in outcome order.

\n", "signature": "(self) -> icepool.collection.counts.CountsValuesView:", "funcdef": "def"}, "icepool.Population.items": {"fullname": "icepool.Population.items", "modulename": "icepool", "qualname": "Population.items", "kind": "function", "doc": "

The (outcome, quantity)s of the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsItemsView[+T_co]:", "funcdef": "def"}, "icepool.Population.outcomes": {"fullname": "icepool.Population.outcomes", "modulename": "icepool", "qualname": "Population.outcomes", "kind": "function", "doc": "

The outcomes of the mapping in ascending order.

\n\n

These are also the keys of the mapping.\nPrefer to use the name outcomes.

\n", "signature": "(self) -> icepool.collection.counts.CountsKeysView[+T_co]:", "funcdef": "def"}, "icepool.Population.common_outcome_length": {"fullname": "icepool.Population.common_outcome_length", "modulename": "icepool", "qualname": "Population.common_outcome_length", "kind": "function", "doc": "

The common length of all outcomes.

\n\n

If outcomes have no lengths or different lengths, the result is None.

\n", "signature": "(self) -> int | None:", "funcdef": "def"}, "icepool.Population.is_empty": {"fullname": "icepool.Population.is_empty", "modulename": "icepool", "qualname": "Population.is_empty", "kind": "function", "doc": "

True iff this population has no outcomes.

\n", "signature": "(self) -> bool:", "funcdef": "def"}, "icepool.Population.min_outcome": {"fullname": "icepool.Population.min_outcome", "modulename": "icepool", "qualname": "Population.min_outcome", "kind": "function", "doc": "

The least outcome.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Population.max_outcome": {"fullname": "icepool.Population.max_outcome", "modulename": "icepool", "qualname": "Population.max_outcome", "kind": "function", "doc": "

The greatest outcome.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Population.nearest_le": {"fullname": "icepool.Population.nearest_le", "modulename": "icepool", "qualname": "Population.nearest_le", "kind": "function", "doc": "

The nearest outcome that is <= the argument.

\n\n

Returns None if there is no such outcome.

\n", "signature": "(self, outcome) -> Optional[+T_co]:", "funcdef": "def"}, "icepool.Population.nearest_lt": {"fullname": "icepool.Population.nearest_lt", "modulename": "icepool", "qualname": "Population.nearest_lt", "kind": "function", "doc": "

The nearest outcome that is < the argument.

\n\n

Returns None if there is no such outcome.

\n", "signature": "(self, outcome) -> Optional[+T_co]:", "funcdef": "def"}, "icepool.Population.nearest_ge": {"fullname": "icepool.Population.nearest_ge", "modulename": "icepool", "qualname": "Population.nearest_ge", "kind": "function", "doc": "

The nearest outcome that is >= the argument.

\n\n

Returns None if there is no such outcome.

\n", "signature": "(self, outcome) -> Optional[+T_co]:", "funcdef": "def"}, "icepool.Population.nearest_gt": {"fullname": "icepool.Population.nearest_gt", "modulename": "icepool", "qualname": "Population.nearest_gt", "kind": "function", "doc": "

The nearest outcome that is > the argument.

\n\n

Returns None if there is no such outcome.

\n", "signature": "(self, outcome) -> Optional[+T_co]:", "funcdef": "def"}, "icepool.Population.quantity": {"fullname": "icepool.Population.quantity", "modulename": "icepool", "qualname": "Population.quantity", "kind": "function", "doc": "

The quantity of a single outcome, or 0 if not present.

\n", "signature": "(self, outcome: Hashable) -> int:", "funcdef": "def"}, "icepool.Population.quantities": {"fullname": "icepool.Population.quantities", "modulename": "icepool", "qualname": "Population.quantities", "kind": "function", "doc": "

The quantities of the mapping in sorted order.

\n\n

These are also the values of the mapping.\nPrefer to use the name quantities.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the quantities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None) -> Union[icepool.collection.counts.CountsValuesView, Sequence[int]]:", "funcdef": "def"}, "icepool.Population.denominator": {"fullname": "icepool.Population.denominator", "modulename": "icepool", "qualname": "Population.denominator", "kind": "function", "doc": "

The sum of all quantities (e.g. weights or duplicates).

\n\n

For the number of unique outcomes, including those with zero quantity,\nuse len().

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Population.scale_quantities": {"fullname": "icepool.Population.scale_quantities", "modulename": "icepool", "qualname": "Population.scale_quantities", "kind": "function", "doc": "

Scales all quantities by an integer.

\n", "signature": "(self: ~C, scale: int) -> ~C:", "funcdef": "def"}, "icepool.Population.has_zero_quantities": {"fullname": "icepool.Population.has_zero_quantities", "modulename": "icepool", "qualname": "Population.has_zero_quantities", "kind": "function", "doc": "

True iff self contains at least one outcome with zero quantity.

\n", "signature": "(self) -> bool:", "funcdef": "def"}, "icepool.Population.quantity_ne": {"fullname": "icepool.Population.quantity_ne", "modulename": "icepool", "qualname": "Population.quantity_ne", "kind": "function", "doc": "

The quantity != a single outcome.

\n", "signature": "(self, outcome) -> int:", "funcdef": "def"}, "icepool.Population.quantity_le": {"fullname": "icepool.Population.quantity_le", "modulename": "icepool", "qualname": "Population.quantity_le", "kind": "function", "doc": "

The quantity <= a single outcome.

\n", "signature": "(self, outcome) -> int:", "funcdef": "def"}, "icepool.Population.quantity_lt": {"fullname": "icepool.Population.quantity_lt", "modulename": "icepool", "qualname": "Population.quantity_lt", "kind": "function", "doc": "

The quantity < a single outcome.

\n", "signature": "(self, outcome) -> int:", "funcdef": "def"}, "icepool.Population.quantity_ge": {"fullname": "icepool.Population.quantity_ge", "modulename": "icepool", "qualname": "Population.quantity_ge", "kind": "function", "doc": "

The quantity >= a single outcome.

\n", "signature": "(self, outcome) -> int:", "funcdef": "def"}, "icepool.Population.quantity_gt": {"fullname": "icepool.Population.quantity_gt", "modulename": "icepool", "qualname": "Population.quantity_gt", "kind": "function", "doc": "

The quantity > a single outcome.

\n", "signature": "(self, outcome) -> int:", "funcdef": "def"}, "icepool.Population.quantities_le": {"fullname": "icepool.Population.quantities_le", "modulename": "icepool", "qualname": "Population.quantities_le", "kind": "function", "doc": "

The quantity <= each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the quantities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
\n", "signature": "(self, outcomes: Optional[Sequence] = None) -> Sequence[int]:", "funcdef": "def"}, "icepool.Population.quantities_ge": {"fullname": "icepool.Population.quantities_ge", "modulename": "icepool", "qualname": "Population.quantities_ge", "kind": "function", "doc": "

The quantity >= each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the quantities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
\n", "signature": "(self, outcomes: Optional[Sequence] = None) -> Sequence[int]:", "funcdef": "def"}, "icepool.Population.quantities_lt": {"fullname": "icepool.Population.quantities_lt", "modulename": "icepool", "qualname": "Population.quantities_lt", "kind": "function", "doc": "

The quantity < each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the quantities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
\n", "signature": "(self, outcomes: Optional[Sequence] = None) -> Sequence[int]:", "funcdef": "def"}, "icepool.Population.quantities_gt": {"fullname": "icepool.Population.quantities_gt", "modulename": "icepool", "qualname": "Population.quantities_gt", "kind": "function", "doc": "

The quantity > each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the quantities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
\n", "signature": "(self, outcomes: Optional[Sequence] = None) -> Sequence[int]:", "funcdef": "def"}, "icepool.Population.probability": {"fullname": "icepool.Population.probability", "modulename": "icepool", "qualname": "Population.probability", "kind": "function", "doc": "

The probability of a single outcome, or 0.0 if not present.

\n", "signature": "(self, outcome: Hashable) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.probability_le": {"fullname": "icepool.Population.probability_le", "modulename": "icepool", "qualname": "Population.probability_le", "kind": "function", "doc": "

The probability <= a single outcome.

\n", "signature": "(self, outcome: Hashable) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.probability_lt": {"fullname": "icepool.Population.probability_lt", "modulename": "icepool", "qualname": "Population.probability_lt", "kind": "function", "doc": "

The probability < a single outcome.

\n", "signature": "(self, outcome: Hashable) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.probability_ge": {"fullname": "icepool.Population.probability_ge", "modulename": "icepool", "qualname": "Population.probability_ge", "kind": "function", "doc": "

The probability >= a single outcome.

\n", "signature": "(self, outcome: Hashable) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.probability_gt": {"fullname": "icepool.Population.probability_gt", "modulename": "icepool", "qualname": "Population.probability_gt", "kind": "function", "doc": "

The probability > a single outcome.

\n", "signature": "(self, outcome: Hashable) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.probabilities": {"fullname": "icepool.Population.probabilities", "modulename": "icepool", "qualname": "Population.probabilities", "kind": "function", "doc": "

The probability of each outcome in order.

\n\n

Also known as the probability mass function (PMF).

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the probabilities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
  • percent: If set, the results will be in percent \n(i.e. total of 100.0) and the values are floats.\nOtherwise, the total will be 1 and the values are Fractions.
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None,\t*,\tpercent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]:", "funcdef": "def"}, "icepool.Population.probabilities_le": {"fullname": "icepool.Population.probabilities_le", "modulename": "icepool", "qualname": "Population.probabilities_le", "kind": "function", "doc": "

The probability of rolling <= each outcome in order.

\n\n

Also known as the cumulative distribution function (CDF),\nthough this term is ambigiuous whether it is < or <=.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the probabilities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
  • percent: If set, the results will be in percent \n(i.e. total of 100.0) and the values are floats.\nOtherwise, the total will be 1 and the values are Fractions.
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None,\t*,\tpercent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]:", "funcdef": "def"}, "icepool.Population.probabilities_ge": {"fullname": "icepool.Population.probabilities_ge", "modulename": "icepool", "qualname": "Population.probabilities_ge", "kind": "function", "doc": "

The probability of rolling >= each outcome in order.

\n\n

Also known as the survival function (SF) or\ncomplementary cumulative distribution function (CCDF),\nthough these term are ambigiuous whether they are is > or >=.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the probabilities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
  • percent: If set, the results will be in percent \n(i.e. total of 100.0) and the values are floats.\nOtherwise, the total will be 1 and the values are Fractions.
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None,\t*,\tpercent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]:", "funcdef": "def"}, "icepool.Population.probabilities_lt": {"fullname": "icepool.Population.probabilities_lt", "modulename": "icepool", "qualname": "Population.probabilities_lt", "kind": "function", "doc": "

The probability of rolling < each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the probabilities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
  • percent: If set, the results will be in percent \n(i.e. total of 100.0) and the values are floats.\nOtherwise, the total will be 1 and the values are Fractions.
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None,\t*,\tpercent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]:", "funcdef": "def"}, "icepool.Population.probabilities_gt": {"fullname": "icepool.Population.probabilities_gt", "modulename": "icepool", "qualname": "Population.probabilities_gt", "kind": "function", "doc": "

The probability of rolling > each outcome in order.

\n\n
Arguments:
\n\n
    \n
  • outcomes: If provided, the probabilities corresponding to these\noutcomes will be returned (or 0 if not present).
    • \n
  • percent: If set, the results will be in percent \n(i.e. total of 100.0) and the values are floats.\nOtherwise, the total will be 1 and the values are Fractions.
    • \n
\n", "signature": "(\tself,\toutcomes: Optional[Sequence] = None,\t*,\tpercent: bool = False) -> Union[Sequence[fractions.Fraction], Sequence[float]]:", "funcdef": "def"}, "icepool.Population.mode": {"fullname": "icepool.Population.mode", "modulename": "icepool", "qualname": "Population.mode", "kind": "function", "doc": "

A tuple containing the most common outcome(s) of the population.

\n\n

These are sorted from lowest to highest.

\n", "signature": "(self) -> tuple:", "funcdef": "def"}, "icepool.Population.modal_quantity": {"fullname": "icepool.Population.modal_quantity", "modulename": "icepool", "qualname": "Population.modal_quantity", "kind": "function", "doc": "

The highest quantity of any single outcome.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Population.kolmogorov_smirnov": {"fullname": "icepool.Population.kolmogorov_smirnov", "modulename": "icepool", "qualname": "Population.kolmogorov_smirnov", "kind": "function", "doc": "

Kolmogorov\u2013Smirnov statistic. The maximum absolute difference between CDFs.

\n", "signature": "(self, other) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.cramer_von_mises": {"fullname": "icepool.Population.cramer_von_mises", "modulename": "icepool", "qualname": "Population.cramer_von_mises", "kind": "function", "doc": "

Cram\u00e9r-von Mises statistic. The sum-of-squares difference between CDFs.

\n", "signature": "(self, other) -> fractions.Fraction:", "funcdef": "def"}, "icepool.Population.median": {"fullname": "icepool.Population.median", "modulename": "icepool", "qualname": "Population.median", "kind": "function", "doc": "

The median, taking the mean in case of a tie.

\n\n

This will fail if the outcomes do not support division;\nin this case, use median_low or median_high instead.

\n", "signature": "(self):", "funcdef": "def"}, "icepool.Population.median_low": {"fullname": "icepool.Population.median_low", "modulename": "icepool", "qualname": "Population.median_low", "kind": "function", "doc": "

The median, taking the lower in case of a tie.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Population.median_high": {"fullname": "icepool.Population.median_high", "modulename": "icepool", "qualname": "Population.median_high", "kind": "function", "doc": "

The median, taking the higher in case of a tie.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Population.quantile": {"fullname": "icepool.Population.quantile", "modulename": "icepool", "qualname": "Population.quantile", "kind": "function", "doc": "

The outcome n / d of the way through the CDF, taking the mean in case of a tie.

\n\n

This will fail if the outcomes do not support addition and division;\nin this case, use quantile_low or quantile_high instead.

\n", "signature": "(self, n: int, d: int = 100):", "funcdef": "def"}, "icepool.Population.quantile_low": {"fullname": "icepool.Population.quantile_low", "modulename": "icepool", "qualname": "Population.quantile_low", "kind": "function", "doc": "

The outcome n / d of the way through the CDF, taking the lesser in case of a tie.

\n", "signature": "(self, n: int, d: int = 100) -> +T_co:", "funcdef": "def"}, "icepool.Population.quantile_high": {"fullname": "icepool.Population.quantile_high", "modulename": "icepool", "qualname": "Population.quantile_high", "kind": "function", "doc": "

The outcome n / d of the way through the CDF, taking the greater in case of a tie.

\n", "signature": "(self, n: int, d: int = 100) -> +T_co:", "funcdef": "def"}, "icepool.Population.mean": {"fullname": "icepool.Population.mean", "modulename": "icepool", "qualname": "Population.mean", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> fractions.Fraction | float:", "funcdef": "def"}, "icepool.Population.variance": {"fullname": "icepool.Population.variance", "modulename": "icepool", "qualname": "Population.variance", "kind": "function", "doc": "

This is the population variance, not the sample variance.

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> fractions.Fraction | float:", "funcdef": "def"}, "icepool.Population.standard_deviation": {"fullname": "icepool.Population.standard_deviation", "modulename": "icepool", "qualname": "Population.standard_deviation", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> float:", "funcdef": "def"}, "icepool.Population.sd": {"fullname": "icepool.Population.sd", "modulename": "icepool", "qualname": "Population.sd", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> float:", "funcdef": "def"}, "icepool.Population.standardized_moment": {"fullname": "icepool.Population.standardized_moment", "modulename": "icepool", "qualname": "Population.standardized_moment", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float],\tk: int) -> float:", "funcdef": "def"}, "icepool.Population.skewness": {"fullname": "icepool.Population.skewness", "modulename": "icepool", "qualname": "Population.skewness", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> float:", "funcdef": "def"}, "icepool.Population.excess_kurtosis": {"fullname": "icepool.Population.excess_kurtosis", "modulename": "icepool", "qualname": "Population.excess_kurtosis", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[numbers.Rational] | icepool.population.base.Population[float]) -> float:", "funcdef": "def"}, "icepool.Population.entropy": {"fullname": "icepool.Population.entropy", "modulename": "icepool", "qualname": "Population.entropy", "kind": "function", "doc": "

The entropy of a random sample from this population.

\n\n
Arguments:
\n\n
    \n
  • base: The logarithm base to use. Default is 2.0, which gives the \nentropy in bits.
    • \n
\n", "signature": "(self, base: float = 2.0) -> float:", "funcdef": "def"}, "icepool.Population.marginals": {"fullname": "icepool.Population.marginals", "modulename": "icepool", "qualname": "Population.marginals", "kind": "variable", "doc": "

A property that applies the [] operator to outcomes.

\n\n

For example, population.marginals[:2] will marginalize the first two\nelements of the outcomes.

\n"}, "icepool.Population.covariance": {"fullname": "icepool.Population.covariance", "modulename": "icepool", "qualname": "Population.covariance", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[tuple[numbers.Rational, ...]] | icepool.population.base.Population[tuple[float, ...]],\ti: int,\tj: int) -> fractions.Fraction | float:", "funcdef": "def"}, "icepool.Population.correlation": {"fullname": "icepool.Population.correlation", "modulename": "icepool", "qualname": "Population.correlation", "kind": "function", "doc": "

\n", "signature": "(\tself: icepool.population.base.Population[tuple[numbers.Rational, ...]] | icepool.population.base.Population[tuple[float, ...]],\ti: int,\tj: int) -> float:", "funcdef": "def"}, "icepool.Population.sample": {"fullname": "icepool.Population.sample", "modulename": "icepool", "qualname": "Population.sample", "kind": "function", "doc": "

A single random sample from this population.

\n\n

Note that this is always \"with replacement\" even for Deck since\ninstances are immutable.

\n\n

This uses the standard random package and is not cryptographically\nsecure.

\n", "signature": "(self) -> +T_co:", "funcdef": "def"}, "icepool.Population.format": {"fullname": "icepool.Population.format", "modulename": "icepool", "qualname": "Population.format", "kind": "function", "doc": "

Formats this mapping as a string.

\n\n

format_spec should start with the output format,\nwhich can be:

\n\n
    \n
  • md for Markdown (default)
    • \n
  • bbcode for BBCode
    • \n
  • csv for comma-separated values
    • \n
  • html for HTML
    • \n
\n\n

After this, you may optionally add a : followed by a series of\nrequested columns. Allowed columns are:

\n\n
    \n
  • o: Outcomes.
    • \n
  • *o: Outcomes, unpacked if applicable.
    • \n
  • q==, q<=, q>=: Quantities ==, <=, or >= each outcome.
    • \n
  • p==, p<=, p>=: Probabilities (0-1) ==, <=, or >= each outcome.
    • \n
  • %==, %<=, %>=: Probabilities (0%-100%) ==, <=, or >= each outcome.
    • \n
\n\n

Columns may optionally be separated using | characters.

\n\n

The default columns are *o|q==|%==, which are the unpacked outcomes,\nthe quantities, and the probabilities. The quantities are omitted from\nthe default columns if any individual quantity is 10**30 or greater.

\n", "signature": "(self, format_spec: str, /, **kwargs) -> str:", "funcdef": "def"}, "icepool.tupleize": {"fullname": "icepool.tupleize", "modulename": "icepool", "qualname": "tupleize", "kind": "function", "doc": "

Returns the Cartesian product of the arguments as tuples or a Population thereof.

\n\n

For example:

\n\n
    \n
  • tupleize(1, 2) would produce (1, 2).
    • \n
  • tupleize(d6, 0) would produce a Die with outcomes (1, 0), (2, 0),\n... (6, 0).
    • \n
  • tupleize(d6, d6) would produce a Die with outcomes (1, 1), (1, 2),\n... (6, 5), (6, 6).
    • \n
\n\n

If Populations are provided, they must all be Die or all Deck and not\na mixture of the two.

\n\n
Returns:
\n\n
\n

If none of the outcomes is a Population, the result is a tuple\n with one element per argument. Otherwise, the result is a Population\n of the same type as the input Population, and the outcomes are\n tuples with one element per argument.

\n
\n", "signature": "(\t*args: Union[~T, icepool.population.base.Population[~T]]) -> tuple[~T, ...] | icepool.population.base.Population[tuple[~T, ...]]:", "funcdef": "def"}, "icepool.vectorize": {"fullname": "icepool.vectorize", "modulename": "icepool", "qualname": "vectorize", "kind": "function", "doc": "

Returns the Cartesian product of the arguments as Vectors or a Population thereof.

\n\n

For example:

\n\n
    \n
  • vectorize(1, 2) would produce Vector(1, 2).
    • \n
  • vectorize(d6, 0) would produce a Die with outcomes Vector(1, 0),\nVector(2, 0), ... Vector(6, 0).
    • \n
  • vectorize(d6, d6) would produce a Die with outcomes Vector(1, 1),\nVector(1, 2), ... Vector(6, 5), Vector(6, 6).
    • \n
\n\n

If Populations are provided, they must all be Die or all Deck and not\na mixture of the two.

\n\n
Returns:
\n\n
\n

If none of the outcomes is a Population, the result is a Vector\n with one element per argument. Otherwise, the result is a Population\n of the same type as the input Population, and the outcomes are\n Vectors with one element per argument.

\n
\n", "signature": "(\t*args: Union[~T, icepool.population.base.Population[~T]]) -> Union[icepool.collection.vector.Vector[~T], icepool.population.base.Population[icepool.collection.vector.Vector[~T]]]:", "funcdef": "def"}, "icepool.Vector": {"fullname": "icepool.Vector", "modulename": "icepool", "qualname": "Vector", "kind": "class", "doc": "

Immutable tuple-like class that applies most operators elementwise.

\n\n

May become a variadic generic type in the future.

\n", "bases": "icepool.typing.Outcome, typing.Sequence[+T_co]"}, "icepool.Vector.unary_operator": {"fullname": "icepool.Vector.unary_operator", "modulename": "icepool", "qualname": "Vector.unary_operator", "kind": "function", "doc": "

Unary operators on Vector are applied elementwise.

\n\n

This is used for the standard unary operators\n-, +, abs, ~, round, trunc, floor, ceil

\n", "signature": "(\tself,\top: Callable[..., ~U],\t*args,\t**kwargs) -> icepool.collection.vector.Vector[~U]:", "funcdef": "def"}, "icepool.Vector.abs": {"fullname": "icepool.Vector.abs", "modulename": "icepool", "qualname": "Vector.abs", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.collection.vector.Vector[+T_co]:", "funcdef": "def"}, "icepool.Vector.round": {"fullname": "icepool.Vector.round", "modulename": "icepool", "qualname": "Vector.round", "kind": "function", "doc": "

\n", "signature": "(self, ndigits: int | None = None) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Vector.trunc": {"fullname": "icepool.Vector.trunc", "modulename": "icepool", "qualname": "Vector.trunc", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Vector.floor": {"fullname": "icepool.Vector.floor", "modulename": "icepool", "qualname": "Vector.floor", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Vector.ceil": {"fullname": "icepool.Vector.ceil", "modulename": "icepool", "qualname": "Vector.ceil", "kind": "function", "doc": "

\n", "signature": "(self) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Vector.binary_operator": {"fullname": "icepool.Vector.binary_operator", "modulename": "icepool", "qualname": "Vector.binary_operator", "kind": "function", "doc": "

Binary operators on Vector are applied elementwise.

\n\n

If the other operand is also a Vector, the operator is applied to each\npair of elements from self and other. Both must have the same\nlength.

\n\n

Otherwise the other operand is broadcast to each element of self.

\n\n

This is used for the standard binary operators\n+, -, *, /, //, %, **, <<, >>, &, |, ^.

\n\n

@ is not included due to its different meaning in Die.

\n\n

This is also used for the comparators\n<, <=, >, >=, ==, !=.

\n\n

In this case, the result also has a truth value based on lexicographic\nordering.

\n", "signature": "(\tself,\tother,\top: Callable[..., ~U],\t*args,\tcompare_for_truth: bool = False,\t**kwargs) -> icepool.collection.vector.Vector[~U]:", "funcdef": "def"}, "icepool.Vector.reverse_binary_operator": {"fullname": "icepool.Vector.reverse_binary_operator", "modulename": "icepool", "qualname": "Vector.reverse_binary_operator", "kind": "function", "doc": "

Reverse version of binary_operator().

\n", "signature": "(\tself,\tother,\top: Callable[..., ~U],\t*args,\t**kwargs) -> icepool.collection.vector.Vector[~U]:", "funcdef": "def"}, "icepool.Vector.append": {"fullname": "icepool.Vector.append", "modulename": "icepool", "qualname": "Vector.append", "kind": "function", "doc": "

\n", "signature": "(self, other) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Vector.concatenate": {"fullname": "icepool.Vector.concatenate", "modulename": "icepool", "qualname": "Vector.concatenate", "kind": "function", "doc": "

\n", "signature": "(self, other: Iterable) -> icepool.collection.vector.Vector:", "funcdef": "def"}, "icepool.Again": {"fullname": "icepool.Again", "modulename": "icepool", "qualname": "Again", "kind": "variable", "doc": "

A symbol indicating that the die should be rolled again, usually with some operation applied.

\n\n

This is designed to be used with the Die() constructor.\nAgainExpressions should not be fed to functions or methods other than\nDie(), but it can be used with operators. Examples:

\n\n
    \n
  • Again + 6: Roll again and add 6.
    • \n
  • Again + Again: Roll again twice and sum.
    • \n
\n\n

The again_depth and again_end arguments to Die() affect how these\narguments are processed.

\n\n

If you want something more complex, use e.g. Die.map() instead.

\n", "annotation": ": Final", "default_value": "<icepool.population.again.AgainExpression object>"}, "icepool.CountsKeysView": {"fullname": "icepool.CountsKeysView", "modulename": "icepool", "qualname": "CountsKeysView", "kind": "class", "doc": "

This functions as both a KeysView and a Sequence.

\n", "bases": "typing.KeysView[~T], typing.Sequence[~T]"}, "icepool.CountsKeysView.__init__": {"fullname": "icepool.CountsKeysView.__init__", "modulename": "icepool", "qualname": "CountsKeysView.__init__", "kind": "function", "doc": "

\n", "signature": "(counts: icepool.collection.counts.Counts[~T])"}, "icepool.CountsValuesView": {"fullname": "icepool.CountsValuesView", "modulename": "icepool", "qualname": "CountsValuesView", "kind": "class", "doc": "

This functions as both a ValuesView and a Sequence.

\n", "bases": "typing.ValuesView[int], typing.Sequence[int]"}, "icepool.CountsValuesView.__init__": {"fullname": "icepool.CountsValuesView.__init__", "modulename": "icepool", "qualname": "CountsValuesView.__init__", "kind": "function", "doc": "

\n", "signature": "(counts: icepool.collection.counts.Counts)"}, "icepool.CountsItemsView": {"fullname": "icepool.CountsItemsView", "modulename": "icepool", "qualname": "CountsItemsView", "kind": "class", "doc": "

This functions as both an ItemsView and a Sequence.

\n", "bases": "typing.ItemsView[~T, int], typing.Sequence[tuple[~T, int]]"}, "icepool.CountsItemsView.__init__": {"fullname": "icepool.CountsItemsView.__init__", "modulename": "icepool", "qualname": "CountsItemsView.__init__", "kind": "function", "doc": "

\n", "signature": "(counts: icepool.collection.counts.Counts)"}, "icepool.from_cumulative": {"fullname": "icepool.from_cumulative", "modulename": "icepool", "qualname": "from_cumulative", "kind": "function", "doc": "

Constructs a Die from a sequence of cumulative values.

\n\n
Arguments:
\n\n
    \n
  • outcomes: The outcomes of the resulting die. Sorted order is recommended\nbut not necessary.
    • \n
  • cumulative: The cumulative values (inclusive) of the outcomes in the\norder they are given to this function. These may be:\n
      \n
    • int cumulative quantities.
      • \n
    • Dice representing the cumulative distribution at that point.
      • \n
    • \n
  • reverse: Iff true, both of the arguments will be reversed. This allows\ne.g. constructing using a survival distribution.
    • \n
\n", "signature": "(\toutcomes: Sequence[~T],\tcumulative: Union[Sequence[int], Sequence[icepool.population.die.Die[bool]]],\t*,\treverse: bool = False) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.from_rv": {"fullname": "icepool.from_rv", "modulename": "icepool", "qualname": "from_rv", "kind": "function", "doc": "

Constructs a Die from a rv object (as scipy.stats).

\n\n
Arguments:
\n\n
    \n
  • rv: A rv object (as scipy.stats).
    • \n
  • outcomes: An iterable of ints or floats that will be the outcomes\nof the resulting Die.\nIf the distribution is discrete, outcomes must be ints.
    • \n
  • denominator: The denominator of the resulting Die will be set to this.
    • \n
  • **kwargs: These will be forwarded to rv.cdf().
    • \n
\n", "signature": "(\trv,\toutcomes: Union[Sequence[int], Sequence[float]],\tdenominator: int,\t**kwargs) -> icepool.population.die.Die[int] | icepool.population.die.Die[float]:", "funcdef": "def"}, "icepool.lowest": {"fullname": "icepool.lowest", "modulename": "icepool", "qualname": "lowest", "kind": "function", "doc": "

The lowest outcome among the rolls, or the sum of some of the lowest.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • args: Dice or individual outcomes in a single iterable, or as two or\nmore separate arguments. Similar to the built-in min().
    • \n
  • keep: The number of lowest dice will be summed.
    • \n
  • drop: This number of lowest dice will be dropped before keeping dice\nto be summed.
    • \n
  • default: If an empty iterable is provided, the result will be a die that\nalways rolls this value.
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError if an empty iterable is provided with no default.
    • \n
\n", "signature": "(\targ0,\t/,\t*more_args: Union[~T, icepool.population.die.Die[~T]],\tkeep: int = 1,\tdrop: int = 0,\tdefault: Optional[~T] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.highest": {"fullname": "icepool.highest", "modulename": "icepool", "qualname": "highest", "kind": "function", "doc": "

The highest outcome among the rolls, or the sum of some of the highest.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • args: Dice or individual outcomes in a single iterable, or as two or\nmore separate arguments. Similar to the built-in max().
    • \n
  • keep: The number of highest dice will be summed.
    • \n
  • drop: This number of highest dice will be dropped before keeping dice\nto be summed.
    • \n
  • default: If an empty iterable is provided, the result will be a die that\nalways rolls this value.
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError if an empty iterable is provided with no default.
    • \n
\n", "signature": "(\targ0,\t/,\t*more_args: Union[~T, icepool.population.die.Die[~T]],\tkeep: int = 1,\tdrop: int = 0,\tdefault: Optional[~T] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.middle": {"fullname": "icepool.middle", "modulename": "icepool", "qualname": "middle", "kind": "function", "doc": "

The middle of the outcomes among the rolls, or the sum of some of the middle.

\n\n

The outcomes should support addition and multiplication if keep != 1.

\n\n
Arguments:
\n\n
    \n
  • args: Dice or individual outcomes in a single iterable, or as two or\nmore separate arguments.
    • \n
  • keep: The number of outcomes to sum.
    • \n
  • tie: What to do if keep is odd but the the number of args is even, or\nvice versa.\n
      \n
    • 'error' (default): Raises IndexError.
      • \n
    • 'high': The higher outcome is taken.
      • \n
    • 'low': The lower outcome is taken.
      • \n
    • \n
  • default: If an empty iterable is provided, the result will be a die that\nalways rolls this value.
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError if an empty iterable is provided with no default.
    • \n
\n", "signature": "(\targ0,\t/,\t*more_args: Union[~T, icepool.population.die.Die[~T]],\tkeep: int = 1,\ttie: Literal['error', 'high', 'low'] = 'error',\tdefault: Optional[~T] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.min_outcome": {"fullname": "icepool.min_outcome", "modulename": "icepool", "qualname": "min_outcome", "kind": "function", "doc": "

The minimum outcome among the dice.

\n", "signature": "(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T:", "funcdef": "def"}, "icepool.max_outcome": {"fullname": "icepool.max_outcome", "modulename": "icepool", "qualname": "max_outcome", "kind": "function", "doc": "

The maximum outcome among the dice.

\n", "signature": "(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T:", "funcdef": "def"}, "icepool.align": {"fullname": "icepool.align", "modulename": "icepool", "qualname": "align", "kind": "function", "doc": "

Pads dice with zero quantities so that all have the same set of outcomes.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of aligned dice.

\n
\n", "signature": "(\t*dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]:", "funcdef": "def"}, "icepool.align_range": {"fullname": "icepool.align_range", "modulename": "icepool", "qualname": "align_range", "kind": "function", "doc": "

Pads dice with zero quantities so that all have the same set of consecutive int outcomes.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of aligned dice.

\n
\n", "signature": "(\t*dice: int | icepool.population.die.Die[int]) -> tuple[icepool.population.die.Die[int], ...]:", "funcdef": "def"}, "icepool.commonize_denominator": {"fullname": "icepool.commonize_denominator", "modulename": "icepool", "qualname": "commonize_denominator", "kind": "function", "doc": "

Scale the weights of the dice so that all of them have the same denominator.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of dice with the same denominator.

\n
\n", "signature": "(\t*dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]:", "funcdef": "def"}, "icepool.reduce": {"fullname": "icepool.reduce", "modulename": "icepool", "qualname": "reduce", "kind": "function", "doc": "

Applies a function of two arguments cumulatively to a sequence of dice.

\n\n

Analogous to\nfunctools.reduce().

\n\n
Arguments:
\n\n
    \n
  • func: The function to map. The function should take two arguments,\nwhich are an outcome from each of two dice, and produce an outcome\nof the same type. It may also return Reroll, in which case the\nentire sequence is effectively rerolled.
    • \n
  • dice: A sequence of dice to map the function to, from left to right.
    • \n
  • initial: If provided, this will be placed at the front of the sequence\nof dice.
    • \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\tfunc: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType]],\tdice: Iterable[Union[~T, icepool.population.die.Die[~T]]],\t*,\tinitial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.accumulate": {"fullname": "icepool.accumulate", "modulename": "icepool", "qualname": "accumulate", "kind": "function", "doc": "

Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.

\n\n

Analogous to\nitertools.accumulate()\n, though with no default function and\nthe same parameter order as reduce().

\n\n

The number of results is equal to the number of elements of dice, with\none additional element if initial is provided.

\n\n
Arguments:
\n\n
    \n
  • func: The function to map. The function should take two arguments,\nwhich are an outcome from each of two dice.
    • \n
  • dice: A sequence of dice to map the function to, from left to right.
    • \n
  • initial: If provided, this will be placed at the front of the sequence\nof dice.
    • \n
\n", "signature": "(\tfunc: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T]]],\tdice: Iterable[Union[~T, icepool.population.die.Die[~T]]],\t*,\tinitial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> Iterator[icepool.population.die.Die[~T]]:", "funcdef": "def"}, "icepool.map": {"fullname": "icepool.map", "modulename": "icepool", "qualname": "map", "kind": "function", "doc": "

Applies func(outcome_of_die_0, outcome_of_die_1, ...) for all joint outcomes.

\n\n

See map_function for a decorator version of this.

\n\n

Example: map(lambda a, b: a + b, d6, d6) is the same as d6 + d6.

\n\n

map() is flexible but not very efficient for more than a few dice.\nIf at all possible, use reduce(), MultisetExpression methods, and/or\nMultisetEvaluators. Even Pool.expand() (which sorts rolls) is more\nefficient than using map on the dice in order.

\n\n

Again can be used but is not recommended with repeat other than 1.\nIt will re-roll the current stage, not the entire series.

\n\n
Arguments:
\n\n
    \n
  • repl: One of the following:\n
      \n
    • A callable that takes in one outcome per element of args and\nproduces a new outcome.
      • \n
    • A mapping from old outcomes to new outcomes.\nUnmapped old outcomes stay the same.\nIn this case args must have exactly one element.\nThe new outcomes may be dice rather than just single outcomes.\nThe special value icepool.Reroll will reroll that old outcome.
      • \n
    • \n
  • *args: func will be called with all joint outcomes of these.\nAllowed arg types are:\n
      \n
    • Single outcome.
      • \n
    • Die. All outcomes will be sent to func.
      • \n
    • MultisetExpression. All sorted tuples of outcomes will be sent\nto func, as MultisetExpression.expand(). The expression must\nbe fully bound.
      • \n
    • \n
  • star: If True, the first of the args will be unpacked before giving\nthem to func.\nIf not provided, it will be guessed based on the signature of func\nand the number of arguments.
    • \n

  • repeat: This will be repeated with the same arguments on the\nresult this many times, except the first of args will be replaced\nby the result of the previous iteration.

    \n\n

    EXPERIMENTAL: If set to None, the result will be as if this\nwere repeated an infinite number of times. In this case, the\nresult will be in simplest form.

    • \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\trepl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]],\t/,\t*args: icepool.typing.Outcome | icepool.population.die.Die | icepool.expression.multiset_expression.MultisetExpression,\tstar: bool | None = None,\trepeat: int | None = 1,\tagain_depth: int = 1,\tagain_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.map_function": {"fullname": "icepool.map_function", "modulename": "icepool", "qualname": "map_function", "kind": "function", "doc": "

Decorator that turns a function that takes outcomes into a function that takes dice.

\n\n

The result must be a Die.

\n\n

This is basically a decorator version of map() and produces behavior\nsimilar to AnyDice functions, though Icepool has different typing rules\namong other differences.

\n\n

map_function can either be used with no arguments:

\n\n
@map_function\ndef explode_six(x):\n    if x == 6:\n        return 6 + Again\n    else:\n        return x\n\nexplode_six(d6, again_depth=2)\n
\n\n

Or with keyword arguments, in which case the extra arguments are bound:

\n\n
@map_function(again_depth=2)\ndef explode_six(x):\n    if x == 6:\n        return 6 + Again\n    else:\n        return x\n\nexplode_six(d6)\n
\n\n
Arguments:
\n\n
    \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\tfunc: Optional[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]] = None,\t/,\t*,\tstar: bool | None = None,\trepeat: int | None = 1,\tagain_depth: int = 1,\tagain_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> Union[Callable[..., icepool.population.die.Die[~T]], Callable[..., Callable[..., icepool.population.die.Die[~T]]]]:", "funcdef": "def"}, "icepool.map_and_time": {"fullname": "icepool.map_and_time", "modulename": "icepool", "qualname": "map_and_time", "kind": "function", "doc": "

Repeatedly map outcomes of the state to other outcomes, while also\ncounting timesteps.

\n\n

This is useful for representing processes.

\n\n

The outcomes of the result are (outcome, time), where time is the\nnumber of repeats needed to reach an absorbing outcome (an outcome that\nonly leads to itself), or repeat, whichever is lesser.

\n\n

This will return early if it reaches a fixed point.\nTherefore, you can set repeat equal to the maximum number of\ntime you could possibly be interested in without worrying about\nit causing extra computations after the fixed point.

\n\n
Arguments:
\n\n
    \n
  • repl: One of the following:\n
      \n
    • A callable returning a new outcome for each old outcome.
      • \n
    • A mapping from old outcomes to new outcomes.\nUnmapped old outcomes stay the same.\nThe new outcomes may be dice rather than just single outcomes.\nThe special value icepool.Reroll will reroll that old outcome.
      • \n
    • \n
  • star: If True, the first of the args will be unpacked before giving\nthem to func.\nIf not provided, it will be guessed based on the signature of func\nand the number of arguments.
    • \n
  • repeat: This will be repeated with the same arguments on the result\nthis many times.
    • \n
\n\n
Returns:
\n\n
\n

The Die after the modification.

\n
\n", "signature": "(\trepl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]],\tstate,\t/,\t*extra_args,\tstar: bool | None = None,\trepeat: int) -> icepool.population.die.Die[tuple[~T, int]]:", "funcdef": "def"}, "icepool.Reroll": {"fullname": "icepool.Reroll", "modulename": "icepool", "qualname": "Reroll", "kind": "variable", "doc": "

Indicates that an outcome should be rerolled (with unlimited depth).

\n\n

This can be used in place of outcomes in many places. See individual function\nand method descriptions for details.

\n\n

This effectively removes the outcome from the probability space, along with its\ncontribution to the denominator.

\n\n

This can be used for conditional probability by removing all outcomes not\nconsistent with the given observations.

\n\n

Operation in specific cases:

\n\n
    \n
  • When used with Again, only that stage is rerolled, not the entire Again\ntree.
    • \n
  • To reroll with limited depth, use Die.reroll(), or Again with no\nmodification.
    • \n
  • When used with MultisetEvaluator, the entire evaluation is rerolled.
    • \n
\n", "annotation": ": Final", "default_value": "<RerollType.Reroll: 'Reroll'>"}, "icepool.RerollType": {"fullname": "icepool.RerollType", "modulename": "icepool", "qualname": "RerollType", "kind": "class", "doc": "

The type of the Reroll singleton.

\n", "bases": "enum.Enum"}, "icepool.RerollType.Reroll": {"fullname": "icepool.RerollType.Reroll", "modulename": "icepool", "qualname": "RerollType.Reroll", "kind": "variable", "doc": "

Indicates an outcome should be rerolled (with unlimited depth).

\n", "default_value": "<RerollType.Reroll: 'Reroll'>"}, "icepool.Pool": {"fullname": "icepool.Pool", "modulename": "icepool", "qualname": "Pool", "kind": "class", "doc": "

Represents a multiset of outcomes resulting from the roll of several dice.

\n\n

This should be used in conjunction with MultisetEvaluator to generate a\nresult.

\n\n

Note that operators are performed on the multiset of rolls, not the multiset\nof dice. For example, d6.pool(3) - d6.pool(3) is not an empty pool, but\nan expression meaning \"roll two pools of 3d6 and get the rolls from the\nfirst pool, with rolls in the second pool cancelling matching rolls in the\nfirst pool one-for-one\".

\n", "bases": "icepool.generator.multiset_generator.MultisetGenerator[~T, tuple[int]]"}, "icepool.Pool.__init__": {"fullname": "icepool.Pool.__init__", "modulename": "icepool", "qualname": "Pool.__init__", "kind": "function", "doc": "

Public constructor for a pool.

\n\n

Evaulation is most efficient when the dice are the same or same-side\ntruncations of each other. For example, d4, d6, d8, d10, d12 are all\nsame-side truncations of d12.

\n\n

It is permissible to create a Pool without providing dice, but not all\nevaluators will handle this case, especially if they depend on the\noutcome type. In this case you may want to provide a die with zero\nquantity.

\n\n
Arguments:
\n\n
    \n

  • dice: The dice to put in the Pool. This can be one of the following:

    \n\n
      \n
    • A Sequence of Die or outcomes.
      • \n
    • A Mapping of Die or outcomes to how many of that Die or\noutcome to put in the Pool.
      • \n
    \n\n

    All outcomes within a Pool must be totally orderable.

    • \n
  • times: Multiplies the number of times each element of dice will\nbe put into the pool.\ntimes can either be a sequence of the same length as\noutcomes or a single int to apply to all elements of\noutcomes.
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError: If a bare Deck or Die argument is provided.\nA Pool of a single Die should constructed as Pool([die]).
    • \n
\n", "signature": "(\tdice: Union[Sequence[Union[icepool.population.die.Die[~T], ~T]], Mapping[icepool.population.die.Die[~T], int], Mapping[~T, int], Mapping[Union[icepool.population.die.Die[~T], ~T], int]],\ttimes: Union[Sequence[int], int] = 1)"}, "icepool.Pool.clear_cache": {"fullname": "icepool.Pool.clear_cache", "modulename": "icepool", "qualname": "Pool.clear_cache", "kind": "function", "doc": "

Clears the global pool cache.

\n", "signature": "(cls):", "funcdef": "def"}, "icepool.Pool.raw_size": {"fullname": "icepool.Pool.raw_size", "modulename": "icepool", "qualname": "Pool.raw_size", "kind": "function", "doc": "

The number of dice in this pool before the keep_tuple is applied.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Pool.keep_size": {"fullname": "icepool.Pool.keep_size", "modulename": "icepool", "qualname": "Pool.keep_size", "kind": "function", "doc": "

The total count produced by this pool after the keep_tuple is applied.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Pool.denominator": {"fullname": "icepool.Pool.denominator", "modulename": "icepool", "qualname": "Pool.denominator", "kind": "function", "doc": "

The total weight of all paths through this generator.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Pool.unique_dice": {"fullname": "icepool.Pool.unique_dice", "modulename": "icepool", "qualname": "Pool.unique_dice", "kind": "function", "doc": "

The collection of unique dice in this pool.

\n", "signature": "(self) -> Collection[icepool.population.die.Die[~T]]:", "funcdef": "def"}, "icepool.Pool.outcomes": {"fullname": "icepool.Pool.outcomes", "modulename": "icepool", "qualname": "Pool.outcomes", "kind": "function", "doc": "

The union of possible outcomes among all dice in this pool in ascending order.

\n", "signature": "(self) -> Sequence[~T]:", "funcdef": "def"}, "icepool.Pool.output_arity": {"fullname": "icepool.Pool.output_arity", "modulename": "icepool", "qualname": "Pool.output_arity", "kind": "function", "doc": "

The number of multisets/counts generated. Must be constant.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Pool.keep_tuple": {"fullname": "icepool.Pool.keep_tuple", "modulename": "icepool", "qualname": "Pool.keep_tuple", "kind": "function", "doc": "

The tuple indicating which dice in the pool will be counted.

\n\n

The tuple has one element per Die in the pool, from lowest roll to\nhighest roll. The Die in the corresponding sorted position will be\ncounted that many times.

\n", "signature": "(self) -> tuple[int, ...]:", "funcdef": "def"}, "icepool.Pool.min_outcome": {"fullname": "icepool.Pool.min_outcome", "modulename": "icepool", "qualname": "Pool.min_outcome", "kind": "function", "doc": "

The min outcome among all dice in this pool.

\n", "signature": "(self) -> ~T:", "funcdef": "def"}, "icepool.Pool.max_outcome": {"fullname": "icepool.Pool.max_outcome", "modulename": "icepool", "qualname": "Pool.max_outcome", "kind": "function", "doc": "

The max outcome among all dice in this pool.

\n", "signature": "(self) -> ~T:", "funcdef": "def"}, "icepool.Pool.keep": {"fullname": "icepool.Pool.keep", "modulename": "icepool", "qualname": "Pool.keep", "kind": "function", "doc": "

A Pool with the selected dice counted after rolling and sorting.

\n\n

Use pool[index] for the same effect as this method.

\n\n

The rolls are sorted in ascending order for this purpose,\nregardless of which order the outcomes are evaluated in.

\n\n

For example, here are some ways of selecting the two highest rolls out\nof five:

\n\n
    \n
  • pool[3:5]
    • \n
  • pool[3:]
    • \n
  • pool[-2:]
    • \n
  • pool[..., 1, 1]
    • \n
  • pool[0, 0, 0, 1, 1]
    • \n
\n\n

These will count the highest as a positive and the lowest as a negative:

\n\n
    \n
  • pool[-1, 0, 0, 0, 1]
    • \n
  • pool[-1, ..., 1]
    • \n
\n\n

The valid types of argument are:

\n\n
    \n
  • An int. This will count only the roll at the specified index.\nIn this case, the result is a Die rather than a Pool.
    • \n
  • A slice. The selected dice are counted once each.
    • \n

  • A sequence of one int for each Die.\nEach roll is counted that many times, which could be multiple or\nnegative times.

    \n\n

    Up to one ... (Ellipsis) may be used.\n... will be replaced with a number of zero\ncounts depending on the size of the pool.\nThis number may be \"negative\" if more ints are provided than\nthe size of the Pool. Specifically:

    \n\n
      \n
    • If index is shorter than size, ...\nacts as enough zero counts to make up the difference.\nE.g. pool[1, ..., 1] on five dice would act as\npool[1, 0, 0, 0, 1].
      • \n
    • If index has length equal to size, ... has no effect.\nE.g. pool[1, ..., 1] on two dice would act as pool[1, 1].
      • \n
    • If index is longer than size and ... is on one side,\nelements will be dropped from index on the side with ....\nE.g. pool[..., 1, 2, 3] on two dice would act as pool[2, 3].
      • \n
    • If index is longer than size and ...\nis in the middle, the counts will be as the sum of two\none-sided ....\nE.g. pool[-1, ..., 1] acts like [-1, ...] plus [..., 1].\nOn a Pool consisting of a single Die this would have\nthe -1 and 1 cancel each other out.
      • \n
    • \n
\n\n

If this is called more than once, the selection is applied relative\nto the previous keep_tuple. For example, applying [:2][-1] would\nproduce the second-lowest roll.

\n\n
Raises:
\n\n
    \n
  • IndexError: If:\n
      \n
    • More than one ... is used.
      • \n
    • The current keep_tuple has negative counts.
      • \n
    • The provided index specifies a fixed length that is\ndifferent than the total of the counts in the current\nkeep_tuple.
      • \n
    • \n
\n", "signature": "(\tself,\tindex: Union[slice, Sequence[int | ellipsis], int]) -> Union[icepool.generator.pool.Pool[~T], icepool.population.die.Die[~T]]:", "funcdef": "def"}, "icepool.Pool.lowest": {"fullname": "icepool.Pool.lowest", "modulename": "icepool", "qualname": "Pool.lowest", "kind": "function", "doc": "

Keep some of the lowest elements from this multiset and drop the rest.

\n\n

In contrast to the die and free function versions, this does not\nautomatically sum the dice. Use .sum() afterwards if you want to sum.\nAlternatively, you can perform some other evaluation.

\n\n

This requires the outcomes to be evaluated in ascending order.

\n\n
Arguments:
\n\n
    \n
  • keep: The number of lowest elements will be kept.
    • \n
  • drop: This number of lowest elements will be dropped before keeping.
    • \n
\n", "signature": "(self, keep: int = 1, drop: int = 0) -> icepool.generator.pool.Pool[~T]:", "funcdef": "def"}, "icepool.Pool.highest": {"fullname": "icepool.Pool.highest", "modulename": "icepool", "qualname": "Pool.highest", "kind": "function", "doc": "

Keep some of the highest elements from this multiset and drop the rest.

\n\n

In contrast to the die and free function versions, this does not\nautomatically sum the dice. Use .sum() afterwards if you want to sum.\nAlternatively, you can perform some other evaluation.

\n\n

This requires the outcomes to be evaluated in descending order.

\n\n
Arguments:
\n\n
    \n
  • keep: The number of highest elements will be kept.
    • \n
  • drop: This number of highest elements will be dropped before keeping.
    • \n
\n", "signature": "(self, keep: int = 1, drop: int = 0) -> icepool.generator.pool.Pool[~T]:", "funcdef": "def"}, "icepool.Pool.middle": {"fullname": "icepool.Pool.middle", "modulename": "icepool", "qualname": "Pool.middle", "kind": "function", "doc": "

Keep some of the middle elements from this multiset and drop the rest.

\n\n

In contrast to the die and free function versions, this does not\nautomatically sum the dice. Use .sum() afterwards if you want to sum.\nAlternatively, you can perform some other evaluation.

\n\n
Arguments:
\n\n
    \n
  • keep: The number of elements to keep. If this is greater than the\ncurrent keep_size, all are kept.
    • \n
  • tie: What to do if keep is odd but the current keep_size\nis even, or vice versa.\n
      \n
    • 'error' (default): Raises IndexError.
      • \n
    • 'low': The lower of the two possible elements is taken.
      • \n
    • 'high': The higher of the two possible elements is taken.
      • \n
    • \n
\n", "signature": "(\tself,\tkeep: int = 1,\t*,\ttie: Literal['error', 'high', 'low'] = 'error') -> icepool.generator.pool.Pool[~T]:", "funcdef": "def"}, "icepool.Pool.additive_union": {"fullname": "icepool.Pool.additive_union", "modulename": "icepool", "qualname": "Pool.additive_union", "kind": "function", "doc": "

The combined elements from all the multisets.

\n\n

We have an optimization here if all arguments are pools with all sorted\npositions counted the same. In this case we can merge the pools directly\ninstead of merging the rolls after the fact.

\n\n

keep_negative_counts: If set, if the result would have a negative \n count, it is preserved. Otherwise, negative counts in the result\n are set to zero, similar to the behavior of\n collections.Counter.

\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[~T], Mapping[~T, int], Sequence[~T]],\tkeep_negative_counts: bool = False) -> icepool.expression.multiset_expression.MultisetExpression[~T]:", "funcdef": "def"}, "icepool.Pool.multiply_counts": {"fullname": "icepool.Pool.multiply_counts", "modulename": "icepool", "qualname": "Pool.multiply_counts", "kind": "function", "doc": "

Multiplies all counts by a constant.

\n\n

Same as self * constant.

\n\n

Example:

\n\n
Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]\n
\n", "signature": "(self, constant: int, /) -> icepool.generator.pool.Pool[~T]:", "funcdef": "def"}, "icepool.standard_pool": {"fullname": "icepool.standard_pool", "modulename": "icepool", "qualname": "standard_pool", "kind": "function", "doc": "

A Pool of standard dice (e.g. d6, d8...).

\n\n
Arguments:
\n\n
    \n
  • die_sizes: A collection of die sizes, which will put one die of that\nsizes in the pool for each element.\nOr, a mapping of die sizes to how many dice of that size to put\ninto the pool.\nIf empty, the pool will be considered to consist of 0d1.
    • \n
\n", "signature": "(\tdie_sizes: Union[Collection[int], Mapping[int, int]]) -> icepool.generator.pool.Pool[int]:", "funcdef": "def"}, "icepool.MultisetGenerator": {"fullname": "icepool.MultisetGenerator", "modulename": "icepool", "qualname": "MultisetGenerator", "kind": "class", "doc": "

Abstract base class for generating one or more multisets.

\n\n

These include dice pools (Pool) and card deals (Deal). Most likely you\nwill be using one of these two rather than writing your own subclass of\nMultisetGenerator.

\n\n

The multisets are incrementally generated one outcome at a time.\nFor each outcome, a count and weight are generated, along with a\nsmaller generator to produce the rest of the multiset.

\n\n

You can perform simple evaluations using built-in operators and methods in\nthis class.\nFor more complex evaluations and better performance, particularly when\nmultiple generators are involved, you will want to write your own subclass\nof MultisetEvaluator.

\n", "bases": "typing.Generic[~T, ~Qs], icepool.expression.multiset_expression.MultisetExpression[~T]"}, "icepool.MultisetGenerator.outcomes": {"fullname": "icepool.MultisetGenerator.outcomes", "modulename": "icepool", "qualname": "MultisetGenerator.outcomes", "kind": "function", "doc": "

The possible outcomes that could be generated, in ascending order.

\n", "signature": "(self) -> Sequence[~T]:", "funcdef": "def"}, "icepool.MultisetGenerator.output_arity": {"fullname": "icepool.MultisetGenerator.output_arity", "modulename": "icepool", "qualname": "MultisetGenerator.output_arity", "kind": "function", "doc": "

The number of multisets/counts generated. Must be constant.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.MultisetGenerator.denominator": {"fullname": "icepool.MultisetGenerator.denominator", "modulename": "icepool", "qualname": "MultisetGenerator.denominator", "kind": "function", "doc": "

The total weight of all paths through this generator.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.MultisetGenerator.equals": {"fullname": "icepool.MultisetGenerator.equals", "modulename": "icepool", "qualname": "MultisetGenerator.equals", "kind": "function", "doc": "

Whether this generator is logically equal to another object.

\n", "signature": "(self, other) -> bool:", "funcdef": "def"}, "icepool.MultisetGenerator.min_outcome": {"fullname": "icepool.MultisetGenerator.min_outcome", "modulename": "icepool", "qualname": "MultisetGenerator.min_outcome", "kind": "function", "doc": "

\n", "signature": "(self) -> ~T:", "funcdef": "def"}, "icepool.MultisetGenerator.max_outcome": {"fullname": "icepool.MultisetGenerator.max_outcome", "modulename": "icepool", "qualname": "MultisetGenerator.max_outcome", "kind": "function", "doc": "

\n", "signature": "(self) -> ~T:", "funcdef": "def"}, "icepool.MultisetGenerator.sample": {"fullname": "icepool.MultisetGenerator.sample", "modulename": "icepool", "qualname": "MultisetGenerator.sample", "kind": "function", "doc": "

EXPERIMENTAL: A single random sample from this generator.

\n\n

This uses the standard random package and is not cryptographically\nsecure.

\n\n
Returns:
\n\n
\n

A sorted tuple of outcomes for each output of this generator.

\n
\n", "signature": "(self) -> tuple[tuple, ...]:", "funcdef": "def"}, "icepool.Alignment": {"fullname": "icepool.Alignment", "modulename": "icepool", "qualname": "Alignment", "kind": "class", "doc": "

A generator that does not output any counts.

\n\n

This can be used to enforce that certain outcomes are seen without otherwise\naffecting a multiset evaluation.

\n", "bases": "icepool.generator.multiset_generator.MultisetGenerator[~T, tuple[()]]"}, "icepool.Alignment.__init__": {"fullname": "icepool.Alignment.__init__", "modulename": "icepool", "qualname": "Alignment.__init__", "kind": "function", "doc": "

\n", "signature": "(outcomes: Collection[~T])"}, "icepool.Alignment.outcomes": {"fullname": "icepool.Alignment.outcomes", "modulename": "icepool", "qualname": "Alignment.outcomes", "kind": "function", "doc": "

The possible outcomes that could be generated, in ascending order.

\n", "signature": "(self) -> Sequence[~T]:", "funcdef": "def"}, "icepool.Alignment.output_arity": {"fullname": "icepool.Alignment.output_arity", "modulename": "icepool", "qualname": "Alignment.output_arity", "kind": "function", "doc": "

The number of multisets/counts generated. Must be constant.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Alignment.denominator": {"fullname": "icepool.Alignment.denominator", "modulename": "icepool", "qualname": "Alignment.denominator", "kind": "function", "doc": "

The total weight of all paths through this generator.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.MultisetExpression": {"fullname": "icepool.MultisetExpression", "modulename": "icepool", "qualname": "MultisetExpression", "kind": "class", "doc": "

Abstract base class representing an expression that operates on multisets.

\n\n

Expression methods can be applied to MultisetGenerators to do simple\nevaluations. For joint evaluations, try multiset_function.

\n\n

Use the provided operations to build up more complicated\nexpressions, or to attach a final evaluator.

\n\n

Operations include:

\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n
OperationCount / notes
additive_union, +l + r
difference, -l - r
intersection, &min(l, r)
union, |max(l, r)
symmetric_difference, ^abs(l - r)
multiply_counts, *count * n
divide_counts, //count // n
keep_countscount if count >= n else 0
unary +same as keep_counts(0)
uniquemin(count, n)
keep_outcomescount if outcome in t else 0
drop_outcomescount if outcome not in t else 0
map_countsf(outcome, *counts)
keep, []less capable than Pool version
highestless capable than Pool version
lowestless capable than Pool version
\n\n\n\n\n \n \n\n\n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n \n \n\n\n
EvaluatorSummary
issubset, <=Whether the left side's counts are all <= their counterparts on the right
issuperset, >=Whether the left side's counts are all >= their counterparts on the right
isdisjointWhether the left side has no positive counts in common with the right side
<As <=, but False if the two multisets are equal
>As >=, but False if the two multisets are equal
==Whether the left side has all the same counts as the right side
!=Whether the left side has any different counts to the right side
expandAll elements in ascending order
sumSum of all elements
countThe number of elements
anyWhether there is at least 1 element
highest_outcome_and_countThe highest outcome and how many of that outcome
all_countsAll counts in descending order
largest_countThe single largest count, aka x-of-a-kind
largest_count_and_outcomeSame but also with the corresponding outcome
largest_straightLength of longest consecutive sequence
largest_straight_and_outcomeSame but also with the corresponding outcome
all_straightsLengths of all consecutive sequences in descending order
\n", "bases": "abc.ABC, typing.Generic[-T_contra]"}, "icepool.MultisetExpression.additive_union": {"fullname": "icepool.MultisetExpression.additive_union", "modulename": "icepool", "qualname": "MultisetExpression.additive_union", "kind": "function", "doc": "

The combined elements from all of the multisets.

\n\n

Same as a + b + c + ....

\n\n

Any resulting counts that would be negative are set to zero.

\n\n

Example:

\n\n
[1, 2, 2, 3] + [1, 2, 4] -> [1, 1, 2, 2, 2, 3, 4]\n
\n\n
Arguments:
\n\n
    \n
  • keep_negative_counts: If set, if the result would have a negative \ncount, it is preserved. Otherwise, negative counts in the result\nare set to zero, similar to the behavior of\ncollections.Counter.
    • \n
\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\tkeep_negative_counts: bool = False) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.difference": {"fullname": "icepool.MultisetExpression.difference", "modulename": "icepool", "qualname": "MultisetExpression.difference", "kind": "function", "doc": "

The elements from the left multiset that are not in any of the others.

\n\n

Same as a - b - c - ....

\n\n

Any resulting counts that would be negative are set to zero.

\n\n

Example:

\n\n
[1, 2, 2, 3] - [1, 2, 4] -> [2, 3]\n
\n\n

If no arguments are given, the result will be an empty multiset, i.e.\nall zero counts.

\n\n

Note that, as a multiset operation, this will only cancel elements 1:1.\nIf you want to drop all elements in a set of outcomes regardless of\ncount, either use drop_outcomes() instead, or use a large number of\ncounts on the right side.

\n\n
Arguments:
\n\n
    \n
  • keep_negative_counts: If set, if the result would have a negative \ncount, it is preserved. Otherwise, negative counts in the result\nare set to zero, similar to the behavior of\ncollections.Counter.
    • \n
\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\tkeep_negative_counts: bool = False) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.intersection": {"fullname": "icepool.MultisetExpression.intersection", "modulename": "icepool", "qualname": "MultisetExpression.intersection", "kind": "function", "doc": "

The elements that all the multisets have in common.

\n\n

Same as a & b & c & ....

\n\n

Any resulting counts that would be negative are set to zero.

\n\n

Example:

\n\n
[1, 2, 2, 3] & [1, 2, 4] -> [1, 2]\n
\n\n

Note that, as a multiset operation, this will only intersect elements\n1:1.\nIf you want to keep all elements in a set of outcomes regardless of\ncount, either use keep_outcomes() instead, or use a large number of\ncounts on the right side.

\n\n
Arguments:
\n\n
    \n
  • keep_negative_counts: If set, if the result would have a negative \ncount, it is preserved. Otherwise, negative counts in the result\nare set to zero, similar to the behavior of\ncollections.Counter.
    • \n
\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\tkeep_negative_counts: bool = False) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.union": {"fullname": "icepool.MultisetExpression.union", "modulename": "icepool", "qualname": "MultisetExpression.union", "kind": "function", "doc": "

The most of each outcome that appear in any of the multisets.

\n\n

Same as a | b | c | ....

\n\n

Any resulting counts that would be negative are set to zero.

\n\n

Example:

\n\n
[1, 2, 2, 3] | [1, 2, 4] -> [1, 2, 2, 3, 4]\n
\n\n
Arguments:
\n\n
    \n
  • keep_negative_counts: If set, if the result would have a negative \ncount, it is preserved. Otherwise, negative counts in the result\nare set to zero, similar to the behavior of\ncollections.Counter.
    • \n
\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\tkeep_negative_counts: bool = False) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.symmetric_difference": {"fullname": "icepool.MultisetExpression.symmetric_difference", "modulename": "icepool", "qualname": "MultisetExpression.symmetric_difference", "kind": "function", "doc": "

The elements that appear in the left or right multiset but not both.

\n\n

Same as a ^ b.

\n\n

Specifically, this produces the absolute difference between counts.\nIf you don't want negative counts to be used from the inputs, you can\ndo left.keep_counts(0) ^ right.keep_counts(0).

\n\n

Example:

\n\n
[1, 2, 2, 3] ^ [1, 2, 4] -> [2, 3, 4]\n
\n", "signature": "(\tself,\tother: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\t/) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.keep_outcomes": {"fullname": "icepool.MultisetExpression.keep_outcomes", "modulename": "icepool", "qualname": "MultisetExpression.keep_outcomes", "kind": "function", "doc": "

Keeps the elements in the target set of outcomes, and drops the rest by setting their counts to zero.

\n\n

This is similar to intersection(), except the right side is considered\nto have unlimited multiplicity.

\n\n
Arguments:
\n\n
    \n
  • target: A callable returning True iff the outcome should be kept,\nor an expression or collection of outcomes to keep.
    • \n
\n", "signature": "(\tself,\ttarget: Union[Callable[[-T_contra], bool], Collection[-T_contra], icepool.expression.multiset_expression.MultisetExpression[-T_contra]],\t/) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.drop_outcomes": {"fullname": "icepool.MultisetExpression.drop_outcomes", "modulename": "icepool", "qualname": "MultisetExpression.drop_outcomes", "kind": "function", "doc": "

Drops the elements in the target set of outcomes by setting their counts to zero, and keeps the rest.

\n\n

This is similar to difference(), except the right side is considered\nto have unlimited multiplicity.

\n\n
Arguments:
\n\n
    \n
  • target: A callable returning True iff the outcome should be\ndropped, or an expression or collection of outcomes to drop.
    • \n
\n", "signature": "(\tself,\ttarget: Union[Callable[[-T_contra], bool], Collection[-T_contra], icepool.expression.multiset_expression.MultisetExpression[-T_contra]],\t/) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.map_counts": {"fullname": "icepool.MultisetExpression.map_counts", "modulename": "icepool", "qualname": "MultisetExpression.map_counts", "kind": "function", "doc": "

Maps the counts to new counts.

\n\n
Arguments:
\n\n
    \n
  • function: A function that takes outcome, *counts and produces a\ncombined count.
    • \n
\n", "signature": "(\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\tfunction: Union[Callable[[int], int], Callable[[-T_contra, int], int]]) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.multiply_counts": {"fullname": "icepool.MultisetExpression.multiply_counts", "modulename": "icepool", "qualname": "MultisetExpression.multiply_counts", "kind": "function", "doc": "

Multiplies all counts by a constant.

\n\n

Same as self * constant.

\n\n

Example:

\n\n
Pool([1, 2, 2, 3]) * 2 -> [1, 1, 2, 2, 2, 2, 3, 3]\n
\n", "signature": "(\tself,\tconstant: int,\t/) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.divide_counts": {"fullname": "icepool.MultisetExpression.divide_counts", "modulename": "icepool", "qualname": "MultisetExpression.divide_counts", "kind": "function", "doc": "

Divides all counts by a constant (rounding down).

\n\n

Same as self // constant.

\n\n

Example:

\n\n
Pool([1, 2, 2, 3]) // 2 -> [2]\n
\n", "signature": "(\tself,\tconstant: int,\t/) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.keep_counts": {"fullname": "icepool.MultisetExpression.keep_counts", "modulename": "icepool", "qualname": "MultisetExpression.keep_counts", "kind": "function", "doc": "

Counts less than min_count are treated as zero.

\n\n

For example, expression.keep_counts(2) would only produce\npairs and better.

\n\n

expression.keep_counts(0) is useful for removing negative counts. \nYou can use the unary operator +expression for the same effect.

\n\n

Example:

\n\n
Pool([1, 2, 2, 3]).keep_counts(2) -> [2, 2]\n
\n", "signature": "(\tself,\tmin_count: int) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.unique": {"fullname": "icepool.MultisetExpression.unique", "modulename": "icepool", "qualname": "MultisetExpression.unique", "kind": "function", "doc": "

Counts each outcome at most max_count times.

\n\n

For example, generator.unique(2) would count each outcome at most\ntwice.

\n\n

Example:

\n\n
Pool([1, 2, 2, 3]).unique() -> [1, 2, 3]\n
\n", "signature": "(\tself,\tmax_count: int = 1) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.keep": {"fullname": "icepool.MultisetExpression.keep", "modulename": "icepool", "qualname": "MultisetExpression.keep", "kind": "function", "doc": "

Selects pulls after drawing and sorting.

\n\n

This is less capable and less efficient than the Pool version.\nIn particular, it does not know how many elements it is selecting from,\nso it must be anchored at the starting end. The advantage is that it\ncan be applied to any expression.

\n\n

The valid types of argument are:

\n\n
    \n
  • A slice. If both start and stop are provided, they must both be\nnon-negative or both be negative. step is not supported.
    • \n
  • A sequence of int with ... (Ellipsis) at exactly one end.\nEach sorted element will be counted that many times, with the\nEllipsis treated as enough zeros (possibly \"negative\") to\nfill the rest of the elements.
    • \n
  • An int, which evaluates by taking the element at the specified\nindex. In this case the result is a Die (if fully bound) or a\nMultisetEvaluator (if there are free variables).
    • \n
\n\n

Use the [] operator for the same effect as this method.

\n", "signature": "(\tself,\tindex: Union[slice, Sequence[int | ellipsis], int]) -> Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], icepool.population.die.Die[-T_contra], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, -T_contra]]:", "funcdef": "def"}, "icepool.MultisetExpression.lowest": {"fullname": "icepool.MultisetExpression.lowest", "modulename": "icepool", "qualname": "MultisetExpression.lowest", "kind": "function", "doc": "

Keep some of the lowest elements from this multiset and drop the rest.

\n\n

In contrast to the die and free function versions, this does not\nautomatically sum the dice. Use .sum() afterwards if you want to sum.\nAlternatively, you can perform some other evaluation.

\n\n

This requires the outcomes to be evaluated in ascending order.

\n\n
Arguments:
\n\n
    \n
  • keep: The number of lowest elements will be kept.
    • \n
  • drop: This number of lowest elements will be dropped before keeping.
    • \n
\n", "signature": "(\tself,\tkeep: int = 1,\tdrop: int = 0) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.highest": {"fullname": "icepool.MultisetExpression.highest", "modulename": "icepool", "qualname": "MultisetExpression.highest", "kind": "function", "doc": "

Keep some of the highest elements from this multiset and drop the rest.

\n\n

In contrast to the die and free function versions, this does not\nautomatically sum the dice. Use .sum() afterwards if you want to sum.\nAlternatively, you can perform some other evaluation.

\n\n

This requires the outcomes to be evaluated in descending order.

\n\n
Arguments:
\n\n
    \n
  • keep: The number of highest elements will be kept.
    • \n
  • drop: This number of highest elements will be dropped before keeping.
    • \n
\n", "signature": "(\tself,\tkeep: int = 1,\tdrop: int = 0) -> icepool.expression.multiset_expression.MultisetExpression[-T_contra]:", "funcdef": "def"}, "icepool.MultisetExpression.evaluate": {"fullname": "icepool.MultisetExpression.evaluate", "modulename": "icepool", "qualname": "MultisetExpression.evaluate", "kind": "function", "doc": "

Attaches a final MultisetEvaluator to expressions.

\n\n

All of the MultisetExpression methods below are evaluations,\nas are the operators <, <=, >, >=, !=, ==. This means if the\nexpression is fully bound, it will be evaluated to a Die.

\n\n
Returns:
\n\n
\n

A Die if the expression is are fully bound.\n A MultisetEvaluator otherwise.

\n
\n", "signature": "(\t*expressions: icepool.expression.multiset_expression.MultisetExpression[-T_contra],\tevaluator: icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, ~U]) -> Union[icepool.population.die.Die[~U], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, ~U]]:", "funcdef": "def"}, "icepool.MultisetExpression.expand": {"fullname": "icepool.MultisetExpression.expand", "modulename": "icepool", "qualname": "MultisetExpression.expand", "kind": "function", "doc": "

Evaluation: All elements of the multiset in ascending order.

\n\n

This is expensive and not recommended unless there are few possibilities.

\n\n
Arguments:
\n\n
    \n
  • order: Whether the elements are in ascending (default) or descending\norder.
    • \n
\n", "signature": "(\tself,\torder: icepool.typing.Order = <Order.Ascending: 1>) -> Union[icepool.population.die.Die[tuple[-T_contra, ...]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple[-T_contra, ...]]]:", "funcdef": "def"}, "icepool.MultisetExpression.sum": {"fullname": "icepool.MultisetExpression.sum", "modulename": "icepool", "qualname": "MultisetExpression.sum", "kind": "function", "doc": "

Evaluation: The sum of all elements.

\n", "signature": "(\tself,\tmap: Union[Callable[[-T_contra], ~U], Mapping[-T_contra, ~U], NoneType] = None) -> Union[icepool.population.die.Die[~U], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, ~U]]:", "funcdef": "def"}, "icepool.MultisetExpression.count": {"fullname": "icepool.MultisetExpression.count", "modulename": "icepool", "qualname": "MultisetExpression.count", "kind": "function", "doc": "

Evaluation: The total number of elements in the multiset.

\n\n

This is usually not very interesting unless some other operation is\nperformed first. Examples:

\n\n

generator.unique().count() will count the number of unique outcomes.

\n\n

(generator & [4, 5, 6]).count() will count up to one each of\n4, 5, and 6.

\n", "signature": "(\tself) -> Union[icepool.population.die.Die[int], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, int]]:", "funcdef": "def"}, "icepool.MultisetExpression.any": {"fullname": "icepool.MultisetExpression.any", "modulename": "icepool", "qualname": "MultisetExpression.any", "kind": "function", "doc": "

Evaluation: Whether the multiset has at least one positive count.

\n", "signature": "(\tself) -> Union[icepool.population.die.Die[bool], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, bool]]:", "funcdef": "def"}, "icepool.MultisetExpression.highest_outcome_and_count": {"fullname": "icepool.MultisetExpression.highest_outcome_and_count", "modulename": "icepool", "qualname": "MultisetExpression.highest_outcome_and_count", "kind": "function", "doc": "

Evaluation: The highest outcome with positive count, along with that count.

\n\n

If no outcomes have positive count, the min outcome will be returned with 0 count.

\n", "signature": "(\tself) -> Union[icepool.population.die.Die[tuple[-T_contra, int]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple[-T_contra, int]]]:", "funcdef": "def"}, "icepool.MultisetExpression.all_counts": {"fullname": "icepool.MultisetExpression.all_counts", "modulename": "icepool", "qualname": "MultisetExpression.all_counts", "kind": "function", "doc": "

Evaluation: Sorted tuple of all counts, i.e. the sizes of all matching sets.

\n\n

The sizes are in descending order.

\n\n
Arguments:
\n\n
    \n

  • filter: Any counts below this value will not be in the output.\nFor example, filter=2 will only produce pairs and better.\nIf None, no filtering will be done.

    \n\n

    Why not just place keep_counts() before this?\nkeep_counts() operates by setting counts to zero, so you\nwould still need an argument to specify whether you want to\noutput zero counts. So we might as well use the argument to do\nboth.

    • \n
\n", "signature": "(\tself,\tfilter: int | None = 1) -> Union[icepool.population.die.Die[tuple[int, ...]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple[int, ...]]]:", "funcdef": "def"}, "icepool.MultisetExpression.largest_count": {"fullname": "icepool.MultisetExpression.largest_count", "modulename": "icepool", "qualname": "MultisetExpression.largest_count", "kind": "function", "doc": "

Evaluation: The size of the largest matching set among the elements.

\n", "signature": "(\tself) -> Union[icepool.population.die.Die[int], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, int]]:", "funcdef": "def"}, "icepool.MultisetExpression.largest_count_and_outcome": {"fullname": "icepool.MultisetExpression.largest_count_and_outcome", "modulename": "icepool", "qualname": "MultisetExpression.largest_count_and_outcome", "kind": "function", "doc": "

Evaluation: The largest matching set among the elements and the corresponding outcome.

\n", "signature": "(\tself) -> Union[icepool.population.die.Die[tuple[int, -T_contra]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple[int, -T_contra]]]:", "funcdef": "def"}, "icepool.MultisetExpression.largest_straight": {"fullname": "icepool.MultisetExpression.largest_straight", "modulename": "icepool", "qualname": "MultisetExpression.largest_straight", "kind": "function", "doc": "

Evaluation: The size of the largest straight among the elements.

\n\n

Outcomes must be ints.

\n", "signature": "(\tself: icepool.expression.multiset_expression.MultisetExpression[int]) -> Union[icepool.population.die.Die[int], icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, int]]:", "funcdef": "def"}, "icepool.MultisetExpression.largest_straight_and_outcome": {"fullname": "icepool.MultisetExpression.largest_straight_and_outcome", "modulename": "icepool", "qualname": "MultisetExpression.largest_straight_and_outcome", "kind": "function", "doc": "

Evaluation: The size of the largest straight among the elements and the highest outcome in that straight.

\n\n

Outcomes must be ints.

\n", "signature": "(\tself: icepool.expression.multiset_expression.MultisetExpression[int]) -> Union[icepool.population.die.Die[tuple[int, int]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, int]]]:", "funcdef": "def"}, "icepool.MultisetExpression.all_straights": {"fullname": "icepool.MultisetExpression.all_straights", "modulename": "icepool", "qualname": "MultisetExpression.all_straights", "kind": "function", "doc": "

Evaluation: The sizes of all straights.

\n\n

The sizes are in descending order.

\n\n

Each element can only contribute to one straight, though duplicates can\nproduce overlapping straights.

\n", "signature": "(\tself: icepool.expression.multiset_expression.MultisetExpression[int]) -> Union[icepool.population.die.Die[tuple[int, ...]], icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, ...]]]:", "funcdef": "def"}, "icepool.MultisetExpression.issubset": {"fullname": "icepool.MultisetExpression.issubset", "modulename": "icepool", "qualname": "MultisetExpression.issubset", "kind": "function", "doc": "

Evaluation: Whether this multiset is a subset of the other multiset.

\n\n

Specifically, if this multiset has a lesser or equal count for each\noutcome than the other multiset, this evaluates to True; \nif there is some outcome for which this multiset has a greater count \nthan the other multiset, this evaluates to False.

\n\n

issubset is the same as self <= other.

\n\n

self < other evaluates a proper subset relation, which is the same\nexcept the result is False if the two multisets are exactly equal.

\n", "signature": "(\tself,\tother: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\t/) -> Union[icepool.population.die.Die[bool], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, bool]]:", "funcdef": "def"}, "icepool.MultisetExpression.issuperset": {"fullname": "icepool.MultisetExpression.issuperset", "modulename": "icepool", "qualname": "MultisetExpression.issuperset", "kind": "function", "doc": "

Evaluation: Whether this multiset is a superset of the other multiset.

\n\n

Specifically, if this multiset has a greater or equal count for each\noutcome than the other multiset, this evaluates to True; \nif there is some outcome for which this multiset has a lesser count \nthan the other multiset, this evaluates to False.

\n\n

A typical use of this evaluation is testing for the presence of a\ncombo of cards in a hand, e.g.

\n\n
deck.deal(5) >= ['a', 'a', 'b']\n
\n\n

represents the chance that a deal of 5 cards contains at least two 'a's\nand one 'b'.

\n\n

issuperset is the same as self >= other.

\n\n

self > other evaluates a proper superset relation, which is the same\nexcept the result is False if the two multisets are exactly equal.

\n", "signature": "(\tself,\tother: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\t/) -> Union[icepool.population.die.Die[bool], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, bool]]:", "funcdef": "def"}, "icepool.MultisetExpression.isdisjoint": {"fullname": "icepool.MultisetExpression.isdisjoint", "modulename": "icepool", "qualname": "MultisetExpression.isdisjoint", "kind": "function", "doc": "

Evaluation: Whether this multiset is disjoint from the other multiset.

\n\n

Specifically, this evaluates to False if there is any outcome for\nwhich both multisets have positive count, and True if there is not.

\n", "signature": "(\tself,\tother: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\t/) -> Union[icepool.population.die.Die[bool], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, bool]]:", "funcdef": "def"}, "icepool.MultisetExpression.compair": {"fullname": "icepool.MultisetExpression.compair", "modulename": "icepool", "qualname": "MultisetExpression.compair", "kind": "function", "doc": "

Evaluation: EXPERIMENTAL: Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

\n\n

Interface is not stable yet.

\n\n

For example, left=1 would count how many pairs were won by the left\nside, and left=1, right=-1 would give the difference in the number of\npairs won by each side.

\n\n

Any score argument \n(initial, tie, left, right, extra_left, extra_right) \nnot provided will be set to a zero value determined from another score \nargument times 0.

\n\n
Arguments:
\n\n
    \n
  • op: Sets the score values based on the given operator and order.\nAllowed values are '<', '<=', '>', '>=', '==', '!='.\nEach pair that fits the comparator counts as 1.\nIf one side has more elements than the other, the extra\nelements are ignored.
    • \n
  • order: If descending (default), pairs are made in descending order\nand the higher element wins. If ascending, pairs are made in\nascending order and the lower element wins.
    • \n
  • initial: The initial score.
    • \n
  • tie: The score for each pair that is a tie.
    • \n
  • left: The score for each pair that left wins.
    • \n
  • right: The score for each pair that right wins.
    • \n
  • extra_left: If left has more elements, each extra element scores\nthis much.
    • \n
  • extra_right: If right has more elements, each extra element scores\nthis much.
    • \n
\n", "signature": "(\tself,\tother: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]],\top: Optional[Literal['<', '<=', '>', '>=', '==', '!=']] = None,\t/,\t*,\torder: icepool.typing.Order = <Order.Descending: -1>,\tinitial=None,\ttie=None,\tleft=None,\tright=None,\textra_left=None,\textra_right=None) -> Union[icepool.population.die.Die, icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, Any]]:", "funcdef": "def"}, "icepool.MultisetEvaluator": {"fullname": "icepool.MultisetEvaluator", "modulename": "icepool", "qualname": "MultisetEvaluator", "kind": "class", "doc": "

An abstract, immutable, callable class for evaulating one or more MultisetGenerators.

\n\n

There is one abstract method to implement: next_state().\nThis should incrementally calculate the result given one outcome at a time\nalong with how many of that outcome were produced.

\n\n

An example sequence of calls, as far as next_state() is concerned, is:

\n\n
    \n
  1. state = next_state(state=None, outcome=1, count_of_1s)
    2. \n
  2. state = next_state(state, 2, count_of_2s)
    3. \n
  3. state = next_state(state, 3, count_of_3s)
    4. \n
  4. state = next_state(state, 4, count_of_4s)
    5. \n
  5. state = next_state(state, 5, count_of_5s)
    6. \n
  6. state = next_state(state, 6, count_of_6s)
    7. \n
  7. outcome = final_outcome(state)
    8. \n
\n\n

A few other methods can optionally be overridden to further customize behavior.

\n\n

It is not expected that subclasses of MultisetEvaluator\nbe able to handle arbitrary types or numbers of generators.\nIndeed, most are expected to handle only a fixed number of generators,\nand often even only generators with a particular type of Die.

\n\n

Instances cache all intermediate state distributions.\nYou should therefore reuse instances when possible.

\n\n

Instances should not be modified after construction\nin any way that affects the return values of these methods.\nOtherwise, values in the cache may be incorrect.

\n", "bases": "abc.ABC, typing.Generic[-T_contra, +U_co]"}, "icepool.MultisetEvaluator.next_state": {"fullname": "icepool.MultisetEvaluator.next_state", "modulename": "icepool", "qualname": "MultisetEvaluator.next_state", "kind": "function", "doc": "

State transition function.

\n\n

This should produce a state given the previous state, an outcome,\nand the number that outcome produced by each generator.

\n\n

evaluate() will always call this using only positional arguments.\nFurthermore, there is no expectation that a subclass be able to handle\nan arbitrary number of counts. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *counts with a fixed set\nof parameters.

\n\n

Make sure to handle the base case where state is None.

\n\n

States must be hashable. At current, they do not have to be orderable.\nHowever, this may change in the future, and if they are not totally\norderable, you must override final_outcome to create totally orderable\nfinal outcomes.

\n\n

The behavior of returning a Die from next_state is currently\nundefined.

\n\n
Arguments:
\n\n
    \n
  • state: A hashable object indicating the state before rolling the\ncurrent outcome. If this is the first outcome being considered,\nstate will be None.
    • \n
  • outcome: The current outcome.\nnext_state will see all rolled outcomes in monotonic order;\neither ascending or descending depending on order().\nIf there are multiple generators, the set of outcomes is the\nunion of the outcomes of the invididual generators. All outcomes\nwith nonzero count will be seen. Outcomes with zero count\nmay or may not be seen. If you need to enforce that certain\noutcomes are seen even if they have zero count, see\nalignment().
    • \n
  • *counts: One value (usually an int) for each generator output\nindicating how many of the current outcome were produced.\nAll outcomes with nonzero count are guaranteed to be seen.\nTo guarantee that outcomes are seen even if they have zero\ncount, override alignment().
    • \n
\n\n
Returns:
\n\n
\n

A hashable object indicating the next state.\n The special value icepool.Reroll can be used to immediately remove\n the state from consideration, effectively performing a full reroll.

\n
\n", "signature": "(self, state: Hashable, outcome: -T_contra, /, *counts: int) -> Hashable:", "funcdef": "def"}, "icepool.MultisetEvaluator.final_outcome": {"fullname": "icepool.MultisetEvaluator.final_outcome", "modulename": "icepool", "qualname": "MultisetEvaluator.final_outcome", "kind": "function", "doc": "

Optional function to generate a final outcome from a final state.

\n\n

By default, the final outcome is equal to the final state.\nNote that None is not a valid outcome for a Die,\nand if there are no outcomes, final_outcome will be immediately\nbe callled with final_state=None.\nSubclasses that want to handle this case should explicitly define what\nhappens.

\n\n
Arguments:
\n\n
    \n
  • final_state: A state after all outcomes have been processed.
    • \n
\n\n
Returns:
\n\n
\n

A final outcome that will be used as part of constructing the result Die.\n As usual for Die(), this could itself be a Die or icepool.Reroll.

\n
\n", "signature": "(\tself,\tfinal_state: Hashable) -> Union[+U_co, icepool.population.die.Die[+U_co], icepool.typing.RerollType]:", "funcdef": "def"}, "icepool.MultisetEvaluator.order": {"fullname": "icepool.MultisetEvaluator.order", "modulename": "icepool", "qualname": "MultisetEvaluator.order", "kind": "function", "doc": "

Optional function to determine the order in which next_state() will see outcomes.

\n\n

The default is ascending order. This has better caching behavior with \nmixed standard dice.

\n\n
Returns:
\n\n
\n
    \n
  • Order.Ascending (= 1)\n if next_state() should always see the outcomes in ascending order.
    • \n
  • Order.Descending (= -1)\n if next_state() should always see the outcomes in descending order.
    • \n
  • Order.Any (= 0)\n if the result of the evaluation is order-independent.
    • \n
\n
\n", "signature": "(self) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.MultisetEvaluator.alignment": {"fullname": "icepool.MultisetEvaluator.alignment", "modulename": "icepool", "qualname": "MultisetEvaluator.alignment", "kind": "function", "doc": "

Optional method to specify additional outcomes that should be seen by next_state().

\n\n

These will be seen by next_state even if they have zero count or do\nnot appear in the generator(s) at all.

\n\n

The default implementation returns (); this means outcomes with zero\ncount may or may not be seen by next_state.

\n\n

If you want next_state to see consecutive int outcomes, you can set\nalignment = icepool.MultisetEvaluator.range_alignment.\nSee range_alignment() below.

\n\n

If you want next_state to see all generator outcomes, you can return\noutcomes as-is.

\n\n
Arguments:
\n\n
    \n
  • outcomes: The outcomes that could be produced by the generators, in
    • \n
  • ascending order.
    • \n
\n", "signature": "(self, outcomes: Sequence[-T_contra]) -> Collection[-T_contra]:", "funcdef": "def"}, "icepool.MultisetEvaluator.range_alignment": {"fullname": "icepool.MultisetEvaluator.range_alignment", "modulename": "icepool", "qualname": "MultisetEvaluator.range_alignment", "kind": "function", "doc": "

Example implementation of alignment() that produces consecutive int outcomes.

\n\n

There is no expectation that a subclass be able to handle\nan arbitrary number of generators. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *generators with a fixed\nset of parameters.

\n\n

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

\n\n
Returns:
\n\n
\n

All ints from the min outcome to the max outcome among the generators,\n inclusive.

\n
\n\n
Raises:
\n\n
    \n
  • TypeError: if any generator has any non-int outcome.
    • \n
\n", "signature": "(self, outcomes: Sequence[int]) -> Collection[int]:", "funcdef": "def"}, "icepool.MultisetEvaluator.prefix_generators": {"fullname": "icepool.MultisetEvaluator.prefix_generators", "modulename": "icepool", "qualname": "MultisetEvaluator.prefix_generators", "kind": "function", "doc": "

An optional sequence of extra generators whose counts will be prepended to *counts.

\n", "signature": "(\tself) -> tuple[icepool.generator.multiset_generator.MultisetGenerator, ...]:", "funcdef": "def"}, "icepool.MultisetEvaluator.validate_arity": {"fullname": "icepool.MultisetEvaluator.validate_arity", "modulename": "icepool", "qualname": "MultisetEvaluator.validate_arity", "kind": "function", "doc": "

An optional method to verify the total input arity.

\n\n

This is called after any implicit conversion to generators, but does\nnot include any extra_generators().

\n\n

Overriding next_state with a fixed number of counts will make this\ncheck redundant.

\n\n
Raises:
\n\n
    \n
  • ValueError if the total input arity is not valid.
    • \n
\n", "signature": "(self, arity: int) -> None:", "funcdef": "def"}, "icepool.MultisetEvaluator.evaluate": {"fullname": "icepool.MultisetEvaluator.evaluate", "modulename": "icepool", "qualname": "MultisetEvaluator.evaluate", "kind": "function", "doc": "

Evaluates generator(s).

\n\n

You can call the MultisetEvaluator object directly for the same effect,\ne.g. sum_evaluator(generator) is an alias for sum_evaluator.evaluate(generator).

\n\n

Most evaluators will expect a fixed number of input multisets.\nThe union of the outcomes of the generator(s) must be totally orderable.

\n\n
Arguments:
\n\n
    \n
  • *args: Each may be one of the following:\n
      \n
    • A GeneratorsWithExpression.
      • \n
    • A MultisetGenerator.
      • \n
    • A mappable mapping outcomes to the number of those outcomes.
      • \n
    • A sequence of outcomes.
      • \n
    • \n
\n\n
Returns:
\n\n
\n

A Die representing the distribution of the final outcome if no\n arg contains a free variable. Otherwise, returns a new evaluator.

\n
\n", "signature": "(\tself,\t*args: Union[icepool.expression.multiset_expression.MultisetExpression[-T_contra], Mapping[-T_contra, int], Sequence[-T_contra]]) -> Union[icepool.population.die.Die[+U_co], icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co]]:", "funcdef": "def"}, "icepool.MultisetEvaluator.sample": {"fullname": "icepool.MultisetEvaluator.sample", "modulename": "icepool", "qualname": "MultisetEvaluator.sample", "kind": "function", "doc": "

EXPERIMENTAL: Samples one result from the generator(s) and evaluates the result.

\n", "signature": "(\tself,\t*generators: Union[icepool.generator.multiset_generator.MultisetGenerator[-T_contra, Any], Mapping[-T_contra, int], Sequence[-T_contra]]):", "funcdef": "def"}, "icepool.Order": {"fullname": "icepool.Order", "modulename": "icepool", "qualname": "Order", "kind": "class", "doc": "

Can be used to define what order outcomes are seen in by MultisetEvaluators.

\n", "bases": "enum.IntEnum"}, "icepool.Order.Ascending": {"fullname": "icepool.Order.Ascending", "modulename": "icepool", "qualname": "Order.Ascending", "kind": "variable", "doc": "

\n", "default_value": "<Order.Ascending: 1>"}, "icepool.Order.Descending": {"fullname": "icepool.Order.Descending", "modulename": "icepool", "qualname": "Order.Descending", "kind": "variable", "doc": "

\n", "default_value": "<Order.Descending: -1>"}, "icepool.Order.Any": {"fullname": "icepool.Order.Any", "modulename": "icepool", "qualname": "Order.Any", "kind": "variable", "doc": "

\n", "default_value": "<Order.Any: 0>"}, "icepool.Order.merge": {"fullname": "icepool.Order.merge", "modulename": "icepool", "qualname": "Order.merge", "kind": "function", "doc": "

Merges the given Orders.

\n\n
Returns:
\n\n
\n

Any if all arguments are Any.\n Ascending if there is at least one Ascending in the arguments.\n Descending if there is at least one Descending in the arguments.

\n
\n\n
Raises:
\n\n
    \n
  • ValueError if both Ascending and Descending are in the
    • \n
  • arguments.
    • \n
\n", "signature": "(*orders: icepool.typing.Order) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.Deck": {"fullname": "icepool.Deck", "modulename": "icepool", "qualname": "Deck", "kind": "class", "doc": "

Sampling without replacement (within a single evaluation).

\n\n

Quantities represent duplicates.

\n", "bases": "icepool.population.base.Population[+T_co]"}, "icepool.Deck.__init__": {"fullname": "icepool.Deck.__init__", "modulename": "icepool", "qualname": "Deck.__init__", "kind": "function", "doc": "

Constructor for a Deck.

\n\n
Arguments:
\n\n
    \n

  • outcomes: The cards of the Deck. This can be one of the following:

    \n\n
      \n
    • A Sequence of outcomes. Duplicates will contribute\nquantity for each appearance.
      • \n
    • A Mapping from outcomes to quantities.
      • \n
    \n\n

    Each outcome may be one of the following:

    \n\n
      \n
    • An outcome, which must be hashable and totally orderable.
      • \n
    • A Deck, which will be flattened into the result. If a\ntimes is assigned to the Deck, the entire Deck will\nbe duplicated that many times.
      • \n
    • \n
  • times: Multiplies the number of times each element of outcomes\nwill be put into the Deck.\ntimes can either be a sequence of the same length as\noutcomes or a single int to apply to all elements of\noutcomes.
    • \n
\n", "signature": "(\toutcomes: Union[Sequence, Mapping[Any, int]],\ttimes: Union[Sequence[int], int] = 1)"}, "icepool.Deck.keys": {"fullname": "icepool.Deck.keys", "modulename": "icepool", "qualname": "Deck.keys", "kind": "function", "doc": "

The outcomes within the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsKeysView[+T_co]:", "funcdef": "def"}, "icepool.Deck.values": {"fullname": "icepool.Deck.values", "modulename": "icepool", "qualname": "Deck.values", "kind": "function", "doc": "

The quantities within the population in outcome order.

\n", "signature": "(self) -> icepool.collection.counts.CountsValuesView:", "funcdef": "def"}, "icepool.Deck.items": {"fullname": "icepool.Deck.items", "modulename": "icepool", "qualname": "Deck.items", "kind": "function", "doc": "

The (outcome, quantity)s of the population in sorted order.

\n", "signature": "(self) -> icepool.collection.counts.CountsItemsView[+T_co]:", "funcdef": "def"}, "icepool.Deck.size": {"fullname": "icepool.Deck.size", "modulename": "icepool", "qualname": "Deck.size", "kind": "function", "doc": "

The sum of all quantities (e.g. weights or duplicates).

\n\n

For the number of unique outcomes, including those with zero quantity,\nuse len().

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Deck.deal": {"fullname": "icepool.Deck.deal", "modulename": "icepool", "qualname": "Deck.deal", "kind": "function", "doc": "

Creates a Deal object from this deck.

\n\n

See Deal() for details.

\n", "signature": "(\tself,\t*hand_sizes: int) -> icepool.generator.deal.Deal[+T_co, tuple[int, ...]]:", "funcdef": "def"}, "icepool.Deck.map": {"fullname": "icepool.Deck.map", "modulename": "icepool", "qualname": "Deck.map", "kind": "function", "doc": "

Maps outcomes of this Deck to other outcomes.

\n\n
Arguments:
\n\n
    \n
  • repl: One of the following:\n
      \n
    • A callable returning a new outcome for each old outcome.
      • \n
    • A map from old outcomes to new outcomes.\nUnmapped old outcomes stay the same.\nThe new outcomes may be Decks, in which case one card is\nreplaced with several. This is not recommended.
      • \n
    • \n
  • star: Whether outcomes should be unpacked into separate arguments\nbefore sending them to a callable repl.\nIf not provided, this will be guessed based on the function\nsignature.
    • \n
\n", "signature": "(\tself,\trepl: Union[Callable[..., Union[~U, icepool.population.deck.Deck[~U], icepool.typing.RerollType]], Mapping[+T_co, Union[~U, icepool.population.deck.Deck[~U], icepool.typing.RerollType]]],\t/,\tstar: bool | None = None) -> icepool.population.deck.Deck[~U]:", "funcdef": "def"}, "icepool.Deal": {"fullname": "icepool.Deal", "modulename": "icepool", "qualname": "Deal", "kind": "class", "doc": "

Represents an sorted/unordered deal of cards from a Deck.

\n", "bases": "icepool.generator.multiset_generator.MultisetGenerator[~T, ~Qs]"}, "icepool.Deal.__init__": {"fullname": "icepool.Deal.__init__", "modulename": "icepool", "qualname": "Deal.__init__", "kind": "function", "doc": "

Constructor.

\n\n

For algorithmic reasons, you must pre-commit to the number of cards to\ndeal for each hand.

\n\n

It is permissible to Deal zero cards from an empty deck, but not all\nevaluators will handle this case, especially if they depend on the\noutcome type. Dealing zero cards from a non-empty deck does not have\nthis issue.

\n\n
Arguments:
\n\n
    \n
  • deck: The Deck to deal from.
    • \n
  • *hand_sizes: How many cards to deal. If multiple hand_sizes are\nprovided, MultisetEvaluator.next_state will recieve one count\nper hand in order. Try to keep the number of hands to a minimum\nas this can be computationally intensive.
    • \n
\n", "signature": "(deck: icepool.population.deck.Deck[~T], *hand_sizes: int)"}, "icepool.Deal.deck": {"fullname": "icepool.Deal.deck", "modulename": "icepool", "qualname": "Deal.deck", "kind": "function", "doc": "

The Deck the cards are dealt from.

\n", "signature": "(self) -> icepool.population.deck.Deck[~T]:", "funcdef": "def"}, "icepool.Deal.hand_sizes": {"fullname": "icepool.Deal.hand_sizes", "modulename": "icepool", "qualname": "Deal.hand_sizes", "kind": "function", "doc": "

The number of cards dealt to each hand as a tuple.

\n", "signature": "(self) -> ~Qs:", "funcdef": "def"}, "icepool.Deal.total_cards_dealt": {"fullname": "icepool.Deal.total_cards_dealt", "modulename": "icepool", "qualname": "Deal.total_cards_dealt", "kind": "function", "doc": "

The total number of cards dealt.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Deal.outcomes": {"fullname": "icepool.Deal.outcomes", "modulename": "icepool", "qualname": "Deal.outcomes", "kind": "function", "doc": "

The outcomes of the Deck in ascending order.

\n\n

These are also the keys of the Deck as a Mapping.\nPrefer to use the name outcomes.

\n", "signature": "(self) -> icepool.collection.counts.CountsKeysView[~T]:", "funcdef": "def"}, "icepool.Deal.output_arity": {"fullname": "icepool.Deal.output_arity", "modulename": "icepool", "qualname": "Deal.output_arity", "kind": "function", "doc": "

The number of multisets/counts generated. Must be constant.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.Deal.denominator": {"fullname": "icepool.Deal.denominator", "modulename": "icepool", "qualname": "Deal.denominator", "kind": "function", "doc": "

The total weight of all paths through this generator.

\n", "signature": "(self) -> int:", "funcdef": "def"}, "icepool.multiset_function": {"fullname": "icepool.multiset_function", "modulename": "icepool", "qualname": "multiset_function", "kind": "function", "doc": "

EXPERIMENTAL: A decorator that turns a function into a MultisetEvaluator.

\n\n

The provided function should take in arguments representing multisets,\ndo a limited set of operations on them (see MultisetExpression), and\nfinish off with an evaluation. You can return tuples to perform a joint\nevaluation.

\n\n

For example, to create an evaluator which computes the elements each of two\nmultisets has that the other doesn't:

\n\n
@multiset_function\ndef two_way_difference(a, b):\n    return (a - b).expand(), (b - a).expand()\n
\n\n

Any globals inside function are effectively bound at the time\nmultiset_function is invoked. Note that this is different than how\nordinary Python closures behave. For example,

\n\n
target = [1, 2, 3]\n\n@multiset_function\ndef count_intersection(a):\n    return (a & target).count()\n\nprint(count_intersection(d6.pool(3)))\n\ntarget = [1]\nprint(count_intersection(d6.pool(3)))\n
\n\n

would produce the same thing both times. Likewise, the function should not\nhave any side effects.

\n\n

Be careful when using control structures: you cannot branch on the value of\na multiset expression or evaluation, so e.g.

\n\n
@multiset_function\ndef bad(a, b)\n    if a == b:\n        ...\n
\n\n

is not allowed.

\n\n

multiset_function has considerable overhead, being effectively a\nmini-language within Python. For better performance, you can try\nimplementing your own subclass of MultisetEvaluator directly.

\n\n
Arguments:
\n\n
    \n
  • function: This should take in a fixed number of multiset variables and\noutput an evaluator or a nested tuple of evaluators. Tuples will\nresult in a JointEvaluator.
    • \n
\n", "signature": "(\tfunction: Callable[..., Union[icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co], tuple[Union[icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co], tuple[ForwardRef('NestedTupleOrEvaluator[T_contra, U_co]'), ...]], ...]]],\t/) -> icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, typing.Union[+U_co, tuple[typing.Union[+U_co, tuple[ForwardRef('NestedTupleOrOutcome[U_co]'), ...]], ...]]]:", "funcdef": "def"}, "icepool.evaluator": {"fullname": "icepool.evaluator", "modulename": "icepool.evaluator", "kind": "module", "doc": "

Submodule containing evaluators.

\n"}, "icepool.evaluator.JointEvaluator": {"fullname": "icepool.evaluator.JointEvaluator", "modulename": "icepool.evaluator", "qualname": "JointEvaluator", "kind": "class", "doc": "

A MultisetEvaluator that jointly evaluates sub-evaluators on the same set of input generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, tuple]"}, "icepool.evaluator.JointEvaluator.__init__": {"fullname": "icepool.evaluator.JointEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.__init__", "kind": "function", "doc": "

\n", "signature": "(*inners: icepool.evaluator.multiset_evaluator.MultisetEvaluator)"}, "icepool.evaluator.JointEvaluator.next_state": {"fullname": "icepool.evaluator.JointEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.next_state", "kind": "function", "doc": "

Runs next_state for all sub-evaluator.

\n\n

The state is a tuple of the sub-states.

\n\n

If any sub-evaluator returns Reroll, the result as a whole is Reroll.

\n", "signature": "(self, state, outcome, *counts):", "funcdef": "def"}, "icepool.evaluator.JointEvaluator.final_outcome": {"fullname": "icepool.evaluator.JointEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.final_outcome", "kind": "function", "doc": "

Runs final_state for all sub-evaluators.

\n\n

The final outcome is a tuple of the final suboutcomes.

\n\n

If any sub-evaluator returns Reroll, the result as a whole is Reroll.

\n", "signature": "(self, final_state) -> tuple | icepool.typing.RerollType:", "funcdef": "def"}, "icepool.evaluator.JointEvaluator.order": {"fullname": "icepool.evaluator.JointEvaluator.order", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.order", "kind": "function", "doc": "

Determines the common order of the sub-evaluators.

\n\n
Raises:
\n\n
    \n
  • ValueError: If sub-evaluators have conflicting orders, i.e. some are\nascending and others are descending.
    • \n
\n", "signature": "(self) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.evaluator.JointEvaluator.alignment": {"fullname": "icepool.evaluator.JointEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.alignment", "kind": "function", "doc": "

Optional method to specify additional outcomes that should be seen by next_state().

\n\n

These will be seen by next_state even if they have zero count or do\nnot appear in the generator(s) at all.

\n\n

The default implementation returns (); this means outcomes with zero\ncount may or may not be seen by next_state.

\n\n

If you want next_state to see consecutive int outcomes, you can set\nalignment = icepool.MultisetEvaluator.range_alignment.\nSee range_alignment() below.

\n\n

If you want next_state to see all generator outcomes, you can return\noutcomes as-is.

\n\n
Arguments:
\n\n
    \n
  • outcomes: The outcomes that could be produced by the generators, in
    • \n
  • ascending order.
    • \n
\n", "signature": "(self, outcomes) -> Collection[-T_contra]:", "funcdef": "def"}, "icepool.evaluator.JointEvaluator.prefix_generators": {"fullname": "icepool.evaluator.JointEvaluator.prefix_generators", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.prefix_generators", "kind": "function", "doc": "

An optional sequence of extra generators whose counts will be prepended to *counts.

\n", "signature": "(\tself) -> tuple[icepool.generator.multiset_generator.MultisetGenerator, ...]:", "funcdef": "def"}, "icepool.evaluator.JointEvaluator.validate_arity": {"fullname": "icepool.evaluator.JointEvaluator.validate_arity", "modulename": "icepool.evaluator", "qualname": "JointEvaluator.validate_arity", "kind": "function", "doc": "

An optional method to verify the total input arity.

\n\n

This is called after any implicit conversion to generators, but does\nnot include any extra_generators().

\n\n

Overriding next_state with a fixed number of counts will make this\ncheck redundant.

\n\n
Raises:
\n\n
    \n
  • ValueError if the total input arity is not valid.
    • \n
\n", "signature": "(self, arity: int) -> None:", "funcdef": "def"}, "icepool.evaluator.ExpandEvaluator": {"fullname": "icepool.evaluator.ExpandEvaluator", "modulename": "icepool.evaluator", "qualname": "ExpandEvaluator", "kind": "class", "doc": "

All elements of the multiset.

\n\n

This is expensive and not recommended unless there are few possibilities.

\n\n

Outcomes with negative count will be treated as 0 count.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple]"}, "icepool.evaluator.ExpandEvaluator.__init__": {"fullname": "icepool.evaluator.ExpandEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "ExpandEvaluator.__init__", "kind": "function", "doc": "

\n", "signature": "(order: icepool.typing.Order = <Order.Ascending: 1>)"}, "icepool.evaluator.ExpandEvaluator.next_state": {"fullname": "icepool.evaluator.ExpandEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "ExpandEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.ExpandEvaluator.order": {"fullname": "icepool.evaluator.ExpandEvaluator.order", "modulename": "icepool.evaluator", "qualname": "ExpandEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"fullname": "icepool.evaluator.ExpandEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "ExpandEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> tuple:", "funcdef": "def"}, "icepool.evaluator.SumEvaluator": {"fullname": "icepool.evaluator.SumEvaluator", "modulename": "icepool.evaluator", "qualname": "SumEvaluator", "kind": "class", "doc": "

Sums all outcomes.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, typing.Any]"}, "icepool.evaluator.SumEvaluator.__init__": {"fullname": "icepool.evaluator.SumEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "SumEvaluator.__init__", "kind": "function", "doc": "

Constructor.

\n\n

map: If provided, outcomes will be mapped according to this just\n before summing.

\n", "signature": "(map: Union[Callable, Mapping, NoneType] = None)"}, "icepool.evaluator.SumEvaluator.next_state": {"fullname": "icepool.evaluator.SumEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "SumEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.SumEvaluator.order": {"fullname": "icepool.evaluator.SumEvaluator.order", "modulename": "icepool.evaluator", "qualname": "SumEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.sum_evaluator": {"fullname": "icepool.evaluator.sum_evaluator", "modulename": "icepool.evaluator", "qualname": "sum_evaluator", "kind": "variable", "doc": "

\n", "default_value": "<icepool.evaluator.basic.SumEvaluator object>"}, "icepool.evaluator.CountEvaluator": {"fullname": "icepool.evaluator.CountEvaluator", "modulename": "icepool.evaluator", "qualname": "CountEvaluator", "kind": "class", "doc": "

Returns the total count of outcomes.

\n\n

Usually not very interesting unless the counts are adjusted by\nunique etc.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]"}, "icepool.evaluator.CountEvaluator.next_state": {"fullname": "icepool.evaluator.CountEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "CountEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.CountEvaluator.final_outcome": {"fullname": "icepool.evaluator.CountEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "CountEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> int:", "funcdef": "def"}, "icepool.evaluator.CountEvaluator.order": {"fullname": "icepool.evaluator.CountEvaluator.order", "modulename": "icepool.evaluator", "qualname": "CountEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.count_evaluator": {"fullname": "icepool.evaluator.count_evaluator", "modulename": "icepool.evaluator", "qualname": "count_evaluator", "kind": "variable", "doc": "

\n", "default_value": "<icepool.evaluator.basic.CountEvaluator object>"}, "icepool.evaluator.AnyEvaluator": {"fullname": "icepool.evaluator.AnyEvaluator", "modulename": "icepool.evaluator", "qualname": "AnyEvaluator", "kind": "class", "doc": "

Returns True iff at least one count is positive.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.AnyEvaluator.next_state": {"fullname": "icepool.evaluator.AnyEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "AnyEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.AnyEvaluator.final_outcome": {"fullname": "icepool.evaluator.AnyEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "AnyEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> bool:", "funcdef": "def"}, "icepool.evaluator.AnyEvaluator.order": {"fullname": "icepool.evaluator.AnyEvaluator.order", "modulename": "icepool.evaluator", "qualname": "AnyEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.any_evaluator": {"fullname": "icepool.evaluator.any_evaluator", "modulename": "icepool.evaluator", "qualname": "any_evaluator", "kind": "variable", "doc": "

\n", "default_value": "<icepool.evaluator.basic.AnyEvaluator object>"}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"fullname": "icepool.evaluator.HighestOutcomeAndCountEvaluator", "modulename": "icepool.evaluator", "qualname": "HighestOutcomeAndCountEvaluator", "kind": "class", "doc": "

The highest outcome that has positive count, along with that count.

\n\n

If no outcomes have positive count, the result is the min outcome with a count of 0.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[typing.Any, int]]"}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"fullname": "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "HighestOutcomeAndCountEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"fullname": "icepool.evaluator.HighestOutcomeAndCountEvaluator.order", "modulename": "icepool.evaluator", "qualname": "HighestOutcomeAndCountEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"fullname": "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "HighestOutcomeAndCountEvaluator.alignment", "kind": "function", "doc": "

Always sees zero counts.

\n", "signature": "(self, outcomes: Sequence) -> Collection:", "funcdef": "def"}, "icepool.evaluator.LargestCountEvaluator": {"fullname": "icepool.evaluator.LargestCountEvaluator", "modulename": "icepool.evaluator", "qualname": "LargestCountEvaluator", "kind": "class", "doc": "

The largest count of any outcome.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]"}, "icepool.evaluator.LargestCountEvaluator.next_state": {"fullname": "icepool.evaluator.LargestCountEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "LargestCountEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, _, count):", "funcdef": "def"}, "icepool.evaluator.LargestCountEvaluator.order": {"fullname": "icepool.evaluator.LargestCountEvaluator.order", "modulename": "icepool.evaluator", "qualname": "LargestCountEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"fullname": "icepool.evaluator.LargestCountAndOutcomeEvaluator", "modulename": "icepool.evaluator", "qualname": "LargestCountAndOutcomeEvaluator", "kind": "class", "doc": "

The largest count of any outcome, along with that outcome.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[int, typing.Any]]"}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"fullname": "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "LargestCountAndOutcomeEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"fullname": "icepool.evaluator.LargestCountAndOutcomeEvaluator.order", "modulename": "icepool.evaluator", "qualname": "LargestCountAndOutcomeEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.AllCountsEvaluator": {"fullname": "icepool.evaluator.AllCountsEvaluator", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator", "kind": "class", "doc": "

All counts in descending order.

\n\n

In other words, this produces tuples of the sizes of all matching sets.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, tuple[int, ...]]"}, "icepool.evaluator.AllCountsEvaluator.__init__": {"fullname": "icepool.evaluator.AllCountsEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator.__init__", "kind": "function", "doc": "
Arguments:
\n\n
    \n
  • filter: Any counts below this value will not be in the output.\nFor example, filter=2 will only produce pairs and better.\nIf None, no filtering will be done.
    • \n
\n", "signature": "(*, filter: int | None = 1)"}, "icepool.evaluator.AllCountsEvaluator.next_state": {"fullname": "icepool.evaluator.AllCountsEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"fullname": "icepool.evaluator.AllCountsEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> tuple:", "funcdef": "def"}, "icepool.evaluator.AllCountsEvaluator.order": {"fullname": "icepool.evaluator.AllCountsEvaluator.order", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.AllCountsEvaluator.alignment": {"fullname": "icepool.evaluator.AllCountsEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "AllCountsEvaluator.alignment", "kind": "function", "doc": "

Always sees zero counts.

\n", "signature": "(self, outcomes: Sequence) -> Collection:", "funcdef": "def"}, "icepool.evaluator.LargestStraightEvaluator": {"fullname": "icepool.evaluator.LargestStraightEvaluator", "modulename": "icepool.evaluator", "qualname": "LargestStraightEvaluator", "kind": "class", "doc": "

The size of the largest straight.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, int]"}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"fullname": "icepool.evaluator.LargestStraightEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "LargestStraightEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, _, count):", "funcdef": "def"}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"fullname": "icepool.evaluator.LargestStraightEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "LargestStraightEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> int:", "funcdef": "def"}, "icepool.evaluator.LargestStraightEvaluator.order": {"fullname": "icepool.evaluator.LargestStraightEvaluator.order", "modulename": "icepool.evaluator", "qualname": "LargestStraightEvaluator.order", "kind": "function", "doc": "

Ascending order.

\n", "signature": "(self) -> Literal[<Order.Ascending: 1>]:", "funcdef": "def"}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"fullname": "icepool.evaluator.LargestStraightEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "LargestStraightEvaluator.alignment", "kind": "function", "doc": "

Example implementation of alignment() that produces consecutive int outcomes.

\n\n

There is no expectation that a subclass be able to handle\nan arbitrary number of generators. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *generators with a fixed\nset of parameters.

\n\n

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

\n\n
Returns:
\n\n
\n

All ints from the min outcome to the max outcome among the generators,\n inclusive.

\n
\n\n
Raises:
\n\n
    \n
  • TypeError: if any generator has any non-int outcome.
    • \n
\n", "signature": "(self, outcomes: Sequence[int]) -> Collection[int]:", "funcdef": "def"}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"fullname": "icepool.evaluator.LargestStraightAndOutcomeEvaluator", "modulename": "icepool.evaluator", "qualname": "LargestStraightAndOutcomeEvaluator", "kind": "class", "doc": "

The size of the largest straight, along with the greatest outcome in that straight.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, int]]"}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"fullname": "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "LargestStraightAndOutcomeEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"fullname": "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "LargestStraightAndOutcomeEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> tuple[int, int]:", "funcdef": "def"}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"fullname": "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order", "modulename": "icepool.evaluator", "qualname": "LargestStraightAndOutcomeEvaluator.order", "kind": "function", "doc": "

Ascending order.

\n", "signature": "(self) -> Literal[<Order.Ascending: 1>]:", "funcdef": "def"}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"fullname": "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "LargestStraightAndOutcomeEvaluator.alignment", "kind": "function", "doc": "

Example implementation of alignment() that produces consecutive int outcomes.

\n\n

There is no expectation that a subclass be able to handle\nan arbitrary number of generators. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *generators with a fixed\nset of parameters.

\n\n

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

\n\n
Returns:
\n\n
\n

All ints from the min outcome to the max outcome among the generators,\n inclusive.

\n
\n\n
Raises:
\n\n
    \n
  • TypeError: if any generator has any non-int outcome.
    • \n
\n", "signature": "(self, outcomes: Sequence[int]) -> Collection[int]:", "funcdef": "def"}, "icepool.evaluator.AllStraightsEvaluator": {"fullname": "icepool.evaluator.AllStraightsEvaluator", "modulename": "icepool.evaluator", "qualname": "AllStraightsEvaluator", "kind": "class", "doc": "

The sizes of all straights in descending order.

\n\n

Each element can only contribute to one straight, though duplicates can\nproduce overlapping straights.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[int, tuple[int, ...]]"}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"fullname": "icepool.evaluator.AllStraightsEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "AllStraightsEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, _, count):", "funcdef": "def"}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"fullname": "icepool.evaluator.AllStraightsEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "AllStraightsEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> tuple[int, ...]:", "funcdef": "def"}, "icepool.evaluator.AllStraightsEvaluator.order": {"fullname": "icepool.evaluator.AllStraightsEvaluator.order", "modulename": "icepool.evaluator", "qualname": "AllStraightsEvaluator.order", "kind": "function", "doc": "

Ascending order.

\n", "signature": "(self) -> Literal[<Order.Ascending: 1>]:", "funcdef": "def"}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"fullname": "icepool.evaluator.AllStraightsEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "AllStraightsEvaluator.alignment", "kind": "function", "doc": "

Example implementation of alignment() that produces consecutive int outcomes.

\n\n

There is no expectation that a subclass be able to handle\nan arbitrary number of generators. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *generators with a fixed\nset of parameters.

\n\n

Set alignment = icepool.MultisetEvaluator.range_alignment to use this.

\n\n
Returns:
\n\n
\n

All ints from the min outcome to the max outcome among the generators,\n inclusive.

\n
\n\n
Raises:
\n\n
    \n
  • TypeError: if any generator has any non-int outcome.
    • \n
\n", "signature": "(self, outcomes: Sequence[int]) -> Collection[int]:", "funcdef": "def"}, "icepool.evaluator.ComparisonEvaluator": {"fullname": "icepool.evaluator.ComparisonEvaluator", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.ComparisonEvaluator.any_all": {"fullname": "icepool.evaluator.ComparisonEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"fullname": "icepool.evaluator.ComparisonEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.ComparisonEvaluator.next_state": {"fullname": "icepool.evaluator.ComparisonEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, left, right):", "funcdef": "def"}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"fullname": "icepool.evaluator.ComparisonEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state) -> bool:", "funcdef": "def"}, "icepool.evaluator.ComparisonEvaluator.order": {"fullname": "icepool.evaluator.ComparisonEvaluator.order", "modulename": "icepool.evaluator", "qualname": "ComparisonEvaluator.order", "kind": "function", "doc": "

Allows any order.

\n", "signature": "(self) -> Literal[<Order.Any: 0>]:", "funcdef": "def"}, "icepool.evaluator.IsSubsetEvaluator": {"fullname": "icepool.evaluator.IsSubsetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsSubsetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"fullname": "icepool.evaluator.IsSubsetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsSubsetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsSubsetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsSubsetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsProperSubsetEvaluator": {"fullname": "icepool.evaluator.IsProperSubsetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsProperSubsetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"fullname": "icepool.evaluator.IsProperSubsetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsProperSubsetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsProperSubsetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsProperSubsetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsSupersetEvaluator": {"fullname": "icepool.evaluator.IsSupersetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsSupersetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"fullname": "icepool.evaluator.IsSupersetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsSupersetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsSupersetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsSupersetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsProperSupersetEvaluator": {"fullname": "icepool.evaluator.IsProperSupersetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsProperSupersetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"fullname": "icepool.evaluator.IsProperSupersetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsProperSupersetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsProperSupersetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsProperSupersetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsEqualSetEvaluator": {"fullname": "icepool.evaluator.IsEqualSetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsEqualSetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"fullname": "icepool.evaluator.IsEqualSetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsEqualSetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsEqualSetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsEqualSetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsNotEqualSetEvaluator": {"fullname": "icepool.evaluator.IsNotEqualSetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsNotEqualSetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"fullname": "icepool.evaluator.IsNotEqualSetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsNotEqualSetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsNotEqualSetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.IsDisjointSetEvaluator": {"fullname": "icepool.evaluator.IsDisjointSetEvaluator", "modulename": "icepool.evaluator", "qualname": "IsDisjointSetEvaluator", "kind": "class", "doc": "

Compares the multisets produced by two generators.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, bool]"}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"fullname": "icepool.evaluator.IsDisjointSetEvaluator.any_all", "modulename": "icepool.evaluator", "qualname": "IsDisjointSetEvaluator.any_all", "kind": "function", "doc": "

Called for each outcome and produces a pair of bools.

\n\n

The final outcome is true iff any of the first and all of the second\nbool are True.

\n", "signature": "(self, left: int, right: int) -> tuple[bool, bool]:", "funcdef": "def"}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"fullname": "icepool.evaluator.IsDisjointSetEvaluator.default_outcome", "modulename": "icepool.evaluator", "qualname": "IsDisjointSetEvaluator.default_outcome", "kind": "function", "doc": "

The final outcome if both left and right have no outcomes.

\n", "signature": "() -> bool:", "funcdef": "def"}, "icepool.evaluator.ConstantEvaluator": {"fullname": "icepool.evaluator.ConstantEvaluator", "modulename": "icepool.evaluator", "qualname": "ConstantEvaluator", "kind": "class", "doc": "

An evaluator that ignores its arguments and returns a constant result.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, +U_co]"}, "icepool.evaluator.ConstantEvaluator.__init__": {"fullname": "icepool.evaluator.ConstantEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "ConstantEvaluator.__init__", "kind": "function", "doc": "

\n", "signature": "(result: icepool.population.die.Die[+U_co])"}, "icepool.evaluator.ConstantEvaluator.next_state": {"fullname": "icepool.evaluator.ConstantEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "ConstantEvaluator.next_state", "kind": "function", "doc": "

State transition function.

\n\n

This should produce a state given the previous state, an outcome,\nand the number that outcome produced by each generator.

\n\n

evaluate() will always call this using only positional arguments.\nFurthermore, there is no expectation that a subclass be able to handle\nan arbitrary number of counts. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *counts with a fixed set\nof parameters.

\n\n

Make sure to handle the base case where state is None.

\n\n

States must be hashable. At current, they do not have to be orderable.\nHowever, this may change in the future, and if they are not totally\norderable, you must override final_outcome to create totally orderable\nfinal outcomes.

\n\n

The behavior of returning a Die from next_state is currently\nundefined.

\n\n
Arguments:
\n\n
    \n
  • state: A hashable object indicating the state before rolling the\ncurrent outcome. If this is the first outcome being considered,\nstate will be None.
    • \n
  • outcome: The current outcome.\nnext_state will see all rolled outcomes in monotonic order;\neither ascending or descending depending on order().\nIf there are multiple generators, the set of outcomes is the\nunion of the outcomes of the invididual generators. All outcomes\nwith nonzero count will be seen. Outcomes with zero count\nmay or may not be seen. If you need to enforce that certain\noutcomes are seen even if they have zero count, see\nalignment().
    • \n
  • *counts: One value (usually an int) for each generator output\nindicating how many of the current outcome were produced.\nAll outcomes with nonzero count are guaranteed to be seen.\nTo guarantee that outcomes are seen even if they have zero\ncount, override alignment().
    • \n
\n\n
Returns:
\n\n
\n

A hashable object indicating the next state.\n The special value icepool.Reroll can be used to immediately remove\n the state from consideration, effectively performing a full reroll.

\n
\n", "signature": "(self, state, outcome, *counts):", "funcdef": "def"}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"fullname": "icepool.evaluator.ConstantEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "ConstantEvaluator.final_outcome", "kind": "function", "doc": "

Optional function to generate a final outcome from a final state.

\n\n

By default, the final outcome is equal to the final state.\nNote that None is not a valid outcome for a Die,\nand if there are no outcomes, final_outcome will be immediately\nbe callled with final_state=None.\nSubclasses that want to handle this case should explicitly define what\nhappens.

\n\n
Arguments:
\n\n
    \n
  • final_state: A state after all outcomes have been processed.
    • \n
\n\n
Returns:
\n\n
\n

A final outcome that will be used as part of constructing the result Die.\n As usual for Die(), this could itself be a Die or icepool.Reroll.

\n
\n", "signature": "(self, final_state) -> icepool.population.die.Die[+U_co]:", "funcdef": "def"}, "icepool.evaluator.CompairEvalautor": {"fullname": "icepool.evaluator.CompairEvalautor", "modulename": "icepool.evaluator", "qualname": "CompairEvalautor", "kind": "class", "doc": "

Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

\n\n

This can be used for e.g. RISK-like mechanics.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, int]"}, "icepool.evaluator.CompairEvalautor.__init__": {"fullname": "icepool.evaluator.CompairEvalautor.__init__", "modulename": "icepool.evaluator", "qualname": "CompairEvalautor.__init__", "kind": "function", "doc": "

Compares sorted pairs of two multisets and scores wins, ties, and extra elements.

\n\n

For example, left=1 would count how many pairs were won by the left\nside, and left=1, right=-1 would give the difference in the number of\npairs won by each side.

\n\n

Any score argument \n(initial, tie, left, right, extra_left, extra_right) \nnot provided will be set to a zero value determined from another score \nargument times 0.

\n\n
Arguments:
\n\n
    \n
  • op: Sets the score values based on the given operator and order.\nAllowed values are '<', '<=', '>', '>=', '==', '!='.\nEach pair that fits the comparator counts as 1.\nIf one side has more elements than the other, the extra\nelements are ignored.
    • \n
  • order: If descending (default), pairs are made in descending order\nand the higher element wins. If ascending, pairs are made in\nascending order and the lower element wins.
    • \n
  • initial: The initial score.
    • \n
  • tie: The score for each pair that is a tie.
    • \n
  • left: The score for each pair that left wins.
    • \n
  • right: The score for each pair that right wins.
    • \n
  • extra_left: If left has more elements, each extra element scores\nthis much.
    • \n
  • extra_right: If right has more elements, each extra element scores\nthis much.
    • \n
\n", "signature": "(\top: Optional[Literal['<', '<=', '>', '>=', '==', '!=']] = None,\t*,\torder: icepool.typing.Order = <Order.Descending: -1>,\tinitial=None,\ttie=None,\tleft=None,\tright=None,\textra_left=None,\textra_right=None)"}, "icepool.evaluator.CompairEvalautor.next_state": {"fullname": "icepool.evaluator.CompairEvalautor.next_state", "modulename": "icepool.evaluator", "qualname": "CompairEvalautor.next_state", "kind": "function", "doc": "

State transition function.

\n\n

This should produce a state given the previous state, an outcome,\nand the number that outcome produced by each generator.

\n\n

evaluate() will always call this using only positional arguments.\nFurthermore, there is no expectation that a subclass be able to handle\nan arbitrary number of counts. Thus, you are free to rename any of\nthe parameters in a subclass, or to replace *counts with a fixed set\nof parameters.

\n\n

Make sure to handle the base case where state is None.

\n\n

States must be hashable. At current, they do not have to be orderable.\nHowever, this may change in the future, and if they are not totally\norderable, you must override final_outcome to create totally orderable\nfinal outcomes.

\n\n

The behavior of returning a Die from next_state is currently\nundefined.

\n\n
Arguments:
\n\n
    \n
  • state: A hashable object indicating the state before rolling the\ncurrent outcome. If this is the first outcome being considered,\nstate will be None.
    • \n
  • outcome: The current outcome.\nnext_state will see all rolled outcomes in monotonic order;\neither ascending or descending depending on order().\nIf there are multiple generators, the set of outcomes is the\nunion of the outcomes of the invididual generators. All outcomes\nwith nonzero count will be seen. Outcomes with zero count\nmay or may not be seen. If you need to enforce that certain\noutcomes are seen even if they have zero count, see\nalignment().
    • \n
  • *counts: One value (usually an int) for each generator output\nindicating how many of the current outcome were produced.\nAll outcomes with nonzero count are guaranteed to be seen.\nTo guarantee that outcomes are seen even if they have zero\ncount, override alignment().
    • \n
\n\n
Returns:
\n\n
\n

A hashable object indicating the next state.\n The special value icepool.Reroll can be used to immediately remove\n the state from consideration, effectively performing a full reroll.

\n
\n", "signature": "(self, state, _, left, right):", "funcdef": "def"}, "icepool.evaluator.CompairEvalautor.final_outcome": {"fullname": "icepool.evaluator.CompairEvalautor.final_outcome", "modulename": "icepool.evaluator", "qualname": "CompairEvalautor.final_outcome", "kind": "function", "doc": "

Optional function to generate a final outcome from a final state.

\n\n

By default, the final outcome is equal to the final state.\nNote that None is not a valid outcome for a Die,\nand if there are no outcomes, final_outcome will be immediately\nbe callled with final_state=None.\nSubclasses that want to handle this case should explicitly define what\nhappens.

\n\n
Arguments:
\n\n
    \n
  • final_state: A state after all outcomes have been processed.
    • \n
\n\n
Returns:
\n\n
\n

A final outcome that will be used as part of constructing the result Die.\n As usual for Die(), this could itself be a Die or icepool.Reroll.

\n
\n", "signature": "(self, final_state):", "funcdef": "def"}, "icepool.evaluator.CompairEvalautor.order": {"fullname": "icepool.evaluator.CompairEvalautor.order", "modulename": "icepool.evaluator", "qualname": "CompairEvalautor.order", "kind": "function", "doc": "

Optional function to determine the order in which next_state() will see outcomes.

\n\n

The default is ascending order. This has better caching behavior with \nmixed standard dice.

\n\n
Returns:
\n\n
\n
    \n
  • Order.Ascending (= 1)\n if next_state() should always see the outcomes in ascending order.
    • \n
  • Order.Descending (= -1)\n if next_state() should always see the outcomes in descending order.
    • \n
  • Order.Any (= 0)\n if the result of the evaluation is order-independent.
    • \n
\n
\n", "signature": "(self) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.evaluator.KeepEvaluator": {"fullname": "icepool.evaluator.KeepEvaluator", "modulename": "icepool.evaluator", "qualname": "KeepEvaluator", "kind": "class", "doc": "

Produces the outcome at a given sorted index.

\n\n

The attached generator or expression must produce enough values to reach\nthe sorted index; otherwise, this raises IndexError.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[typing.Any, typing.Any]"}, "icepool.evaluator.KeepEvaluator.__init__": {"fullname": "icepool.evaluator.KeepEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "KeepEvaluator.__init__", "kind": "function", "doc": "

Constructor.

\n\n
Arguments:
\n\n
    \n
  • index: The index to keep.\n
      \n
    • If non-negative, this runs in ascending order.
      • \n
    • If negative, this runs in descending order.
      • \n
    • If None, this assumes only one element is produced.
      • \n
    • \n
\n", "signature": "(index: int | None = None)"}, "icepool.evaluator.KeepEvaluator.next_state": {"fullname": "icepool.evaluator.KeepEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "KeepEvaluator.next_state", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, state, outcome, count):", "funcdef": "def"}, "icepool.evaluator.KeepEvaluator.final_outcome": {"fullname": "icepool.evaluator.KeepEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "KeepEvaluator.final_outcome", "kind": "function", "doc": "

Implementation.

\n", "signature": "(self, final_state):", "funcdef": "def"}, "icepool.evaluator.KeepEvaluator.order": {"fullname": "icepool.evaluator.KeepEvaluator.order", "modulename": "icepool.evaluator", "qualname": "KeepEvaluator.order", "kind": "function", "doc": "

The required order is determined by whether the index is negative.

\n", "signature": "(self) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator": {"fullname": "icepool.evaluator.ExpressionEvaluator", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator", "kind": "class", "doc": "

Assigns an expression to be evaluated first to each input of an evaluator.

\n", "bases": "icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co]"}, "icepool.evaluator.ExpressionEvaluator.__init__": {"fullname": "icepool.evaluator.ExpressionEvaluator.__init__", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.__init__", "kind": "function", "doc": "

\n", "signature": "(\t*expressions: icepool.expression.multiset_expression.MultisetExpression[-T_contra],\tevaluator: icepool.evaluator.multiset_evaluator.MultisetEvaluator[-T_contra, +U_co],\ttruth_value: bool | None = None)"}, "icepool.evaluator.ExpressionEvaluator.next_state": {"fullname": "icepool.evaluator.ExpressionEvaluator.next_state", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.next_state", "kind": "function", "doc": "

Adjusts the counts, then forwards to inner.

\n", "signature": "(self, state, outcome, *counts):", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"fullname": "icepool.evaluator.ExpressionEvaluator.final_outcome", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.final_outcome", "kind": "function", "doc": "

Optional function to generate a final outcome from a final state.

\n\n

By default, the final outcome is equal to the final state.\nNote that None is not a valid outcome for a Die,\nand if there are no outcomes, final_outcome will be immediately\nbe callled with final_state=None.\nSubclasses that want to handle this case should explicitly define what\nhappens.

\n\n
Arguments:
\n\n
    \n
  • final_state: A state after all outcomes have been processed.
    • \n
\n\n
Returns:
\n\n
\n

A final outcome that will be used as part of constructing the result Die.\n As usual for Die(), this could itself be a Die or icepool.Reroll.

\n
\n", "signature": "(\tself,\tfinal_state) -> Union[+U_co, icepool.population.die.Die[+U_co], icepool.typing.RerollType]:", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator.order": {"fullname": "icepool.evaluator.ExpressionEvaluator.order", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.order", "kind": "function", "doc": "

Forwards to inner.

\n", "signature": "(self) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator.alignment": {"fullname": "icepool.evaluator.ExpressionEvaluator.alignment", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.alignment", "kind": "function", "doc": "

Forwards to inner.

\n", "signature": "(self, *generators) -> Collection[-T_contra]:", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"fullname": "icepool.evaluator.ExpressionEvaluator.prefix_generators", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.prefix_generators", "kind": "function", "doc": "

An optional sequence of extra generators whose counts will be prepended to *counts.

\n", "signature": "(\tself) -> tuple[icepool.generator.multiset_generator.MultisetGenerator, ...]:", "funcdef": "def"}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"fullname": "icepool.evaluator.ExpressionEvaluator.validate_arity", "modulename": "icepool.evaluator", "qualname": "ExpressionEvaluator.validate_arity", "kind": "function", "doc": "

An optional method to verify the total input arity.

\n\n

This is called after any implicit conversion to generators, but does\nnot include any extra_generators().

\n\n

Overriding next_state with a fixed number of counts will make this\ncheck redundant.

\n\n
Raises:
\n\n
    \n
  • ValueError if the total input arity is not valid.
    • \n
\n", "signature": "(self, arity: int) -> None:", "funcdef": "def"}, "icepool.function": {"fullname": "icepool.function", "modulename": "icepool.function", "kind": "module", "doc": "

Free functions.

\n"}, "icepool.function.d": {"fullname": "icepool.function.d", "modulename": "icepool.function", "qualname": "d", "kind": "function", "doc": "

A standard die.

\n\n

Specifically, the outcomes are ints from 1 to sides inclusive,\nwith quantity 1 each.

\n\n

Don't confuse this with icepool.Die():

\n\n
    \n
  • icepool.Die([6]): A Die that always rolls the integer 6.
    • \n
  • icepool.d(6): A d6.
    • \n
\n\n

You can also import individual standard dice from the icepool module, e.g.\nfrom icepool import d6.

\n", "signature": "(sides: int, /) -> icepool.population.die.Die[int]:", "funcdef": "def"}, "icepool.function.coin": {"fullname": "icepool.function.coin", "modulename": "icepool.function", "qualname": "coin", "kind": "function", "doc": "

A Die that rolls True with probability n / d, and False otherwise.

\n\n

If n == 0 or n == d the result will have only one outcome.

\n", "signature": "(n: int, d: int, /) -> icepool.population.die.Die[bool]:", "funcdef": "def"}, "icepool.function.one_hot": {"fullname": "icepool.function.one_hot", "modulename": "icepool.function", "qualname": "one_hot", "kind": "function", "doc": "

A Die with Vector outcomes with one element set to True uniformly at random and the rest False.

\n\n

This is an easy (if somewhat expensive) way of representing how many dice\nin a pool rolled each number. For example, the outcomes of 10 @ one_hot(6)\nare the (ones, twos, threes, fours, fives, sixes) rolled in 10d6.

\n", "signature": "(sides: int, /) -> icepool.population.die.Die[tuple[bool, ...]]:", "funcdef": "def"}, "icepool.function.from_cumulative": {"fullname": "icepool.function.from_cumulative", "modulename": "icepool.function", "qualname": "from_cumulative", "kind": "function", "doc": "

Constructs a Die from a sequence of cumulative values.

\n\n
Arguments:
\n\n
    \n
  • outcomes: The outcomes of the resulting die. Sorted order is recommended\nbut not necessary.
    • \n
  • cumulative: The cumulative values (inclusive) of the outcomes in the\norder they are given to this function. These may be:\n
      \n
    • int cumulative quantities.
      • \n
    • Dice representing the cumulative distribution at that point.
      • \n
    • \n
  • reverse: Iff true, both of the arguments will be reversed. This allows\ne.g. constructing using a survival distribution.
    • \n
\n", "signature": "(\toutcomes: Sequence[~T],\tcumulative: Union[Sequence[int], Sequence[icepool.population.die.Die[bool]]],\t*,\treverse: bool = False) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.function.from_rv": {"fullname": "icepool.function.from_rv", "modulename": "icepool.function", "qualname": "from_rv", "kind": "function", "doc": "

Constructs a Die from a rv object (as scipy.stats).

\n\n
Arguments:
\n\n
    \n
  • rv: A rv object (as scipy.stats).
    • \n
  • outcomes: An iterable of ints or floats that will be the outcomes\nof the resulting Die.\nIf the distribution is discrete, outcomes must be ints.
    • \n
  • denominator: The denominator of the resulting Die will be set to this.
    • \n
  • **kwargs: These will be forwarded to rv.cdf().
    • \n
\n", "signature": "(\trv,\toutcomes: Union[Sequence[int], Sequence[float]],\tdenominator: int,\t**kwargs) -> icepool.population.die.Die[int] | icepool.population.die.Die[float]:", "funcdef": "def"}, "icepool.function.min_outcome": {"fullname": "icepool.function.min_outcome", "modulename": "icepool.function", "qualname": "min_outcome", "kind": "function", "doc": "

The minimum outcome among the dice.

\n", "signature": "(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T:", "funcdef": "def"}, "icepool.function.max_outcome": {"fullname": "icepool.function.max_outcome", "modulename": "icepool.function", "qualname": "max_outcome", "kind": "function", "doc": "

The maximum outcome among the dice.

\n", "signature": "(*dice: Union[~T, icepool.population.die.Die[~T]]) -> ~T:", "funcdef": "def"}, "icepool.function.align": {"fullname": "icepool.function.align", "modulename": "icepool.function", "qualname": "align", "kind": "function", "doc": "

Pads dice with zero quantities so that all have the same set of outcomes.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of aligned dice.

\n
\n", "signature": "(\t*dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]:", "funcdef": "def"}, "icepool.function.align_range": {"fullname": "icepool.function.align_range", "modulename": "icepool.function", "qualname": "align_range", "kind": "function", "doc": "

Pads dice with zero quantities so that all have the same set of consecutive int outcomes.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of aligned dice.

\n
\n", "signature": "(\t*dice: int | icepool.population.die.Die[int]) -> tuple[icepool.population.die.Die[int], ...]:", "funcdef": "def"}, "icepool.function.commonize_denominator": {"fullname": "icepool.function.commonize_denominator", "modulename": "icepool.function", "qualname": "commonize_denominator", "kind": "function", "doc": "

Scale the weights of the dice so that all of them have the same denominator.

\n\n
Arguments:
\n\n
    \n
  • *dice: Any number of dice or single outcomes convertible to dice.
    • \n
\n\n
Returns:
\n\n
\n

A tuple of dice with the same denominator.

\n
\n", "signature": "(\t*dice: Union[~T, icepool.population.die.Die[~T]]) -> tuple[icepool.population.die.Die[~T], ...]:", "funcdef": "def"}, "icepool.function.reduce": {"fullname": "icepool.function.reduce", "modulename": "icepool.function", "qualname": "reduce", "kind": "function", "doc": "

Applies a function of two arguments cumulatively to a sequence of dice.

\n\n

Analogous to\nfunctools.reduce().

\n\n
Arguments:
\n\n
    \n
  • func: The function to map. The function should take two arguments,\nwhich are an outcome from each of two dice, and produce an outcome\nof the same type. It may also return Reroll, in which case the\nentire sequence is effectively rerolled.
    • \n
  • dice: A sequence of dice to map the function to, from left to right.
    • \n
  • initial: If provided, this will be placed at the front of the sequence\nof dice.
    • \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\tfunc: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType]],\tdice: Iterable[Union[~T, icepool.population.die.Die[~T]]],\t*,\tinitial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.function.accumulate": {"fullname": "icepool.function.accumulate", "modulename": "icepool.function", "qualname": "accumulate", "kind": "function", "doc": "

Applies a function of two arguments cumulatively to a sequence of dice, yielding each result in turn.

\n\n

Analogous to\nitertools.accumulate()\n, though with no default function and\nthe same parameter order as reduce().

\n\n

The number of results is equal to the number of elements of dice, with\none additional element if initial is provided.

\n\n
Arguments:
\n\n
    \n
  • func: The function to map. The function should take two arguments,\nwhich are an outcome from each of two dice.
    • \n
  • dice: A sequence of dice to map the function to, from left to right.
    • \n
  • initial: If provided, this will be placed at the front of the sequence\nof dice.
    • \n
\n", "signature": "(\tfunc: Callable[[~T, ~T], Union[~T, icepool.population.die.Die[~T]]],\tdice: Iterable[Union[~T, icepool.population.die.Die[~T]]],\t*,\tinitial: Union[~T, icepool.population.die.Die[~T], NoneType] = None) -> Iterator[icepool.population.die.Die[~T]]:", "funcdef": "def"}, "icepool.function.iter_cartesian_product": {"fullname": "icepool.function.iter_cartesian_product", "modulename": "icepool.function", "qualname": "iter_cartesian_product", "kind": "function", "doc": "

Yields the independent joint distribution of the arguments.

\n\n
Arguments:
\n\n
    \n
  • *args: These may be dice, which will be expanded into their joint\noutcomes. Non-dice are left as-is.
    • \n
\n\n
Yields:
\n\n
\n

Tuples containing one outcome per arg and the joint quantity.

\n
\n", "signature": "(\t*args: icepool.typing.Outcome | icepool.population.base.Population | icepool.expression.multiset_expression.MultisetExpression) -> Iterator[tuple[tuple, int]]:", "funcdef": "def"}, "icepool.function.map": {"fullname": "icepool.function.map", "modulename": "icepool.function", "qualname": "map", "kind": "function", "doc": "

Applies func(outcome_of_die_0, outcome_of_die_1, ...) for all joint outcomes.

\n\n

See map_function for a decorator version of this.

\n\n

Example: map(lambda a, b: a + b, d6, d6) is the same as d6 + d6.

\n\n

map() is flexible but not very efficient for more than a few dice.\nIf at all possible, use reduce(), MultisetExpression methods, and/or\nMultisetEvaluators. Even Pool.expand() (which sorts rolls) is more\nefficient than using map on the dice in order.

\n\n

Again can be used but is not recommended with repeat other than 1.\nIt will re-roll the current stage, not the entire series.

\n\n
Arguments:
\n\n
    \n
  • repl: One of the following:\n
      \n
    • A callable that takes in one outcome per element of args and\nproduces a new outcome.
      • \n
    • A mapping from old outcomes to new outcomes.\nUnmapped old outcomes stay the same.\nIn this case args must have exactly one element.\nThe new outcomes may be dice rather than just single outcomes.\nThe special value icepool.Reroll will reroll that old outcome.
      • \n
    • \n
  • *args: func will be called with all joint outcomes of these.\nAllowed arg types are:\n
      \n
    • Single outcome.
      • \n
    • Die. All outcomes will be sent to func.
      • \n
    • MultisetExpression. All sorted tuples of outcomes will be sent\nto func, as MultisetExpression.expand(). The expression must\nbe fully bound.
      • \n
    • \n
  • star: If True, the first of the args will be unpacked before giving\nthem to func.\nIf not provided, it will be guessed based on the signature of func\nand the number of arguments.
    • \n

  • repeat: This will be repeated with the same arguments on the\nresult this many times, except the first of args will be replaced\nby the result of the previous iteration.

    \n\n

    EXPERIMENTAL: If set to None, the result will be as if this\nwere repeated an infinite number of times. In this case, the\nresult will be in simplest form.

    • \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\trepl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]],\t/,\t*args: icepool.typing.Outcome | icepool.population.die.Die | icepool.expression.multiset_expression.MultisetExpression,\tstar: bool | None = None,\trepeat: int | None = 1,\tagain_depth: int = 1,\tagain_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> icepool.population.die.Die[~T]:", "funcdef": "def"}, "icepool.function.map_function": {"fullname": "icepool.function.map_function", "modulename": "icepool.function", "qualname": "map_function", "kind": "function", "doc": "

Decorator that turns a function that takes outcomes into a function that takes dice.

\n\n

The result must be a Die.

\n\n

This is basically a decorator version of map() and produces behavior\nsimilar to AnyDice functions, though Icepool has different typing rules\namong other differences.

\n\n

map_function can either be used with no arguments:

\n\n
@map_function\ndef explode_six(x):\n    if x == 6:\n        return 6 + Again\n    else:\n        return x\n\nexplode_six(d6, again_depth=2)\n
\n\n

Or with keyword arguments, in which case the extra arguments are bound:

\n\n
@map_function(again_depth=2)\ndef explode_six(x):\n    if x == 6:\n        return 6 + Again\n    else:\n        return x\n\nexplode_six(d6)\n
\n\n
Arguments:
\n\n
    \n
  • again_depth: Forwarded to the final die constructor.
    • \n
  • again_end: Forwarded to the final die constructor.
    • \n
\n", "signature": "(\tfunc: Optional[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]] = None,\t/,\t*,\tstar: bool | None = None,\trepeat: int | None = 1,\tagain_depth: int = 1,\tagain_end: Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, NoneType] = None) -> Union[Callable[..., icepool.population.die.Die[~T]], Callable[..., Callable[..., icepool.population.die.Die[~T]]]]:", "funcdef": "def"}, "icepool.function.map_and_time": {"fullname": "icepool.function.map_and_time", "modulename": "icepool.function", "qualname": "map_and_time", "kind": "function", "doc": "

Repeatedly map outcomes of the state to other outcomes, while also\ncounting timesteps.

\n\n

This is useful for representing processes.

\n\n

The outcomes of the result are (outcome, time), where time is the\nnumber of repeats needed to reach an absorbing outcome (an outcome that\nonly leads to itself), or repeat, whichever is lesser.

\n\n

This will return early if it reaches a fixed point.\nTherefore, you can set repeat equal to the maximum number of\ntime you could possibly be interested in without worrying about\nit causing extra computations after the fixed point.

\n\n
Arguments:
\n\n
    \n
  • repl: One of the following:\n
      \n
    • A callable returning a new outcome for each old outcome.
      • \n
    • A mapping from old outcomes to new outcomes.\nUnmapped old outcomes stay the same.\nThe new outcomes may be dice rather than just single outcomes.\nThe special value icepool.Reroll will reroll that old outcome.
      • \n
    • \n
  • star: If True, the first of the args will be unpacked before giving\nthem to func.\nIf not provided, it will be guessed based on the signature of func\nand the number of arguments.
    • \n
  • repeat: This will be repeated with the same arguments on the result\nthis many times.
    • \n
\n\n
Returns:
\n\n
\n

The Die after the modification.

\n
\n", "signature": "(\trepl: Union[Callable[..., Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]], Mapping[Any, Union[~T, icepool.population.die.Die[~T], icepool.typing.RerollType, icepool.population.again.AgainExpression]]],\tstate,\t/,\t*extra_args,\tstar: bool | None = None,\trepeat: int) -> icepool.population.die.Die[tuple[~T, int]]:", "funcdef": "def"}, "icepool.typing": {"fullname": "icepool.typing", "modulename": "icepool.typing", "kind": "module", "doc": "

\n"}, "icepool.typing.S": {"fullname": "icepool.typing.S", "modulename": "icepool.typing", "qualname": "S", "kind": "variable", "doc": "

A sequence type.

\n", "default_value": "~S"}, "icepool.typing.T": {"fullname": "icepool.typing.T", "modulename": "icepool.typing", "qualname": "T", "kind": "variable", "doc": "

An outcome type.

\n", "default_value": "~T"}, "icepool.typing.T_co": {"fullname": "icepool.typing.T_co", "modulename": "icepool.typing", "qualname": "T_co", "kind": "variable", "doc": "

An outcome type.

\n", "default_value": "+T_co"}, "icepool.typing.T_contra": {"fullname": "icepool.typing.T_contra", "modulename": "icepool.typing", "qualname": "T_contra", "kind": "variable", "doc": "

An outcome type.

\n", "default_value": "-T_contra"}, "icepool.typing.U": {"fullname": "icepool.typing.U", "modulename": "icepool.typing", "qualname": "U", "kind": "variable", "doc": "

Another outcome type.

\n", "default_value": "~U"}, "icepool.typing.U_co": {"fullname": "icepool.typing.U_co", "modulename": "icepool.typing", "qualname": "U_co", "kind": "variable", "doc": "

Another outcome type.

\n", "default_value": "+U_co"}, "icepool.typing.Qs": {"fullname": "icepool.typing.Qs", "modulename": "icepool.typing", "qualname": "Qs", "kind": "variable", "doc": "

A tuple of count types. In this future this may be replaced with a TypeVarTuple.

\n", "default_value": "~Qs"}, "icepool.typing.Order": {"fullname": "icepool.typing.Order", "modulename": "icepool.typing", "qualname": "Order", "kind": "class", "doc": "

Can be used to define what order outcomes are seen in by MultisetEvaluators.

\n", "bases": "enum.IntEnum"}, "icepool.typing.Order.Ascending": {"fullname": "icepool.typing.Order.Ascending", "modulename": "icepool.typing", "qualname": "Order.Ascending", "kind": "variable", "doc": "

\n", "default_value": "<Order.Ascending: 1>"}, "icepool.typing.Order.Descending": {"fullname": "icepool.typing.Order.Descending", "modulename": "icepool.typing", "qualname": "Order.Descending", "kind": "variable", "doc": "

\n", "default_value": "<Order.Descending: -1>"}, "icepool.typing.Order.Any": {"fullname": "icepool.typing.Order.Any", "modulename": "icepool.typing", "qualname": "Order.Any", "kind": "variable", "doc": "

\n", "default_value": "<Order.Any: 0>"}, "icepool.typing.Order.merge": {"fullname": "icepool.typing.Order.merge", "modulename": "icepool.typing", "qualname": "Order.merge", "kind": "function", "doc": "

Merges the given Orders.

\n\n
Returns:
\n\n
\n

Any if all arguments are Any.\n Ascending if there is at least one Ascending in the arguments.\n Descending if there is at least one Descending in the arguments.

\n
\n\n
Raises:
\n\n
    \n
  • ValueError if both Ascending and Descending are in the
    • \n
  • arguments.
    • \n
\n", "signature": "(*orders: icepool.typing.Order) -> icepool.typing.Order:", "funcdef": "def"}, "icepool.typing.RerollType": {"fullname": "icepool.typing.RerollType", "modulename": "icepool.typing", "qualname": "RerollType", "kind": "class", "doc": "

The type of the Reroll singleton.

\n", "bases": "enum.Enum"}, "icepool.typing.RerollType.Reroll": {"fullname": "icepool.typing.RerollType.Reroll", "modulename": "icepool.typing", "qualname": "RerollType.Reroll", "kind": "variable", "doc": "

Indicates an outcome should be rerolled (with unlimited depth).

\n", "default_value": "<RerollType.Reroll: 'Reroll'>"}, "icepool.typing.Outcome": {"fullname": "icepool.typing.Outcome", "modulename": "icepool.typing", "qualname": "Outcome", "kind": "class", "doc": "

Protocol to attempt to verify that outcome types are hashable and sortable.

\n\n

Far from foolproof, e.g. it cannot enforce total ordering.

\n", "bases": "typing.Hashable, typing.Protocol[-T_contra]"}, "icepool.typing.count_positional_parameters": {"fullname": "icepool.typing.count_positional_parameters", "modulename": "icepool.typing", "qualname": "count_positional_parameters", "kind": "function", "doc": "

Counts the number of positional parameters of the callable.

\n\n
Returns:
\n\n
\n

Two ints. The first is the number of required positional arguments;\n the second is total number of positional arguments, or None if there\n is a variadic *args.

\n
\n", "signature": "(function: Callable) -> tuple[int, int | None]:", "funcdef": "def"}, "icepool.typing.guess_star": {"fullname": "icepool.typing.guess_star", "modulename": "icepool.typing", "qualname": "guess_star", "kind": "function", "doc": "

Guesses whether the first argument should be unpacked before giving it to the function.

\n\n
Arguments:
\n\n
    \n
  • arg_count: The number of arguments that will be provided to the function.
    • \n
\n", "signature": "(function, arg_count=1) -> bool:", "funcdef": "def"}}, "docInfo": {"icepool": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 110}, "icepool.d": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 99}, "icepool.coin": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 44}, "icepool.one_hot": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 79}, "icepool.Outcome": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 28}, "icepool.Die": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 204}, "icepool.Die.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 168, "bases": 0, "doc": 745}, "icepool.Die.unary_operator": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 109, "bases": 0, "doc": 125}, "icepool.Die.binary_operator": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 106, "bases": 0, "doc": 247}, "icepool.Die.keys": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "icepool.Die.values": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 11}, "icepool.Die.items": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 13}, "icepool.Die.simplify": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "icepool.Die.reroll": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 153, "bases": 0, "doc": 161}, "icepool.Die.filter": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 140, "bases": 0, "doc": 158}, "icepool.Die.truncate": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 89}, "icepool.Die.clip": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 91}, "icepool.Die.set_range": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 112, "bases": 0, "doc": 110}, "icepool.Die.set_outcomes": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 57, "bases": 0, "doc": 41}, "icepool.Die.trim": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 8}, "icepool.Die.map": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 383, "bases": 0, "doc": 34}, "icepool.Die.map_and_time": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 248, "bases": 0, "doc": 37}, "icepool.Die.explode": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 152, "bases": 0, "doc": 166}, "icepool.Die.if_else": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 235, "bases": 0, "doc": 57}, "icepool.Die.is_in": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 19}, "icepool.Die.count": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 18}, "icepool.Die.pool": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 79, "bases": 0, "doc": 110}, "icepool.Die.lowest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 83, "bases": 0, "doc": 119}, "icepool.Die.highest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 92, "bases": 0, "doc": 108}, "icepool.Die.middle": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 123, "bases": 0, "doc": 138}, "icepool.Die.abs": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "icepool.Die.round": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 3}, "icepool.Die.trunc": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Die.floor": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Die.ceil": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Die.zero": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 59}, "icepool.Die.zero_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 28}, "icepool.Die.cmp": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 54}, "icepool.Die.sign": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 42}, "icepool.Die.equals": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 191}, "icepool.Population": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 9, "doc": 37}, "icepool.Population.keys": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "icepool.Population.values": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 11}, "icepool.Population.items": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 13}, "icepool.Population.outcomes": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 32}, "icepool.Population.common_outcome_length": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 26}, "icepool.Population.is_empty": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "icepool.Population.min_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 6}, "icepool.Population.max_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 6}, "icepool.Population.nearest_le": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 24}, "icepool.Population.nearest_lt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 24}, "icepool.Population.nearest_ge": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 24}, "icepool.Population.nearest_gt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 24}, "icepool.Population.quantity": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 14}, "icepool.Population.quantities": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 70, "bases": 0, "doc": 61}, "icepool.Population.denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 32}, "icepool.Population.scale_quantities": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 9}, "icepool.Population.has_zero_quantities": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 18}, "icepool.Population.quantity_ne": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 9}, "icepool.Population.quantity_le": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 9}, "icepool.Population.quantity_lt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 9}, "icepool.Population.quantity_ge": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 9}, "icepool.Population.quantity_gt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 9}, "icepool.Population.quantities_le": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 39}, "icepool.Population.quantities_ge": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 39}, "icepool.Population.quantities_lt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 39}, "icepool.Population.quantities_gt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 39}, "icepool.Population.probability": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 15}, "icepool.Population.probability_le": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 9}, "icepool.Population.probability_lt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 9}, "icepool.Population.probability_ge": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 9}, "icepool.Population.probability_gt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 9}, "icepool.Population.probabilities": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 90}, "icepool.Population.probabilities_le": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 103}, "icepool.Population.probabilities_ge": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 109}, "icepool.Population.probabilities_lt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 81}, "icepool.Population.probabilities_gt": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 81}, "icepool.Population.mode": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 24}, "icepool.Population.modal_quantity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 10}, "icepool.Population.kolmogorov_smirnov": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 11}, "icepool.Population.cramer_von_mises": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 14}, "icepool.Population.median": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 40}, "icepool.Population.median_low": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 13}, "icepool.Population.median_high": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 13}, "icepool.Population.quantile": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 53}, "icepool.Population.quantile_low": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 24}, "icepool.Population.quantile_high": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 24}, "icepool.Population.mean": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 3}, "icepool.Population.variance": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 12}, "icepool.Population.standard_deviation": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "icepool.Population.sd": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "icepool.Population.standardized_moment": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 3}, "icepool.Population.skewness": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "icepool.Population.excess_kurtosis": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "icepool.Population.entropy": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 40}, "icepool.Population.marginals": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 32}, "icepool.Population.covariance": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 128, "bases": 0, "doc": 3}, "icepool.Population.correlation": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 117, "bases": 0, "doc": 3}, "icepool.Population.sample": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 45}, "icepool.Population.format": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 227}, "icepool.tupleize": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 112, "bases": 0, "doc": 211}, "icepool.vectorize": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 130, "bases": 0, "doc": 211}, "icepool.Vector": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 24}, "icepool.Vector.unary_operator": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 80, "bases": 0, "doc": 32}, "icepool.Vector.abs": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "icepool.Vector.round": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 3}, "icepool.Vector.trunc": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Vector.floor": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Vector.ceil": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.Vector.binary_operator": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 106, "bases": 0, "doc": 144}, "icepool.Vector.reverse_binary_operator": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 86, "bases": 0, "doc": 11}, "icepool.Vector.append": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "icepool.Vector.concatenate": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "icepool.Again": {"qualname": 1, "fullname": 2, "annotation": 2, "default_value": 9, "signature": 0, "bases": 0, "doc": 131}, "icepool.CountsKeysView": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "icepool.CountsKeysView.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "icepool.CountsValuesView": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "icepool.CountsValuesView.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.CountsItemsView": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 16}, "icepool.CountsItemsView.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "icepool.from_cumulative": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 125, "bases": 0, "doc": 111}, "icepool.from_rv": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 113, "bases": 0, "doc": 111}, "icepool.lowest": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 155, "bases": 0, "doc": 149}, "icepool.highest": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 155, "bases": 0, "doc": 149}, "icepool.middle": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 189, "bases": 0, "doc": 182}, "icepool.min_outcome": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 9}, "icepool.max_outcome": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 9}, "icepool.align": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 55}, "icepool.align_range": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 81, "bases": 0, "doc": 59}, "icepool.commonize_denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 59}, "icepool.reduce": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 229, "bases": 0, "doc": 148}, "icepool.accumulate": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 217, "bases": 0, "doc": 146}, "icepool.map": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 431, "bases": 0, "doc": 451}, "icepool.map_function": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 356, "bases": 0, "doc": 174}, "icepool.map_and_time": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 282, "bases": 0, "doc": 268}, "icepool.Reroll": {"qualname": 1, "fullname": 2, "annotation": 2, "default_value": 9, "signature": 0, "bases": 0, "doc": 140}, "icepool.RerollType": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 9}, "icepool.RerollType.Reroll": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 12}, "icepool.Pool": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 99}, "icepool.Pool.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 196, "bases": 0, "doc": 275}, "icepool.Pool.clear_cache": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 8}, "icepool.Pool.raw_size": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 16}, "icepool.Pool.keep_size": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 16}, "icepool.Pool.denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "icepool.Pool.unique_dice": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 11}, "icepool.Pool.outcomes": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 17}, "icepool.Pool.output_arity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 11}, "icepool.Pool.keep_tuple": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 50}, "icepool.Pool.min_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 12}, "icepool.Pool.max_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 12}, "icepool.Pool.keep": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 108, "bases": 0, "doc": 606}, "icepool.Pool.lowest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 104}, "icepool.Pool.highest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 104}, "icepool.Pool.middle": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 114, "bases": 0, "doc": 154}, "icepool.Pool.additive_union": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 124, "bases": 0, "doc": 85}, "icepool.Pool.multiply_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 43}, "icepool.standard_pool": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 76}, "icepool.MultisetGenerator": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 128}, "icepool.MultisetGenerator.outcomes": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 13}, "icepool.MultisetGenerator.output_arity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 11}, "icepool.MultisetGenerator.denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "icepool.MultisetGenerator.equals": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 12}, "icepool.MultisetGenerator.min_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "icepool.MultisetGenerator.max_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "icepool.MultisetGenerator.sample": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 48}, "icepool.Alignment": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 31}, "icepool.Alignment.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "icepool.Alignment.outcomes": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 13}, "icepool.Alignment.output_arity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 11}, "icepool.Alignment.denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "icepool.MultisetExpression": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 820}, "icepool.MultisetExpression.additive_union": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 110}, "icepool.MultisetExpression.difference": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 176}, "icepool.MultisetExpression.intersection": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 155}, "icepool.MultisetExpression.union": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 112}, "icepool.MultisetExpression.symmetric_difference": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 122, "bases": 0, "doc": 85}, "icepool.MultisetExpression.keep_outcomes": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 122, "bases": 0, "doc": 77}, "icepool.MultisetExpression.drop_outcomes": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 122, "bases": 0, "doc": 77}, "icepool.MultisetExpression.map_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 165, "bases": 0, "doc": 35}, "icepool.MultisetExpression.multiply_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 43}, "icepool.MultisetExpression.divide_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 38}, "icepool.MultisetExpression.keep_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 80}, "icepool.MultisetExpression.unique": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 60, "bases": 0, "doc": 49}, "icepool.MultisetExpression.keep": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 153, "bases": 0, "doc": 202}, "icepool.MultisetExpression.lowest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 104}, "icepool.MultisetExpression.highest": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 104}, "icepool.MultisetExpression.evaluate": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 158, "bases": 0, "doc": 80}, "icepool.MultisetExpression.expand": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 152, "bases": 0, "doc": 49}, "icepool.MultisetExpression.sum": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 148, "bases": 0, "doc": 9}, "icepool.MultisetExpression.count": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 68}, "icepool.MultisetExpression.any": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 13}, "icepool.MultisetExpression.highest_outcome_and_count": {"qualname": 5, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 104, "bases": 0, "doc": 32}, "icepool.MultisetExpression.all_counts": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 122, "bases": 0, "doc": 127}, "icepool.MultisetExpression.largest_count": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 14}, "icepool.MultisetExpression.largest_count_and_outcome": {"qualname": 5, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 104, "bases": 0, "doc": 15}, "icepool.MultisetExpression.largest_straight": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 99, "bases": 0, "doc": 22}, "icepool.MultisetExpression.largest_straight_and_outcome": {"qualname": 5, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 119, "bases": 0, "doc": 29}, "icepool.MultisetExpression.all_straights": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 121, "bases": 0, "doc": 37}, "icepool.MultisetExpression.issubset": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 157, "bases": 0, "doc": 109}, "icepool.MultisetExpression.issuperset": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 157, "bases": 0, "doc": 168}, "icepool.MultisetExpression.isdisjoint": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 157, "bases": 0, "doc": 43}, "icepool.MultisetExpression.compair": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 357, "bases": 0, "doc": 282}, "icepool.MultisetEvaluator": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 271}, "icepool.MultisetEvaluator.next_state": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 385}, "icepool.MultisetEvaluator.final_outcome": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 80, "bases": 0, "doc": 144}, "icepool.MultisetEvaluator.order": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 102}, "icepool.MultisetEvaluator.alignment": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 159}, "icepool.MultisetEvaluator.range_alignment": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 124}, "icepool.MultisetEvaluator.prefix_generators": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 16}, "icepool.MultisetEvaluator.validate_arity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 74}, "icepool.MultisetEvaluator.evaluate": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 159, "bases": 0, "doc": 157}, "icepool.MultisetEvaluator.sample": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 95, "bases": 0, "doc": 15}, "icepool.Order": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "icepool.Order.Ascending": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.Order.Descending": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.Order.Any": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.Order.merge": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 85}, "icepool.Deck": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 16}, "icepool.Deck.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 187}, "icepool.Deck.keys": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "icepool.Deck.values": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 11}, "icepool.Deck.items": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 13}, "icepool.Deck.size": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 32}, "icepool.Deck.deal": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 70, "bases": 0, "doc": 22}, "icepool.Deck.map": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 213, "bases": 0, "doc": 119}, "icepool.Deal": {"qualname": 1, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 14}, "icepool.Deal.__init__": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 138}, "icepool.Deal.deck": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 12}, "icepool.Deal.hand_sizes": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 14}, "icepool.Deal.total_cards_dealt": {"qualname": 4, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 9}, "icepool.Deal.outcomes": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 41}, "icepool.Deal.output_arity": {"qualname": 3, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 11}, "icepool.Deal.denominator": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "icepool.multiset_function": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 259, "bases": 0, "doc": 302}, "icepool.evaluator": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "icepool.evaluator.JointEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 19}, "icepool.evaluator.JointEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 3}, "icepool.evaluator.JointEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 44}, "icepool.evaluator.JointEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 45}, "icepool.evaluator.JointEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 39}, "icepool.evaluator.JointEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 159}, "icepool.evaluator.JointEvaluator.prefix_generators": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 16}, "icepool.evaluator.JointEvaluator.validate_arity": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 74}, "icepool.evaluator.ExpandEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 35}, "icepool.evaluator.ExpandEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 3}, "icepool.evaluator.ExpandEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.ExpandEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.SumEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 6}, "icepool.evaluator.SumEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 20}, "icepool.evaluator.SumEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.SumEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.sum_evaluator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "icepool.evaluator.CountEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 26}, "icepool.evaluator.CountEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.CountEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.CountEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.count_evaluator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "icepool.evaluator.AnyEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 14}, "icepool.evaluator.AnyEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.AnyEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.AnyEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.any_evaluator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 9, "doc": 34}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 7}, "icepool.evaluator.LargestCountEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 9}, "icepool.evaluator.LargestCountEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 4}, "icepool.evaluator.LargestCountEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 9, "doc": 13}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.AllCountsEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 24}, "icepool.evaluator.AllCountsEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 45}, "icepool.evaluator.AllCountsEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.AllCountsEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.AllCountsEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 7}, "icepool.evaluator.LargestStraightEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 9}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 4}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.LargestStraightEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 5}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 124}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 17}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 4}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 5}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 124}, "icepool.evaluator.AllStraightsEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 28}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 4}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 4}, "icepool.evaluator.AllStraightsEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 5}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 124}, "icepool.evaluator.ComparisonEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.ComparisonEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.ComparisonEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 4}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 4}, "icepool.evaluator.ComparisonEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 6}, "icepool.evaluator.IsSubsetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsProperSubsetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsSupersetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsProperSupersetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsEqualSetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsNotEqualSetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.IsDisjointSetEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 10}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 36}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 14}, "icepool.evaluator.ConstantEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 14}, "icepool.evaluator.ConstantEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "icepool.evaluator.ConstantEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 385}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 144}, "icepool.evaluator.CompairEvalautor": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 7, "doc": 29}, "icepool.evaluator.CompairEvalautor.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 208, "bases": 0, "doc": 272}, "icepool.evaluator.CompairEvalautor.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 385}, "icepool.evaluator.CompairEvalautor.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 144}, "icepool.evaluator.CompairEvalautor.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 102}, "icepool.evaluator.KeepEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 8, "doc": 34}, "icepool.evaluator.KeepEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 59}, "icepool.evaluator.KeepEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "icepool.evaluator.KeepEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 4}, "icepool.evaluator.KeepEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 14}, "icepool.evaluator.ExpressionEvaluator": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 9, "doc": 16}, "icepool.evaluator.ExpressionEvaluator.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 114, "bases": 0, "doc": 3}, "icepool.evaluator.ExpressionEvaluator.next_state": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 10}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 144}, "icepool.evaluator.ExpressionEvaluator.order": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 6}, "icepool.evaluator.ExpressionEvaluator.alignment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 6}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 16}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 74}, "icepool.function": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 5}, "icepool.function.d": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 99}, "icepool.function.coin": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 44}, "icepool.function.one_hot": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 79}, "icepool.function.from_cumulative": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 125, "bases": 0, "doc": 111}, "icepool.function.from_rv": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 113, "bases": 0, "doc": 111}, "icepool.function.min_outcome": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 9}, "icepool.function.max_outcome": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 9}, "icepool.function.align": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 55}, "icepool.function.align_range": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 81, "bases": 0, "doc": 59}, "icepool.function.commonize_denominator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 59}, "icepool.function.reduce": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 229, "bases": 0, "doc": 148}, "icepool.function.accumulate": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 217, "bases": 0, "doc": 146}, "icepool.function.iter_cartesian_product": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 62}, "icepool.function.map": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 431, "bases": 0, "doc": 451}, "icepool.function.map_function": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 356, "bases": 0, "doc": 174}, "icepool.function.map_and_time": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 282, "bases": 0, "doc": 268}, "icepool.typing": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "icepool.typing.S": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.T": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.T_co": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.T_contra": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 3, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.U": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.U_co": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 6}, "icepool.typing.Qs": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 18}, "icepool.typing.Order": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "icepool.typing.Order.Ascending": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.typing.Order.Descending": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.typing.Order.Any": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "icepool.typing.Order.merge": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 85}, "icepool.typing.RerollType": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 9}, "icepool.typing.RerollType.Reroll": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 12}, "icepool.typing.Outcome": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 28}, "icepool.typing.count_positional_parameters": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 55}, "icepool.typing.guess_star": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 42}}, "length": 378, "save": true}, "index": {"qualname": {"root": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 16, "d": {"docs": {"icepool.d": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}}, "df": 35}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.unique_dice": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 2}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.denominator": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 7}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.standard_deviation": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Descending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}}, "df": 9}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Deck.deal": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}}, "df": 9, "t": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}}, "df": 8}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {"icepool.typing.T_co": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.coin": {"tf": 1}, "icepool.function.coin": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.count": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 6, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsKeysView": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsValuesView": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsItemsView": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.common_outcome_length": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.commonize_denominator": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 5}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.covariance": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.correlation": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.concatenate": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.typing.T_contra": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.ceil": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.cmp": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 2}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 39, "s": {"docs": {"icepool.Die.set_outcomes": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 8}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 5}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 27}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.highest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}}, "df": 5, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.has_zero_quantities": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Deal.hand_sizes": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.is_in": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 16}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.items": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Deck.items": {"tf": 1}}, "df": 3}}, "r": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}, "s": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issubset": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.isdisjoint": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {"icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.unique_dice": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 3}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 3}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.excess_kurtosis": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.values": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Deck.values": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.variance": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}}, "df": 11, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.vectorize": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {"icepool.typing.S": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.simplify": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.sign": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Deck.size": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.Deal.hand_sizes": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}}, "df": 2}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.scale_quantities": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.standard_deviation": {"tf": 1}, "icepool.standard_pool": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.standardized_moment": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 18}}, "r": {"docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.MultisetExpression.all_straights": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {"icepool.Population.sd": {"tf": 1}}, "df": 1}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.skewness": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}}, "df": 3}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.MultisetExpression.sum": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.RerollType": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 4}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.function.reduce": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4}}}, "w": {"docs": {"icepool.Pool.raw_size": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.round": {"tf": 1}, "icepool.Vector.round": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 14}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.floor": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 3}}}}}}}}, "t": {"docs": {"icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}}, "df": 3, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Die.trunc": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Die.trim": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep_tuple": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.tupleize": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 10}, "x": {"docs": {"icepool.Population.max_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.marginals": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {"icepool.Population.min_outcome": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}}, "df": 5}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.mode": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.modal_quantity": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.standardized_moment": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.mean": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Order.merge": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 8}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}}, "df": 32}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 6}, "y": {"docs": {"icepool.MultisetExpression.any": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}}, "df": 12, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.abs": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}}, "df": 2}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Vector.append": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 14}}}}}}}, "l": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}}, "df": 10, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 7}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}}, "df": 2}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.excess_kurtosis": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}}, "df": 2}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.is_empty": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 2}, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.clear_cache": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1}}, "df": 20}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}}, "df": 60}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}}, "df": 5}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}}}}}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Population.median_low": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Population.common_outcome_length": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}}, "df": 5}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}}, "df": 3}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantity_ne": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}}, "df": 4}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 18}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 3}}}}}}}}}, "t": {"docs": {"icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}}, "df": 7}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.quantities": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}}, "df": 7}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}}, "df": 3}}}}}}}, "s": {"docs": {"icepool.typing.Qs": {"tf": 1}}, "df": 1}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}, "fullname": {"root": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 16, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.clear_cache": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing": {"tf": 1}, "icepool.typing.S": {"tf": 1}, "icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 378}}}}}}, "n": {"docs": {"icepool.Die.is_in": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 16}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.items": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Deck.items": {"tf": 1}}, "df": 3}}, "r": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}, "s": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issubset": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.isdisjoint": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {"icepool.d": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}}, "df": 35}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.unique_dice": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 2}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.denominator": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 7}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.standard_deviation": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Descending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}}, "df": 9}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Deck.deal": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}}, "df": 9, "t": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}}, "df": 8}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {"icepool.typing.T_co": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.coin": {"tf": 1}, "icepool.function.coin": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.count": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 6, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsKeysView": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsValuesView": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsItemsView": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.common_outcome_length": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.commonize_denominator": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 5}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.covariance": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.correlation": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.concatenate": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.typing.T_contra": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.ceil": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.cmp": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 2}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 39, "s": {"docs": {"icepool.Die.set_outcomes": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 8}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 5}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 27}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.highest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}}, "df": 5, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.has_zero_quantities": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Deal.hand_sizes": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {"icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.unique_dice": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 3}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 3}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.excess_kurtosis": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.values": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Deck.values": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.variance": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}}, "df": 11, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.vectorize": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {"icepool.typing.S": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.simplify": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.sign": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Deck.size": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.Deal.hand_sizes": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}}, "df": 2}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.scale_quantities": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.standard_deviation": {"tf": 1}, "icepool.standard_pool": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.standardized_moment": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 18}}, "r": {"docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.MultisetExpression.all_straights": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {"icepool.Population.sd": {"tf": 1}}, "df": 1}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.skewness": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}}, "df": 3}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.MultisetExpression.sum": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.RerollType": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 4}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.function.reduce": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4}}}, "w": {"docs": {"icepool.Pool.raw_size": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.round": {"tf": 1}, "icepool.Vector.round": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 14}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.floor": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 19}}}}}}}}, "t": {"docs": {"icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}}, "df": 3, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Die.trunc": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Die.trim": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep_tuple": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.tupleize": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.typing": {"tf": 1}, "icepool.typing.S": {"tf": 1}, "icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 18}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 10}, "x": {"docs": {"icepool.Population.max_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.marginals": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {"icepool.Population.min_outcome": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}}, "df": 5}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.mode": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.modal_quantity": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.standardized_moment": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.mean": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Order.merge": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 8}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}}, "df": 32}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 6}, "y": {"docs": {"icepool.MultisetExpression.any": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}}, "df": 12, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.abs": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}}, "df": 2}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Vector.append": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 14}}}}}}}, "l": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}}, "df": 10, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 7}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}}, "df": 2}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.excess_kurtosis": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}}, "df": 2}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.is_empty": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 2}, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 109}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.clear_cache": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1}}, "df": 20}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}}, "df": 60}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}}, "df": 5}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}}}}}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Population.median_low": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Population.common_outcome_length": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}}, "df": 5}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}}, "df": 3}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantity_ne": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}}, "df": 4}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 18}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 3}}}}}}}}}, "t": {"docs": {"icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}}, "df": 7}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.quantities": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}}, "df": 7}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}}, "df": 3}}}}}}}, "s": {"docs": {"icepool.typing.Qs": {"tf": 1}}, "df": 1}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}, "annotation": {"root": {"docs": {"icepool.Again": {"tf": 1}, "icepool.Reroll": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Again": {"tf": 1}, "icepool.Reroll": {"tf": 1}}, "df": 2}}}}}}}, "default_value": {"root": {"0": {"docs": {"icepool.Order.Any": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}}, "df": 2}, "1": {"docs": {"icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}}, "df": 4}, "docs": {"icepool.Again": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType.Reroll": {"tf": 1.4142135623730951}, "icepool.Order.Ascending": {"tf": 1.4142135623730951}, "icepool.Order.Descending": {"tf": 1.4142135623730951}, "icepool.Order.Any": {"tf": 1.4142135623730951}, "icepool.evaluator.sum_evaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.count_evaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.any_evaluator": {"tf": 1.4142135623730951}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1.4142135623730951}, "icepool.typing.Order.Descending": {"tf": 1.4142135623730951}, "icepool.typing.Order.Any": {"tf": 1.4142135623730951}, "icepool.typing.RerollType.Reroll": {"tf": 1.4142135623730951}}, "df": 14, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Again": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 13}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Again": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 4}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}}, "df": 2}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Order.Any": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Again": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 4}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}}, "df": 6}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Again": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Order.Ascending": {"tf": 1}, "icepool.Order.Descending": {"tf": 1}, "icepool.Order.Any": {"tf": 1}, "icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}, "icepool.typing.Order.Ascending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}, "icepool.typing.Order.Any": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 13}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType.Reroll": {"tf": 1.4142135623730951}, "icepool.typing.RerollType.Reroll": {"tf": 1.4142135623730951}}, "df": 3, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 3}}}}}}}}}}, "x": {"2": {"7": {"docs": {"icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType.Reroll": {"tf": 1.4142135623730951}, "icepool.typing.RerollType.Reroll": {"tf": 1.4142135623730951}}, "df": 3}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Order.Descending": {"tf": 1}, "icepool.typing.Order.Descending": {"tf": 1}}, "df": 2}}}}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 3}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.evaluator.sum_evaluator": {"tf": 1}, "icepool.evaluator.count_evaluator": {"tf": 1}, "icepool.evaluator.any_evaluator": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {"icepool.typing.S": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.sum_evaluator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {"icepool.typing.T_co": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.count_evaluator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.typing.T_contra": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}}, "df": 3}, "u": {"docs": {"icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 2}, "q": {"docs": {}, "df": 0, "s": {"docs": {"icepool.typing.Qs": {"tf": 1}}, "df": 1}}}}, "signature": {"root": {"0": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}}, "df": 18}, "1": {"0": {"0": {"docs": {"icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}, "docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.typing.guess_star": {"tf": 1}}, "df": 32}, "2": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}, "3": {"9": {"docs": {"icepool.Die.middle": {"tf": 2.8284271247461903}, "icepool.middle": {"tf": 2.8284271247461903}, "icepool.Pool.middle": {"tf": 2.8284271247461903}, "icepool.MultisetExpression.compair": {"tf": 3.4641016151377544}, "icepool.multiset_function": {"tf": 2}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 3.4641016151377544}}, "df": 6}, "docs": {}, "df": 0}, "9": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}, "docs": {"icepool.d": {"tf": 6.164414002968976}, "icepool.coin": {"tf": 6.782329983125268}, "icepool.one_hot": {"tf": 6.928203230275509}, "icepool.Die.__init__": {"tf": 11.74734012447073}, "icepool.Die.unary_operator": {"tf": 9.591663046625438}, "icepool.Die.binary_operator": {"tf": 9.486832980505138}, "icepool.Die.keys": {"tf": 5.5677643628300215}, "icepool.Die.values": {"tf": 4.898979485566356}, "icepool.Die.items": {"tf": 5.5677643628300215}, "icepool.Die.simplify": {"tf": 5.5677643628300215}, "icepool.Die.reroll": {"tf": 11.357816691600547}, "icepool.Die.filter": {"tf": 10.862780491200215}, "icepool.Die.truncate": {"tf": 7.0710678118654755}, "icepool.Die.clip": {"tf": 7.0710678118654755}, "icepool.Die.set_range": {"tf": 9.539392014169456}, "icepool.Die.set_outcomes": {"tf": 6.782329983125268}, "icepool.Die.trim": {"tf": 5.5677643628300215}, "icepool.Die.map": {"tf": 17.74823934929885}, "icepool.Die.map_and_time": {"tf": 14.177446878757825}, "icepool.Die.explode": {"tf": 11.269427669584644}, "icepool.Die.if_else": {"tf": 13.820274961085254}, "icepool.Die.is_in": {"tf": 7}, "icepool.Die.count": {"tf": 7.810249675906654}, "icepool.Die.pool": {"tf": 8.12403840463596}, "icepool.Die.lowest": {"tf": 8.366600265340756}, "icepool.Die.highest": {"tf": 8.774964387392123}, "icepool.Die.middle": {"tf": 9.9498743710662}, "icepool.Die.abs": {"tf": 5.5677643628300215}, "icepool.Die.round": {"tf": 6.557438524302}, "icepool.Die.trunc": {"tf": 4.898979485566356}, "icepool.Die.floor": {"tf": 4.898979485566356}, "icepool.Die.ceil": {"tf": 4.898979485566356}, "icepool.Die.zero": {"tf": 5.5677643628300215}, "icepool.Die.zero_outcome": {"tf": 3.7416573867739413}, "icepool.Die.cmp": {"tf": 5.744562646538029}, "icepool.Die.sign": {"tf": 5.385164807134504}, "icepool.Die.equals": {"tf": 5.916079783099616}, "icepool.Population.keys": {"tf": 5.5677643628300215}, "icepool.Population.values": {"tf": 4.898979485566356}, "icepool.Population.items": {"tf": 5.5677643628300215}, "icepool.Population.outcomes": {"tf": 5.5677643628300215}, "icepool.Population.common_outcome_length": {"tf": 4.123105625617661}, "icepool.Population.is_empty": {"tf": 3.4641016151377544}, "icepool.Population.min_outcome": {"tf": 3.7416573867739413}, "icepool.Population.max_outcome": {"tf": 3.7416573867739413}, "icepool.Population.nearest_le": {"tf": 4.795831523312719}, "icepool.Population.nearest_lt": {"tf": 4.795831523312719}, "icepool.Population.nearest_ge": {"tf": 4.795831523312719}, "icepool.Population.nearest_gt": {"tf": 4.795831523312719}, "icepool.Population.quantity": {"tf": 4.47213595499958}, "icepool.Population.quantities": {"tf": 7.615773105863909}, "icepool.Population.denominator": {"tf": 3.4641016151377544}, "icepool.Population.scale_quantities": {"tf": 5.291502622129181}, "icepool.Population.has_zero_quantities": {"tf": 3.4641016151377544}, "icepool.Population.quantity_ne": {"tf": 4}, "icepool.Population.quantity_le": {"tf": 4}, "icepool.Population.quantity_lt": {"tf": 4}, "icepool.Population.quantity_ge": {"tf": 4}, "icepool.Population.quantity_gt": {"tf": 4}, "icepool.Population.quantities_le": {"tf": 6}, "icepool.Population.quantities_ge": {"tf": 6}, "icepool.Population.quantities_lt": {"tf": 6}, "icepool.Population.quantities_gt": {"tf": 6}, "icepool.Population.probability": {"tf": 4.898979485566356}, "icepool.Population.probability_le": {"tf": 4.898979485566356}, "icepool.Population.probability_lt": {"tf": 4.898979485566356}, "icepool.Population.probability_ge": {"tf": 4.898979485566356}, "icepool.Population.probability_gt": {"tf": 4.898979485566356}, "icepool.Population.probabilities": {"tf": 8.602325267042627}, "icepool.Population.probabilities_le": {"tf": 8.602325267042627}, "icepool.Population.probabilities_ge": {"tf": 8.602325267042627}, "icepool.Population.probabilities_lt": {"tf": 8.602325267042627}, "icepool.Population.probabilities_gt": {"tf": 8.602325267042627}, "icepool.Population.mode": {"tf": 3.4641016151377544}, "icepool.Population.modal_quantity": {"tf": 3.4641016151377544}, "icepool.Population.kolmogorov_smirnov": {"tf": 4.47213595499958}, "icepool.Population.cramer_von_mises": {"tf": 4.47213595499958}, "icepool.Population.median": {"tf": 3.1622776601683795}, "icepool.Population.median_low": {"tf": 3.7416573867739413}, "icepool.Population.median_high": {"tf": 3.7416573867739413}, "icepool.Population.quantile": {"tf": 5.656854249492381}, "icepool.Population.quantile_low": {"tf": 6}, "icepool.Population.quantile_high": {"tf": 6}, "icepool.Population.mean": {"tf": 8.306623862918075}, "icepool.Population.variance": {"tf": 8.306623862918075}, "icepool.Population.standard_deviation": {"tf": 7.745966692414834}, "icepool.Population.sd": {"tf": 7.745966692414834}, "icepool.Population.standardized_moment": {"tf": 8.306623862918075}, "icepool.Population.skewness": {"tf": 7.745966692414834}, "icepool.Population.excess_kurtosis": {"tf": 7.745966692414834}, "icepool.Population.entropy": {"tf": 5.0990195135927845}, "icepool.Population.covariance": {"tf": 10.344080432788601}, "icepool.Population.correlation": {"tf": 9.899494936611665}, "icepool.Population.sample": {"tf": 3.7416573867739413}, "icepool.Population.format": {"tf": 5.5677643628300215}, "icepool.tupleize": {"tf": 9.797958971132712}, "icepool.vectorize": {"tf": 10.344080432788601}, "icepool.Vector.unary_operator": {"tf": 8.306623862918075}, "icepool.Vector.abs": {"tf": 5.5677643628300215}, "icepool.Vector.round": {"tf": 6.557438524302}, "icepool.Vector.trunc": {"tf": 4.898979485566356}, "icepool.Vector.floor": {"tf": 4.898979485566356}, "icepool.Vector.ceil": {"tf": 4.898979485566356}, "icepool.Vector.binary_operator": {"tf": 9.433981132056603}, "icepool.Vector.reverse_binary_operator": {"tf": 8.602325267042627}, "icepool.Vector.append": {"tf": 5.291502622129181}, "icepool.Vector.concatenate": {"tf": 5.656854249492381}, "icepool.CountsKeysView.__init__": {"tf": 5.5677643628300215}, "icepool.CountsValuesView.__init__": {"tf": 4.898979485566356}, "icepool.CountsItemsView.__init__": {"tf": 4.898979485566356}, "icepool.from_cumulative": {"tf": 10.198039027185569}, "icepool.from_rv": {"tf": 9.643650760992955}, "icepool.lowest": {"tf": 11.40175425099138}, "icepool.highest": {"tf": 11.40175425099138}, "icepool.middle": {"tf": 12.36931687685298}, "icepool.min_outcome": {"tf": 7}, "icepool.max_outcome": {"tf": 7}, "icepool.align": {"tf": 8.774964387392123}, "icepool.align_range": {"tf": 8.246211251235321}, "icepool.commonize_denominator": {"tf": 8.774964387392123}, "icepool.reduce": {"tf": 13.820274961085254}, "icepool.accumulate": {"tf": 13.45362404707371}, "icepool.map": {"tf": 18.81488772222678}, "icepool.map_function": {"tf": 17.26267650163207}, "icepool.map_and_time": {"tf": 15.264337522473747}, "icepool.Pool.__init__": {"tf": 12.68857754044952}, "icepool.Pool.clear_cache": {"tf": 3.1622776601683795}, "icepool.Pool.raw_size": {"tf": 3.4641016151377544}, "icepool.Pool.keep_size": {"tf": 3.4641016151377544}, "icepool.Pool.denominator": {"tf": 3.4641016151377544}, "icepool.Pool.unique_dice": {"tf": 5.830951894845301}, "icepool.Pool.outcomes": {"tf": 4.358898943540674}, "icepool.Pool.output_arity": {"tf": 3.4641016151377544}, "icepool.Pool.keep_tuple": {"tf": 4.898979485566356}, "icepool.Pool.min_outcome": {"tf": 3.7416573867739413}, "icepool.Pool.max_outcome": {"tf": 3.7416573867739413}, "icepool.Pool.keep": {"tf": 9.433981132056603}, "icepool.Pool.lowest": {"tf": 7.681145747868608}, "icepool.Pool.highest": {"tf": 7.681145747868608}, "icepool.Pool.middle": {"tf": 9.539392014169456}, "icepool.Pool.additive_union": {"tf": 10}, "icepool.Pool.multiply_counts": {"tf": 6.6332495807108}, "icepool.standard_pool": {"tf": 7.416198487095663}, "icepool.MultisetGenerator.outcomes": {"tf": 4.358898943540674}, "icepool.MultisetGenerator.output_arity": {"tf": 3.4641016151377544}, "icepool.MultisetGenerator.denominator": {"tf": 3.4641016151377544}, "icepool.MultisetGenerator.equals": {"tf": 4}, "icepool.MultisetGenerator.min_outcome": {"tf": 3.7416573867739413}, "icepool.MultisetGenerator.max_outcome": {"tf": 3.7416573867739413}, "icepool.MultisetGenerator.sample": {"tf": 4.898979485566356}, "icepool.Alignment.__init__": {"tf": 4.358898943540674}, "icepool.Alignment.outcomes": {"tf": 4.358898943540674}, "icepool.Alignment.output_arity": {"tf": 3.4641016151377544}, "icepool.Alignment.denominator": {"tf": 3.4641016151377544}, "icepool.MultisetExpression.additive_union": {"tf": 10.198039027185569}, "icepool.MultisetExpression.difference": {"tf": 10.198039027185569}, "icepool.MultisetExpression.intersection": {"tf": 10.198039027185569}, "icepool.MultisetExpression.union": {"tf": 10.198039027185569}, "icepool.MultisetExpression.symmetric_difference": {"tf": 9.899494936611665}, "icepool.MultisetExpression.keep_outcomes": {"tf": 9.899494936611665}, "icepool.MultisetExpression.drop_outcomes": {"tf": 9.899494936611665}, "icepool.MultisetExpression.map_counts": {"tf": 11.489125293076057}, "icepool.MultisetExpression.multiply_counts": {"tf": 6.928203230275509}, "icepool.MultisetExpression.divide_counts": {"tf": 6.928203230275509}, "icepool.MultisetExpression.keep_counts": {"tf": 6.48074069840786}, "icepool.MultisetExpression.unique": {"tf": 6.928203230275509}, "icepool.MultisetExpression.keep": {"tf": 11.045361017187261}, "icepool.MultisetExpression.lowest": {"tf": 7.937253933193772}, "icepool.MultisetExpression.highest": {"tf": 7.937253933193772}, "icepool.MultisetExpression.evaluate": {"tf": 11.269427669584644}, "icepool.MultisetExpression.expand": {"tf": 11.135528725660043}, "icepool.MultisetExpression.sum": {"tf": 11}, "icepool.MultisetExpression.count": {"tf": 7.810249675906654}, "icepool.MultisetExpression.any": {"tf": 7.810249675906654}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 9.1104335791443}, "icepool.MultisetExpression.all_counts": {"tf": 10.04987562112089}, "icepool.MultisetExpression.largest_count": {"tf": 7.810249675906654}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 9.1104335791443}, "icepool.MultisetExpression.largest_straight": {"tf": 8.888194417315589}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 9.746794344808963}, "icepool.MultisetExpression.all_straights": {"tf": 9.9498743710662}, "icepool.MultisetExpression.issubset": {"tf": 11.224972160321824}, "icepool.MultisetExpression.issuperset": {"tf": 11.224972160321824}, "icepool.MultisetExpression.isdisjoint": {"tf": 11.224972160321824}, "icepool.MultisetExpression.compair": {"tf": 16.852299546352718}, "icepool.MultisetEvaluator.next_state": {"tf": 6.782329983125268}, "icepool.MultisetEvaluator.final_outcome": {"tf": 8}, "icepool.MultisetEvaluator.order": {"tf": 4.47213595499958}, "icepool.MultisetEvaluator.alignment": {"tf": 6}, "icepool.MultisetEvaluator.range_alignment": {"tf": 5.477225575051661}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 6.082762530298219}, "icepool.MultisetEvaluator.validate_arity": {"tf": 4.47213595499958}, "icepool.MultisetEvaluator.evaluate": {"tf": 11.224972160321824}, "icepool.MultisetEvaluator.sample": {"tf": 8.774964387392123}, "icepool.Order.merge": {"tf": 5.830951894845301}, "icepool.Deck.__init__": {"tf": 7.681145747868608}, "icepool.Deck.keys": {"tf": 5.5677643628300215}, "icepool.Deck.values": {"tf": 4.898979485566356}, "icepool.Deck.items": {"tf": 5.5677643628300215}, "icepool.Deck.size": {"tf": 3.4641016151377544}, "icepool.Deck.deal": {"tf": 7.615773105863909}, "icepool.Deck.map": {"tf": 13.30413469565007}, "icepool.Deal.__init__": {"tf": 6.4031242374328485}, "icepool.Deal.deck": {"tf": 5.5677643628300215}, "icepool.Deal.hand_sizes": {"tf": 3.7416573867739413}, "icepool.Deal.total_cards_dealt": {"tf": 3.4641016151377544}, "icepool.Deal.outcomes": {"tf": 5.5677643628300215}, "icepool.Deal.output_arity": {"tf": 3.4641016151377544}, "icepool.Deal.denominator": {"tf": 3.4641016151377544}, "icepool.multiset_function": {"tf": 14.352700094407323}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 5.0990195135927845}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 5.385164807134504}, "icepool.evaluator.JointEvaluator.order": {"tf": 4.47213595499958}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 4.898979485566356}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 6.082762530298219}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 4.47213595499958}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 6.324555320336759}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 5.744562646538029}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.SumEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.CountEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.AnyEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 4.47213595499958}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 5.291502622129181}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 4.47213595499958}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 5.477225575051661}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 5.0990195135927845}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 5.477225575051661}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 5.291502622129181}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 5.477225575051661}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 5.0990195135927845}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 4}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 5.5677643628300215}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 6.164414002968976}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 3}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 5.5677643628300215}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 5.916079783099616}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 12.84523257866513}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 5.291502622129181}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 3.7416573867739413}, "icepool.evaluator.CompairEvalautor.order": {"tf": 4.47213595499958}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 4.795831523312719}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 4.69041575982343}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 3.7416573867739413}, "icepool.evaluator.KeepEvaluator.order": {"tf": 4.47213595499958}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 9.539392014169456}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 4.898979485566356}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 7.745966692414834}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 4.47213595499958}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 5.0990195135927845}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 6.082762530298219}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 4.47213595499958}, "icepool.function.d": {"tf": 6.164414002968976}, "icepool.function.coin": {"tf": 6.782329983125268}, "icepool.function.one_hot": {"tf": 6.928203230275509}, "icepool.function.from_cumulative": {"tf": 10.198039027185569}, "icepool.function.from_rv": {"tf": 9.643650760992955}, "icepool.function.min_outcome": {"tf": 7}, "icepool.function.max_outcome": {"tf": 7}, "icepool.function.align": {"tf": 8.774964387392123}, "icepool.function.align_range": {"tf": 8.246211251235321}, "icepool.function.commonize_denominator": {"tf": 8.774964387392123}, "icepool.function.reduce": {"tf": 13.820274961085254}, "icepool.function.accumulate": {"tf": 13.45362404707371}, "icepool.function.iter_cartesian_product": {"tf": 8.602325267042627}, "icepool.function.map": {"tf": 18.81488772222678}, "icepool.function.map_function": {"tf": 17.26267650163207}, "icepool.function.map_and_time": {"tf": 15.264337522473747}, "icepool.typing.Order.merge": {"tf": 5.830951894845301}, "icepool.typing.count_positional_parameters": {"tf": 5.5677643628300215}, "icepool.typing.guess_star": {"tf": 4.47213595499958}}, "df": 310, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 4}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.standard_pool": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}}, "df": 3}}}}, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.quantities_le": {"tf": 1.4142135623730951}, "icepool.Population.quantities_ge": {"tf": 1.4142135623730951}, "icepool.Population.quantities_lt": {"tf": 1.4142135623730951}, "icepool.Population.quantities_gt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_le": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_gt": {"tf": 1.7320508075688772}, "icepool.from_cumulative": {"tf": 1.7320508075688772}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.7320508075688772}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 43}}}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 236}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 12}, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 34}}}, "r": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.scale_quantities": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {"icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.d": {"tf": 1.4142135623730951}, "icepool.coin": {"tf": 1.4142135623730951}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.set_range": {"tf": 2}, "icepool.Die.map": {"tf": 1.4142135623730951}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.count": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1.7320508075688772}, "icepool.Die.highest": {"tf": 1.7320508075688772}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.round": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.quantile": {"tf": 1.4142135623730951}, "icepool.Population.quantile_low": {"tf": 1.4142135623730951}, "icepool.Population.quantile_high": {"tf": 1.4142135623730951}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.covariance": {"tf": 1.4142135623730951}, "icepool.Population.correlation": {"tf": 1.4142135623730951}, "icepool.Vector.round": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1}, "icepool.align_range": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 2.23606797749979}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 2}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 2.23606797749979}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 2}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 2.449489742783178}, "icepool.MultisetExpression.all_straights": {"tf": 2}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.7320508075688772}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.d": {"tf": 1.4142135623730951}, "icepool.function.coin": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.align_range": {"tf": 1.7320508075688772}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1.4142135623730951}}, "df": 134}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 6}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.JointEvaluator.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 3}, "icepool.Die.map_and_time": {"tf": 2.23606797749979}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 2.23606797749979}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.mean": {"tf": 1.4142135623730951}, "icepool.Population.variance": {"tf": 1.4142135623730951}, "icepool.Population.standard_deviation": {"tf": 1.4142135623730951}, "icepool.Population.sd": {"tf": 1.4142135623730951}, "icepool.Population.standardized_moment": {"tf": 1.4142135623730951}, "icepool.Population.skewness": {"tf": 1.4142135623730951}, "icepool.Population.excess_kurtosis": {"tf": 1.4142135623730951}, "icepool.Population.covariance": {"tf": 1.4142135623730951}, "icepool.Population.correlation": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 2}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 1.4142135623730951}, "icepool.align_range": {"tf": 1.4142135623730951}, "icepool.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 2.23606797749979}, "icepool.accumulate": {"tf": 2}, "icepool.map": {"tf": 3.4641016151377544}, "icepool.map_function": {"tf": 2.6457513110645907}, "icepool.map_and_time": {"tf": 2.6457513110645907}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 2}, "icepool.MultisetExpression.expand": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.sum": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.any": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_straights": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issubset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issuperset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 2.23606797749979}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1.4142135623730951}, "icepool.function.align_range": {"tf": 1.4142135623730951}, "icepool.function.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 2.23606797749979}, "icepool.function.accumulate": {"tf": 2}, "icepool.function.iter_cartesian_product": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 3.4641016151377544}, "icepool.function.map_function": {"tf": 2.6457513110645907}, "icepool.function.map_and_time": {"tf": 2.6457513110645907}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 165}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.set_outcomes": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 6}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 3}}}}}}}, "f": {"docs": {"icepool.Die.if_else": {"tf": 1.4142135623730951}}, "df": 1}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 2.449489742783178}, "icepool.Die.map_and_time": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 2}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.round": {"tf": 1}, "icepool.Die.trunc": {"tf": 1}, "icepool.Die.floor": {"tf": 1}, "icepool.Die.ceil": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.mean": {"tf": 2}, "icepool.Population.variance": {"tf": 2}, "icepool.Population.standard_deviation": {"tf": 2}, "icepool.Population.sd": {"tf": 2}, "icepool.Population.standardized_moment": {"tf": 2}, "icepool.Population.skewness": {"tf": 2}, "icepool.Population.excess_kurtosis": {"tf": 2}, "icepool.Population.covariance": {"tf": 2}, "icepool.Population.correlation": {"tf": 2}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 1.4142135623730951}, "icepool.align_range": {"tf": 1.4142135623730951}, "icepool.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 2}, "icepool.accumulate": {"tf": 2}, "icepool.map": {"tf": 2.6457513110645907}, "icepool.map_function": {"tf": 2.23606797749979}, "icepool.map_and_time": {"tf": 2.23606797749979}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1.4142135623730951}, "icepool.function.align_range": {"tf": 1.4142135623730951}, "icepool.function.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 2}, "icepool.function.accumulate": {"tf": 2}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2.6457513110645907}, "icepool.function.map_function": {"tf": 2.23606797749979}, "icepool.function.map_and_time": {"tf": 2.23606797749979}}, "df": 101}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1.4142135623730951}}, "df": 7}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}}}}}}}, "d": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.function.coin": {"tf": 1}}, "df": 5, "i": {"docs": {}, "df": 0, "e": {"docs": {"icepool.d": {"tf": 1.4142135623730951}, "icepool.coin": {"tf": 1.4142135623730951}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.unary_operator": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 2}, "icepool.Die.simplify": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 2}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.trim": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 2.8284271247461903}, "icepool.Die.map_and_time": {"tf": 2.449489742783178}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 2.8284271247461903}, "icepool.Die.is_in": {"tf": 1.4142135623730951}, "icepool.Die.count": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.abs": {"tf": 1.4142135623730951}, "icepool.Die.round": {"tf": 1.4142135623730951}, "icepool.Die.trunc": {"tf": 1.4142135623730951}, "icepool.Die.floor": {"tf": 1.4142135623730951}, "icepool.Die.ceil": {"tf": 1.4142135623730951}, "icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.from_cumulative": {"tf": 2}, "icepool.from_rv": {"tf": 2}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 2}, "icepool.min_outcome": {"tf": 1.4142135623730951}, "icepool.max_outcome": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 2}, "icepool.align_range": {"tf": 2}, "icepool.commonize_denominator": {"tf": 2}, "icepool.reduce": {"tf": 2.8284271247461903}, "icepool.accumulate": {"tf": 2.8284271247461903}, "icepool.map": {"tf": 3.1622776601683795}, "icepool.map_function": {"tf": 2.8284271247461903}, "icepool.map_and_time": {"tf": 2.449489742783178}, "icepool.Pool.__init__": {"tf": 2.449489742783178}, "icepool.Pool.unique_dice": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.any": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1.4142135623730951}, "icepool.function.coin": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 2}, "icepool.function.from_rv": {"tf": 2}, "icepool.function.min_outcome": {"tf": 1.4142135623730951}, "icepool.function.max_outcome": {"tf": 1.4142135623730951}, "icepool.function.align": {"tf": 2}, "icepool.function.align_range": {"tf": 2}, "icepool.function.commonize_denominator": {"tf": 2}, "icepool.function.reduce": {"tf": 2.8284271247461903}, "icepool.function.accumulate": {"tf": 2.8284271247461903}, "icepool.function.map": {"tf": 3.1622776601683795}, "icepool.function.map_function": {"tf": 2.8284271247461903}, "icepool.function.map_and_time": {"tf": 2.449489742783178}}, "df": 87}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 15}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 10}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 2}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Deck.deal": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"icepool.Deck.map": {"tf": 2.449489742783178}, "icepool.Deal.__init__": {"tf": 1.7320508075688772}, "icepool.Deal.deck": {"tf": 1.4142135623730951}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 8}}}}, "n": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.function.coin": {"tf": 1}}, "df": 5, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 2.23606797749979}, "icepool.Die.filter": {"tf": 2}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 2}, "icepool.Die.map": {"tf": 2}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 2}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.round": {"tf": 1.4142135623730951}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Vector.round": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 2.23606797749979}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.6457513110645907}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.6457513110645907}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 2.23606797749979}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 49, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 14}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.round": {"tf": 1}, "icepool.Vector.round": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}}, "df": 9}}}}}}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 5}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "u": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 60}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.mean": {"tf": 1.4142135623730951}, "icepool.Population.variance": {"tf": 1.4142135623730951}, "icepool.Population.standard_deviation": {"tf": 1.4142135623730951}, "icepool.Population.sd": {"tf": 1.4142135623730951}, "icepool.Population.standardized_moment": {"tf": 1.4142135623730951}, "icepool.Population.skewness": {"tf": 1.4142135623730951}, "icepool.Population.excess_kurtosis": {"tf": 1.4142135623730951}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.covariance": {"tf": 1.4142135623730951}, "icepool.Population.correlation": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 13}}}}, "t": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 2.449489742783178}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.Vector.abs": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 2}, "icepool.min_outcome": {"tf": 1.7320508075688772}, "icepool.max_outcome": {"tf": 1.7320508075688772}, "icepool.align": {"tf": 1.7320508075688772}, "icepool.commonize_denominator": {"tf": 1.7320508075688772}, "icepool.reduce": {"tf": 3}, "icepool.accumulate": {"tf": 3}, "icepool.map": {"tf": 2.6457513110645907}, "icepool.map_function": {"tf": 2.449489742783178}, "icepool.map_and_time": {"tf": 2.23606797749979}, "icepool.Pool.__init__": {"tf": 2.449489742783178}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 2}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.min_outcome": {"tf": 1}, "icepool.MultisetGenerator.max_outcome": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 2}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 2}, "icepool.MultisetExpression.drop_outcomes": {"tf": 2}, "icepool.MultisetExpression.map_counts": {"tf": 2.23606797749979}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.expand": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.sum": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issubset": {"tf": 2}, "icepool.MultisetExpression.issuperset": {"tf": 2}, "icepool.MultisetExpression.isdisjoint": {"tf": 2}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 2}, "icepool.MultisetEvaluator.sample": {"tf": 1.7320508075688772}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.min_outcome": {"tf": 1.7320508075688772}, "icepool.function.max_outcome": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 1.7320508075688772}, "icepool.function.commonize_denominator": {"tf": 1.7320508075688772}, "icepool.function.reduce": {"tf": 3}, "icepool.function.accumulate": {"tf": 3}, "icepool.function.map": {"tf": 2.6457513110645907}, "icepool.function.map_function": {"tf": 2.449489742783178}, "icepool.function.map_and_time": {"tf": 2.23606797749979}}, "df": 120, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.covariance": {"tf": 1.4142135623730951}, "icepool.Population.correlation": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.multiset_function": {"tf": 2}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 43}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 3}}}, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 5}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1.7320508075688772}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 29}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 37, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 26}}}}}}}, "p": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 21}}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}}, "df": 15}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 23, "s": {"docs": {"icepool.Order.merge": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {"icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 2.6457513110645907}, "icepool.Die.if_else": {"tf": 2.6457513110645907}, "icepool.Vector.unary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.reverse_binary_operator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.sum": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 2.23606797749979}, "icepool.multiset_function": {"tf": 2.23606797749979}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}}, "df": 17, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map": {"tf": 2}, "icepool.Die.map_and_time": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1.7320508075688772}, "icepool.Die.pool": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 1.7320508075688772}, "icepool.accumulate": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 2}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.multiset_function": {"tf": 2}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1.7320508075688772}, "icepool.function.accumulate": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}}, "df": 78}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"icepool.MultisetExpression.sum": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 26}}}}}, "x": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 43, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 29}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 21}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 17}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 2}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 9, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.map": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 7}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "g": {"0": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 3}, "docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 24}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}}, "df": 5}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 8}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 6}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool.additive_union": {"tf": 2}, "icepool.MultisetExpression.additive_union": {"tf": 2}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 2}, "icepool.MultisetExpression.drop_outcomes": {"tf": 2}, "icepool.MultisetExpression.map_counts": {"tf": 2}, "icepool.MultisetExpression.multiply_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.divide_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 29, "s": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}}, "df": 3}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 2.23606797749979}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.any": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 2.449489742783178}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.7320508075688772}}, "df": 21}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.map": {"tf": 1.7320508075688772}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 16}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 8}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.standard_deviation": {"tf": 1}, "icepool.Population.sd": {"tf": 1}, "icepool.Population.standardized_moment": {"tf": 1}, "icepool.Population.skewness": {"tf": 1}, "icepool.Population.excess_kurtosis": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}}, "df": 9}}}}}}}, "v": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 12}}}}}, "c": {"docs": {"icepool.Population.scale_quantities": {"tf": 1.4142135623730951}}, "df": 1, "o": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 2.449489742783178}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.abs": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 2.449489742783178}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}}, "df": 46, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.abs": {"tf": 1}, "icepool.Vector.round": {"tf": 1}, "icepool.Vector.trunc": {"tf": 1}, "icepool.Vector.floor": {"tf": 1}, "icepool.Vector.ceil": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.Vector.append": {"tf": 1}, "icepool.Vector.concatenate": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1}, "icepool.CountsValuesView.__init__": {"tf": 1}, "icepool.CountsItemsView.__init__": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.Alignment.__init__": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 43}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 15, "s": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.CountsKeysView.__init__": {"tf": 1.7320508075688772}, "icepool.CountsValuesView.__init__": {"tf": 1.7320508075688772}, "icepool.CountsItemsView.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 24, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 5}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Die.values": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Deck.values": {"tf": 1}}, "df": 4}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Die.items": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Deck.items": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.MultisetExpression.additive_union": {"tf": 2}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 2}, "icepool.MultisetExpression.drop_outcomes": {"tf": 2}, "icepool.MultisetExpression.map_counts": {"tf": 2.23606797749979}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.expand": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.sum": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issubset": {"tf": 2}, "icepool.MultisetExpression.issuperset": {"tf": 2}, "icepool.MultisetExpression.isdisjoint": {"tf": 2}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 2}, "icepool.MultisetEvaluator.sample": {"tf": 1.7320508075688772}, "icepool.multiset_function": {"tf": 2}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 36}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 3}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 28}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}, "k": {"docs": {"icepool.Population.standardized_moment": {"tf": 1}}, "df": 1, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 8}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 16}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}}, "df": 3}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.if_else": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 15}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}}, "df": 15, "s": {"docs": {"icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.mean": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.covariance": {"tf": 1}}, "df": 15}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mean": {"tf": 1.4142135623730951}, "icepool.Population.variance": {"tf": 1.4142135623730951}, "icepool.Population.standard_deviation": {"tf": 1.4142135623730951}, "icepool.Population.sd": {"tf": 1.4142135623730951}, "icepool.Population.standardized_moment": {"tf": 1.4142135623730951}, "icepool.Population.skewness": {"tf": 1.4142135623730951}, "icepool.Population.excess_kurtosis": {"tf": 1.4142135623730951}, "icepool.Population.entropy": {"tf": 1.4142135623730951}, "icepool.Population.covariance": {"tf": 1.4142135623730951}, "icepool.Population.correlation": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 17}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"icepool.multiset_function": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 14}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.sample": {"tf": 1.4142135623730951}, "icepool.Deck.deal": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1.4142135623730951}}, "df": 12, "s": {"docs": {"icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 2}}}}}}}}}, "t": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}}, "df": 16}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 17}}}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}, "t": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}}, "df": 16}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 12}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantity": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}}, "df": 8}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Deck.deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}}, "df": 2}}}}, "j": {"docs": {"icepool.Population.covariance": {"tf": 1}, "icepool.Population.correlation": {"tf": 1}}, "df": 2}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.vectorize": {"tf": 2}, "icepool.Vector.unary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.abs": {"tf": 1.4142135623730951}, "icepool.Vector.round": {"tf": 1.4142135623730951}, "icepool.Vector.trunc": {"tf": 1.4142135623730951}, "icepool.Vector.floor": {"tf": 1.4142135623730951}, "icepool.Vector.ceil": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.reverse_binary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.append": {"tf": 1.4142135623730951}, "icepool.Vector.concatenate": {"tf": 1.4142135623730951}}, "df": 11}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Deal.hand_sizes": {"tf": 1}}, "df": 1}}}}, "bases": {"root": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 3, "t": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 6, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Outcome": {"tf": 1.4142135623730951}, "icepool.Population": {"tf": 1.4142135623730951}, "icepool.Vector": {"tf": 1.4142135623730951}, "icepool.CountsKeysView": {"tf": 1.4142135623730951}, "icepool.CountsValuesView": {"tf": 1.4142135623730951}, "icepool.CountsItemsView": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1.4142135623730951}}, "df": 13}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}}, "df": 3, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 5}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 2}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 2, "[": {"docs": {}, "df": 0, "+": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 7, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 6}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 31}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Order": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsItemsView": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}}, "df": 9}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Population": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}}, "df": 3}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1.4142135623730951}}, "df": 20}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2, "[": {"docs": {}, "df": 0, "+": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population": {"tf": 1}}, "df": 1}}, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Alignment": {"tf": 1.4142135623730951}, "icepool.Deal": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 28, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Deal": {"tf": 1}}, "df": 3}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 2, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}}, "df": 19}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "+": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Vector": {"tf": 1}}, "df": 1}}, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsKeysView": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsValuesView": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsItemsView": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "~": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsKeysView": {"tf": 1}}, "df": 1}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.CountsValuesView": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.RerollType": {"tf": 1.4142135623730951}, "icepool.Order": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1.4142135623730951}}, "df": 4}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetGenerator": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.SumEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AnyEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1.4142135623730951}}, "df": 24}}}}}}}}}, "q": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.Deal": {"tf": 1}}, "df": 2}}, "u": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 3}}}, "doc": {"root": {"0": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 2.449489742783178}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1.4142135623730951}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.8284271247461903}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 35, "d": {"1": {"docs": {"icepool.standard_pool": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}, "1": {"0": {"0": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 1}}, "df": 6}, "docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2, "d": {"6": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "*": {"docs": {}, "df": 0, "*": {"3": {"0": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "2": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 2.449489742783178}, "icepool.vectorize": {"tf": 2.449489742783178}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 4.47213595499958}, "icepool.Pool.multiply_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 2}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 41, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 4}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "2": {"5": {"docs": {"icepool": {"tf": 1}}, "df": 1}, "docs": {"icepool.Die.__init__": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Population.entropy": {"tf": 1}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.Pool.multiply_counts": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.additive_union": {"tf": 2.449489742783178}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 2.23606797749979}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.multiply_counts": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.divide_counts": {"tf": 2}, "icepool.MultisetExpression.keep_counts": {"tf": 2.449489742783178}, "icepool.MultisetExpression.unique": {"tf": 2}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 22, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "2": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "3": {"6": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {"icepool.Die.__init__": {"tf": 2.449489742783178}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}}, "df": 15, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "d": {"6": {"docs": {"icepool.Pool": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "4": {"docs": {"icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 8, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "5": {"docs": {"icepool.Die.__init__": {"tf": 2}, "icepool.Die.pool": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 7, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "d": {"6": {"docs": {"icepool.Die.pool": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "6": {"docs": {"icepool.d": {"tf": 1.7320508075688772}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 3}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.Again": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 2}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.function.d": {"tf": 1.7320508075688772}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.map_function": {"tf": 2}}, "df": 12, ":": {"1": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "docs": {"icepool": {"tf": 5.656854249492381}, "icepool.d": {"tf": 6.4031242374328485}, "icepool.coin": {"tf": 4.358898943540674}, "icepool.one_hot": {"tf": 4.69041575982343}, "icepool.Outcome": {"tf": 2.449489742783178}, "icepool.Die": {"tf": 6.557438524302}, "icepool.Die.__init__": {"tf": 15.716233645501712}, "icepool.Die.unary_operator": {"tf": 7}, "icepool.Die.binary_operator": {"tf": 8.94427190999916}, "icepool.Die.keys": {"tf": 1.7320508075688772}, "icepool.Die.values": {"tf": 1.7320508075688772}, "icepool.Die.items": {"tf": 1.7320508075688772}, "icepool.Die.simplify": {"tf": 1.7320508075688772}, "icepool.Die.reroll": {"tf": 7.3484692283495345}, "icepool.Die.filter": {"tf": 7.3484692283495345}, "icepool.Die.truncate": {"tf": 4.47213595499958}, "icepool.Die.clip": {"tf": 3.7416573867739413}, "icepool.Die.set_range": {"tf": 5.656854249492381}, "icepool.Die.set_outcomes": {"tf": 2.8284271247461903}, "icepool.Die.trim": {"tf": 1.7320508075688772}, "icepool.Die.map": {"tf": 3.7416573867739413}, "icepool.Die.map_and_time": {"tf": 3.4641016151377544}, "icepool.Die.explode": {"tf": 6.928203230275509}, "icepool.Die.if_else": {"tf": 4.69041575982343}, "icepool.Die.is_in": {"tf": 1.7320508075688772}, "icepool.Die.count": {"tf": 1.7320508075688772}, "icepool.Die.pool": {"tf": 5.830951894845301}, "icepool.Die.lowest": {"tf": 6.708203932499369}, "icepool.Die.highest": {"tf": 6.557438524302}, "icepool.Die.middle": {"tf": 7.3484692283495345}, "icepool.Die.abs": {"tf": 1.7320508075688772}, "icepool.Die.round": {"tf": 1.7320508075688772}, "icepool.Die.trunc": {"tf": 1.7320508075688772}, "icepool.Die.floor": {"tf": 1.7320508075688772}, "icepool.Die.ceil": {"tf": 1.7320508075688772}, "icepool.Die.zero": {"tf": 4.69041575982343}, "icepool.Die.zero_outcome": {"tf": 3.3166247903554}, "icepool.Die.cmp": {"tf": 3.872983346207417}, "icepool.Die.sign": {"tf": 3.605551275463989}, "icepool.Die.equals": {"tf": 7.54983443527075}, "icepool.Population": {"tf": 3.872983346207417}, "icepool.Population.keys": {"tf": 1.7320508075688772}, "icepool.Population.values": {"tf": 1.7320508075688772}, "icepool.Population.items": {"tf": 1.7320508075688772}, "icepool.Population.outcomes": {"tf": 3.1622776601683795}, "icepool.Population.common_outcome_length": {"tf": 2.8284271247461903}, "icepool.Population.is_empty": {"tf": 2.23606797749979}, "icepool.Population.min_outcome": {"tf": 1.7320508075688772}, "icepool.Population.max_outcome": {"tf": 1.7320508075688772}, "icepool.Population.nearest_le": {"tf": 2.8284271247461903}, "icepool.Population.nearest_lt": {"tf": 2.8284271247461903}, "icepool.Population.nearest_ge": {"tf": 2.8284271247461903}, "icepool.Population.nearest_gt": {"tf": 2.8284271247461903}, "icepool.Population.quantity": {"tf": 1.7320508075688772}, "icepool.Population.quantities": {"tf": 4.58257569495584}, "icepool.Population.denominator": {"tf": 3}, "icepool.Population.scale_quantities": {"tf": 1.7320508075688772}, "icepool.Population.has_zero_quantities": {"tf": 2.6457513110645907}, "icepool.Population.quantity_ne": {"tf": 2}, "icepool.Population.quantity_le": {"tf": 1.7320508075688772}, "icepool.Population.quantity_lt": {"tf": 1.7320508075688772}, "icepool.Population.quantity_ge": {"tf": 1.7320508075688772}, "icepool.Population.quantity_gt": {"tf": 1.7320508075688772}, "icepool.Population.quantities_le": {"tf": 3.7416573867739413}, "icepool.Population.quantities_ge": {"tf": 3.7416573867739413}, "icepool.Population.quantities_lt": {"tf": 3.7416573867739413}, "icepool.Population.quantities_gt": {"tf": 3.7416573867739413}, "icepool.Population.probability": {"tf": 1.7320508075688772}, "icepool.Population.probability_le": {"tf": 1.7320508075688772}, "icepool.Population.probability_lt": {"tf": 1.7320508075688772}, "icepool.Population.probability_ge": {"tf": 1.7320508075688772}, "icepool.Population.probability_gt": {"tf": 1.7320508075688772}, "icepool.Population.probabilities": {"tf": 4.898979485566356}, "icepool.Population.probabilities_le": {"tf": 4.898979485566356}, "icepool.Population.probabilities_ge": {"tf": 4.898979485566356}, "icepool.Population.probabilities_lt": {"tf": 4.58257569495584}, "icepool.Population.probabilities_gt": {"tf": 4.58257569495584}, "icepool.Population.mode": {"tf": 2.449489742783178}, "icepool.Population.modal_quantity": {"tf": 1.7320508075688772}, "icepool.Population.kolmogorov_smirnov": {"tf": 1.7320508075688772}, "icepool.Population.cramer_von_mises": {"tf": 1.7320508075688772}, "icepool.Population.median": {"tf": 3.1622776601683795}, "icepool.Population.median_low": {"tf": 1.7320508075688772}, "icepool.Population.median_high": {"tf": 1.7320508075688772}, "icepool.Population.quantile": {"tf": 3.605551275463989}, "icepool.Population.quantile_low": {"tf": 2.449489742783178}, "icepool.Population.quantile_high": {"tf": 2.449489742783178}, "icepool.Population.mean": {"tf": 1.7320508075688772}, "icepool.Population.variance": {"tf": 1.7320508075688772}, "icepool.Population.standard_deviation": {"tf": 1.7320508075688772}, "icepool.Population.sd": {"tf": 1.7320508075688772}, "icepool.Population.standardized_moment": {"tf": 1.7320508075688772}, "icepool.Population.skewness": {"tf": 1.7320508075688772}, "icepool.Population.excess_kurtosis": {"tf": 1.7320508075688772}, "icepool.Population.entropy": {"tf": 3.7416573867739413}, "icepool.Population.marginals": {"tf": 3.3166247903554}, "icepool.Population.covariance": {"tf": 1.7320508075688772}, "icepool.Population.correlation": {"tf": 1.7320508075688772}, "icepool.Population.sample": {"tf": 3.605551275463989}, "icepool.Population.format": {"tf": 9.9498743710662}, "icepool.tupleize": {"tf": 9.591663046625438}, "icepool.vectorize": {"tf": 9.16515138991168}, "icepool.Vector": {"tf": 2.449489742783178}, "icepool.Vector.unary_operator": {"tf": 3.4641016151377544}, "icepool.Vector.abs": {"tf": 1.7320508075688772}, "icepool.Vector.round": {"tf": 1.7320508075688772}, "icepool.Vector.trunc": {"tf": 1.7320508075688772}, "icepool.Vector.floor": {"tf": 1.7320508075688772}, "icepool.Vector.ceil": {"tf": 1.7320508075688772}, "icepool.Vector.binary_operator": {"tf": 7.14142842854285}, "icepool.Vector.reverse_binary_operator": {"tf": 2.449489742783178}, "icepool.Vector.append": {"tf": 1.7320508075688772}, "icepool.Vector.concatenate": {"tf": 1.7320508075688772}, "icepool.Again": {"tf": 6.6332495807108}, "icepool.CountsKeysView": {"tf": 2.6457513110645907}, "icepool.CountsKeysView.__init__": {"tf": 1.7320508075688772}, "icepool.CountsValuesView": {"tf": 2.6457513110645907}, "icepool.CountsValuesView.__init__": {"tf": 1.7320508075688772}, "icepool.CountsItemsView": {"tf": 2.6457513110645907}, "icepool.CountsItemsView.__init__": {"tf": 1.7320508075688772}, "icepool.from_cumulative": {"tf": 6.082762530298219}, "icepool.from_rv": {"tf": 6.708203932499369}, "icepool.lowest": {"tf": 7}, "icepool.highest": {"tf": 7}, "icepool.middle": {"tf": 8.246211251235321}, "icepool.min_outcome": {"tf": 1.7320508075688772}, "icepool.max_outcome": {"tf": 1.7320508075688772}, "icepool.align": {"tf": 4.795831523312719}, "icepool.align_range": {"tf": 5}, "icepool.commonize_denominator": {"tf": 4.795831523312719}, "icepool.reduce": {"tf": 6.6332495807108}, "icepool.accumulate": {"tf": 6.48074069840786}, "icepool.map": {"tf": 11.313708498984761}, "icepool.map_function": {"tf": 7.0710678118654755}, "icepool.map_and_time": {"tf": 8.426149773176359}, "icepool.Reroll": {"tf": 6.164414002968976}, "icepool.RerollType": {"tf": 1.7320508075688772}, "icepool.RerollType.Reroll": {"tf": 1.7320508075688772}, "icepool.Pool": {"tf": 3.7416573867739413}, "icepool.Pool.__init__": {"tf": 9.433981132056603}, "icepool.Pool.clear_cache": {"tf": 1.7320508075688772}, "icepool.Pool.raw_size": {"tf": 1.7320508075688772}, "icepool.Pool.keep_size": {"tf": 1.7320508075688772}, "icepool.Pool.denominator": {"tf": 1.7320508075688772}, "icepool.Pool.unique_dice": {"tf": 1.7320508075688772}, "icepool.Pool.outcomes": {"tf": 1.7320508075688772}, "icepool.Pool.output_arity": {"tf": 1.7320508075688772}, "icepool.Pool.keep_tuple": {"tf": 3.1622776601683795}, "icepool.Pool.min_outcome": {"tf": 1.7320508075688772}, "icepool.Pool.max_outcome": {"tf": 1.7320508075688772}, "icepool.Pool.keep": {"tf": 14.560219778561036}, "icepool.Pool.lowest": {"tf": 5.385164807134504}, "icepool.Pool.highest": {"tf": 5.385164807134504}, "icepool.Pool.middle": {"tf": 6.928203230275509}, "icepool.Pool.additive_union": {"tf": 3.3166247903554}, "icepool.Pool.multiply_counts": {"tf": 4.123105625617661}, "icepool.standard_pool": {"tf": 4}, "icepool.MultisetGenerator": {"tf": 4.898979485566356}, "icepool.MultisetGenerator.outcomes": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.output_arity": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.denominator": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.equals": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.min_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.max_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.sample": {"tf": 4.123105625617661}, "icepool.Alignment": {"tf": 2.449489742783178}, "icepool.Alignment.__init__": {"tf": 1.7320508075688772}, "icepool.Alignment.outcomes": {"tf": 1.7320508075688772}, "icepool.Alignment.output_arity": {"tf": 1.7320508075688772}, "icepool.Alignment.denominator": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 22.15851980616034}, "icepool.MultisetExpression.additive_union": {"tf": 6}, "icepool.MultisetExpression.difference": {"tf": 6.4031242374328485}, "icepool.MultisetExpression.intersection": {"tf": 6.164414002968976}, "icepool.MultisetExpression.union": {"tf": 6}, "icepool.MultisetExpression.symmetric_difference": {"tf": 4.898979485566356}, "icepool.MultisetExpression.keep_outcomes": {"tf": 4.69041575982343}, "icepool.MultisetExpression.drop_outcomes": {"tf": 4.69041575982343}, "icepool.MultisetExpression.map_counts": {"tf": 4}, "icepool.MultisetExpression.multiply_counts": {"tf": 4.123105625617661}, "icepool.MultisetExpression.divide_counts": {"tf": 4.123105625617661}, "icepool.MultisetExpression.keep_counts": {"tf": 5.0990195135927845}, "icepool.MultisetExpression.unique": {"tf": 4.242640687119285}, "icepool.MultisetExpression.keep": {"tf": 6.855654600401044}, "icepool.MultisetExpression.lowest": {"tf": 5.385164807134504}, "icepool.MultisetExpression.highest": {"tf": 5.385164807134504}, "icepool.MultisetExpression.evaluate": {"tf": 5.477225575051661}, "icepool.MultisetExpression.expand": {"tf": 4.123105625617661}, "icepool.MultisetExpression.sum": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.count": {"tf": 4.242640687119285}, "icepool.MultisetExpression.any": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 2.449489742783178}, "icepool.MultisetExpression.all_counts": {"tf": 5.830951894845301}, "icepool.MultisetExpression.largest_count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_straight": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.all_straights": {"tf": 3.3166247903554}, "icepool.MultisetExpression.issubset": {"tf": 4.898979485566356}, "icepool.MultisetExpression.issuperset": {"tf": 6.082762530298219}, "icepool.MultisetExpression.isdisjoint": {"tf": 3.1622776601683795}, "icepool.MultisetExpression.compair": {"tf": 8.54400374531753}, "icepool.MultisetEvaluator": {"tf": 8.366600265340756}, "icepool.MultisetEvaluator.next_state": {"tf": 8.94427190999916}, "icepool.MultisetEvaluator.final_outcome": {"tf": 6.557438524302}, "icepool.MultisetEvaluator.order": {"tf": 5.830951894845301}, "icepool.MultisetEvaluator.alignment": {"tf": 7.211102550927978}, "icepool.MultisetEvaluator.range_alignment": {"tf": 6.4031242374328485}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.validate_arity": {"tf": 5}, "icepool.MultisetEvaluator.evaluate": {"tf": 7.615773105863909}, "icepool.MultisetEvaluator.sample": {"tf": 1.7320508075688772}, "icepool.Order": {"tf": 1.7320508075688772}, "icepool.Order.Ascending": {"tf": 1.7320508075688772}, "icepool.Order.Descending": {"tf": 1.7320508075688772}, "icepool.Order.Any": {"tf": 1.7320508075688772}, "icepool.Order.merge": {"tf": 6.4031242374328485}, "icepool.Deck": {"tf": 2.449489742783178}, "icepool.Deck.__init__": {"tf": 8.366600265340756}, "icepool.Deck.keys": {"tf": 1.7320508075688772}, "icepool.Deck.values": {"tf": 1.7320508075688772}, "icepool.Deck.items": {"tf": 1.7320508075688772}, "icepool.Deck.size": {"tf": 3}, "icepool.Deck.deal": {"tf": 3.3166247903554}, "icepool.Deck.map": {"tf": 5.744562646538029}, "icepool.Deal": {"tf": 2.23606797749979}, "icepool.Deal.__init__": {"tf": 5.744562646538029}, "icepool.Deal.deck": {"tf": 2.23606797749979}, "icepool.Deal.hand_sizes": {"tf": 1.7320508075688772}, "icepool.Deal.total_cards_dealt": {"tf": 1.7320508075688772}, "icepool.Deal.outcomes": {"tf": 4}, "icepool.Deal.output_arity": {"tf": 1.7320508075688772}, "icepool.Deal.denominator": {"tf": 1.7320508075688772}, "icepool.multiset_function": {"tf": 8.06225774829855}, "icepool.evaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator": {"tf": 2.23606797749979}, "icepool.evaluator.JointEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 3.872983346207417}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 3.872983346207417}, "icepool.evaluator.JointEvaluator.order": {"tf": 3.7416573867739413}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 7.211102550927978}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 5}, "icepool.evaluator.ExpandEvaluator": {"tf": 3}, "icepool.evaluator.ExpandEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.SumEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 2.449489742783178}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.SumEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.sum_evaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.CountEvaluator": {"tf": 2.8284271247461903}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CountEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.count_evaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.AnyEvaluator": {"tf": 2.23606797749979}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.any_evaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 2.449489742783178}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.AllCountsEvaluator": {"tf": 2.449489742783178}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 3.872983346207417}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 6.4031242374328485}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 6.4031242374328485}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 2.449489742783178}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 6.4031242374328485}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 2.8284271247461903}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 8.94427190999916}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 6.557438524302}, "icepool.evaluator.CompairEvalautor": {"tf": 2.449489742783178}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 8.366600265340756}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 8.94427190999916}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 6.557438524302}, "icepool.evaluator.CompairEvalautor.order": {"tf": 5.830951894845301}, "icepool.evaluator.KeepEvaluator": {"tf": 2.8284271247461903}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 5.291502622129181}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 6.557438524302}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 5}, "icepool.function": {"tf": 1.7320508075688772}, "icepool.function.d": {"tf": 6.4031242374328485}, "icepool.function.coin": {"tf": 4.358898943540674}, "icepool.function.one_hot": {"tf": 4.69041575982343}, "icepool.function.from_cumulative": {"tf": 6.082762530298219}, "icepool.function.from_rv": {"tf": 6.708203932499369}, "icepool.function.min_outcome": {"tf": 1.7320508075688772}, "icepool.function.max_outcome": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 4.795831523312719}, "icepool.function.align_range": {"tf": 5}, "icepool.function.commonize_denominator": {"tf": 4.795831523312719}, "icepool.function.reduce": {"tf": 6.6332495807108}, "icepool.function.accumulate": {"tf": 6.48074069840786}, "icepool.function.iter_cartesian_product": {"tf": 4.795831523312719}, "icepool.function.map": {"tf": 11.313708498984761}, "icepool.function.map_function": {"tf": 7.0710678118654755}, "icepool.function.map_and_time": {"tf": 8.426149773176359}, "icepool.typing": {"tf": 1.7320508075688772}, "icepool.typing.S": {"tf": 1.7320508075688772}, "icepool.typing.T": {"tf": 1.7320508075688772}, "icepool.typing.T_co": {"tf": 1.7320508075688772}, "icepool.typing.T_contra": {"tf": 1.7320508075688772}, "icepool.typing.U": {"tf": 1.7320508075688772}, "icepool.typing.U_co": {"tf": 1.7320508075688772}, "icepool.typing.Qs": {"tf": 1.7320508075688772}, "icepool.typing.Order": {"tf": 1.7320508075688772}, "icepool.typing.Order.Ascending": {"tf": 1.7320508075688772}, "icepool.typing.Order.Descending": {"tf": 1.7320508075688772}, "icepool.typing.Order.Any": {"tf": 1.7320508075688772}, "icepool.typing.Order.merge": {"tf": 6.4031242374328485}, "icepool.typing.RerollType": {"tf": 1.7320508075688772}, "icepool.typing.RerollType.Reroll": {"tf": 1.7320508075688772}, "icepool.typing.Outcome": {"tf": 2.449489742783178}, "icepool.typing.count_positional_parameters": {"tf": 4.123105625617661}, "icepool.typing.guess_star": {"tf": 3.7416573867739413}}, "df": 378, "p": {"docs": {"icepool.Population.format": {"tf": 1.7320508075688772}}, "df": 1, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 8}}}}}}}, "t": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}}, "df": 11, "s": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.23606797749979}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.23606797749979}}, "df": 7}}}, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}}, "df": 7}}}, "y": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.function.coin": {"tf": 1}}, "df": 15}}}}}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}}, "df": 3}, "e": {"docs": {"icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.reduce": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.reduce": {"tf": 1}}, "df": 16, "s": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 20}, "d": {"docs": {"icepool.Pool.keep_size": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}}, "df": 16}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {"icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 41}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 4}, "d": {"docs": {"icepool.Again": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 5}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.marginals": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.multiset_function": {"tf": 1.4142135623730951}}, "df": 1}}}, "e": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 14}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 5}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 3}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 3}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.pool": {"tf": 2.23606797749979}, "icepool.map": {"tf": 1}, "icepool.Pool": {"tf": 2.449489742783178}, "icepool.Pool.__init__": {"tf": 2.8284271247461903}, "icepool.Pool.clear_cache": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 3.3166247903554}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 2}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 27, "s": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1}}, "df": 3}, "[": {"0": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}, "1": {"docs": {"icepool.Pool.keep": {"tf": 2}}, "df": 1}, "2": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}, "3": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1, ":": {"5": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}, "docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 4}, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 8}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression.expand": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}}, "df": 2}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.cmp": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}}, "df": 8}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.keep_tuple": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Pool.additive_union": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1.7320508075688772}}, "df": 4}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.tupleize": {"tf": 2.23606797749979}, "icepool.vectorize": {"tf": 2.23606797749979}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}}, "df": 17}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 3, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 4}, "s": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 8, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}}, "df": 3}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}}, "df": 5}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.standard_pool": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}}, "df": 4}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}}, "df": 2}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Population.probabilities": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.multiset_function": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "f": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool": {"tf": 1.7320508075688772}, "icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 3.1622776601683795}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1.4142135623730951}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 2}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 67, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 9}}, "s": {"docs": {"icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 2}}}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 10}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1.7320508075688772}, "icepool.Outcome": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.pool": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.7320508075688772}, "icepool.Deal.deck": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.d": {"tf": 1.7320508075688772}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 61}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 4}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}}, "df": 5}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function": {"tf": 1}}, "df": 15}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 9}, "y": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "t": {"docs": {"icepool.Pool.additive_union": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2.8284271247461903}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2.8284271247461903}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2.8284271247461903}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 36}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.if_else": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 22}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 16}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.Die": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}, "d": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2.449489742783178}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 2.449489742783178}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 8, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.from_cumulative": {"tf": 1}, "icepool.reduce": {"tf": 2}, "icepool.accumulate": {"tf": 2.23606797749979}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 2.23606797749979}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 3.1622776601683795}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 2}, "icepool.function.accumulate": {"tf": 2.23606797749979}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 2.23606797749979}, "icepool.typing.guess_star": {"tf": 1.4142135623730951}}, "df": 38, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 8}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.function.reduce": {"tf": 1}}, "df": 2}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.explode": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3, "y": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.sign": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 8}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {"icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 4, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 11}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.probabilities_ge": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {"icepool.Again": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.simplify": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 6}}, "a": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.binary_operator": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 6}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 7}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.standard_pool": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": null}, "icepool.Die.if_else": {"tf": null}, "icepool.Again": {"tf": null}, "icepool.reduce": {"tf": null}, "icepool.map": {"tf": null}, "icepool.map_function": {"tf": null}, "icepool.Pool.__init__": {"tf": null}, "icepool.Deck.__init__": {"tf": null}, "icepool.Deal.__init__": {"tf": null}, "icepool.evaluator.SumEvaluator.__init__": {"tf": null}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": null}, "icepool.function.reduce": {"tf": null}, "icepool.function.map": {"tf": null}, "icepool.function.map_function": {"tf": null}}, "df": 14}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 7}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 4}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.divide_counts": {"tf": 1.4142135623730951}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}}, "df": 8}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.align_range": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 9}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1}}, "df": 3, "d": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 4}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.is_in": {"tf": 1}}, "df": 1}}, "s": {"docs": {"icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.mode": {"tf": 1}, "icepool.evaluator": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 3}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.if_else": {"tf": 1}, "icepool.Reroll": {"tf": 1}}, "df": 2}}}}}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 12}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 3.605551275463989}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 2}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 2}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 2.449489742783178}, "icepool.MultisetEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 2}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 2}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.23606797749979}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 38, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 4}, "r": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 5, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "s": {"docs": {"icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 3.605551275463989}, "icepool.MultisetExpression.additive_union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.difference": {"tf": 2.23606797749979}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 2.23606797749979}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 2.449489742783178}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 36}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}}, "df": 15}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}}, "df": 5}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.format": {"tf": 2.23606797749979}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.pool": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.equals": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.Deck.map": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 2}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 7}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Population.format": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 42, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 4}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 3}}}, "e": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Population.median": {"tf": 1.4142135623730951}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1.4142135623730951}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1}}, "df": 27, "s": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 15}, "r": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 12}}}}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 4}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.binary_operator": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 5, "s": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "\u00e9": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.function.map": {"tf": 1}}, "df": 8, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.from_cumulative": {"tf": 2.23606797749979}, "icepool.function.from_cumulative": {"tf": 2.23606797749979}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 4}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 6, "s": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Population.probabilities_ge": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}, "d": {"1": {"0": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}, "2": {"docs": {"icepool.Pool.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "3": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}}, "df": 1, "+": {"3": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}}, "4": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}}, "df": 2}, "6": {"docs": {"icepool.d": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 3}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 15}, "8": {"docs": {"icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.standard_pool": {"tf": 1}}, "df": 3}, "docs": {"icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 2}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1.4142135623730951}}, "df": 8, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.lowest": {"tf": 2}, "icepool.Die.highest": {"tf": 1.7320508075688772}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.equals": {"tf": 2}, "icepool.from_cumulative": {"tf": 1}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.align": {"tf": 2.23606797749979}, "icepool.align_range": {"tf": 2.23606797749979}, "icepool.commonize_denominator": {"tf": 2.23606797749979}, "icepool.reduce": {"tf": 2.23606797749979}, "icepool.accumulate": {"tf": 2.449489742783178}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 2.23606797749979}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.standard_pool": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.align": {"tf": 2.23606797749979}, "icepool.function.align_range": {"tf": 2.23606797749979}, "icepool.function.commonize_denominator": {"tf": 2.23606797749979}, "icepool.function.reduce": {"tf": 2.23606797749979}, "icepool.function.accumulate": {"tf": 2.449489742783178}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 58}, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 11, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 2}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.isdisjoint": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"icepool.d": {"tf": 2}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.__init__": {"tf": 4}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 2.23606797749979}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 2}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1.7320508075688772}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.Die.zero_outcome": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 2.449489742783178}, "icepool.Population": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 2.23606797749979}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2.23606797749979}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2.6457513110645907}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.standard_pool": {"tf": 2}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2}, "icepool.function.d": {"tf": 2}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2.23606797749979}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1}}, "df": 68}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 8}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 10, "s": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 5}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Die.simplify": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}}, "df": 2}}}}}}, "d": {"docs": {"icepool.Die.zero": {"tf": 1}}, "df": 1}}, "o": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 15, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 4, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}}, "df": 4}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 14, "n": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {"icepool.map_function": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 3, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 6, "d": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.7320508075688772}, "icepool.accumulate": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 22}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.__init__": {"tf": 2}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 15}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 3, "s": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 2}, "d": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}}, "df": 4}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 2.449489742783178}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.commonize_denominator": {"tf": 1.4142135623730951}}, "df": 8, "s": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"icepool.Population": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2.449489742783178}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 2}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1.4142135623730951}}, "df": 13}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.4142135623730951}, "icepool.Order.merge": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.7320508075688772}}, "df": 19}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.Deck.deal": {"tf": 1.4142135623730951}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 2}}, "df": 5, "s": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"icepool.Deal.deck": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 7}, "d": {"docs": {"icepool.Deck.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}, "e": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}}, "df": 13, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 10}}}, "s": {"docs": {"icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1.7320508075688772}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 2.23606797749979}, "icepool.Die.__init__": {"tf": 4.898979485566356}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 2}, "icepool.Die.reroll": {"tf": 2.23606797749979}, "icepool.Die.filter": {"tf": 2}, "icepool.Die.explode": {"tf": 2.23606797749979}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 2.8284271247461903}, "icepool.Population": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.tupleize": {"tf": 2.6457513110645907}, "icepool.vectorize": {"tf": 2.6457513110645907}, "icepool.Vector": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1.4142135623730951}, "icepool.CountsValuesView": {"tf": 1.4142135623730951}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.7320508075688772}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 1.7320508075688772}, "icepool.accumulate": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 2.6457513110645907}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 2}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 3.3166247903554}, "icepool.Pool.keep": {"tf": 3.3166247903554}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.standard_pool": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.sample": {"tf": 1.4142135623730951}, "icepool.Alignment": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 2.23606797749979}, "icepool.MultisetExpression.intersection": {"tf": 2.23606797749979}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2}, "icepool.MultisetExpression.evaluate": {"tf": 2}, "icepool.MultisetExpression.issubset": {"tf": 2}, "icepool.MultisetExpression.issuperset": {"tf": 3.3166247903554}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2.6457513110645907}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 2.8284271247461903}, "icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2.6457513110645907}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 2}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 4.123105625617661}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2.6457513110645907}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2.6457513110645907}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2.6457513110645907}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.d": {"tf": 1.7320508075688772}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1.7320508075688772}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1.7320508075688772}, "icepool.function.accumulate": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 2.6457513110645907}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 2}, "icepool.typing.S": {"tf": 1}, "icepool.typing.Qs": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 145, "n": {"docs": {"icepool": {"tf": 1.4142135623730951}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 59, "d": {"docs": {"icepool": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 2}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 1.7320508075688772}, "icepool.Population": {"tf": 1.4142135623730951}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 1.7320508075688772}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 2}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.449489742783178}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.449489742783178}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 113, "/": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 4}}}}, "y": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 59, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 4}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}}, "df": 5}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1.4142135623730951}, "icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.count": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 2}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 2}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.449489742783178}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.evaluate": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 2.449489742783178}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.deck": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.449489742783178}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.449489742783178}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}, "icepool.typing.Outcome": {"tf": 1}}, "df": 101}, "g": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 5, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.typing.guess_star": {"tf": 1}}, "df": 16, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Again": {"tf": 1.4142135623730951}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 1.7320508075688772}, "icepool.accumulate": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Order.merge": {"tf": 2}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 1.7320508075688772}, "icepool.function.accumulate": {"tf": 1.7320508075688772}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}, "icepool.typing.Order.merge": {"tf": 2}, "icepool.typing.count_positional_parameters": {"tf": 1.4142135623730951}, "icepool.typing.guess_star": {"tf": 1.4142135623730951}}, "df": 92}}}}}}, "s": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2.23606797749979}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 2.23606797749979}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 10}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 8}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}}, "df": 3}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 3, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 9}, "s": {"docs": {"icepool.Population.marginals": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 8}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Population.format": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.keep": {"tf": 1.7320508075688772}}, "df": 1, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.pool": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Population.sample": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1}}, "df": 14}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.7320508075688772}, "icepool.reduce": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 18}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}}, "df": 10}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 1}}}, "l": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 2.23606797749979}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.7320508075688772}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 3}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map": {"tf": 2.23606797749979}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 78, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}}, "s": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 11}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}}, "df": 7}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 5}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 31, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}}, "df": 1}, "d": {"docs": {"icepool.evaluator.KeepEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.8284271247461903}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}}, "df": 63, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 2}}, "s": {"docs": {"icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.outcomes": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Order.merge": {"tf": 1.7320508075688772}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.7320508075688772}}, "df": 26}}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Again": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Alignment": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 15, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 6}}}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 3.3166247903554}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 2.8284271247461903}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_function": {"tf": 2.449489742783178}, "icepool.Reroll": {"tf": 1.7320508075688772}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 2.449489742783178}}, "df": 11, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 21}}}, "p": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 6}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}}, "df": 2}}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}}, "df": 3, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 8}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Again": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 7, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.binary_operator": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.clip": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}}, "df": 2}}, "s": {"docs": {"icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "k": {"docs": {}, "df": 0, "a": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.items": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.mode": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.Again": {"tf": 1}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 37, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 8, "t": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool.d": {"tf": 1.4142135623730951}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Population.sample": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.d": {"tf": 1.4142135623730951}}, "df": 11}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 4.69041575982343}, "icepool.MultisetEvaluator.next_state": {"tf": 3.3166247903554}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 3.3166247903554}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 3.3166247903554}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 21, "s": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 2}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 3}}, "y": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 5}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.Deck.deal": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1}}, "df": 15, "n": {"docs": {"icepool.Alignment": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.Order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.23606797749979}, "icepool.typing.Order": {"tf": 1}}, "df": 8}, "s": {"docs": {"icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}}, "df": 2}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Deck.map": {"tf": 1}}, "df": 8, "d": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 43, "s": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 6}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 3}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Deck.map": {"tf": 1}}, "df": 4}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.pool": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.reduce": {"tf": 2}, "icepool.accumulate": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 2}, "icepool.function.accumulate": {"tf": 1.7320508075688772}, "icepool.typing.S": {"tf": 1}}, "df": 22, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Deck.map": {"tf": 1}}, "df": 6}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.if_else": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 12, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 3}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "f": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}}, "df": 11}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 3}, "s": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}, "c": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Reroll": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.d": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 7}}}}}}, "y": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}}, "df": 3}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 2.8284271247461903}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}}, "df": 13, "s": {"docs": {"icepool.d": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 2}, "d": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}}, "x": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_function": {"tf": 2}, "icepool.function.map_function": {"tf": 2}}, "df": 3, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 36, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.RerollType": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}}, "df": 2}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 8}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 11}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.449489742783178}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}}, "df": 10, "s": {"docs": {"icepool.standard_pool": {"tf": 2}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 6}}}}, "o": {"docs": {"icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 9, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 18, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 23, "/": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Deal": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "s": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"icepool.Population.variance": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 4, "s": {"docs": {"icepool.MultisetEvaluator.sample": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 2}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 45}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}}, "df": 6}}, "m": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.Pool.middle": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Deck.size": {"tf": 1}}, "df": 20, "s": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}}, "df": 2}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}}, "df": 2}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.evaluator.SumEvaluator.__init__": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.explode": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "b": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.order": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.pool": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}}, "df": 9, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 6}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.evaluator": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.probabilities_ge": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Again": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 37}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.commonize_denominator": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 2, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "s": {"docs": {"icepool.Population.scale_quantities": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.compair": {"tf": 2.6457513110645907}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.6457513110645907}}, "df": 2, "s": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "f": {"docs": {"icepool.Population.probabilities_ge": {"tf": 1}}, "df": 1}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Again": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool": {"tf": 2}, "icepool.d": {"tf": 1.4142135623730951}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.Again": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 2.6457513110645907}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.d": {"tf": 1.4142135623730951}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 77, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 12}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 5}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 2.6457513110645907}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 2.23606797749979}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_le": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_gt": {"tf": 1.7320508075688772}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1.7320508075688772}, "icepool.highest": {"tf": 1.7320508075688772}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 3.3166247903554}, "icepool.map_and_time": {"tf": 2.23606797749979}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 3.3166247903554}, "icepool.function.map_and_time": {"tf": 2.23606797749979}, "icepool.typing.guess_star": {"tf": 1}}, "df": 88}}, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression.compair": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.23606797749979}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 20}}}, "e": {"docs": {"icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}}, "df": 5, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}}, "df": 5}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 3}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 8}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 18}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.AllCountsEvaluator": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 2}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.7320508075688772}, "icepool.Die.filter": {"tf": 1.7320508075688772}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.explode": {"tf": 1.7320508075688772}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 29, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 6}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.449489742783178}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 17}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 5}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 9}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.zero_outcome": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}}, "df": 4}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}, "v": {"0": {"docs": {"icepool": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool": {"tf": 1.4142135623730951}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 8, "s": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 5}}}, "y": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 4}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.vectorize": {"tf": 3.3166247903554}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}}, "df": 5, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.vectorize": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.explode": {"tf": 1.7320508075688772}, "icepool.Die.equals": {"tf": 2.23606797749979}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 20, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.format": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}}, "df": 15, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsValuesView": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 14}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 10}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.variance": {"tf": 1.4142135623730951}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 2}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 2}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.function.d": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 37, "r": {"docs": {"icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"icepool.MultisetExpression": {"tf": 2.23606797749979}}, "df": 1, "e": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 9, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}, "d": {"docs": {"icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}}, "df": 5}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Deck": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 18}}}, "s": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.Deal": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1}}, "df": 14, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 49}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}}, "df": 13}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 8}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 53, "s": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 8}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 9}}}}}}, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 11}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.zero": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.cmp": {"tf": 1}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 6, "s": {"docs": {"icepool.Die.trim": {"tf": 1}, "icepool.Reroll": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.cmp": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 2}, "icepool.Die.reroll": {"tf": 2.449489742783178}, "icepool.Die.filter": {"tf": 2.449489742783178}, "icepool.Die.clip": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.RerollType": {"tf": 1}}, "df": 22, "s": {"docs": {"icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.truncate": {"tf": 1}}, "df": 3}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1}, "icepool.Reroll": {"tf": 1.7320508075688772}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 6}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}, "d": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 4}, "d": {"docs": {"icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 2}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 3, "d": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.from_cumulative": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 7}}}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 3}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.keep": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 7}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1}}, "df": 13, "s": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.Pool": {"tf": 2}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 19}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}}, "df": 7}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 9}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.divide_counts": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.sample": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.sample": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}}, "df": 5}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1.7320508075688772}, "icepool.Die.set_range": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 9}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 22}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.6457513110645907}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.6457513110645907}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 21}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"icepool.evaluator.CompairEvalautor": {"tf": 1}}, "df": 1}}}, "v": {"docs": {"icepool.from_rv": {"tf": 2}, "icepool.function.from_rv": {"tf": 2}}, "df": 2}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}}, "df": 3}}}}, "l": {"docs": {"icepool.MultisetExpression": {"tf": 2.23606797749979}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}, "z": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}}, "df": 9}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.7320508075688772}, "icepool.Population.mode": {"tf": 1}, "icepool.lowest": {"tf": 2}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}}, "df": 9}}, "r": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 6}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetGenerator.equals": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 1}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Die": {"tf": 1.4142135623730951}, "icepool.Vector": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 8}}, "d": {"docs": {}, "df": 0, "s": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}, "n": {"docs": {"icepool.Population.denominator": {"tf": 1}, "icepool.Deck.size": {"tf": 1}}, "df": 2, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 9, "s": {"docs": {"icepool.Population.common_outcome_length": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 3}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 3}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 19}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.sign": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}}, "df": 4, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Population.quantile_low": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 5}}}}, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 2}, "icepool.Die.cmp": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.format": {"tf": 2.449489742783178}, "icepool.Vector.binary_operator": {"tf": 2}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 19}}, "i": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 8, "n": {"docs": {"icepool": {"tf": 1}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 2}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.median": {"tf": 1.4142135623730951}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1.4142135623730951}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.from_cumulative": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2.23606797749979}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1.7320508075688772}, "icepool.Pool": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1.4142135623730951}, "icepool.Pool.keep_tuple": {"tf": 1.7320508075688772}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.449489742783178}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Order.merge": {"tf": 1.7320508075688772}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 2.23606797749979}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.7320508075688772}}, "df": 120, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1.4142135623730951}, "icepool.Population": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 8}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.align_range": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.align_range": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 29, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.unary_operator": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.count": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression.intersection": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}}, "df": 3}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 5}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 12}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 9}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 8, "d": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.denominator": {"tf": 1}, "icepool.Deck.size": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 8}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Again": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}}, "df": 5}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {"icepool.Pool.keep": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}}, "df": 5}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 3}}}}}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}, "f": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}}, "df": 8, "s": {"docs": {"icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}}, "df": 6}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 5}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 8}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"icepool.d": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1.4142135623730951}}, "df": 3}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 4}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.SumEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AnyEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AnyEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.next_state": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.final_outcome": {"tf": 1}}, "df": 28}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"icepool": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 2}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}, "icepool.typing.Outcome": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 29, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 2}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.7320508075688772}, "icepool.highest": {"tf": 1.7320508075688772}, "icepool.middle": {"tf": 1.7320508075688772}, "icepool.function.from_rv": {"tf": 1}}, "df": 5}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsItemsView": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.d": {"tf": 2.23606797749979}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.map": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.d": {"tf": 2.23606797749979}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 24}}}}}}, "f": {"docs": {"icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 2.23606797749979}, "icepool.Die.filter": {"tf": 2}, "icepool.Die.truncate": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 1.7320508075688772}, "icepool.Die.set_range": {"tf": 2}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 2}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.7320508075688772}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 2}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.quantities_le": {"tf": 1.4142135623730951}, "icepool.Population.quantities_ge": {"tf": 1.4142135623730951}, "icepool.Population.quantities_lt": {"tf": 1.4142135623730951}, "icepool.Population.quantities_gt": {"tf": 1.4142135623730951}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_le": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_gt": {"tf": 1.7320508075688772}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.7320508075688772}, "icepool.highest": {"tf": 1.7320508075688772}, "icepool.middle": {"tf": 2}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2.23606797749979}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.6457513110645907}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1.7320508075688772}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issuperset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.next_state": {"tf": 2.449489742783178}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Order.merge": {"tf": 2}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.449489742783178}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.449489742783178}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2.23606797749979}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}, "icepool.typing.Order.merge": {"tf": 2}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 126, "f": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 17}}, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 2.23606797749979}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1.7320508075688772}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.middle": {"tf": 2.23606797749979}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.equals": {"tf": 2}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1.4142135623730951}, "icepool.Population.nearest_lt": {"tf": 1.4142135623730951}, "icepool.Population.nearest_ge": {"tf": 1.4142135623730951}, "icepool.Population.nearest_gt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.sample": {"tf": 1.4142135623730951}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.vectorize": {"tf": 1.7320508075688772}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 2.449489742783178}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 2.449489742783178}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep": {"tf": 3.3166247903554}, "icepool.Pool.middle": {"tf": 2.23606797749979}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2.23606797749979}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 2.23606797749979}, "icepool.MultisetExpression.issuperset": {"tf": 2.449489742783178}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.23606797749979}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1.7320508075688772}}, "df": 118, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}}, "df": 2}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 2}, "s": {"docs": {"icepool.evaluator.ConstantEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"icepool.d": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 6, "h": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 2}, "icepool.d": {"tf": 1.7320508075688772}, "icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1.7320508075688772}, "icepool.Die": {"tf": 2}, "icepool.Die.__init__": {"tf": 5.830951894845301}, "icepool.Die.unary_operator": {"tf": 2.8284271247461903}, "icepool.Die.binary_operator": {"tf": 4.58257569495584}, "icepool.Die.keys": {"tf": 1.4142135623730951}, "icepool.Die.values": {"tf": 1.4142135623730951}, "icepool.Die.items": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 2.6457513110645907}, "icepool.Die.filter": {"tf": 2.6457513110645907}, "icepool.Die.truncate": {"tf": 2.6457513110645907}, "icepool.Die.clip": {"tf": 3}, "icepool.Die.set_range": {"tf": 3}, "icepool.Die.set_outcomes": {"tf": 1.7320508075688772}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 2}, "icepool.Die.if_else": {"tf": 2}, "icepool.Die.is_in": {"tf": 1.7320508075688772}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 3}, "icepool.Die.lowest": {"tf": 3}, "icepool.Die.highest": {"tf": 2.8284271247461903}, "icepool.Die.middle": {"tf": 3}, "icepool.Die.zero": {"tf": 1.7320508075688772}, "icepool.Die.cmp": {"tf": 1.7320508075688772}, "icepool.Die.equals": {"tf": 2.8284271247461903}, "icepool.Population.keys": {"tf": 1.4142135623730951}, "icepool.Population.values": {"tf": 1.4142135623730951}, "icepool.Population.items": {"tf": 1.4142135623730951}, "icepool.Population.outcomes": {"tf": 2.23606797749979}, "icepool.Population.common_outcome_length": {"tf": 1.4142135623730951}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1.4142135623730951}, "icepool.Population.nearest_lt": {"tf": 1.4142135623730951}, "icepool.Population.nearest_ge": {"tf": 1.4142135623730951}, "icepool.Population.nearest_gt": {"tf": 1.4142135623730951}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 2.449489742783178}, "icepool.Population.denominator": {"tf": 1.4142135623730951}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1.4142135623730951}, "icepool.Population.quantities_ge": {"tf": 1.4142135623730951}, "icepool.Population.quantities_lt": {"tf": 1.4142135623730951}, "icepool.Population.quantities_gt": {"tf": 1.4142135623730951}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 2.6457513110645907}, "icepool.Population.probabilities_le": {"tf": 2.6457513110645907}, "icepool.Population.probabilities_ge": {"tf": 2.6457513110645907}, "icepool.Population.probabilities_lt": {"tf": 2.449489742783178}, "icepool.Population.probabilities_gt": {"tf": 2.449489742783178}, "icepool.Population.mode": {"tf": 1.4142135623730951}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1.7320508075688772}, "icepool.Population.median_low": {"tf": 1.4142135623730951}, "icepool.Population.median_high": {"tf": 1.4142135623730951}, "icepool.Population.quantile": {"tf": 2.23606797749979}, "icepool.Population.quantile_low": {"tf": 2}, "icepool.Population.quantile_high": {"tf": 2}, "icepool.Population.variance": {"tf": 1.4142135623730951}, "icepool.Population.entropy": {"tf": 1.7320508075688772}, "icepool.Population.marginals": {"tf": 1.7320508075688772}, "icepool.Population.sample": {"tf": 1}, "icepool.Population.format": {"tf": 2.6457513110645907}, "icepool.tupleize": {"tf": 3}, "icepool.vectorize": {"tf": 3}, "icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 2.6457513110645907}, "icepool.Again": {"tf": 1.7320508075688772}, "icepool.from_cumulative": {"tf": 2.6457513110645907}, "icepool.from_rv": {"tf": 2.23606797749979}, "icepool.lowest": {"tf": 2.8284271247461903}, "icepool.highest": {"tf": 2.8284271247461903}, "icepool.middle": {"tf": 3.4641016151377544}, "icepool.min_outcome": {"tf": 1.4142135623730951}, "icepool.max_outcome": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 2}, "icepool.reduce": {"tf": 3}, "icepool.accumulate": {"tf": 2.8284271247461903}, "icepool.map": {"tf": 4.69041575982343}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 4.242640687119285}, "icepool.Reroll": {"tf": 2.449489742783178}, "icepool.RerollType": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 2.6457513110645907}, "icepool.Pool.__init__": {"tf": 3.1622776601683795}, "icepool.Pool.clear_cache": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1.4142135623730951}, "icepool.Pool.keep_size": {"tf": 1.4142135623730951}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 2.449489742783178}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 5.477225575051661}, "icepool.Pool.lowest": {"tf": 2.449489742783178}, "icepool.Pool.highest": {"tf": 2.449489742783178}, "icepool.Pool.middle": {"tf": 3.3166247903554}, "icepool.Pool.additive_union": {"tf": 3}, "icepool.standard_pool": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 4.358898943540674}, "icepool.MultisetExpression.additive_union": {"tf": 2.23606797749979}, "icepool.MultisetExpression.difference": {"tf": 2.8284271247461903}, "icepool.MultisetExpression.intersection": {"tf": 2.449489742783178}, "icepool.MultisetExpression.union": {"tf": 2.23606797749979}, "icepool.MultisetExpression.symmetric_difference": {"tf": 2}, "icepool.MultisetExpression.keep_outcomes": {"tf": 2.23606797749979}, "icepool.MultisetExpression.drop_outcomes": {"tf": 2.23606797749979}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 3.4641016151377544}, "icepool.MultisetExpression.lowest": {"tf": 2.449489742783178}, "icepool.MultisetExpression.highest": {"tf": 2.449489742783178}, "icepool.MultisetExpression.evaluate": {"tf": 2}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 2}, "icepool.MultisetExpression.largest_count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_straight": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 2}, "icepool.MultisetExpression.all_straights": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 2.6457513110645907}, "icepool.MultisetExpression.issuperset": {"tf": 3}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 3.7416573867739413}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.next_state": {"tf": 4.242640687119285}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 2.449489742783178}, "icepool.MultisetEvaluator.alignment": {"tf": 2}, "icepool.MultisetEvaluator.range_alignment": {"tf": 2}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 3}, "icepool.MultisetEvaluator.sample": {"tf": 1.4142135623730951}, "icepool.Order.merge": {"tf": 2}, "icepool.Deck.__init__": {"tf": 3.1622776601683795}, "icepool.Deck.keys": {"tf": 1.4142135623730951}, "icepool.Deck.values": {"tf": 1.4142135623730951}, "icepool.Deck.items": {"tf": 1.4142135623730951}, "icepool.Deck.size": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 2}, "icepool.Deal.__init__": {"tf": 2}, "icepool.Deal.deck": {"tf": 1.4142135623730951}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 2.23606797749979}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.multiset_function": {"tf": 2.6457513110645907}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.order": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 2}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 2}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 2}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 4.242640687119285}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 3.7416573867739413}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 4.242640687119285}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 2.449489742783178}, "icepool.evaluator.KeepEvaluator": {"tf": 1.7320508075688772}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1.7320508075688772}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.7320508075688772}, "icepool.function.from_cumulative": {"tf": 2.6457513110645907}, "icepool.function.from_rv": {"tf": 2.23606797749979}, "icepool.function.min_outcome": {"tf": 1.4142135623730951}, "icepool.function.max_outcome": {"tf": 1.4142135623730951}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 2}, "icepool.function.reduce": {"tf": 3}, "icepool.function.accumulate": {"tf": 2.8284271247461903}, "icepool.function.iter_cartesian_product": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 4.69041575982343}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 4.242640687119285}, "icepool.typing.Order.merge": {"tf": 2}, "icepool.typing.RerollType": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 2.23606797749979}, "icepool.typing.guess_star": {"tf": 2}}, "df": 255, "y": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 19}, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 29}}, "m": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 12, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 6}}, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}}, "df": 3}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 26, "o": {"docs": {}, "df": 0, "f": {"docs": {"icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1.4142135623730951}, "icepool.d": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment": {"tf": 1.4142135623730951}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.function.d": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}, "icepool.typing.Outcome": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 90}, "n": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.map": {"tf": 2}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.8284271247461903}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1}}, "df": 19}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 2.23606797749979}, "icepool.Die.set_range": {"tf": 2.23606797749979}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.if_else": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1.7320508075688772}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.zero": {"tf": 1.7320508075688772}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1.7320508075688772}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.median": {"tf": 1.4142135623730951}, "icepool.Population.quantile": {"tf": 1.4142135623730951}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.sample": {"tf": 1.7320508075688772}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.7320508075688772}, "icepool.Again": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2.449489742783178}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 2}, "icepool.Reroll": {"tf": 1.7320508075688772}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.6457513110645907}, "icepool.Pool.lowest": {"tf": 2}, "icepool.Pool.highest": {"tf": 2}, "icepool.Pool.middle": {"tf": 1.7320508075688772}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1.7320508075688772}, "icepool.Alignment": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 2}, "icepool.MultisetExpression.highest": {"tf": 2}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 2.23606797749979}, "icepool.MultisetExpression.issuperset": {"tf": 2.449489742783178}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 2}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.Deal.__init__": {"tf": 1.7320508075688772}, "icepool.Deal.denominator": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 2.449489742783178}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 2}, "icepool.typing.Qs": {"tf": 1.4142135623730951}}, "df": 129}, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}}, "df": 8}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 10}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.size": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 7}}}, "o": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Outcome": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 2}, "icepool.Die.__init__": {"tf": 3.1622776601683795}, "icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.reroll": {"tf": 2.23606797749979}, "icepool.Die.filter": {"tf": 2}, "icepool.Die.truncate": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 2}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 2.6457513110645907}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.7320508075688772}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.7320508075688772}, "icepool.Again": {"tf": 1.7320508075688772}, "icepool.from_cumulative": {"tf": 1}, "icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.reduce": {"tf": 2.8284271247461903}, "icepool.accumulate": {"tf": 2.6457513110645907}, "icepool.map": {"tf": 2.6457513110645907}, "icepool.map_function": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 2.449489742783178}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2.6457513110645907}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 2}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.Pool.middle": {"tf": 2}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.additive_union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 2}, "icepool.MultisetExpression.drop_outcomes": {"tf": 2}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 2}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 3.1622776601683795}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.range_alignment": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.Deal.__init__": {"tf": 2.6457513110645907}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 3.1622776601683795}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 3.1622776601683795}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.from_rv": {"tf": 1.4142135623730951}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.reduce": {"tf": 2.8284271247461903}, "icepool.function.accumulate": {"tf": 2.6457513110645907}, "icepool.function.map": {"tf": 2.6457513110645907}, "icepool.function.map_function": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 2.449489742783178}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1.4142135623730951}, "icepool.typing.guess_star": {"tf": 1.4142135623730951}}, "df": 142, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.typing.Outcome": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 22, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}}, "df": 8}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 31}, "n": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}, "d": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Pool.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.equals": {"tf": 2}, "icepool.Vector.binary_operator": {"tf": 1}}, "df": 3, "y": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.explode": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}}, "df": 5}}}}, "e": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}, "y": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}}, "df": 3}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"icepool.Population.marginals": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1.7320508075688772}, "icepool.accumulate": {"tf": 1.7320508075688772}, "icepool.Pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 2}, "icepool.Pool.middle": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1.7320508075688772}, "icepool.function.accumulate": {"tf": 1.7320508075688772}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 30, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Again": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}}, "df": 2}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.RerollType": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.typing.S": {"tf": 1}, "icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}}, "df": 16, "s": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 8}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 4}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.typing.Qs": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}}, "df": 7, "s": {"docs": {"icepool.Die.__init__": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.count": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.7320508075688772}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2.23606797749979}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 18, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}}, "df": 11, "s": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}}, "df": 2}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.if_else": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.pool": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.tupleize": {"tf": 1.7320508075688772}, "icepool.Vector": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}}, "df": 22, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 7}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.tupleize": {"tf": 1.7320508075688772}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"icepool.accumulate": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}}, "df": 5, "s": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 9}, "n": {"docs": {"icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1.4142135623730951}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 7}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.7320508075688772}}, "df": 5}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {"icepool": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Die": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}}, "df": 6}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}}, "df": 7}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.Deck.size": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}}, "df": 7}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 6}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.unary_operator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}}, "df": 4}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 10}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.filter": {"tf": 1.7320508075688772}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 5}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.entropy": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 34, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 6}}}, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Reroll": {"tf": 2}, "icepool.Pool": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 28}, "s": {"docs": {"icepool.Population.sample": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 7}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 10}}}}, "p": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}}, "df": 5}}, "o": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1, "l": {"docs": {}, "df": 0, "d": {"docs": {"icepool": {"tf": 1}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 2}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 2}}, "df": 6}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1.7320508075688772}, "icepool.Again": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 2.23606797749979}, "icepool.MultisetExpression.issuperset": {"tf": 2.23606797749979}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 32, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}, "icepool.coin": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.coin": {"tf": 1}}, "df": 23}}}}, "s": {"docs": {"icepool.MultisetExpression.difference": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 2, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.7320508075688772}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 2.449489742783178}, "icepool.Die.explode": {"tf": 1.7320508075688772}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.min_outcome": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1.4142135623730951}, "icepool.Population.nearest_lt": {"tf": 1.4142135623730951}, "icepool.Population.nearest_ge": {"tf": 1.4142135623730951}, "icepool.Population.nearest_gt": {"tf": 1.4142135623730951}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probability_le": {"tf": 1}, "icepool.Population.probability_lt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.min_outcome": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 2.449489742783178}, "icepool.map_and_time": {"tf": 2.449489742783178}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 3.1622776601683795}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.4142135623730951}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2.23606797749979}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2.23606797749979}, "icepool.function.coin": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 2.449489742783178}, "icepool.function.map_and_time": {"tf": 2.449489742783178}, "icepool.typing.T": {"tf": 1}, "icepool.typing.T_co": {"tf": 1}, "icepool.typing.T_contra": {"tf": 1}, "icepool.typing.U": {"tf": 1}, "icepool.typing.U_co": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 135, "s": {"docs": {"icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 2.6457513110645907}, "icepool.Die.__init__": {"tf": 3.3166247903554}, "icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.keys": {"tf": 1}, "icepool.Die.reroll": {"tf": 2.23606797749979}, "icepool.Die.filter": {"tf": 2.23606797749979}, "icepool.Die.truncate": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 1.7320508075688772}, "icepool.Die.set_range": {"tf": 1.7320508075688772}, "icepool.Die.set_outcomes": {"tf": 1.7320508075688772}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.map": {"tf": 1.4142135623730951}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 2}, "icepool.Die.if_else": {"tf": 1.4142135623730951}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1.4142135623730951}, "icepool.Die.sign": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population": {"tf": 1.4142135623730951}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1.4142135623730951}, "icepool.Population.common_outcome_length": {"tf": 1.4142135623730951}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1.4142135623730951}, "icepool.Population.quantities_ge": {"tf": 1.4142135623730951}, "icepool.Population.quantities_lt": {"tf": 1.4142135623730951}, "icepool.Population.quantities_gt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.marginals": {"tf": 1.4142135623730951}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.from_cumulative": {"tf": 1.7320508075688772}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 2}, "icepool.align": {"tf": 1.4142135623730951}, "icepool.align_range": {"tf": 1.4142135623730951}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 3}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 2.8284271247461903}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2.23606797749979}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 3}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 2.6457513110645907}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 2}, "icepool.Order": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2.449489742783178}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deck.map": {"tf": 2.6457513110645907}, "icepool.Deal.outcomes": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2.6457513110645907}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 3}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 3}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1.7320508075688772}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 1.4142135623730951}, "icepool.function.align_range": {"tf": 1.4142135623730951}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 3}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 2.8284271247461903}, "icepool.typing.Order": {"tf": 1}}, "df": 128}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.truncate": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Population.format": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 9}}}}}, "r": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die.__init__": {"tf": 2.23606797749979}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.format": {"tf": 2}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 2.23606797749979}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2.449489742783178}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 79, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.keys": {"tf": 1}, "icepool.Die.values": {"tf": 1}, "icepool.Die.items": {"tf": 1}, "icepool.Population.keys": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.order": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Order": {"tf": 1}, "icepool.Deck.keys": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ExpandEvaluator.order": {"tf": 1}, "icepool.evaluator.SumEvaluator.order": {"tf": 1}, "icepool.evaluator.CountEvaluator.order": {"tf": 1}, "icepool.evaluator.AnyEvaluator.order": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.order": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.order": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.order": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.order": {"tf": 2.8284271247461903}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 68, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}}, "df": 8}}}}, "s": {"docs": {"icepool.Order.merge": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.6457513110645907}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.4142135623730951}}, "df": 27, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 20}}, "e": {"docs": {"icepool.coin": {"tf": 1}, "icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.binary_operator": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 2.23606797749979}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Order.merge": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.AnyEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1.4142135623730951}}, "df": 48, "s": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.explode": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}}, "df": 2}}}, "f": {"docs": {"icepool.one_hot": {"tf": 1.4142135623730951}, "icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 4.47213595499958}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 2.449489742783178}, "icepool.Die.items": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.7320508075688772}, "icepool.Die.filter": {"tf": 2.23606797749979}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1.4142135623730951}, "icepool.Die.set_range": {"tf": 2.23606797749979}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1}, "icepool.Die.explode": {"tf": 1.4142135623730951}, "icepool.Die.is_in": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 2.23606797749979}, "icepool.Die.lowest": {"tf": 2.449489742783178}, "icepool.Die.highest": {"tf": 2.449489742783178}, "icepool.Die.middle": {"tf": 1.7320508075688772}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1.4142135623730951}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.denominator": {"tf": 1.4142135623730951}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_le": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_ge": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_lt": {"tf": 1.4142135623730951}, "icepool.Population.probabilities_gt": {"tf": 1.4142135623730951}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.Population.quantile": {"tf": 1.4142135623730951}, "icepool.Population.quantile_low": {"tf": 1.4142135623730951}, "icepool.Population.quantile_high": {"tf": 1.4142135623730951}, "icepool.Population.entropy": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.tupleize": {"tf": 2}, "icepool.vectorize": {"tf": 2}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.from_cumulative": {"tf": 2}, "icepool.from_rv": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 2.23606797749979}, "icepool.align": {"tf": 1.7320508075688772}, "icepool.align_range": {"tf": 1.7320508075688772}, "icepool.commonize_denominator": {"tf": 2}, "icepool.reduce": {"tf": 2.6457513110645907}, "icepool.accumulate": {"tf": 3}, "icepool.map": {"tf": 3.605551275463989}, "icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 2.8284271247461903}, "icepool.Reroll": {"tf": 1}, "icepool.RerollType": {"tf": 1}, "icepool.Pool": {"tf": 2.23606797749979}, "icepool.Pool.__init__": {"tf": 3.3166247903554}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.denominator": {"tf": 1}, "icepool.Pool.unique_dice": {"tf": 1}, "icepool.Pool.outcomes": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep": {"tf": 3.3166247903554}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.Pool.middle": {"tf": 2}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.standard_pool": {"tf": 2.449489742783178}, "icepool.MultisetGenerator": {"tf": 2}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1.4142135623730951}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.449489742783178}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 2.23606797749979}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 2.23606797749979}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 3.605551275463989}, "icepool.MultisetEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 2}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 2.6457513110645907}, "icepool.Deck.__init__": {"tf": 2.8284271247461903}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1.4142135623730951}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.multiset_function": {"tf": 2.449489742783178}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestCountAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 2}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 2}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 2}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.one_hot": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 2}, "icepool.function.from_rv": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 1.7320508075688772}, "icepool.function.align_range": {"tf": 1.7320508075688772}, "icepool.function.commonize_denominator": {"tf": 2}, "icepool.function.reduce": {"tf": 2.6457513110645907}, "icepool.function.accumulate": {"tf": 3}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 3.605551275463989}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 2.8284271247461903}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.RerollType": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 2}, "icepool.typing.guess_star": {"tf": 1}}, "df": 181, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}, "p": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.if_else": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Vector.reverse_binary_operator": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 10, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}}, "df": 11}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.unary_operator": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}}, "df": 8, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}}, "df": 4}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 14, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.additive_union": {"tf": 1}}, "df": 1}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}}, "df": 2}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 3}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Population.format": {"tf": 1}}, "df": 4}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}, "|": {"docs": {}, "df": 0, "q": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.from_rv": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.deal": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 1.4142135623730951}}, "df": 8}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Reroll": {"tf": 1}}, "df": 1}}}}}}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}}, "df": 2}}}, "n": {"docs": {"icepool.coin": {"tf": 1.7320508075688772}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.quantile_low": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.function.coin": {"tf": 1.7320508075688772}}, "df": 6, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.4142135623730951}, "icepool.Die.highest": {"tf": 1.4142135623730951}, "icepool.Die.middle": {"tf": 1.4142135623730951}, "icepool.Population.denominator": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.Deal.total_cards_dealt": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}, "icepool.typing.count_positional_parameters": {"tf": 1.7320508075688772}, "icepool.typing.guess_star": {"tf": 1}}, "df": 66, "s": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 45, "t": {"docs": {"icepool.Die": {"tf": 1.7320508075688772}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1.7320508075688772}, "icepool.Die.reroll": {"tf": 1.4142135623730951}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.7320508075688772}, "icepool.Die.clip": {"tf": 1.7320508075688772}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.set_outcomes": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 1.7320508075688772}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.equals": {"tf": 2}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.Population.variance": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.map": {"tf": 2}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.Deck.map": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1}}, "df": 78, "e": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 11, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 10, "e": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}, "icepool.typing.count_positional_parameters": {"tf": 1}}, "df": 22}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 2}, "icepool.Pool.additive_union": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.additive_union": {"tf": 2}, "icepool.MultisetExpression.difference": {"tf": 2}, "icepool.MultisetExpression.intersection": {"tf": 2}, "icepool.MultisetExpression.union": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}}, "df": 13}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}}, "df": 3}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Population.nearest_le": {"tf": 1}, "icepool.Population.nearest_lt": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}}, "df": 5}}}}}, "w": {"docs": {"icepool.map": {"tf": 1.7320508075688772}, "icepool.map_and_time": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1.7320508075688772}, "icepool.function.map_and_time": {"tf": 1.7320508075688772}}, "df": 7}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2.23606797749979}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1.7320508075688772}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 13}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.sign": {"tf": 1}}, "df": 1}, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.outcomes": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 3}}}}, "g": {"docs": {"icepool.d": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.Pool.keep": {"tf": 2}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 18, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool": {"tf": 1}, "icepool.Pool": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 5, "d": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}}, "df": 7}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Pool.denominator": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.denominator": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1.4142135623730951}, "icepool.Alignment": {"tf": 1}, "icepool.Alignment.denominator": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 2}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.Deal.denominator": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator": {"tf": 1}}, "df": 22, "s": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1.7320508075688772}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1.4142135623730951}}, "df": 26, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetGenerator": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.Vector": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 3, "n": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 19}, "s": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 5}}}}}, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 2}, "icepool.Die.cmp": {"tf": 1}, "icepool.Population.nearest_ge": {"tf": 1}, "icepool.Population.nearest_gt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probability_ge": {"tf": 1}, "icepool.Population.probability_gt": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 2.449489742783178}, "icepool.Vector.binary_operator": {"tf": 2}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2.23606797749979}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 29}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.simplify": {"tf": 1}, "icepool.Population.max_outcome": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator": {"tf": 1}}, "df": 3}}, "r": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Die.sign": {"tf": 1}, "icepool.Population.quantile_high": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}}, "df": 7}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 8}, "s": {"docs": {"icepool.typing.guess_star": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3, "d": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Pool.clear_cache": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 7}}}, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 5, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.evaluator.JointEvaluator": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {"icepool.d": {"tf": 1}, "icepool.Outcome": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.Pool.keep": {"tf": 2}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 26, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 32, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}}, "df": 3}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 5}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"icepool.Die.explode": {"tf": 2}, "icepool.map_function": {"tf": 2}, "icepool.function.map_function": {"tf": 2}}, "df": 3, "d": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.explode": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 4}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 7}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator": {"tf": 1.4142135623730951}}, "df": 1}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 7}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 12, "s": {"docs": {"icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}}, "df": 2}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.8284271247461903}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.map_function": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 13}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.tupleize": {"tf": 1.4142135623730951}, "icepool.vectorize": {"tf": 1.4142135623730951}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 22, "s": {"docs": {"icepool": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Population.marginals": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.Pool.middle": {"tf": 2}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.expand": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.23606797749979}, "icepool.Deck.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.23606797749979}, "icepool.function.accumulate": {"tf": 1}}, "df": 35}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Vector": {"tf": 1}, "icepool.Vector.unary_operator": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}}, "df": 3}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.map_function": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.function.map_function": {"tf": 1.4142135623730951}}, "df": 3}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"icepool": {"tf": 1}, "icepool.evaluator.CountEvaluator": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.d": {"tf": 1}, "icepool.one_hot": {"tf": 1}, "icepool.Die.__init__": {"tf": 2}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.truncate": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}, "icepool.Population.probabilities_lt": {"tf": 1}, "icepool.Population.probabilities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.sample": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 2.6457513110645907}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1.7320508075688772}, "icepool.Deck.map": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.hand_sizes": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 2.6457513110645907}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 1}}, "df": 58}}, "s": {"docs": {}, "df": 0, "y": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.map_and_time": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.typing.Outcome": {"tf": 1}}, "df": 6}}}}}, "d": {"docs": {"icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.if_else": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 11, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}}, "df": 2, "s": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.Die.clip": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Population.entropy": {"tf": 1.4142135623730951}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1.4142135623730951}, "icepool.Deck.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 6}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.evaluator.KeepEvaluator": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die": {"tf": 1}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}}, "df": 8}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 10}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.binary_operator": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator.equals": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 15, "s": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.filter": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.truncate": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.reduce": {"tf": 1}}, "df": 8}}}}}, "s": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.sample": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}}, "df": 14}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 4, "d": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 8}, "s": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.issuperset": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.sample": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}}, "df": 7}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Reroll": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.sum": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.all_straights": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.multiset_function": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 26, "s": {"docs": {"icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.evaluate": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.7320508075688772}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}}, "df": 7, "s": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1.4142135623730951}}, "df": 8}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Pool": {"tf": 1.7320508075688772}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.expand": {"tf": 1}, "icepool.MultisetExpression.count": {"tf": 1}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 2.449489742783178}, "icepool.MultisetExpression.issuperset": {"tf": 2.449489742783178}, "icepool.MultisetExpression.isdisjoint": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 2.6457513110645907}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}}, "df": 20, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 19, "s": {"docs": {"icepool.Order": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 2}}}}}}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.map": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map": {"tf": 1.7320508075688772}}, "df": 4}}}}}}}}}}, "s": {"docs": {"icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 22, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}}, "df": 4}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 4}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}}, "df": 5}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}}, "df": 6}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.zero": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 6}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.map_function": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.KeepEvaluator": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}, "icepool.function.map_function": {"tf": 1}}, "df": 27}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.d": {"tf": 1}, "icepool.function.d": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Population.mode": {"tf": 1}, "icepool.Vector": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 9, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Again": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.MultisetGenerator": {"tf": 1.4142135623730951}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 12}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 25}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"icepool.Pool.keep": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 7}}, "x": {"docs": {"icepool.Die.set_range": {"tf": 1.7320508075688772}, "icepool.Die.explode": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.max_outcome": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.unique": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 10, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.max_outcome": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.function.max_outcome": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 9}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die.equals": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.largest_count": {"tf": 1}, "icepool.MultisetExpression.largest_count_and_outcome": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator": {"tf": 1}}, "df": 5}}}}}}, "p": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.Die.map_and_time": {"tf": 1.4142135623730951}, "icepool.Again": {"tf": 1}, "icepool.reduce": {"tf": 1.4142135623730951}, "icepool.accumulate": {"tf": 1.4142135623730951}, "icepool.map": {"tf": 2}, "icepool.map_function": {"tf": 2}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.function.reduce": {"tf": 1.4142135623730951}, "icepool.function.accumulate": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 2}, "icepool.function.map_function": {"tf": 2}, "icepool.function.map_and_time": {"tf": 1}}, "df": 16, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.outcomes": {"tf": 1.4142135623730951}, "icepool.Population.quantities": {"tf": 1.4142135623730951}, "icepool.Population.format": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 15}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetEvaluator.evaluate": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.evaluator.SumEvaluator.__init__": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"icepool.Die.map": {"tf": 1}, "icepool.MultisetExpression.map_counts": {"tf": 1}, "icepool.Deck.map": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.unary_operator": {"tf": 1}}, "df": 1, "[": {"docs": {}, "df": 0, ":": {"2": {"docs": {"icepool.Population.marginals": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.marginals": {"tf": 1}}, "df": 1}}}}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.Vector": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.evaluate": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.reduce": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.Qs": {"tf": 1}}, "df": 26}, "s": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.probabilities": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}}, "df": 12, "s": {"docs": {"icepool.Die": {"tf": 1.4142135623730951}, "icepool.Die.__init__": {"tf": 1}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 1}}, "df": 11}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.median": {"tf": 1.7320508075688772}, "icepool.Population.median_low": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}, "icepool.Pool": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.additive_union": {"tf": 1}}, "df": 1, "s": {"docs": {"icepool.Order.merge": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Pool.additive_union": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"icepool.evaluator.CompairEvalautor": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.7320508075688772}, "icepool.lowest": {"tf": 1}, "icepool.Pool.min_outcome": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}}, "df": 12, "d": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}, "i": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"icepool.min_outcome": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.function.min_outcome": {"tf": 1}}, "df": 3}}}}}, "x": {"docs": {"icepool.Die.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.cramer_von_mises": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.middle": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 4}}}}}, "d": {"docs": {"icepool.Population.format": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"icepool": {"tf": 1}, "icepool.Die": {"tf": 2.23606797749979}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.unary_operator": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.zero_outcome": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.difference": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.Deck.size": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 40, "s": {"docs": {"icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep": {"tf": 1}}, "df": 2}}}}}, "q": {"docs": {"icepool.Population.format": {"tf": 1.7320508075688772}}, "df": 1, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"icepool": {"tf": 1}, "icepool.d": {"tf": 1}, "icepool.Die": {"tf": 2.23606797749979}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.items": {"tf": 1}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1}, "icepool.Die.set_outcomes": {"tf": 1}, "icepool.Die.trim": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.items": {"tf": 1}, "icepool.Population.quantity": {"tf": 1}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.has_zero_quantities": {"tf": 1}, "icepool.Population.quantity_ne": {"tf": 1}, "icepool.Population.quantity_le": {"tf": 1}, "icepool.Population.quantity_lt": {"tf": 1}, "icepool.Population.quantity_ge": {"tf": 1}, "icepool.Population.quantity_gt": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.items": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.function.d": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1}}, "df": 32}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1.7320508075688772}, "icepool.Die.values": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.Population.values": {"tf": 1}, "icepool.Population.quantities": {"tf": 1.7320508075688772}, "icepool.Population.denominator": {"tf": 1}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.format": {"tf": 1.7320508075688772}, "icepool.from_cumulative": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.Deck": {"tf": 1}, "icepool.Deck.__init__": {"tf": 1}, "icepool.Deck.values": {"tf": 1}, "icepool.Deck.size": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}}, "df": 26}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.quantile": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"icepool.coin": {"tf": 1}, "icepool.Die": {"tf": 2.449489742783178}, "icepool.Die.__init__": {"tf": 1.4142135623730951}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.zero": {"tf": 1}, "icepool.Die.cmp": {"tf": 1}, "icepool.Die.equals": {"tf": 1.7320508075688772}, "icepool.Population.common_outcome_length": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.align": {"tf": 1}, "icepool.align_range": {"tf": 1}, "icepool.commonize_denominator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.coin": {"tf": 1}, "icepool.function.align": {"tf": 1}, "icepool.function.align_range": {"tf": 1}, "icepool.function.commonize_denominator": {"tf": 1}, "icepool.function.map": {"tf": 1}}, "df": 50}}, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.Population.is_empty": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.any": {"tf": 1}, "icepool.MultisetExpression.issubset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.compair": {"tf": 1.7320508075688772}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.multiset_function": {"tf": 1.4142135623730951}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 25, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Outcome": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.Population": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.Deck.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.7320508075688772}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.7320508075688772}, "icepool.typing.Outcome": {"tf": 1}}, "df": 8}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression.issuperset": {"tf": 1}, "icepool.Deal.__init__": {"tf": 2}, "icepool.Deal.hand_sizes": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.__init__": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 14}}, "s": {"docs": {"icepool.Deal.__init__": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.Die.count": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 16, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 5}}}}}, "t": {"docs": {"icepool.one_hot": {"tf": 1}, "icepool.function.one_hot": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Pool.keep": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.median": {"tf": 1}, "icepool.Population.quantile": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Die.highest": {"tf": 1.7320508075688772}, "icepool.Population.mode": {"tf": 1}, "icepool.Population.modal_quantity": {"tf": 1}, "icepool.highest": {"tf": 2}, "icepool.Pool.keep_tuple": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.evaluator.HighestOutcomeAndCountEvaluator": {"tf": 1}}, "df": 13}}, "r": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Population.median_high": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}}, "df": 6}}}}}, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1}}}}, "b": {"docs": {"icepool.map": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.issuperset": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 2.23606797749979}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 9, "e": {"docs": {"icepool.Die": {"tf": 1}, "icepool.Die.__init__": {"tf": 3.1622776601683795}, "icepool.Die.reroll": {"tf": 2}, "icepool.Die.filter": {"tf": 1.7320508075688772}, "icepool.Die.truncate": {"tf": 1.4142135623730951}, "icepool.Die.clip": {"tf": 1}, "icepool.Die.set_range": {"tf": 1.4142135623730951}, "icepool.Die.explode": {"tf": 2.6457513110645907}, "icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.equals": {"tf": 1.4142135623730951}, "icepool.Population": {"tf": 1}, "icepool.Population.quantities": {"tf": 1}, "icepool.Population.quantities_le": {"tf": 1}, "icepool.Population.quantities_ge": {"tf": 1}, "icepool.Population.quantities_lt": {"tf": 1}, "icepool.Population.quantities_gt": {"tf": 1}, "icepool.Population.probabilities": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_le": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_ge": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_lt": {"tf": 1.7320508075688772}, "icepool.Population.probabilities_gt": {"tf": 1.7320508075688772}, "icepool.Population.format": {"tf": 1.4142135623730951}, "icepool.tupleize": {"tf": 1}, "icepool.vectorize": {"tf": 1}, "icepool.Again": {"tf": 2}, "icepool.from_cumulative": {"tf": 1.4142135623730951}, "icepool.from_rv": {"tf": 2}, "icepool.lowest": {"tf": 2}, "icepool.highest": {"tf": 2}, "icepool.middle": {"tf": 1}, "icepool.reduce": {"tf": 1}, "icepool.accumulate": {"tf": 1}, "icepool.map": {"tf": 3.4641016151377544}, "icepool.map_function": {"tf": 1.4142135623730951}, "icepool.map_and_time": {"tf": 2.23606797749979}, "icepool.Reroll": {"tf": 1.7320508075688772}, "icepool.RerollType.Reroll": {"tf": 1}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 2}, "icepool.Pool.output_arity": {"tf": 1}, "icepool.Pool.keep_tuple": {"tf": 1.4142135623730951}, "icepool.Pool.keep": {"tf": 2.449489742783178}, "icepool.Pool.lowest": {"tf": 1.7320508075688772}, "icepool.Pool.highest": {"tf": 1.7320508075688772}, "icepool.standard_pool": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetGenerator.outcomes": {"tf": 1}, "icepool.MultisetGenerator.output_arity": {"tf": 1}, "icepool.Alignment": {"tf": 1}, "icepool.Alignment.outcomes": {"tf": 1}, "icepool.Alignment.output_arity": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 2.23606797749979}, "icepool.MultisetExpression.lowest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.highest": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.highest_outcome_and_count": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.largest_straight": {"tf": 1}, "icepool.MultisetExpression.largest_straight_and_outcome": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 2}, "icepool.MultisetEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.MultisetEvaluator.final_outcome": {"tf": 2}, "icepool.MultisetEvaluator.alignment": {"tf": 2}, "icepool.MultisetEvaluator.range_alignment": {"tf": 1}, "icepool.MultisetEvaluator.prefix_generators": {"tf": 1}, "icepool.MultisetEvaluator.evaluate": {"tf": 1.4142135623730951}, "icepool.Order": {"tf": 1}, "icepool.Deck.__init__": {"tf": 2.6457513110645907}, "icepool.Deck.map": {"tf": 1.7320508075688772}, "icepool.Deal.__init__": {"tf": 1}, "icepool.Deal.output_arity": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2}, "icepool.evaluator.JointEvaluator.prefix_generators": {"tf": 1}, "icepool.evaluator.ExpandEvaluator": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.LargestStraightEvaluator.alignment": {"tf": 1}, "icepool.evaluator.LargestStraightAndOutcomeEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllStraightsEvaluator.alignment": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 2}, "icepool.evaluator.CompairEvalautor": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 2.8284271247461903}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 2}, "icepool.evaluator.ExpressionEvaluator": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 2}, "icepool.evaluator.ExpressionEvaluator.prefix_generators": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1.4142135623730951}, "icepool.function.from_rv": {"tf": 2}, "icepool.function.reduce": {"tf": 1}, "icepool.function.accumulate": {"tf": 1}, "icepool.function.iter_cartesian_product": {"tf": 1.4142135623730951}, "icepool.function.map": {"tf": 3.4641016151377544}, "icepool.function.map_function": {"tf": 1.4142135623730951}, "icepool.function.map_and_time": {"tf": 2.23606797749979}, "icepool.typing.Qs": {"tf": 1}, "icepool.typing.Order": {"tf": 1}, "icepool.typing.RerollType.Reroll": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1.4142135623730951}}, "df": 112, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"icepool.Die": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}}, "df": 8}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.pool": {"tf": 1}, "icepool.Population.kolmogorov_smirnov": {"tf": 1}, "icepool.Population.cramer_von_mises": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}}, "df": 6}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 5}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}}, "df": 5}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.Die.equals": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.SumEvaluator.__init__": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}, "icepool.typing.guess_star": {"tf": 1}}, "df": 24}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.clip": {"tf": 1.4142135623730951}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Die.sign": {"tf": 1.4142135623730951}, "icepool.Vector": {"tf": 1}}, "df": 2}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetEvaluator": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.order": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.order": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 13}}}, "e": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.MultisetExpression.evaluate": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 1}, "icepool.evaluator.AllCountsEvaluator.__init__": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"icepool.Die.unary_operator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}}, "df": 9, "s": {"docs": {"icepool.evaluator.ComparisonEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.any_all": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.any_all": {"tf": 1}}, "df": 8}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.equals": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.CountsKeysView": {"tf": 1}, "icepool.CountsValuesView": {"tf": 1}, "icepool.CountsItemsView": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.isdisjoint": {"tf": 1}, "icepool.Order.merge": {"tf": 1}, "icepool.multiset_function": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator.default_outcome": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator.default_outcome": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.typing.Order.merge": {"tf": 1}}, "df": 22}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.map": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.evaluate": {"tf": 1.4142135623730951}, "icepool.multiset_function": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 7}}}}, "y": {"docs": {"icepool.Die.binary_operator": {"tf": 1}, "icepool.Die.simplify": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Die.zero": {"tf": 1.4142135623730951}, "icepool.Die.equals": {"tf": 1.7320508075688772}, "icepool.Population.scale_quantities": {"tf": 1}, "icepool.Population.format": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.Reroll": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}, "icepool.MultisetExpression.multiply_counts": {"tf": 1}, "icepool.MultisetExpression.divide_counts": {"tf": 1}, "icepool.MultisetExpression.keep": {"tf": 1}, "icepool.MultisetExpression.all_counts": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1.4142135623730951}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.MultisetEvaluator.final_outcome": {"tf": 1}, "icepool.MultisetEvaluator.alignment": {"tf": 2}, "icepool.Order": {"tf": 1}, "icepool.evaluator.JointEvaluator.alignment": {"tf": 2}, "icepool.evaluator.CountEvaluator": {"tf": 1}, "icepool.evaluator.ComparisonEvaluator": {"tf": 1}, "icepool.evaluator.IsSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSubsetEvaluator": {"tf": 1}, "icepool.evaluator.IsSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsProperSupersetEvaluator": {"tf": 1}, "icepool.evaluator.IsEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsNotEqualSetEvaluator": {"tf": 1}, "icepool.evaluator.IsDisjointSetEvaluator": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.final_outcome": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1.4142135623730951}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.final_outcome": {"tf": 1}, "icepool.evaluator.KeepEvaluator.order": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.final_outcome": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.typing.Order": {"tf": 1}}, "df": 41}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"icepool.Die.binary_operator": {"tf": 2}, "icepool.Vector.binary_operator": {"tf": 1.4142135623730951}, "icepool.Vector.reverse_binary_operator": {"tf": 1}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Population.entropy": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.entropy": {"tf": 1.4142135623730951}, "icepool.MultisetGenerator": {"tf": 1}, "icepool.MultisetExpression": {"tf": 1}, "icepool.MultisetEvaluator.next_state": {"tf": 1}, "icepool.evaluator.ConstantEvaluator.next_state": {"tf": 1}, "icepool.evaluator.CompairEvalautor.next_state": {"tf": 1}}, "df": 6, "d": {"docs": {"icepool.Die.reroll": {"tf": 1}, "icepool.Die.filter": {"tf": 1}, "icepool.Die.explode": {"tf": 1}, "icepool.Vector.binary_operator": {"tf": 1}, "icepool.map": {"tf": 1}, "icepool.map_and_time": {"tf": 1}, "icepool.MultisetExpression.compair": {"tf": 1}, "icepool.Deck.map": {"tf": 1}, "icepool.evaluator.CompairEvalautor.__init__": {"tf": 1}, "icepool.function.map": {"tf": 1}, "icepool.function.map_and_time": {"tf": 1}}, "df": 11}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 2}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Pool.__init__": {"tf": 1}}, "df": 1}}, "d": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.Die.clip": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"icepool.Die.set_range": {"tf": 1}, "icepool.Die.middle": {"tf": 1}, "icepool.Again": {"tf": 1}, "icepool.from_cumulative": {"tf": 1}, "icepool.middle": {"tf": 1}, "icepool.map": {"tf": 1.4142135623730951}, "icepool.Pool": {"tf": 1}, "icepool.Pool.__init__": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1}, "icepool.MultisetEvaluator.validate_arity": {"tf": 1}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.JointEvaluator.validate_arity": {"tf": 1}, "icepool.evaluator.ExpressionEvaluator.validate_arity": {"tf": 1}, "icepool.function.from_cumulative": {"tf": 1}, "icepool.function.map": {"tf": 1.4142135623730951}}, "df": 17}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.MultisetGenerator": {"tf": 1}}, "df": 3}, "d": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"icepool.Population.format": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Vector.binary_operator": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"icepool.multiset_function": {"tf": 1}}, "df": 1}}}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.from_rv": {"tf": 1}, "icepool.function.from_rv": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"icepool.Die.__init__": {"tf": 1}, "icepool.map_function": {"tf": 1}, "icepool.function.map_function": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {"icepool.Population.outcomes": {"tf": 1}, "icepool.Deal.outcomes": {"tf": 1}}, "df": 2, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"icepool.CountsKeysView": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"icepool.Die.pool": {"tf": 1}, "icepool.Die.lowest": {"tf": 1.7320508075688772}, "icepool.Die.highest": {"tf": 1.7320508075688772}, "icepool.Die.middle": {"tf": 2.23606797749979}, "icepool.lowest": {"tf": 1.4142135623730951}, "icepool.highest": {"tf": 1.4142135623730951}, "icepool.middle": {"tf": 1.7320508075688772}, "icepool.Pool.raw_size": {"tf": 1}, "icepool.Pool.keep_size": {"tf": 1}, "icepool.Pool.keep": {"tf": 1.7320508075688772}, "icepool.Pool.lowest": {"tf": 1.4142135623730951}, "icepool.Pool.highest": {"tf": 1.4142135623730951}, "icepool.Pool.middle": {"tf": 2.449489742783178}, "icepool.Pool.additive_union": {"tf": 1}, "icepool.MultisetExpression": {"tf": 2}, "icepool.MultisetExpression.additive_union": {"tf": 1}, "icepool.MultisetExpression.difference": {"tf": 1}, "icepool.MultisetExpression.intersection": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.union": {"tf": 1}, "icepool.MultisetExpression.symmetric_difference": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.keep_counts": {"tf": 1.7320508075688772}, "icepool.MultisetExpression.lowest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.highest": {"tf": 1.4142135623730951}, "icepool.MultisetExpression.all_counts": {"tf": 1.4142135623730951}, "icepool.Deal.__init__": {"tf": 1}, "icepool.evaluator.KeepEvaluator.__init__": {"tf": 1}}, "df": 27, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"icepool.Die.lowest": {"tf": 1}, "icepool.Die.highest": {"tf": 1}, "icepool.lowest": {"tf": 1}, "icepool.highest": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 8}}}, "s": {"docs": {"icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.drop_outcomes": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {"icepool.Die.middle": {"tf": 1}, "icepool.Pool.lowest": {"tf": 1}, "icepool.Pool.highest": {"tf": 1}, "icepool.Pool.middle": {"tf": 1}, "icepool.MultisetExpression.keep_outcomes": {"tf": 1}, "icepool.MultisetExpression.lowest": {"tf": 1}, "icepool.MultisetExpression.highest": {"tf": 1}}, "df": 7}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"icepool.MultisetExpression.keep": {"tf": 1}}, "df": 1, "n": {"docs": {"icepool.Population.probabilities": {"tf": 1}, "icepool.Population.probabilities_le": {"tf": 1}, "icepool.Population.probabilities_ge": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "\u2013": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"icepool.Population.kolmogorov_smirnov": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"icepool.MultisetExpression": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {"icepool.map_function": {"tf": 2.449489742783178}, "icepool.MultisetExpression": {"tf": 1}, "icepool.function.map_function": {"tf": 2.449489742783178}}, "df": 3}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file