J-jLPdZddlmZmZmZddlZddlZddl m Z [[[dZ ddZ dZ e ejjfd Ze d ejjfd Zd Zej&d dddZddZdZdZddZdZdZGddeZdZGddeZeZy) zT various math utilities, notably `eig` and a collection of simple functions in `Mh` )absolute_importdivisionprint_functionN)rangec<t|tr|St|S)aremove np type of a number, return `int` or `float`. Return the unchanged argument iff ``isinstance(float_, int)``. Remark that `np.float64` is an instance of `float` however `np.int64` is not an instance if `int` (for good reasons). That is, ``isinstance(np.array([1])[0], int) is False`` while ``isinstance(np.array([1.])[0], float) is True``, as of numpy 2.x in 2025. ) isinstanceintfloat)float_s `/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/utilities/math.pyifloatr s ,6?%-?ct|trMt||kr?t|dts,t |d|dur|Dcgc] }t |c}S|Scc}w)z(make print([np.float64(3.3)]) look nicerr)r listlenr r r)limaxlenis r lifloatrs[2tRF!22a5#&5A>> from cma.utilities.math import randhss >>> dim = 3 >>> assert dim - 1e-7 < sum(randhss(1, dim)[0]**2) < dim + 1e-7 r)npsum)ndimnorm_randnarvvs r randhssr%$sB 3-C  U1Xq!t c) )) Jrc d|z S)N?)ds r r*7sb1frct||||}td||f}|dkDr:|dkDrtd|z|D]"}|d|dzz dzz}|||d|dzz }$|S)z`n` iid vectors uniformly distributed on the hypersphere surface with mixing in of normal distribution, which can be beneficial in smaller dimension. rrzc(dim)=%f should be <=1rr)r%min ValueError)rr r!cr"r#r$s r randhss_mixinr/6s !S% 'C Q#KA1u q56:; ;A !ad(S A U1c]1%% %A Jrct|jdD].}|||fdz}|dd|fxx|zcc<||ddfxx|zcc<0||jzdz }tjtj |dsJ|S)z:change C in place into a correlation matrix, AKA whiteningrrN@r)rshapeTrallclosediag)r.rfacs r to_correlation_matrixr7Fs 1771: 1gsl !Q$3 !Q$3 QSSCA ;;rwwqz1 %% % Hroncez3using exponential smoothing with .* rolling average)messagec|dk(r|St|trxt|t|f}t j t d|Dcgc]}t j|d|c}t j||d|z gzdgS|t|k(r$tjdj|dd|z z }t jt t|Dcgc]\}tt |dzDcgc]}||z|||z zc}tt |dzDcgc]}||z c}z ^c}}Scc}wcc}wcc}wcc}}w)u=rolling average without biasing boundary effects. The first entries give the average over all first values (until the window width is reached). If `w` is not an integer, expontential smoothing with weights proportionate to ``(1 - 1/w)**i`` summing to one is executed, thereby putting about 1 - exp(-1) ≈ 0.63 of the weight sum on the last `w` entries. Details: the average is mainly based on `np.convolve`, whereas exponential smoothing is for the time being numerically inefficient and scales quadratically with the length of `x`. rNvalid)modez^using exponential smoothing with time horizon {0}. Use `int` type to get the rolling average.)r r r,rrhstackrmeanconvolve _warningswarnformatasarrayr)rwrr$js r moving_averagerFRsW Av As  CF yy5A;?;a2771Ra5>;?++aa!eW7CEF F A; NN//5vay : AIzz$)#a&M3$1quQU|D|!1q1v |DE"%A,#?,QAqD,#?@A$134 4@ E#?3s* E0E( EE( : E# E(  E( c|d}tj|}tjt|}d|z}t t|D]k}|||z}t |dzD]P}|||z}|||z|z|||zz |||zz ||z|dzz |||f<|||f|||f<Rm|S)z Hessian estimate for `f` at `x0`ư>rrr)rrCeyerr) fx0epseHreirEejs r HessianrQqs { BB s2wA AA 3r7^ 1Q4ZqsAqtBR" o"r' 2QrBwZ?!B%G3PQ6QAacF1gAadG Hrc ztjtjtj|fi|S)zreturn geometric standard deviation of `vals`. The gsd is invariant under linear scaling and independent of the choice of the log-exp base. ``kwargs`` are passed to `np.std`, in particular `ddof`. )rexpstdlog)valskwargss r geometric_sdrXs) 66"&&00 11rc 2tj|dkDstj|dkrtdj|d}|d dz }||tjdtj | dz z||dzzzS)a return an approximation of the inverse cdf value of a standard normal distribution, assuming 0 < p <= 1/2. This is the "sigma" for which the tail distribution has probability `p` (AKA quantile or percentile point function). For ``p=1/2`` we have ``sigma = 0``. The approximation ``0.79 + 1.49 x sqrt(-log(p)) + alpha x sqrt(p)``, where alpha=0.637... is such that p=1/2 maps to sigma=0, has a sigma error within [-0.02, 0.029] for ``p >= 1e-12`` and for ``p >= 1e-22`` with an additional correction as applied. The error is less than 0.0121 for all p <= 0.1. The relative sigma error for p->1/2 and hence sigma->0 is < 0.11. The input `p` may be an `np.array`. The following is the Python code to assess the accuracy:: %pylab import scipy from scipy import stats import cma normal_ppf = cma.utilities.math.normal_ppf pp = np.logspace(-15, np.log10(0.5), 5400) # target tail probabilities if 1 < 3: # sigma vs p figure(53) gcf().clear() grid(True, which='both') xlabel('tail probability') ylabel('sigma') semilogx(pp, normal_ppf(pp), label='approximation') semilogx(pp, scipy.stats.norm.ppf(pp), label='true') legend() # semilogx(pp, -sqrt(7 * log(1/pp/4 + pp)) / 2) # semilogx(pp, -scipy.stats.norm.ppf(pp/2)) # semilogx(pp, sqrt(7 * log((1/pp + pp) / 2)) / 2) if 1 < 3: # Delta sigma vs p figure(54) gcf().clear() grid(True, which='both') xlabel('tail probability') ylabel('sigma difference (error)') semilogx(pp, normal_ppf(pp) - scipy.stats.norm.ppf(pp), label='absolute') abs_error = max(np.abs(normal_ppf(pp) - scipy.stats.norm.ppf(pp))) semilogx(pp, (normal_ppf(pp) - scipy.stats.norm.ppf(pp)) / np.maximum(1e-12, -scipy.stats.norm.ppf(pp)), label='relative') rel_error = max((normal_ppf(pp) - scipy.stats.norm.ppf(pp)) / np.maximum(1e-12, -scipy.stats.norm.ppf(pp))) ylim(-max(np.abs(ylim())), max(np.abs(ylim()))) text(xlim()[0], ylim()[0] * 0.98, ' the largest absolute and relative errors are {} and {}' .format(np.round(abs_error, 6), np.round(rel_error, 6))) legend() if 11 < 3: figure(55) gcf().clear() grid(True, which='both') xlabel('tail probability') ylabel('sigma ratio') semilogx(pp, normal_ppf(pp) / scipy.stats.norm.ppf(pp)) if 11 < 3: figure(56) gcf().clear() ylabel('probability ratio') xlabel('sigma') plot(stats.norm.ppf(pp), stats.norm.cdf(normal_ppf(pp)) / pp) grid(True, which='both') if 1 < 3: # true p of sigma vs p input figure(56) gcf().clear() ylabel('true probability ratio') xlabel('tail probability (input)') semilogx(pp, pp / stats.norm.cdf(normal_ppf(pp))) grid(True, which='both') The approximation is by construction exact for p=1/2. For small probabilities (sigma < -7), the probability is quite sensitive: roughly speaking, a Delta sigma of 0.05 / 0.25 / 1 changes the probability by a factor of 1.4 / 3 / 50, respectively. rrz&0 < p <= 1/2 is required but p was {0}c`ddtjtj| zz S)zia sigma approximation with an error in ]-0.013, 0.008[ for 1e-12 <= p <= 1e-4 where sigma < -3.5 gHzG?gףp= ?)rsqrtrU)ps r valznormal_ppf..vals'dRWWbffQiZ0000rg;f?r)ranyr-rBmaximumrU)r\r]r6s r normal_ppfrash vva#g"&&a.AHHKLL1 H*z !C q2::a"&&)b11 3, rc ddl}||}t |j j j|||z g|||z ggfi|jS#t$rtjdYywxYw)a test (success) frequency nsucc1 of n1 against nsucc2 of n2. By default, ``n2 = n1``, hence `n2` can be omitted in this case. The frequency data ``nsucc1, n1, nsucc2, n2`` and the `kwargs` are passed to `scipy.stats.contingency.chi2_contingency` for a chi-square test of independence. Return the probability that both success "frequencies" stem from the same underlying distribution (H0). More specifically, return the probability (upper bound) to observe the given or a greater discrepancy between the two success frequency data, given the data stem from the same distribution (formally, are independent of the "row" index (1, 2), hence "test of independence"). Example: when testing 3 versus 8 successes observed in 25 trials respectively, we find that p = 0.17 = 17% or about 1/6 under H0:: import cma cma.utilities.math.testchisquare(3, 25, 8) 0.17207161769462614 Details: testing the successes ``nsucc1, nsucc2`` is equivalent to testing the respective failures ``n1 - nsucc1, n2 - nsucc2``. With ``n1 = n2 = 15``, we test ``nsucc1 = [0, 1, ...]`` against several ``nsucc2``:: import cma t = cma.utilities.math.testchisquare # scipy needs to be installed n = 15 print('nsucc nfail p') for p1 in range(6): for delta in [4, 5, 6]: p2 = p1 + (p1 > 1) + delta print(' {} {} (= {} {}) {:.2}'.format( p1, p2, n-p1, n-p2, t(p1, n, p2))) print(' ') nsucc nfail p 0 4 (= 15 11) 0.11 0 5 (= 15 10) 0.05 0 6 (= 15 9) 0.022 1 5 (= 14 10) 0.17 1 6 (= 14 9) 0.084 1 7 (= 14 8) 0.039 2 7 (= 13 8) 0.11 2 8 (= 13 7) 0.053 2 9 (= 13 6) 0.023 3 8 (= 12 7) 0.13 3 9 (= 12 6) 0.062 3 10 (= 12 5) 0.027 4 9 (= 11 6) 0.14 4 10 (= 11 5) 0.067 4 11 (= 11 4) 0.028 5 10 (= 10 5) 0.14 5 11 (= 10 4) 0.067 5 12 (= 10 3) 0.027 Testing 1 (of n=15) versus 6 yields p=0.084 (4-th row), testing 1 versus 7 yields p=0.039. The shown p-values are monotonuously increasing(!) with increasing n: with n = 7, the mentioned p-values are smaller (about 0.033 and 0.007, respectively), with ``n -> infinity`` they reach about 0.13 and 0.077, respectively. Remark: under H0, p~U[0,1], hence E ln(p) = -1 and the geometric average p equals 1/e. rN6Please 'pip install scipy' to run the statistical test) scipy.stats ImportErrorr@rAr stats contingencychi2_contingencypvalue)nsucc1n1nsucc2n2rWscipys r testchisquarerosT z  9((99 "v+.f0EF" ""(& ** OPsAA10A1ic B ddl}t |t |zt k}|j d|rdnd|j ddt|jj||fi|jS#t$rtjdYywxYw) aDreturn p-value computed with `mannwhitneyu` from `scipy.stats`. ``testranksum(data1, data2)`` returns the probability that `data1` and `data2`, or more discrepant data, are generated while P(d1 < d2) = P(d1 > d2) = 1/2 is true (AKA H0). This function calls `scipy.stats.mannwhitneyu` passing data and `kwargs`, setting by default ``alternative='two-sided'`` and ``method='exact' if len(data1) * len(data2) < 55000 else 'auto'``. Pass ``method='auto'`` when execution speed is an issue. The minimal data sizes to possibly get p < 1% two-sided are:: import cma ranksum = cma.utilities.math.testranksum [(n, 1e-4 * int(0.5 + 1e4 * # round and remove np type ranksum(range(n[0]), range(n[0], n[0] + n[1])))) for n in [[5, 5], [4, 6], [3, 9], [2, 19], [1, 200]]] # n1, n2, p-value [([5, 5], 0.0079), ([4, 6], 0.0095), ([3, 9], 0.0091), ([2, 19], 0.0095), ([1, 200], 0.01)] The probabilities are exactly doubled with ``'alterative='less'`` passed as argument. Details: the above threshold for ``method='exact'`` can be changed by assigning `cma.utilities.math._testranksum_method_exact_threshold`. Remark: under H0, p~U[0,1], hence E ln(p) = -1 and the geometric average p equals 1/e. rNrcmethodexactauto alternativez two-sided) rdrer@rAr#_testranksum_method_exact_threshold setdefaultr rf mannwhitneyuri)data1data2rWrnrrs r testranksumrzGsF JU #&I IE h5f= m[1 )))%A&AHH II OPsA==BBc2eZdZdZdZdZdZedZy)UpdatingAveragez=use instead of a `list` when too many values must be averagedc d|_d|_y)Nr)countrselfs r __init__zUpdatingAverage.__init__vs rc||yNr(rr]s r appendzUpdatingAverage.appendys  S rcX|xj|z c_|xjdz c_y)z"add a value to compute the averagerNrr~rs r __call__zUpdatingAverage.__call__{s C a rc4|j|jz S)zcurrent average valuerrs r valuezUpdatingAverage.valuesxx$**$$rN) __name__ __module__ __qualname____doc__rrrpropertyrr(rr r|r|ts(G%%rr|c d}d}t|d}ddkr`tj|Dcgc]}|dd c}}|dj}tj|}tj|}n7|Dcgc]}t |Dcgc]}|| c} }}}|dgz}|dgz}||||||||||tj|tj|fScc}wcc}wcc}}w)aeigendecomposition of a symmetric matrix, much slower than `numpy.linalg.eigh`, return ``(EVals, Basis)``, the eigenvalues and an orthonormal basis of the corresponding eigenvectors, where ``Basis[i]`` the i-th row of ``Basis`` columns of ``Basis``, ``[Basis[j][i] for j in range(len(Basis))]`` the i-th eigenvector with eigenvalue ``EVals[i]`` c  d}t|D]}||dz |||<t|dz ddD]%}d}|s$d}t|D]} |t|| z}ntt|d|}|dk(r;||dz ||<t|D] }||dz |||<d|||<d|||<"n|s,t|D]} || xx|zcc<||| || zz }n*|d|xxx|zccctj|d||d|}||dz } |dz} | dkDr| } || z||<|| | zz }| | z ||dz <|st|D]}d||< nd|d|t|D]}||} | |||<|||||| zz} |sAt|dz|D])} | || ||| zz } || xx|| || zz cc<+| ||<d||dz|xxx|j ||dz|| zz ccc| tj|j ||dz|||dz|z||<d} |s,t|D]}||xx|zcc<| ||||zz } n-|d|xxx|zccc| tj|d||d|z } | ||zz } |s$t|D]}||xx| ||zzcc<n|d|xxx| |d|zzccct|D]}||} ||} |s1t||D]!} || |xx| || z| || zzzcc<#n*|j |||xxx| |||z| |||zzzccc||dz |||<d|||<|||<(t|dz D]}}|||||dz |<d|||<||dz}|dk7r|s%t|dzD]} || |dz|z || <n!|j |dzd|dz|z |d|dzt|dzD]}|sVd} t|dzD]} | || |dz|| |zz } t|dzD]} || |xx| || zzcc<[tj|j |dzd|dz|j |d|dz} |j |d|dzxxx| |d|dzzzccc|s t|dzD] } d|| |dz<fd|j |dzd|dz|s*t|D]}||dz |||<d||dz |<n||dz d||d|d||dz d|d||dz |dz <d|d<y)NFrrrr')rabsrrdotr3) rVr)rMnum_optrErhscalekrJghhs r tred2zeig..tred2sy qAQU8A;AaD q1ua$AAqA!C!I-E"C!AK(|Qx!qAQU8A;AaD!AaDG!AaDG""1X! QqTAaD[(&bqEUNEq!uae,Aa!eHsFq5Aqy!AIq5!a%"1X"!& AbqEqA!AAaDG!qtAw{*A"!&q1uaA1a1Q4/AaDAaDGaK/D"1 !!!a% acc!fQU1o&99  266!##a&Qq/1QU1:#FF!""1X! QqTAaD[(&bqEQJE"1q!u--A!a%["1X!QqT )&bqER!BQ%Z'EqA!A!A"!&q!AaDGAaD1qt8(;}|||dz}||||z||zz|||dz<||||z||zz |||<@|j|dzj }||j|z||zz|j|dz<||j|z||zz |j|<&| |z|z|z|| z|z } || z|| <|| z|| <t|| ||zkrn'|| |z|| <d|| <d d krt|dz D]n}|}||} t|dz|D]}||| ks |}||} ||k7s4||||<| ||<t|D] }|||} ||||||<| |||<"pyy) NFrrrg.tql2?s1a[Q4!a%!1QAaAJ!a% qAtS1YQqT23DAa%qt9d *Qa%1uQJE!A1q5A#!*5AACA1uBQ41q5>AaD tq1u~Aa!eHAE(CAaDA"!&q1uaAaDAID"1!a% a AA!AABBAE(CAB#1q5!a%4!HETAaD!G^c1#$q5!a%aD1HE!Hq1u,#$qAEA!H,<'=#=!a% '%*1X$%aDQK./!A$q'kAE.A!QU *+ad1g+A*=!Q&. "#QU!2B)*QSSVa"f)tj d|z |z|kxrtj |d|z|zkSr)rrnonzerorboolall)rrrLidxs r vequals_approximatelyz)MathHelperFunctions.vequals_approximatelysxx{BHHQK1jjQ" s8!C&["qv+NAcFAcFRVVAGaK(@RVVACK-@QC1}q01ObffQ!c'Q=N6OR Rrc||\}}tj|tj||zjS)z)matrix exponential for a symmetric matrix)rrrSr3)ArDBs r expmszMathHelperFunctions.expmss4 1v1vva"&&)a-**++rcTtjtj||Sr)rrrr)vec vec_or_scalars r amaxzMathHelperFunctions.amaxsxx+//]CDDrc|}tj|r|Dcgc]}t||}}|Stt |Dcgc]}t||||}}|Scc}wcc}wr)risscalarrrr)rrrrrrs r rzMathHelperFunctions.maxsp  ;;q>$'(CqQCA(-2#s*,=>,=qSVQqT",=A>)>s A& A+c@||ksJt|t||ffSr)r,r)r]min_valmax_vals r minmaxzMathHelperFunctions.minmaxs)'!!!GS#w0122rc ~tj|Dcgc]}t|t||ffc}Scc}wr)rrr,r)r]rrr$s r aminmaxzMathHelperFunctions.aminmaxs6xxCHCqgsAw<'89:CHIIHs:cTtjtj||Sr)rrrr,)rvec_or_scalar2s r aminzMathHelperFunctions.aminsxx+// ~NOOrc.tj}||r||r t||S||r||}}||r|Dcgc]}t||c}Stt |Dcgc]}t||||c}Scc}wcc}wr)rrr,rr)rrissrrs r r,zMathHelperFunctions.minskk q6c!fq!9  q6aqA q6'()q!C1Iq) )-238_=_C!adO_= =*=s B 1Bc*t||zd|z zS)Nr)r)rexpos r normzMathHelperFunctions.norms39~D))rc8|dk(r|dkD|zS|||kD||z zzS)z4clips argument (scalar or array) from below at lowerrr()rlowers r rzMathHelperFunctions.aposs1 A:EQ; AI!e)44 4rNc|tj|dz}tj||z }~tj||z }|dkD||k|dzdz z||kD|z||dz z zzzS)aYHuber-like smooth penality which starts at lower. The penalty is zero below lower and affine linear above upper. Return:: 0, if x <= lower quadratic in x, if lower <= x <= upper affine linear in x with slope upper - lower, if x >= upper `upper` defaults to ``lower + 1``. rrrrrC)rrrzus r apenalty_quadlinz$MathHelperFunctions.apenalty_quadlins~ =JJu%)E JJqME ! JJu  %A16a1fqj1QUaK1q1u94MMNNrctj|}||dzk|dz |d|zz zz||dzk\tj|zz|zS)ay-shifted Huber function, return huber(x, delta) + delta/2 + eps. `huber2` maps `x` to ``abs(x) + eps`` if ``abs(x) >= delta`` and otherwise to a quadratic law of `x` mapping 0 to ``delta/2 + eps`` which makes the first derivative of `huber2` continuous. Details: `x` may be scalar or a `numpy` array. Setting eps = -delta/2 recovers the Huber loss. >>> import numpy as np >>> import cma >>> hus = cma.utilities.math.Mh.huber2(np.asarray([ ... -1, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8, 2]), 0.5) >>> ' '.join(['{0:.2}'.format(n) for n in hus]) '1.0 0.8 0.6 0.41 0.29 0.25 0.29 0.41 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0' r)rsquarer)rdeltarLx2s r huber2zMathHelperFunctions.huber2/s]&YYq\eQh519rQY/?#?@uax266!9,-/23 4rgQ63E?g( ?gM63E?g:\?w@@)rrr)ergR63E?g' ?gR63E?g:\?rrgڑv)m@g:@ggX@gS@gH @gѫ¢_$ @gK @gygg @g|5x@goƓ@gu@@gwf@gr15@g@gvC @gFܻ@g=k@gGڕd@gWk@gN?nnq3@gxԗ@g|rAX@gvC[@gn$@gʃÚ@g[9+s@g$ @gFj('@g7-~@gU޵|@gsD*@g@~@g8M@gv#@gH}ʾt@g@gYg@gḱa@g]%@g*RRw@g OhF@g{d>ߠ@g\4@g?$@g}hm@gm@g,qQ@gDB@g@g֜o@gR<^2@g_U@g<@g9@gr@gۏ^@gxp@g˥O@g  @g1rH/ @g8JO @g"n @g>EOF @gm @gnl @gg @g,="!@gHQ%!@gdKC!@gl`!@g<8~!@g[d!@gb`!@ga-!@g!@gk>"@g0~*"@g: לF"@go>b"@g)xO~"@gh\?"@gL\"@guR"@g8 T"@gY#@g-ܚ!#@gr8eVK<#@g(:V#@gUb>q#@gn#@g#@g2Π#@g"|#@gX7#@c tj|S#t$r?|dkDsJ||}|dzddd|zz z dd|dzzz zztj|<YnwxYwtj|S)a^approximation of the expectation of norm(randn(dimension)). The exact value can be computed by:: from scipy.special import gamma return 2**0.5 * gamma((self.dimension+1) / 2) / gamma(self.dimension / 2) The approximation obeys ``chin < chin_hat < (1 + 5e-5) * chin``. >>> import cma.utilities.math as um ... >>> um.Mh.chiN(3) == 1.595769121605731 True >>> um.Mh.chiN(100) == 9.97503163955105 True >>> 31.6148721 < um.Mh.chiN(1000) < 31.6148722 True >>> len(um.MathHelperFunctions._chiN_dict) # internal checking 102 >>> assert all([-1 / (10*(N+1)**2) < um.Mh.chiN(N) - N**0.5 * (1 - 1. / (4 * N) + 1. / (26 * N**2)) ... < 1 / (10*(N+1)**2) for N in range(1, len(um.MathHelperFunctions._chiN_dict))]) rrrr'rr)r _chiN_dictKeyError) dimensionrs r chiNzMathHelperFunctions.chiNLs2 ?&11)< < ?q= +) +=A3!bAEl*R219-==> * *9 5  ? #--i88sAAA)r2KdFctj|r|gn|}|s t|}t|}g}|D]{}||zdz dz }|dkr|j |d(||dz k\r|j |dEt |}|j |dz|z ||z||z ||dzzz}tj|r|dS|S)z``prctile(data, 50)`` returns the median, but p_vals can also be a sequence. Provides for small samples or extremes IMHO better values than matplotlib.mlab.prctile or np.percentile, however also slower. rrrrr)rrsortedrrr ) datap_valssorted_psrr)r\firs r prctilezMathHelperFunctions.prctilensV,fX&$ R such that :: upper - 10^-x -> x, and lower + 10^-x -> -x for large enough x. By default, simplifies close to `log10(x / (1 - x))`. >>> from cma.utilities.math import Mh >>> l, u = -1, 2 >>> print(Mh.logit10([l+0.01, 0.5, u-0.01], l, u)) [-1.9949189 0. 1.9949189] r)rrClog10)rrrrs r logit10zMathHelperFunctions.logit10sL" JJqM Y55= )xxUac*eai!^;<!FFAFFrc:tjjtjjz }t|dkDrLtjjtjjz }t|dkDrL|dz S)Nir)rrr"r)rs r cauchy_with_variance_onez,MathHelperFunctions.cauchy_with_variance_onesc IIOO   1 1!ftm !BIIOO$55A!ftm2v rc T t|}|dk(r>tjt |Dcgc]}t j c}S|dk(rAtjt |dDcgc]}t j c}S|dk(r]tjt |dDcgc]0}t |dDcgc]}t j c}2c}}Std#t$rd}YwxYwcc}wcc}wcc}wcc}}w)Nrrrz#len(size) cannot be larger than two)r TypeErrorrrrrrr-)rr_i_js r standard_finite_cauchyz*MathHelperFunctions.standard_finite_cauchys# D A 688V[\`VabVaPR0IIKVabc c !V88V[\`ab\cVdeVdPR0IIKVdef f !V88#(a>3#1RX]]abc]dWefWeQS1JJLWef#134 4BC C A cef3s4 DD4D;D$ D+D$  DDD$ )g-q=)r)r)rN)rr)r)"rrrr staticmethodrrrrlinalgeighrrrrrrr,rrrrrdict enumeraterr percentilerr rrrrr(rr rrs55NNRRYY^^,, EE33JJPP > >**55OO(44,(O%,<',>@Ji!WJ 9 9B15220&(mm1135==11GG(GG DDrr)r))rHr) r __future__rrrwarningsr@numpyr python3for2rrrrrr"r%r/r7filterwarningsrFrQrXrarorurzobjectr|rrMhr(rr r+sA@X~ @$299??$!*$BIIOO    IK4>  2`NS*j',#+JZ%f%$G$R pD&pDdr